AutoMovie API
    Preparing search index...

    Function RecoveryAtlasObservationPublish

    • Fit the completely registered selected domain and publish its canonical assembly and coverage.

      Parameters

      • context: {
            boundaryOwner: {
                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: object[];
            controls: IAutoMovieVector3[];
            encounteredFaces: Set<number>;
            failedSelectedComponents: Set<string>;
            fittedCharts: {
                boundaries: readonly {
                    canonicalCurve: IAutoMovieCubicBezierCurve64;
                    canonicalKnots: number[];
                    corners: [string, string];
                    fit: IAutoMovieRecoveryCurveFit;
                    id: string;
                    knots: number[];
                    parameters: number[];
                    reversed: boolean;
                }[];
                controlsMm: readonly (readonly [number, number, number])[];
                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;
                    }[];
                };
                name: string;
                partition: { u: readonly number[]; v: readonly number[] };
                patches: readonly { controlIds: readonly number[]; id: string }[];
            }[];
            incrementUnsupported: () => void;
            input: IAutoMovieRecoveryAtlasObservationInput;
            inventory: IAutoMovieRecoveryChartInventory[];
            observe: ((record: object) => void) | undefined;
            order: readonly number[];
            patches: { controlIds: number[]; id: string }[];
            pending: IAutoMovieRecoveryPendingChartObservation[];
            privateLedger: object[];
            representedFaces: Set<number>;
            selection: {
                excludedIntervals: number;
                intervals: number[];
                wholeSlabBoundsMm: [number, number] | null;
                windowMm: [number, number] | null;
            };
            sourceNormals: number[][];
            unsupportedCount: () => number;
            visitedComponents: number;
            visitedIntervalIds: number[];
            visitedIntervals: number;
        }
        • boundaryOwner: {
              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;
          }

          One pass-owned boundary registry reused by all charts sharing the same declared incidence words.

          • 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.

        • charts: object[]

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

        • controls: IAutoMovieVector3[]

          Shared coefficient registry or its declared population, addressed by patch control IDs.

        • encounteredFaces: Set<number>

          Original faces encountered in the requested observation population, including refused components.

        • failedSelectedComponents: Set<string>

          Stable identities of selected source components that failed observation or chart preparation.

        • fittedCharts: {
              boundaries: readonly {
                  canonicalCurve: IAutoMovieCubicBezierCurve64;
                  canonicalKnots: number[];
                  corners: [string, string];
                  fit: IAutoMovieRecoveryCurveFit;
                  id: string;
                  knots: number[];
                  parameters: number[];
                  reversed: boolean;
              }[];
              controlsMm: readonly (readonly [number, number, number])[];
              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;
                  }[];
              };
              name: string;
              partition: { u: readonly number[]; v: readonly number[] };
              patches: readonly { controlIds: readonly number[]; id: string }[];
          }[]

          Admitted fitted chart coefficients prepared for the final common-atlas assembly.

        • incrementUnsupported: () => void

          Synchronous accounting callback that records one unsupported component; it supplies no replacement geometry.

        • input: IAutoMovieRecoveryAtlasObservationInput

          Borrowed complete admitted observation request shared by this phase; the phase does not change its source selection.

        • inventory: IAutoMovieRecoveryChartInventory[]

          Unfitted chart population measurements retained independently of later fitting success.

        • observe: ((record: object) => void) | undefined

          Synchronous observation callback; caller-owned work and retained copies are outside the numerical operation's resource bound.

        • order: readonly number[]

          Complete source-plane ordering used for deterministic scalar-interval selection.

        • patches: { controlIds: number[]; id: string }[]

          Bicubic coefficient patches indexed by the shared control registry, with u varying fastest within each v row.

        • pending: IAutoMovieRecoveryPendingChartObservation[]

          Prepared chart jobs awaiting common boundary fitting; their outcome arrays are shared with the observation ledger.

        • privateLedger: object[]

          Acquisition-only diagnostic records retained outside the published source-free coefficient geometry.

        • representedFaces: Set<number>

          Original faces represented by admitted chart observations; tracked separately from encountered faces.

        • selection: {
              excludedIntervals: number;
              intervals: number[];
              wholeSlabBoundsMm: [number, number] | null;
              windowMm: [number, number] | null;
          }

          Admitted scalar interval selection, including explicit excluded-window accounting.

          • excludedIntervals: number

            Number of complete source intervals outside the requested scalar window.

          • intervals: number[]

            Selected adjacent saved-plane interval ordinals in deterministic source order.

          • wholeSlabBoundsMm: [number, number] | null

            Bounds of the full selected slab population in millimetres, or null for an empty selection.

          • windowMm: [number, number] | null

            Requested physical scalar window [lower,upper], or null when no window restricts selection.

        • sourceNormals: number[][]

          Observed original face-normal directions used only for acquisition qualification, never generated-surface fallback.

        • unsupportedCount: () => number

          Returns the current unsupported-component count without consuming or resetting it.

        • visitedComponents: number

          Number of source components actually visited across the selected intervals.

        • visitedIntervalIds: number[]

          Original scalar interval ordinals actually visited in this observation pass.

        • visitedIntervals: number

          Number of requested scalar intervals actually visited.

      Returns IAutoMovieRecoveryAtlasObservation