AutoMovie API
    Preparing search index...
    Operation: (
        input: {
            contours: ReturnType<ReturnType<IAutoMovieMeshPlaneCut.Prepare>>;
            coordinateMm: number;
            faceEdges: ReadonlyMap<string, ReadonlySet<number>>;
            name?: string;
            onAcceptedFit?: (
                trace: {
                    contourIndex: number;
                    reversed: boolean;
                    spans: {
                        first: number;
                        last: number;
                        parameters: number[];
                        span: number;
                    }[];
                },
            ) => void;
            onSourceLineage?: (observation: IAutoMovieRecoverySourceLineage) => void;
            orientation: ReturnType<IAutoMovieMeshSectionOrientation.Operation>;
            plane: ReturnType<IAutoMoviePlaneFrameConstruction.Operation>;
            policy: Pick<
                IAutoMovieRecoveryInput,
                "cornerDegrees"
                | "toleranceMm"
                | "maxSpans",
            >;
            vertexFaces: ReadonlyMap<number, ReadonlySet<number>>;
        },
    ) => {
        defects: Set<number>[];
        faces: Set<number>[];
        observations: number;
        report: IAutoMovieRecoveryMeshSections["reports"][number];
        section: IAutoMovieContourLoft64.ISection;
        spans: number;
        supports: Set<number>[];
    }

    Observe and fit every contour on one fixed private section. An optional collection name prefixes curve identities; an optional acquisition observer receives copied original face incidence after local fitting, including rejected contours. Observer exceptions escape the fitting catch.

    Type Declaration

      • (
            input: {
                contours: ReturnType<ReturnType<IAutoMovieMeshPlaneCut.Prepare>>;
                coordinateMm: number;
                faceEdges: ReadonlyMap<string, ReadonlySet<number>>;
                name?: string;
                onAcceptedFit?: (
                    trace: {
                        contourIndex: number;
                        reversed: boolean;
                        spans: {
                            first: number;
                            last: number;
                            parameters: number[];
                            span: number;
                        }[];
                    },
                ) => void;
                onSourceLineage?: (observation: IAutoMovieRecoverySourceLineage) => void;
                orientation: ReturnType<IAutoMovieMeshSectionOrientation.Operation>;
                plane: ReturnType<IAutoMoviePlaneFrameConstruction.Operation>;
                policy: Pick<
                    IAutoMovieRecoveryInput,
                    "cornerDegrees"
                    | "toleranceMm"
                    | "maxSpans",
                >;
                vertexFaces: ReadonlyMap<number, ReadonlySet<number>>;
            },
        ): {
            defects: Set<number>[];
            faces: Set<number>[];
            observations: number;
            report: IAutoMovieRecoveryMeshSections["reports"][number];
            section: IAutoMovieContourLoft64.ISection;
            spans: number;
            supports: Set<number>[];
        }
      • Parameters

        • input: {
              contours: ReturnType<ReturnType<IAutoMovieMeshPlaneCut.Prepare>>;
              coordinateMm: number;
              faceEdges: ReadonlyMap<string, ReadonlySet<number>>;
              name?: string;
              onAcceptedFit?: (
                  trace: {
                      contourIndex: number;
                      reversed: boolean;
                      spans: {
                          first: number;
                          last: number;
                          parameters: number[];
                          span: number;
                      }[];
                  },
              ) => void;
              onSourceLineage?: (observation: IAutoMovieRecoverySourceLineage) => void;
              orientation: ReturnType<IAutoMovieMeshSectionOrientation.Operation>;
              plane: ReturnType<IAutoMoviePlaneFrameConstruction.Operation>;
              policy: Pick<
                  IAutoMovieRecoveryInput,
                  "cornerDegrees"
                  | "toleranceMm"
                  | "maxSpans",
              >;
              vertexFaces: ReadonlyMap<number, ReadonlySet<number>>;
          }
          • contours: ReturnType<ReturnType<IAutoMovieMeshPlaneCut.Prepare>>

            Every raw plane-cut contour, including open paths, contacts and unsupported junction chains.

          • coordinateMm: number

            Signed section-plane coordinate along the registered unit sweep axis, in millimetres.

          • faceEdges: ReadonlyMap<string, ReadonlySet<number>>

            Canonical undirected edge identity to original incident-face set.

          • Optionalname?: string

            Caller-assigned stable semantic identity retained in generated coefficient and observation records.

          • OptionalonAcceptedFit?: (
                trace: {
                    contourIndex: number;
                    reversed: boolean;
                    spans: { first: number; last: number; parameters: number[]; span: number }[];
                },
            ) => void

            Acquisition-only copied accepted trace, delivered outside the fitter failure catch. Observer exceptions escape. Acceptance does not itself imply the original fit met tolerance, and no historical accepted trace is asserted.

          • OptionalonSourceLineage?: (observation: IAutoMovieRecoverySourceLineage) => void

            Optional synchronous acquisition observer; copied records belong to the caller and callback exceptions escape fitting.

          • orientation: ReturnType<IAutoMovieMeshSectionOrientation.Operation>

            Prepared source-material side observer in the registered plane; it supplies no generated normal field.

          • plane: ReturnType<IAutoMoviePlaneFrameConstruction.Operation>

            Registered right-handed cutting frame; positions and scalar levels use its common physical millimetre chart.

          • policy: Pick<IAutoMovieRecoveryInput, "cornerDegrees" | "toleranceMm" | "maxSpans">

            Borrowed explicit fitting thresholds and work bounds; this operation introduces no inferred numerical policy.

          • vertexFaces: ReadonlyMap<number, ReadonlySet<number>>

            Original vertex index to incident original-face set; borrowed for this observation pass.

        Returns {
            defects: Set<number>[];
            faces: Set<number>[];
            observations: number;
            report: IAutoMovieRecoveryMeshSections["reports"][number];
            section: IAutoMovieContourLoft64.ISection;
            spans: number;
            supports: Set<number>[];
        }

        • defects: Set<number>[]

          Original face supports of unsupported open, isolated or unrepresented source contours.

        • faces: Set<number>[]

          Original source-face indices retained as incidence support; these never become generated mesh indices.

        • observations: number

          Actual raw observation population processed by this operation.

        • report: IAutoMovieRecoveryMeshSections["reports"][number]

          This section's coefficient-fit reports and unsupported observations, preserving original contour order.

        • section: IAutoMovieContourLoft64.ISection

          Saved-section ordinal in the input observation sequence.

        • spans: number

          Actual retained cubic-span population, separate from original observation count.

        • supports: Set<number>[]

          Original source-incidence support assigned to the corresponding boundary observations.