AutoMovie API
    Preparing search index...

    Function RecoveryChartBatch

    • Fit a selected private chart batch after one common boundary-network pass. All chart families enter the same network before any coefficient solve, so observed quarter cuts and maximal physical arcs can be reconciled across selected slabs. Chart names retain the caller's private ownership metadata. A failed global network falls back to explicitly unqualified independent networks, preserving finite siblings without claiming shared-bank continuity. Failed maps and fits remain local results and never supply a source mesh.

      Parameters

      • input: {
            charts: readonly {
                insertions: readonly {
                    edgeKeys: [string, string];
                    fractionFromFirst: number;
                    key: string;
                    pointMm: readonly [number, number, number];
                }[];
                name: string;
                physicalKeys: readonly string[];
                sides: readonly [number[], number[], number[], number[]];
                triangles: readonly (readonly [number, number, number])[];
                verticesMm: readonly (readonly [number, number, number])[];
            }[];
            fit: {
                cornerDegrees: number;
                maxIterations: number;
                maxObservationRows?: number;
                maxPatches: number;
                maxRefinements?: number;
                maxSpans: number;
                physicalGradientLengthMm?: number;
                toleranceMm: number;
            };
            owner: {
                get: (
                    word: readonly string[],
                    pointsMm: readonly (readonly [number, number, number])[],
                ) => {
                    canonicalCurve: IAutoMovieCubicBezierCurve64;
                    canonicalKnots: number[];
                    corners: [string, string];
                    fit: IAutoMovieRecoveryCurveFit;
                    id: string;
                    knots: number[];
                    parameters: number[];
                    reversed: boolean;
                };
                size: () => number;
            };
        }
        • charts: readonly {
              insertions: readonly {
                  edgeKeys: [string, string];
                  fractionFromFirst: number;
                  key: string;
                  pointMm: readonly [number, number, number];
              }[];
              name: string;
              physicalKeys: readonly string[];
              sides: readonly [number[], number[], number[], number[]];
              triangles: readonly (readonly [number, number, number])[];
              verticesMm: readonly (readonly [number, number, number])[];
          }[]

          Prepared or fitted source charts in deterministic observation order, including each independently retained feature piece.

        • fit: {
              cornerDegrees: number;
              maxIterations: number;
              maxObservationRows?: number;
              maxPatches: number;
              maxRefinements?: number;
              maxSpans: number;
              physicalGradientLengthMm?: number;
              toleranceMm: number;
          }

          Explicit fitting and work-limit policy shared by all chart jobs in this batch.

          • cornerDegrees: number

            Declared turning-angle threshold in degrees for preserving an independent corner tangent.

          • maxIterations: number

            Explicit positive numerical iteration ceiling; exhaustion remains a reported termination, not convergence.

          • OptionalmaxObservationRows?: number

            Optional ceiling on retained area-quadrature observation rows; omission admits at most 250,000 rows per fit.

          • maxPatches: number

            Positive integer ceiling on emitted chart patches; the fitter reports unresolved refinement at the limit.

          • OptionalmaxRefinements?: number

            Optional ceiling on residual-driven refinement rounds; omission permits four rounds after the initial fit.

          • maxSpans: number

            Positive integer ceiling on fitted cubic spans; exhausting it refuses the affected fit.

          • OptionalphysicalGradientLengthMm?: number

            Optional nonnegative millimetre exchange length multiplying physical derivatives; zero or omission disables that objective term.

          • toleranceMm: number

            Positive finite requested positional discrepancy in millimetres; it is not a continuous-surface certificate.

        • owner: {
              get: (
                  word: readonly string[],
                  pointsMm: readonly (readonly [number, number, number])[],
              ) => {
                  canonicalCurve: IAutoMovieCubicBezierCurve64;
                  canonicalKnots: number[];
                  corners: [string, string];
                  fit: IAutoMovieRecoveryCurveFit;
                  id: string;
                  knots: number[];
                  parameters: number[];
                  reversed: boolean;
              };
              size: () => number;
          }

          Shared boundary registry for this immutable observation pass; its lifetime ends when the caller releases the pass.

          • get: (
                word: readonly string[],
                pointsMm: readonly (readonly [number, number, number])[],
            ) => {
                canonicalCurve: IAutoMovieCubicBezierCurve64;
                canonicalKnots: number[];
                corners: [string, string];
                fit: IAutoMovieRecoveryCurveFit;
                id: string;
                knots: number[];
                parameters: number[];
                reversed: boolean;
            }

            Admits or reuses one complete boundary word; conflicting observations for an existing word throw instead of reusing stale coefficients.

          • size: () => number

            Returns the current registry population without mutating the retained observation state.

      Returns Generator<
          {
              chart: | {
                  boundaries: (
                      {
                          canonicalCurve: IAutoMovieCubicBezierCurve64;
                          canonicalKnots: number[];
                          corners: [string, string];
                          fit: IAutoMovieRecoveryCurveFit;
                          id: string;
                          knots: number[];
                          parameters: number[];
                          reversed: boolean;
                      } & {
                          pieces: {
                              boundary: {
                                  canonicalCurve: IAutoMovieCubicBezierCurve64;
                                  canonicalKnots: (...)[];
                                  corners: [(...), (...)];
                                  fit: IAutoMovieRecoveryCurveFit;
                                  id: string;
                                  knots: (...)[];
                                  parameters: (...)[];
                                  reversed: boolean;
                              };
                              end: number;
                              knots: number[];
                              start: number;
                          }[];
                      }
                  )[];
                  name: string;
                  physicalKeys: string[];
                  sides: [number[], number[], number[], number[]];
                  triangles: [number, number, number][];
                  verticesMm: (readonly [number, number, number])[];
              }
              | null;
              diagnostics: string[];
              fit: | {
                  areaObservation: {
                      integratedAreaMm2: number
                      | null;
                      maximumRelativeAreaDiscrepancy: number | null;
                      quadratureMinimumRows: number;
                      qualified: boolean;
                      reason: string | null;
                      rows: number;
                      sourceAreaMm2: number;
                  };
                  boundary: IAutoMovieRecoveryCurveFit[];
                  continuity: "C0-only";
                  controlsMm: (readonly [number, number, number])[];
                  joint: Omit<IAutoMovieRecoveryChartFit.Result, "controls">;
                  leafLayout: {
                      bindings: {
                          edge: string;
                          end: number;
                          patch: string;
                          side: 0 | 1 | 2 | 3;
                          start: number;
                      }[];
                      edges: {
                          axis: 0
                          | 1;
                          controlIds: [number, number, number, number];
                          end: number;
                          id: string;
                          line: number;
                          start: number;
                      }[];
                      leaves: {
                          bounds: [number, number, number, number];
                          id: string;
                          level: number;
                          root: string;
                      }[];
                  };
                  map: IAutoMovieRecoveryChartMap.Result;
                  partition: { u: number[]; v: number[] };
                  patches: { controlIds: number[]; id: string }[];
                  qualified: boolean;
                  refinement: {
                      areaRmsMm: (number | null)[];
                      attemptedPatches: number[];
                      reason: string;
                      residualsMm: number[];
                      rounds: number;
                  };
              }
              | null;
              name: string;
              networkMaximumPointChangeMm: number;
              reason: string
              | null;
              sharedBoundaryQualified: boolean;
          },
      >