AutoMovie API
    Preparing search index...

    Function reconstructAutoMovieRecoveryModel

    • Reconstruct saved cubic and domain coefficients without access to source geometry. Hermite input is converted to the same Bernstein engine coefficients using its saved phase widths; finite arithmetic may round handles. The legacy operator is explicit so another triangulator is not substituted during package migration. Local unsupported incidence remains a partial usable result; strip quality diagnostics do not discard finite geometry or certify smoothness.

      Parameters

      • input:
            | IAutoMovieRecoveryTensorFamiliesInput
            | {
                analyticDomains?: readonly {
                    closedGroups: readonly { group: number; interval: number }[];
                    curveBindings: readonly {
                        authority: string;
                        curveName: string;
                        span: number;
                    }[];
                    geometry: {
                        boundaryAuthorities?: {
                            controlIds: [number, number, number, number];
                            id: string;
                        }[];
                        boundaryBindings?: {
                            authority: string;
                            end: number;
                            normalFan: string;
                            patch: string;
                            side: 0
                            | 1
                            | 2
                            | 3;
                            start: number;
                        }[];
                        cellBudgetPolicy?: "retain-coarse"
                        | "omit-unresolved";
                        controls: { x: number; y: number; z: number }[];
                        maxCells: number;
                        maxVertices: number;
                        patches: { controlIds: number[]; id: string }[];
                        sourceFit?: {
                            diagnostics: string[];
                            maximumResidual: number | null;
                            qualified: boolean;
                            unqualifiedPatches: string[];
                        };
                        tolerance: number;
                        topologyDomain: string;
                        type: "bicubic-atlas";
                    };
                    id: string;
                    observationComplete: boolean;
                    openPairs: readonly { interval: number; pair: number }[];
                    openUnresolved: readonly { group: number; interval: number }[];
                    ports: readonly { curveName: string; side: "lower" | "upper" }[];
                    unrepresentedDomains: readonly string[];
                }[];
                coefficientPublication?: {
                    originalReportsRetained: true;
                    overrides: readonly { curveName: string; dataUpperEstimateMm: number }[];
                    sourceCommit: string;
                };
                coverage?: {
                    complete: false;
                    missingSourceRangeMm: [number, number]
                    | null;
                    observedStationRangeMm: [number, number];
                    plannedSections: number;
                    retainedSections: number;
                    sourceRangeMm: [number, number];
                    unobservedStationRangeMm: [number, number] | null;
                };
                diagnostics: string[];
                loft: {
                    chordToleranceMm: number;
                    events: readonly {
                        after: readonly number[];
                        afterMm: number;
                        before: readonly number[];
                        beforeMm: number;
                        coordinateMm: number;
                        kind: "minimum"
                        | "maximum"
                        | "saddle";
                        name: string;
                        regular: boolean;
                        terminal: readonly [number, number, number] | null;
                    }[];
                    intervals?: readonly {
                        afterMm: number;
                        beforeMm: number;
                        groups: readonly {
                            after: readonly number[];
                            before: readonly number[];
                            reason: string
                            | null;
                            supported: boolean;
                        }[];
                    }[];
                    observeWork?: boolean;
                    sections: readonly {
                        coordinateMm: number;
                        loops: readonly {
                            curve: {
                                closed: boolean;
                                name: string;
                                phaseIntervals: readonly number[];
                                phaseUnit: "mm"
                                | "turn"
                                | "normalized";
                                unit: "mm";
                            } & IAutoMovieRecoveryHermiteCurve;
                            winding: -1
                            | 1;
                        }[];
                    }[];
                };
                policy: {
                    axis: [number, number, number];
                    chordToleranceMm: number;
                    cornerDegrees: number;
                    criticalPolicy?: "legacy-link-cycle-v1" | "boundary-regular-path-v1";
                    exactCoordinateAliases: boolean;
                    maxSections: number;
                    maxSpans: number;
                    reference: [number, number, number];
                    sourceOrientationSign: -1 | 1;
                    stepMm: number;
                    toleranceMm: number;
                };
                reports: {
                    coordinateMm: number;
                    diagnostics: string[];
                    fits: {
                        handleFallbacks: number;
                        observationsPerSpan: number;
                        polylineUpperEstimateMm: number;
                        sampleMaximumMm: number;
                        toleranceMet: boolean;
                    }[];
                    isolatedContactsMm: (readonly [number, number, number])[];
                    open: {
                        curve: {
                            closed: boolean;
                            name: string;
                            phaseIntervals: readonly number[];
                            phaseUnit: "mm" | "turn" | "normalized";
                            unit: "mm";
                        } & IAutoMovieRecoveryHermiteCurve;
                        handleFallbacks: number;
                        observationsPerSpan: number;
                        polylineUpperEstimateMm: number;
                        sampleMaximumMm: number;
                        toleranceMet: boolean;
                    }[];
                }[];
                summary: {
                    aliases: number;
                    events: number;
                    observations: number;
                    sections: number;
                    spans: number;
                };
                tensorFamilies?: readonly {
                    boundaries: readonly {
                        controlIds: readonly (readonly number[])[];
                        curveName: string;
                        phaseIntervals: readonly number[];
                    }[];
                    geometry: {
                        boundaryAuthorities?: {
                            controlIds: [number, number, number, number];
                            id: string;
                        }[];
                        boundaryBindings?: {
                            authority: string;
                            end: number;
                            normalFan: string;
                            patch: string;
                            side: 0
                            | 1
                            | 2
                            | 3;
                            start: number;
                        }[];
                        cellBudgetPolicy?: "retain-coarse"
                        | "omit-unresolved";
                        controls: { x: number; y: number; z: number }[];
                        maxCells: number;
                        maxVertices: number;
                        patches: { controlIds: number[]; id: string }[];
                        sourceFit?: {
                            diagnostics: string[];
                            maximumResidual: number | null;
                            qualified: boolean;
                            unqualifiedPatches: string[];
                        };
                        tolerance: number;
                        topologyDomain: string;
                        type: "bicubic-atlas";
                    };
                    id: string;
                    replacedGroups: readonly { group: number; interval: number }[];
                }[];
                topologyGaps: { afterMm: number; beforeMm: number; reason: string }[];
                unconsumedEvents: {
                    event: {
                        after: readonly number[];
                        afterMm: number;
                        before: readonly number[];
                        beforeMm: number;
                        coordinateMm: number;
                        kind: "minimum" | "maximum" | "saddle";
                        name: string;
                        regular: boolean;
                        terminal: readonly [number, number, number] | null;
                    };
                    reason: string;
                }[];
            }
        • IAutoMovieRecoveryTensorFamiliesInput
        • {
              analyticDomains?: readonly {
                  closedGroups: readonly { group: number; interval: number }[];
                  curveBindings: readonly {
                      authority: string;
                      curveName: string;
                      span: number;
                  }[];
                  geometry: {
                      boundaryAuthorities?: {
                          controlIds: [number, number, number, number];
                          id: string;
                      }[];
                      boundaryBindings?: {
                          authority: string;
                          end: number;
                          normalFan: string;
                          patch: string;
                          side: 0
                          | 1
                          | 2
                          | 3;
                          start: number;
                      }[];
                      cellBudgetPolicy?: "retain-coarse"
                      | "omit-unresolved";
                      controls: { x: number; y: number; z: number }[];
                      maxCells: number;
                      maxVertices: number;
                      patches: { controlIds: number[]; id: string }[];
                      sourceFit?: {
                          diagnostics: string[];
                          maximumResidual: number | null;
                          qualified: boolean;
                          unqualifiedPatches: string[];
                      };
                      tolerance: number;
                      topologyDomain: string;
                      type: "bicubic-atlas";
                  };
                  id: string;
                  observationComplete: boolean;
                  openPairs: readonly { interval: number; pair: number }[];
                  openUnresolved: readonly { group: number; interval: number }[];
                  ports: readonly { curveName: string; side: "lower" | "upper" }[];
                  unrepresentedDomains: readonly string[];
              }[];
              coefficientPublication?: {
                  originalReportsRetained: true;
                  overrides: readonly { curveName: string; dataUpperEstimateMm: number }[];
                  sourceCommit: string;
              };
              coverage?: {
                  complete: false;
                  missingSourceRangeMm: [number, number]
                  | null;
                  observedStationRangeMm: [number, number];
                  plannedSections: number;
                  retainedSections: number;
                  sourceRangeMm: [number, number];
                  unobservedStationRangeMm: [number, number] | null;
              };
              diagnostics: string[];
              loft: {
                  chordToleranceMm: number;
                  events: readonly {
                      after: readonly number[];
                      afterMm: number;
                      before: readonly number[];
                      beforeMm: number;
                      coordinateMm: number;
                      kind: "minimum"
                      | "maximum"
                      | "saddle";
                      name: string;
                      regular: boolean;
                      terminal: readonly [number, number, number] | null;
                  }[];
                  intervals?: readonly {
                      afterMm: number;
                      beforeMm: number;
                      groups: readonly {
                          after: readonly number[];
                          before: readonly number[];
                          reason: string
                          | null;
                          supported: boolean;
                      }[];
                  }[];
                  observeWork?: boolean;
                  sections: readonly {
                      coordinateMm: number;
                      loops: readonly {
                          curve: {
                              closed: boolean;
                              name: string;
                              phaseIntervals: readonly number[];
                              phaseUnit: "mm"
                              | "turn"
                              | "normalized";
                              unit: "mm";
                          } & IAutoMovieRecoveryHermiteCurve;
                          winding: -1
                          | 1;
                      }[];
                  }[];
              };
              policy: {
                  axis: [number, number, number];
                  chordToleranceMm: number;
                  cornerDegrees: number;
                  criticalPolicy?: "legacy-link-cycle-v1" | "boundary-regular-path-v1";
                  exactCoordinateAliases: boolean;
                  maxSections: number;
                  maxSpans: number;
                  reference: [number, number, number];
                  sourceOrientationSign: -1 | 1;
                  stepMm: number;
                  toleranceMm: number;
              };
              reports: {
                  coordinateMm: number;
                  diagnostics: string[];
                  fits: {
                      handleFallbacks: number;
                      observationsPerSpan: number;
                      polylineUpperEstimateMm: number;
                      sampleMaximumMm: number;
                      toleranceMet: boolean;
                  }[];
                  isolatedContactsMm: (readonly [number, number, number])[];
                  open: {
                      curve: {
                          closed: boolean;
                          name: string;
                          phaseIntervals: readonly number[];
                          phaseUnit: "mm" | "turn" | "normalized";
                          unit: "mm";
                      } & IAutoMovieRecoveryHermiteCurve;
                      handleFallbacks: number;
                      observationsPerSpan: number;
                      polylineUpperEstimateMm: number;
                      sampleMaximumMm: number;
                      toleranceMet: boolean;
                  }[];
              }[];
              summary: {
                  aliases: number;
                  events: number;
                  observations: number;
                  sections: number;
                  spans: number;
              };
              tensorFamilies?: readonly {
                  boundaries: readonly {
                      controlIds: readonly (readonly number[])[];
                      curveName: string;
                      phaseIntervals: readonly number[];
                  }[];
                  geometry: {
                      boundaryAuthorities?: {
                          controlIds: [number, number, number, number];
                          id: string;
                      }[];
                      boundaryBindings?: {
                          authority: string;
                          end: number;
                          normalFan: string;
                          patch: string;
                          side: 0
                          | 1
                          | 2
                          | 3;
                          start: number;
                      }[];
                      cellBudgetPolicy?: "retain-coarse"
                      | "omit-unresolved";
                      controls: { x: number; y: number; z: number }[];
                      maxCells: number;
                      maxVertices: number;
                      patches: { controlIds: number[]; id: string }[];
                      sourceFit?: {
                          diagnostics: string[];
                          maximumResidual: number | null;
                          qualified: boolean;
                          unqualifiedPatches: string[];
                      };
                      tolerance: number;
                      topologyDomain: string;
                      type: "bicubic-atlas";
                  };
                  id: string;
                  replacedGroups: readonly { group: number; interval: number }[];
              }[];
              topologyGaps: { afterMm: number; beforeMm: number; reason: string }[];
              unconsumedEvents: {
                  event: {
                      after: readonly number[];
                      afterMm: number;
                      before: readonly number[];
                      beforeMm: number;
                      coordinateMm: number;
                      kind: "minimum" | "maximum" | "saddle";
                      name: string;
                      regular: boolean;
                      terminal: readonly [number, number, number] | null;
                  };
                  reason: string;
              }[];
          }
          • OptionalanalyticDomains?: readonly {
                closedGroups: readonly { group: number; interval: number }[];
                curveBindings: readonly {
                    authority: string;
                    curveName: string;
                    span: number;
                }[];
                geometry: {
                    boundaryAuthorities?: {
                        controlIds: [number, number, number, number];
                        id: string;
                    }[];
                    boundaryBindings?: {
                        authority: string;
                        end: number;
                        normalFan: string;
                        patch: string;
                        side: 0
                        | 1
                        | 2
                        | 3;
                        start: number;
                    }[];
                    cellBudgetPolicy?: "retain-coarse"
                    | "omit-unresolved";
                    controls: { x: number; y: number; z: number }[];
                    maxCells: number;
                    maxVertices: number;
                    patches: { controlIds: number[]; id: string }[];
                    sourceFit?: {
                        diagnostics: string[];
                        maximumResidual: number | null;
                        qualified: boolean;
                        unqualifiedPatches: string[];
                    };
                    tolerance: number;
                    topologyDomain: string;
                    type: "bicubic-atlas";
                };
                id: string;
                observationComplete: boolean;
                openPairs: readonly { interval: number; pair: number }[];
                openUnresolved: readonly { group: number; interval: number }[];
                ports: readonly { curveName: string; side: "lower" | "upper" }[];
                unrepresentedDomains: readonly string[];
            }[]

            Optional analytic owners; absence leaves the ordinary saved contour and open operators responsible.

          • OptionalcoefficientPublication?: {
                originalReportsRetained: true;
                overrides: readonly { curveName: string; dataUpperEstimateMm: number }[];
                sourceCommit: string;
            }

            Optional coefficient-override provenance; original observation reports are retained.

            • originalReportsRetained: true

              Confirms that the original reports remain attached rather than being rewritten for the overrides.

            • overrides: readonly { curveName: string; dataUpperEstimateMm: number }[]

              Per-curve numerical estimates belonging to the override publication.

            • sourceCommit: string

              Producer source revision for this coefficient publication.

          • Optionalcoverage?: {
                complete: false;
                missingSourceRangeMm: [number, number] | null;
                observedStationRangeMm: [number, number];
                plannedSections: number;
                retainedSections: number;
                sourceRangeMm: [number, number];
                unobservedStationRangeMm: [number, number] | null;
            }

            Present only for an incomplete automatic station-prefix checkpoint.

            • complete: false

              This checkpoint is incomplete; omission of the enclosing record indicates full extraction.

            • missingSourceRangeMm: [number, number] | null

              Source extent outside observed coverage in millimetres, or null when no extent is missing.

            • observedStationRangeMm: [number, number]

              Physical range of retained section stations, millimetres.

            • plannedSections: number

              Number of sections planned for the full automatic extraction.

            • retainedSections: number

              Number of sections retained in this checkpoint.

            • sourceRangeMm: [number, number]

              Full source extent along the slicing axis, millimetres.

            • unobservedStationRangeMm: [number, number] | null

              Unobserved planned-station range in millimetres, or null when no planned stations remain.

          • diagnostics: string[]

            Unresolved events, flat plateaus and numerical source issues.

          • loft: {
                chordToleranceMm: number;
                events: readonly {
                    after: readonly number[];
                    afterMm: number;
                    before: readonly number[];
                    beforeMm: number;
                    coordinateMm: number;
                    kind: "minimum" | "maximum" | "saddle";
                    name: string;
                    regular: boolean;
                    terminal: readonly [number, number, number] | null;
                }[];
                intervals?: readonly {
                    afterMm: number;
                    beforeMm: number;
                    groups: readonly {
                        after: readonly number[];
                        before: readonly number[];
                        reason: string
                        | null;
                        supported: boolean;
                    }[];
                }[];
                observeWork?: boolean;
                sections: readonly {
                    coordinateMm: number;
                    loops: readonly {
                        curve: {
                            closed: boolean;
                            name: string;
                            phaseIntervals: readonly number[];
                            phaseUnit: "mm"
                            | "turn"
                            | "normalized";
                            unit: "mm";
                        } & IAutoMovieRecoveryHermiteCurve;
                        winding: -1
                        | 1;
                    }[];
                }[];
            }

            Engine loft contract with the retained physical section coefficients.

            • chordToleranceMm: number

              Positive chord-error tolerance for cubic tessellation, millimetres; not a surface-error bound.

            • events: readonly {
                  after: readonly number[];
                  afterMm: number;
                  before: readonly number[];
                  beforeMm: number;
                  coordinateMm: number;
                  kind: "minimum" | "maximum" | "saddle";
                  name: string;
                  regular: boolean;
                  terminal: readonly [number, number, number] | null;
              }[]

              Explicit topology relationships with incident loops on both sides of each critical level.

            • Optionalintervals?: readonly {
                  afterMm: number;
                  beforeMm: number;
                  groups: readonly {
                      after: readonly number[];
                      before: readonly number[];
                      reason: string | null;
                      supported: boolean;
                  }[];
              }[]

              Optional complete adjacency partition. When supplied, every adjacent saved-section pair and every loop must occur exactly once; no nearest continuation fills missing relationships.

            • OptionalobserveWork?: boolean

              Explicitly measure strip-search elapsed time; omitted or false leaves elapsedMs null. Mesh and qualification arithmetic do not depend on this observation.

            • sections: readonly {
                  coordinateMm: number;
                  loops: readonly {
                      curve: {
                          closed: boolean;
                          name: string;
                          phaseIntervals: readonly number[];
                          phaseUnit: "mm" | "turn" | "normalized";
                          unit: "mm";
                      } & IAutoMovieRecoveryHermiteCurve;
                      winding: -1
                      | 1;
                  }[];
              }[]

              Ordered physical section coordinates and their oriented closed curves.

          • policy: {
                axis: [number, number, number];
                chordToleranceMm: number;
                cornerDegrees: number;
                criticalPolicy?: "legacy-link-cycle-v1" | "boundary-regular-path-v1";
                exactCoordinateAliases: boolean;
                maxSections: number;
                maxSpans: number;
                reference: [number, number, number];
                sourceOrientationSign: -1 | 1;
                stepMm: number;
                toleranceMm: number;
            }

            Extraction policy without the source vertex and triangle arrays.

            • axis: [number, number, number]

              Sweep direction normalized once; coordinates use its unit projection in millimetres.

            • chordToleranceMm: number

              Positive cubic tessellation chord tolerance, millimetres; not a surface bound.

            • cornerDegrees: number

              Operational turn angle for automatic C0 corners, degrees in (0,180).

            • OptionalcriticalPolicy?: "legacy-link-cycle-v1" | "boundary-regular-path-v1"

              Explicit PL critical classifier; omission preserves the legacy closed-link policy.

            • exactCoordinateAliases: boolean

              Exact equal-position aliases establish incidence without moving positions.

            • maxSections: number

              Maximum station population; exhaustion rejects rather than drops cuts.

            • maxSpans: number

              Maximum fitted spans per observed curve.

            • reference: [number, number, number]

              Nonparallel frame reference used by the existing right-handed plane-frame operator.

            • sourceOrientationSign: -1 | 1

              Registered face material-side sign; mixed shells are not repaired by global volume.

            • stepMm: number

              Positive nominal station spacing, millimetres; every resolvable critical bracket is added.

            • toleranceMm: number

              Positive complete-polyline fitting tolerance, millimetres.

          • reports: {
                coordinateMm: number;
                diagnostics: string[];
                fits: {
                    handleFallbacks: number;
                    observationsPerSpan: number;
                    polylineUpperEstimateMm: number;
                    sampleMaximumMm: number;
                    toleranceMet: boolean;
                }[];
                isolatedContactsMm: (readonly [number, number, number])[];
                open: {
                    curve: {
                        closed: boolean;
                        name: string;
                        phaseIntervals: readonly number[];
                        phaseUnit: "mm" | "turn" | "normalized";
                        unit: "mm";
                    } & IAutoMovieRecoveryHermiteCurve;
                    handleFallbacks: number;
                    observationsPerSpan: number;
                    polylineUpperEstimateMm: number;
                    sampleMaximumMm: number;
                    toleranceMet: boolean;
                }[];
            }[]

            Same-order section reports, including open fitted arcs and tolerance status.

          • summary: {
                aliases: number;
                events: number;
                observations: number;
                sections: number;
                spans: number;
            }

            Counts of observations, coefficients and topology declarations.

            • aliases: number

              Number of exact source-position aliases retained by extraction.

            • events: number

              Number of declared reconstruction events.

            • observations: number

              Number of physical observations supplied to curve fitting.

            • sections: number

              Number of retained physical sections.

            • spans: number

              Total emitted cubic span count.

          • OptionaltensorFamilies?: readonly {
                boundaries: readonly {
                    controlIds: readonly (readonly number[])[];
                    curveName: string;
                    phaseIntervals: readonly number[];
                }[];
                geometry: {
                    boundaryAuthorities?: {
                        controlIds: [number, number, number, number];
                        id: string;
                    }[];
                    boundaryBindings?: {
                        authority: string;
                        end: number;
                        normalFan: string;
                        patch: string;
                        side: 0
                        | 1
                        | 2
                        | 3;
                        start: number;
                    }[];
                    cellBudgetPolicy?: "retain-coarse"
                    | "omit-unresolved";
                    controls: { x: number; y: number; z: number }[];
                    maxCells: number;
                    maxVertices: number;
                    patches: { controlIds: number[]; id: string }[];
                    sourceFit?: {
                        diagnostics: string[];
                        maximumResidual: number | null;
                        qualified: boolean;
                        unqualifiedPatches: string[];
                    };
                    tolerance: number;
                    topologyDomain: string;
                    type: "bicubic-atlas";
                };
                id: string;
                replacedGroups: readonly { group: number; interval: number }[];
            }[]

            Optional tensor owners; absence retains the existing curve-only and analytic-domain paths.

          • topologyGaps: { afterMm: number; beforeMm: number; reason: string }[]

            Unsupported physical intervals that reconstruction must leave open.

          • unconsumedEvents: {
                event: {
                    after: readonly number[];
                    afterMm: number;
                    before: readonly number[];
                    beforeMm: number;
                    coordinateMm: number;
                    kind: "minimum" | "maximum" | "saddle";
                    name: string;
                    regular: boolean;
                    terminal: readonly [number, number, number] | null;
                };
                reason: string;
            }[]

            Source events that have no consumable incident closed curve.

      • options: IAutoMovieRecoveryOptions = {}

      Returns IAutoMovieRecoveryResult<IAutoMovieRecoveryReconstructedModel>