@itwin/core-geometry 4.7.0-dev.6 → 4.7.0-dev.8

package/lib/cjs/polyface/PolyfaceQuery.d.ts

@@ -26,61 +26,69 @@ import { RangeLengthData } from "./RangeLengthData";
  * @public
  */
 export declare class SweepLineStringToFacetsOptions {
-    /** vector "towards the eye"
-     * * In the common case of sweeping to an XY (e.g. ground or DTM) mesh,
-     *    use the positive Z vector as an up vector.
+    /**
+     * Vector towards the eye.
+     * * In the common case of sweeping to an XY (e.g., ground or DTM) mesh, use the positive Z vector as an up vector.
      * * In general case, this is a vector from the mesh towards an eye at infinity.
      */
     vectorToEye: Vector3d;
-    /** true to collect edges from facets that face towards the eye */
+    /** True to collect edges from facets that face towards the eye. */
     collectOnForwardFacets: boolean;
-    /** true to collect facets that are "on the side", i.e. their outward vector is perpendicular to vectorToEye. */
+    /** True to collect facets that are "on the side", i.e., their outward vector is perpendicular to vectorToEye. */
     collectOnSideFacets: boolean;
-    /** true to collect facets that face away from the eye */
+    /** True to collect facets that face away from the eye. */
     collectOnRearFacets: boolean;
-    /** (small) angle to use as tolerance for deciding if a facet is "on the side".  Default (if given in degrees) is Geometry.smallAngleDegrees */
+    /**
+     * (Small) angle to use as tolerance for deciding if a facet is "on the side".
+     * * Default (if given in degrees) is `Geometry.smallAngleDegrees`.
+     */
     sideAngle: Angle;
-    /** option to assemble lines into chains */
+    /** Option to assemble lines into chains. */
     assembleChains: boolean;
-    /** constructor -- captures fully-checked parameters from static create method.
-    */
+    /** Constructor. Captures fully-checked parameters from static create method. */
     private constructor();
-    /** Create an options structure.
-     * * Default vectorToEye is positive Z
-     * * Default sideAngle has radians value Geometry.smallAngleRadians
-     * * Default assembleChains is true
-     * * Default collectOnForwardFacets, collectOnSideFacets, collectOnRearFacets are all true.
+    /**
+     * Create an options structure.
+     * * Default `vectorToEye` is (0,0,1).
+     * * Default `sideAngle` is `Geometry.smallAngleRadians`.
+     * * Default `assembleChains` is `true`.
+     * * Default `collectOnForwardFacets`, `collectOnSideFacets`, `collectOnRearFacets` are all `true`.
      */
     static create(vectorToEye?: Vector3d, sideAngle?: Angle, assembleChains?: boolean, collectOnForwardFacets?: boolean, collectOnSideFacets?: boolean, collectOnRearFacets?: boolean): SweepLineStringToFacetsOptions;
-    /** Return true if all outputs are requested */
+    /** Return `true` if all outputs are requested. */
     get collectAll(): boolean;
-    /** Decide if the instance flags accept this facet.
-     * * Facets whose facet normal have positive, zero, or negative dot product with the vectorToEye are forward, side, and rear.
-     * * Undefined facet normal returns false
+    /**
+     * Decide if the instance collector flags accept a facet with the given normal.
+     * * A facet whose facet normal has a positive, zero, or negative dot product with `vectorToEye` is classified
+     * as forward, side, or rear, respectively.
+     * * `undefined` facet normal returns `false`.
     */
     collectFromThisFacetNormal(facetNormal: Vector3d | undefined): boolean;
 }
 /**
- * Options carrier for [[fillSimpleHoles]]
+ * Options carrier for [[PolyfaceQuery.fillSimpleHoles]].
  * @public
  */
 export interface HoleFillOptions {
-    /** REJECT hole candidates if its boundary chain is longer than this limit. */
+    /** Reject hole candidates if its boundary chain is longer than this limit. */
     maxPerimeter?: number;
-    /** REJECT hole candidates if they have more than this number of edges */
+    /** Reject hole candidates if they have more than this number of edges. */
     maxEdgesAroundHole?: number;
-    /** REJECT hole candidates if their orientation is not COUNTERCLOCKWISE around this vector.
-     * * For instance, use an upward Z vector for a DTM whose facets face upward.  This suppresses incorrectly treating the outer boundary as a hole.
+    /**
+     * Reject hole candidates if their orientation is not COUNTERCLOCKWISE around this vector.
+     * * For instance, use an upward Z vector for a DTM whose facets face upward. This suppresses incorrectly
+     * treating the outer boundary as a hole.
      */
     upVector?: Vector3d;
-    /** requests that all content from the original mesh be copied to the mesh with filled holes. */
+    /** Requests that all content from the original mesh be copied to the mesh with filled holes. */
     includeOriginalMesh?: boolean;
 }
-/**  Selective output options for PolyfaceQuery.cloneOffset:
-*  * undefined means the usual facets in the expected offset mesh.
-*  * if present as a json object, the various booleans select respective outputs.
-*  * @public
-*/
+/**
+ * Selective output options for [[PolyfaceQuery.cloneOffset]]:
+ * * `undefined` means the usual facets in the expected offset mesh.
+ * * If present as a json object, the various booleans select respective outputs.
+ * * @public
+ */
 export interface OffsetMeshSelectiveOutputOptions {
     outputOffsetsFromFacesBeforeChamfers?: boolean;
     outputOffsetsFromFaces?: boolean;
@@ -90,212 +98,252 @@ export interface OffsetMeshSelectiveOutputOptions {
 /**
  * Options carrier for [[PolyfaceQuery.cloneOffset]].
  * * Default options are strongly recommended.
- * * The option most likely to be changed is chamferTurnAngle
+ * * The option most likely to be changed is `chamferAngleBetweenNormals`.
  * @public
  */
 export declare class OffsetMeshOptions {
-    /** max angle between normals to be considered smooth */
+    /** Max angle between normals to be considered smooth. */
     smoothSingleAngleBetweenNormals: Angle;
-    /** max accumulation of angle between normals to be considered smooth */
+    /** Max accumulation of angle between normals to be considered smooth. */
     smoothAccumulatedAngleBetweenNormals: Angle;
-    /** When crossing an edge, this turn angle (typically 120 degrees) triggers a chamfer */
+    /**
+     * When facets meet and the turn angle (i.e., angle between facet normals) is larger than
+     * `chamferTurnAngleBetweenNormals`, a chamfer edge may be added to prevent offset mesh from having
+     *  facets that extend out too far away from the source mesh.
+     */
     chamferAngleBetweenNormals: Angle;
-    /** optional control structure for selective output.
-     * * If undefined, output all expected offset facets.
+    /**
+     * Optional control structure for selective output.
+     * * If `undefined`, output all expected offset facets.
      */
     outputSelector?: OffsetMeshSelectiveOutputOptions;
-    /** Constructor -- CAPTURE parameters ... */
+    /** Constructor -- CAPTURE parameters. */
     private constructor();
-    /** construct and return an OffsetMeshOptions with given parameters.
+    /**
+     * Construct and return an `OffsetMeshOptions` with given parameters.
      * * Angles are forced to minimum values.
      * * Clones of the angles are given to the constructor.
-     * @param smoothSingleRadiansBetweenNormals an angle larger than this (between facets) is considered a sharp edge
-     * @param smoothAccumulatedAngleBetweenNormals angles that sum to this much may be consolidated for average normal
-     * @param chamferTurnAngleBetweenNormals when facets meet with larger angle, a chamfer edge may be added if the angle between facet normals is larger than this.
+     * @param smoothSingleRadiansBetweenNormals an angle larger than this (between facets) is considered a sharp edge.
+     * Default value is `25` degrees.
+     * @param smoothAccumulatedAngleBetweenNormals angles that sum to this much may be consolidated for average normal.
+     * Default value is `60` degrees.
+     * @param chamferTurnAngleBetweenNormals when facets meet and the turn angle (i.e., angle between facet normals)
+     * is larger than `chamferTurnAngleBetweenNormals`, a chamfer edge may be added to prevent offset mesh from having
+     * facets that extend out too far away from the source mesh. Default value is `120` degrees.
      */
     static create(smoothSingleAngleBetweenNormals?: Angle, smoothAccumulatedAngleBetweenNormals?: Angle, chamferTurnAngleBetweenNormals?: Angle): OffsetMeshOptions;
 }
 /**
- * Structure to return multiple results from volume between facets and plane
+ * Structure to return multiple results from volume between facets and plane.
  * @public
  */
 export interface FacetProjectedVolumeSums {
-    /** Summed (signed) volume */
+    /** Summed (signed) volume. */
     volume: number;
-    /** summed area moments for positive contributions */
+    /** Summed area moments for positive contributions. */
     positiveProjectedFacetAreaMoments?: MomentData;
-    /** summed area moments for negative contributions */
+    /** Summed area moments for negative contributions. */
     negativeProjectedFacetAreaMoments?: MomentData;
 }
 /**
- * Enumeration of cases for retaining facets among duplicates
+ * Enumeration of cases for retaining facets among duplicates.
  * @public
  */
 export declare enum DuplicateFacetClusterSelector {
-    /** retain none of the duplicates */
+    /** Retain none of the duplicates. */
     SelectNone = 0,
-    /** retain any one member among duplicates */
+    /** Retain any one member among duplicates. */
     SelectAny = 1,
-    /** retain all members among duplicates */
+    /** Retain all members among duplicates. */
     SelectAll = 2,
-    /** retain one from any cluster with an odd number of faces */
+    /** Retain one from any cluster with an odd number of faces. */
     SelectOneByParity = 3
 }
-/** PolyfaceQuery is a static class whose methods implement queries on a polyface or polyface visitor provided as a parameter to each method.
+/**
+ * PolyfaceQuery is a static class whose methods implement queries on a `Polyface` or `PolyfaceVisitor` provided as a
+ * parameter to each method.
  * @public
  */
 export declare class PolyfaceQuery {
-    /** copy the points from a visitor into a Linestring3d in a Loop object */
+    /** Copy the points from a visitor into a linestring loop. */
     static visitorToLoop(visitor: PolyfaceVisitor): Loop;
     /** Create a linestring loop for each facet of the polyface. */
     static indexedPolyfaceToLoops(polyface: Polyface): BagOfCurves;
-    /** Return the sum of all facet areas.
-     * @param vectorToEye compute sum of *signed* facet areas projected to a view plane perpendicular to this vector
-    */
+    /**
+     * Sum all facet areas.
+     * @param source polyface or visitor.
+     * @param vectorToEye compute sum of (signed) facet areas projected to a view plane perpendicular to `vectorToEye`.
+     * If `vectorToEye` is not provided, actual facet areas are calculated (without any projection).
+     * @returns the sum of all facet areas. Return 0 if `source` is `undefined`.
+     */
     static sumFacetAreas(source: Polyface | PolyfaceVisitor | undefined, vectorToEye?: Vector3d): number;
-    /** sum volumes of tetrahedra from origin to all facets.
-     * * if origin is omitted, the first point encountered (by the visitor) is used as origin.
+    /**
+     * Sum volumes of tetrahedra from origin to all facets.
+     * * If origin is `undefined`, the first point encountered (by the visitor) is used as origin.
      * * If the mesh is closed, this sum is the volume.
-     * * If the mesh is not closed, this sum is the volume of a mesh with various additional facets
-     * from the origin to facets.
-    */
+     * * If the mesh is not closed, this sum is the volume of a mesh with various additional facets from the origin
+     * to facets.
+     */
     static sumTetrahedralVolumes(source: Polyface | PolyfaceVisitor, origin?: Point3d): number;
-    /** sum (signed) volumes between facets and a plane.
+    /**
+     * Sum (signed) volumes between facets and a plane.
      * Return a structure with multiple sums:
      * * volume = the sum of (signed) volumes between facets and the plane.
-     * * positiveAreaMomentData, negativeProjectedFacetAreaMoments = moment data with centroid, area, and second moments with respect to the centroid.
-     *
-    */
+     * * positiveProjectedFacetAreaMoments, negativeProjectedFacetAreaMoments = moment data with centroid, area, and second
+     * moments with respect to the centroid.
+     */
     static sumVolumeBetweenFacetsAndPlane(source: Polyface | PolyfaceVisitor, plane: Plane3dByOriginAndUnitNormal): FacetProjectedVolumeSums;
-    /** Return the inertia products [xx,xy,xz,xw, yw, etc] integrated over all all facets, as viewed from origin. */
+    /** Return the inertia products [xx,xy,xz,xw,yw, etc] integrated over all all facets as viewed from origin. */
     static sumFacetSecondAreaMomentProducts(source: Polyface | PolyfaceVisitor, origin: Point3d): Matrix4d;
-    /** Return the inertia products [xx,xy,xz,xw, yw, etc] integrated over all tetrahedral volumes from origin */
+    /** Return the inertia products [xx,xy,xz,xw,yw, etc] integrated over all tetrahedral volumes from origin. */
     static sumFacetSecondVolumeMomentProducts(source: Polyface | PolyfaceVisitor, origin: Point3d): Matrix4d;
-    /** Compute area moments for the mesh. In the returned MomentData:
-     * * origin is the centroid.
-     * * localToWorldMap has the origin and principal directions
-     * * radiiOfGyration radii for rotation around the x,y,z axes.
+    /**
+     * Compute area moments for the mesh. In the returned `MomentData`:
+     * * `origin` is the centroid.
+     * * `localToWorldMap` has the origin and principal directions.
+     * * `radiiOfGyration` radii for rotation around the x,y,z axes.
      */
     static computePrincipalAreaMoments(source: Polyface): MomentData | undefined;
-    /** Compute area moments for the mesh. In the returned MomentData:
-     * * origin is the centroid.
-     * * localToWorldMap has the origin and principal directions
-     * * radiiOfGyration radii for rotation around the x,y,z axes.
+    /**
+     * Compute area moments for the mesh. In the returned MomentData:
+     * * `origin` is the centroid.
+     * * `localToWorldMap` has the origin and principal directions.
+     * * `radiiOfGyration` radii for rotation around the x,y,z axes.
      * * The result is only valid if the mesh is closed.
-     * * There is no test for closure.  Use `PolyfaceQuery.isPolyfaceClosedByEdgePairing(polyface)` to test for closure.
+     * * There is no test for closure. Use `PolyfaceQuery.isPolyfaceClosedByEdgePairing(polyface)` to test for closure.
      */
     static computePrincipalVolumeMoments(source: Polyface): MomentData | undefined;
-    /** Determine whether all facets are convex.
-     * @param source mesh to examine
+    /**
+     * Determine whether all facets are convex.
+     * @param source polyface or visitor.
+     * @returns `true` if all facets are convex; `false` otherwise.
      */
     static areFacetsConvex(source: Polyface | PolyfaceVisitor): boolean;
     /**
      * Test for convex volume by dihedral angle tests on all edges.
-     * * This tests if all dihedral angles are positive.
-     * * In a closed solid, this is a strong test for overall convexity.
-     * * With `ignoreBoundaries` true, this may be a useful test when all the facets are in a single edge-connected component, such as a pyramid with no underside.
+     * * This tests if all dihedral angles of the mesh are positive.
+     * * In a closed solid, this is a strong test for overall mesh convexity with outward facing normals.
+     * * See [[dihedralAngleSummary]] for the definition of "dihedral angle".
+     * * With `ignoreBoundaries` true, this may be a useful test when all the facets are in a single edge-connected
+     * component, such as a pyramid with no underside.
      * * It is not a correct test if there are multiple, disjoint components.
-     *   * Take the above-mentioned pyramid with no underside.
-     *   * Within the same mesh, have a second pyramid placed to the side, still facing upward.
-     *   * The angles will pass the dihedral convexity test, but the composite thing surely is not convex.
-     * @param source mesh to examine
-     * @param ignoreBoundaries if true, ignore simple boundary edges, i.e. allow unclosed meshes.
-     * @returns true if the mesh is closed and has all dihedral angles (angle across edge) positive
+     * * Take the above-mentioned pyramid with no underside.
+     * * Within the same mesh, have a second pyramid placed to the side, still facing upward.
+     * * The angles will pass the dihedral convexity test, but the composite thing surely is not convex.
+     * @param source mesh.
+     * @param ignoreBoundaries if `true` ignore simple boundary edges, i.e., allow unclosed meshes. Default is `false`.
+     * @returns true if all dihedral angles of the mesh are positive.
      */
     static isConvexByDihedralAngleCount(source: Polyface, ignoreBoundaries?: boolean): boolean;
     /**
     * Compute a number summarizing the dihedral angles in the mesh.
-    * @see [[isConvexByDihedralAngleCount]] for comments about ignoreBoundaries===true when there are multiple connected components.
-    * @param source mesh to examine
-    * @param ignoreBoundaries if true, ignore simple boundary edges, i.e. allow unclosed meshes.
-    * @returns a number summarizing the dihedral angles in the mesh.
-    *   * Return 1 if all angles are positive or planar.  The mesh is probably convex with outward normals.
-    *   * Return -1 if all angles are negative or planar.  The mesh is probably convex with inward normals.
-    *   * Return 0 if
-    *     * angles area mixed
-    *     * any edge has other than 1 incident facet or more than 2 incident facets.
-    *     * (but null edges are permitted -- These occur naturally at edges of quads at north or south pole)
+    * * A dihedral angle is the signed angle between adjacent facets' normals. This angle is positive when the cross
+    * product `normalA x normalB` has the same direction as facetA's traversal of the facets' shared edge.
+    * @param source mesh.
+    * @param ignoreBoundaries if `true` ignore simple boundary edges, i.e., allow unclosed meshes. Default is `false`.
+    * See [[isConvexByDihedralAngleCount]] for comments about passing true when there are multiple
+    * connected components.
+    * * Return `0` if all dihedral angles are zero (and `ignoreBoundaries === true`). The mesh is planar.
+    * * Otherwise, return `1` if all dihedral angles are non-negative. The mesh probably encloses a convex volume and
+    * has outward normals.
+    * * Otherwise, return `-1` if all dihedral angles are non-positive. The mesh probably encloses a convex volume and
+    * has inward normals.
+    * * Otherwise, return `-2`. Also return `-2` if a non-manifold condition was detected, or a facet normal could not
+    * be computed. A non-manifold condition is a positive-length edge adjacent to more than 2 facets or (if
+    * `ignoreBoundaries` is false) adjacent to exactly one facet.
     */
     static dihedralAngleSummary(source: Polyface, ignoreBoundaries?: boolean): number;
-    /**
-     * Test if the facets in `source` occur in perfectly mated pairs, as is required for a closed manifold volume.
-     */
+    /** Test if the facets in `source` occur in perfectly mated pairs, as is required for a closed manifold volume. */
     static isPolyfaceClosedByEdgePairing(source: Polyface): boolean;
-    /** Test edges pairing in `source` mesh.
-     * * for `allowSimpleBoundaries === false` true return means this is a closed 2-manifold surface
-     * * for `allowSimpleBoundaries === true` true means this is a 2-manifold surface which may have boundary, but is still properly matched internally.
-     * * Any edge with 3 or more incident facets triggers `false` return.
-     * * Any edge with 2 incident facets in the same direction triggers a `false` return.
+    /**
+     * Test edges pairing in `source` mesh.
+     * * For `allowSimpleBoundaries === false` true return means this is a closed 2-manifold surface.
+     * * For `allowSimpleBoundaries === true` true means this is a 2-manifold surface which may have boundary, but is
+     * still properly matched internally.
+     * * Any edge with 3 or more adjacent facets triggers `false` return.
+     * * Any edge with 2 adjacent facets in the same direction triggers a `false` return.
     */
     static isPolyfaceManifold(source: Polyface, allowSimpleBoundaries?: boolean): boolean;
     /**
-     * construct a CurveCollection containing boundary edges.
-     *   * each edge is a LineSegment3d
-     * @param source polyface or visitor
-     * @param includeTypical true to in include typical boundary edges with a single incident facet
-     * @param includeMismatch true to include edges with more than 2 incident facets
+     * Construct a CurveCollection containing boundary edges.
+     * * Each edge is a LineSegment3d.
+     * @param source polyface or visitor.
+     * @param includeTypical true to in include typical boundary edges with a single adjacent facet.
+     * @param includeMismatch true to include edges with more than 2 adjacent facets.
      * @param includeNull true to include edges with identical start and end vertex indices.
      */
     static boundaryEdges(source: Polyface | PolyfaceVisitor | undefined, includeTypical?: boolean, includeMismatch?: boolean, includeNull?: boolean): CurveCollection | undefined;
     /**
      * Collect boundary edges.
      * * Return the edges as the simplest collection of chains of line segments.
-     * @param source facets
-     * @param includeTypical true to in include typical boundary edges with a single incident facet
-     * @param includeMismatch true to include edges with more than 2 incident facets
+     * @param source polyface or visitor.
+     * @param includeTypical true to in include typical boundary edges with a single adjacent facet.
+     * @param includeMismatch true to include edges with more than 2 adjacent facets.
      * @param includeNull true to include edges with identical start and end vertex indices.
      */
     static collectBoundaryEdges(source: Polyface | PolyfaceVisitor, includeTypical?: boolean, includeMismatch?: boolean, includeNull?: boolean): AnyChain | undefined;
     /**
      * Test if the facets in `source` occur in perfectly mated pairs, as is required for a closed manifold volume.
      * If not, extract the boundary edges as lines.
-     * @param source polyface or visitor
-     * @param announceEdge function to be called with each boundary edge. The announcement is start and end points, start and end indices, and facet index.
-     * @param includeTypical true to announce typical boundary edges with a single incident facet
-     * @param includeMismatch true to announce edges with more than 2 incident facets
+     * @param source polyface or visitor.
+     * @param announceEdge function to be called with each boundary edge. The announcement is start and end points,
+     * start and end indices, and facet index.
+     * @param includeTypical true to announce typical boundary edges with a single adjacent facet.
+     * @param includeMismatch true to announce edges with more than 2 adjacent facets.
      * @param includeNull true to announce edges with identical start and end vertex indices.
      */
     static announceBoundaryEdges(source: Polyface | PolyfaceVisitor | undefined, announceEdge: (pointA: Point3d, pointB: Point3d, indexA: number, indexB: number, facetIndex: number) => void, includeTypical?: boolean, includeMismatch?: boolean, includeNull?: boolean): void;
     /**
-     * Invoke the callback on each manifold edge whose adjacent facet normals form vectorToEye dot products with opposite sign.
+     * Load all half edges from a mesh to an IndexedEdgeMatcher.
+     * @param polyface a mesh or a visitor assumed to have numWrap === 1.
+    */
+    static createIndexedEdges(polyface: Polyface | PolyfaceVisitor): IndexedEdgeMatcher;
+    /**
+     * Invoke the callback on each manifold edge whose adjacent facet normals form vectorToEye dot products
+     * with opposite sign.
      * * The callback is not called on boundary edges.
-     * @param source facets
-     * @param announce callback function invoked on manifold silhouette edges
-     * @param vectorToEye normal of plane in which to compute silhouette edges
-     * @param sideAngle angular tolerance for perpendicularity test
+     * @param source polyface or visitor.
+     * @param announce callback function invoked on manifold silhouette edges.
+     * @param vectorToEye normal of plane in which to compute silhouette edges.
+     * @param sideAngle angular tolerance for perpendicularity test.
      */
     static announceSilhouetteEdges(source: Polyface | PolyfaceVisitor, announce: (pointA: Point3d, pointB: Point3d, vertexIndexA: number, vertexIndexB: number, facetIndex: number) => void, vectorToEye: Vector3d, sideAngle?: Angle): void;
     /**
      * Collect manifold edges whose adjacent facet normals form vectorToEye dot products with opposite sign.
      * * Does not return boundary edges.
      * * Return the edges as chains of line segments.
-     * @param source facets
-     * @param vectorToEye normal of plane in which to compute silhouette edges
-     * @param sideAngle angular tolerance for perpendicularity test
+     * @param source polyface or visitor.
+     * @param vectorToEye normal of plane in which to compute silhouette edges.
+     * @param sideAngle angular tolerance for perpendicularity test.
      */
     static collectSilhouetteEdges(source: Polyface | PolyfaceVisitor, vectorToEye: Vector3d, sideAngle?: Angle): AnyChain | undefined;
-    /** Find segments (within the linestring) which project to facets.
+    /**
+     * Find segments (within the linestring) which project to facets.
      * * Announce each pair of linestring segment and on-facet segment through a callback.
      * * Facets are ASSUMED to be convex and planar, and not overlap in the z direction.
      */
     static announceSweepLinestringToConvexPolyfaceXY(linestringPoints: GrowableXYZArray, polyface: Polyface, announce: AnnounceDrapePanel): any;
-    /** Execute context.projectToPolygon until its work estimates accumulate to workLimit  */
-    private static continueAnnounceSweepLinestringToConvexPolyfaceXY;
     private static _asyncWorkLimit;
-    /** Set the limit on work during an async time blocks, and return the old value.
+    /**
+     * Set the limit on work during an async time blocks, and return the old value.
      * * This should be a large number -- default is 1.0e6
      * @internal
      */
     static setAsyncWorkLimit(value: number): number;
-    /** Query the current limit on work during an async time block.
+    /**
+     * Query the current limit on work during an async time block.
      * @internal
      */
     static get asyncWorkLimit(): number;
-    /** Number of "await" steps executed in recent async calls.
+    /**
+     * Number of "await" steps executed in recent async calls.
      * @internal
      */
     static awaitBlockCount: number;
-    /** Find segments (within the linestring) which project to facets.
+    /** Execute `context.projectToPolygon` until its work estimates accumulate to workLimit.  */
+    private static continueAnnounceSweepLinestringToConvexPolyfaceXY;
+    /**
+     * Find segments (within the linestring) which project to facets.
      * * Announce each pair of linestring segment and on-facet segment through a callback.
      * * Facets are ASSUMED to be convex and planar, and not overlap in the z direction.
      * * REMARK: Although this is public, the usual use is via slightly higher level public methods, viz:
@@ -303,44 +351,44 @@ export declare class PolyfaceQuery {
      * @internal
      */
     static asyncAnnounceSweepLinestringToConvexPolyfaceXY(linestringPoints: GrowableXYZArray, polyface: Polyface, announce: AnnounceDrapePanel): Promise<number>;
-    /** Search the facets for facet subsets that are connected with at least vertex contact.
+    /**
+     * Search the facets for facet subsets that are connected with at least vertex contact.
      * * Return array of arrays of facet indices.
      */
     static partitionFacetIndicesByVertexConnectedComponent(polyface: Polyface | PolyfaceVisitor): number[][];
     /**
      * * Examine the normal orientation for each faces.
      * * Separate to 3 partitions:
-     *    * facets with normal in the positive direction of the vectorToEye (partition 0)
-     *    * facets with normal in the negative direction of the vectorToEye (partition 1)
-     *    * facets nearly perpendicular to the view vector  (partition 2)
+     *    * Facets with normal in the positive direction of the vectorToEye (partition 0).
+     *    * Facets with normal in the negative direction of the vectorToEye (partition 1).
+     *    * Facets nearly perpendicular to the view vector  (partition 2).
      * * Return array of arrays of facet indices.
      */
     static partitionFacetIndicesByVisibilityVector(polyface: Polyface | PolyfaceVisitor, vectorToEye: Vector3d, sideAngleTolerance: Angle): number[][];
     /**
      * Return the boundary of facets that are facing the eye.
-     * @param polyface
+     * @param polyface the indexed polyface
      * @param visibilitySubset selector among the visible facet sets extracted by partitionFacetIndicesByVisibilityVector
      *   * 0 ==> forward facing
      *   * 1 ==> rear facing
      *   * 2 ==> side facing
-     * @param vectorToEye
-     * @param sideAngleTolerance
+     * @param vectorToEye the vector to eye
+     * @param sideAngleTolerance the tolerance of side angle
      */
     static boundaryOfVisibleSubset(polyface: IndexedPolyface, visibilitySelect: 0 | 1 | 2, vectorToEye: Vector3d, sideAngleTolerance?: Angle): CurveCollection | undefined;
     /**
-     * Search for edges with only 1 incident facet.
-     * * chain them into loops
-     * * emit the loops to the announceLoop function
-     * @param mesh
+     * Search for edges with only 1 adjacent facet.
+     * * Chain them into loops.
+     * * Emit the loops to the announceLoop function.
      */
     static announceBoundaryChainsAsLineString3d(mesh: Polyface | PolyfaceVisitor, announceLoop: (points: LineString3d) => void): void;
     /**
      * Return a mesh with
      *  * clusters of adjacent, coplanar facets merged into larger facets.
      *  * other facets included unchanged.
-     * @param mesh existing mesh or visitor
-     * @param maxSmoothEdgeAngle maximum dihedral angle across an edge between facets deemed coplanar. If undefined, uses `Geometry.smallAngleRadians`.
-     * @returns
+     * @param mesh existing mesh or visitor.
+     * @param maxSmoothEdgeAngle maximum dihedral angle across an edge between facets deemed coplanar. If undefined,
+     * uses `Geometry.smallAngleRadians`.
      */
     static cloneWithMaximalPlanarFacets(mesh: Polyface | PolyfaceVisitor, maxSmoothEdgeAngle?: Angle): IndexedPolyface | undefined;
     /**
@@ -349,50 +397,49 @@ export declare class PolyfaceQuery {
      *  * Unclosed chains are rejected.
      *  * Closed chains are triangulated and returned as a mesh.
      *  * The options structure enforces restrictions on how complicated the hole filling can be:
-     *     * maxEdgesAroundHole -- holes with more edges are skipped
+     *     * maxEdgesAroundHole -- holes with more edges are skipped.
      *     * maxPerimeter -- holes with larger summed edge lengths are skipped.
      *     * upVector -- holes that do not have positive area along this view are skipped.
-     *     * includeOriginalMesh -- includes the original mesh in the output mesh, so the composite mesh is a clone with holes filled
-     * @param mesh existing mesh
+     *     * includeOriginalMesh -- includes the original mesh in the output mesh, so the composite mesh is a
+     * clone with holes filled.
+     * @param mesh existing mesh.
      * @param options options controlling the hole fill.
      * @param unfilledChains optional array to receive the points around holes that were not filled.
-     * @returns
      */
     static fillSimpleHoles(mesh: Polyface | PolyfaceVisitor, options: HoleFillOptions, unfilledChains?: LineString3d[]): IndexedPolyface | undefined;
-    /** Clone the facets in each partition to a separate polyface.
-   *
-   */
+    /** Clone the facets in each partition to a separate polyface. */
     static clonePartitions(polyface: Polyface | PolyfaceVisitor, partitions: number[][]): Polyface[];
-    /** Clone facets that pass a filter function */
+    /** Clone facets that pass a filter function. */
     static cloneFiltered(source: Polyface | PolyfaceVisitor, filter: (visitor: PolyfaceVisitor) => boolean): IndexedPolyface;
     /** Clone the facets with in-facet dangling edges removed. */
     static cloneWithDanglingEdgesRemoved(source: Polyface | PolyfaceVisitor): IndexedPolyface;
-    /** If the visitor's client is a polyface, simply return its point array length.
-     * If not a polyface, visit all facets to find the largest index.
-     */
-    static visitorClientPointCount(visitor: Polyface | PolyfaceVisitor): number;
-    /** If the visitor's client is a polyface, simply return its facet count.
-     * If not a polyface, visit all facets to accumulate a count.
-     */
-    static visitorClientFacetCount(visitor: Polyface | PolyfaceVisitor): number;
-    /** Partition the facet set into connected components such that two adjacent facets are in the same component if and only if they are adjacent across a clustered edge.
+    /** Return the point count of the `source`. */
+    static visitorClientPointCount(source: Polyface | PolyfaceVisitor): number;
+    /** Return the facet count of the `source`. */
+    static visitorClientFacetCount(source: Polyface | PolyfaceVisitor): number;
+    /**
+     * Partition the facet set into connected components such that two adjacent facets are in the same component if and
+     * only if they are adjacent across a clustered edge.
      * @param edgeClusters sorted and clustered edges (cf. `IndexedEdgeMatcher.sortAndCollectClusters`).
      * @param numFacets facet count in the parent mesh. In particular, `edge.facetIndex < numFacets` for every input edge.
-     * @return collection of facet index arrays, one array per connected component
+     * @return collection of facet index arrays, one array per connected component.
      */
     private static partitionFacetIndicesBySortableEdgeClusters;
-    /** Partition the facet set into connected components. Each facet in a given component shares an edge only with other facets in the component (or is a boundary edge).
-     * @param polyface facets to partition
-     * @param stopAtVisibleEdges whether to further split connected components by visible edges of the polyface
-     * @return collection of facet index arrays, one per connected component
+    /**
+     * Partition the facet set into connected components. Each facet in a given component shares an edge only with
+     * other facets in the component (or is a boundary edge).
+     * @param polyface facets to partition.
+     * @param stopAtVisibleEdges whether to further split connected components by visible edges of the polyface.
+     * @return collection of facet index arrays, one per connected component.
      */
     static partitionFacetIndicesByEdgeConnectedComponent(polyface: Polyface | PolyfaceVisitor, stopAtVisibleEdges?: boolean): number[][];
-    /** Find segments (within the line string) which project to facets.
+    /**
+     * Find segments (within the line string) which project to facets.
      * * Assemble each input segment paired with its projected segment/point as a quad/triangle facet in a new polyface.
      * * Input facets are ASSUMED to be convex and planar, and not overlap in the z direction.
      */
     static sweepLineStringToFacetsXYReturnSweptFacets(lineStringPoints: GrowableXYZArray, polyface: Polyface): Polyface;
-    /** @deprecated in 4.x. Use sweepLineStringToFacetsXYReturnSweptFacets instead. */
+    /** @deprecated in 4.x. Use [[sweepLineStringToFacetsXYReturnSweptFacets]] instead. */
     static sweepLinestringToFacetsXYreturnSweptFacets(linestringPoints: GrowableXYZArray, polyface: Polyface): Polyface;
     /**
      * Sweep the line string to intersections with a mesh.
@@ -404,9 +451,9 @@ export declare class PolyfaceQuery {
     static sweepLineStringToFacets(linestringPoints: GrowableXYZArray, polyfaceOrVisitor: Polyface | PolyfaceVisitor, options?: SweepLineStringToFacetsOptions): LinearCurvePrimitive[];
     /**
      * Sweep the line string in the z-direction to intersections with a mesh, using a search object for speedup.
-     * @param lineStringPoints input line string to drape on the mesh
-     * @param polyfaceOrVisitor mesh, or mesh visitor to traverse only part of a mesh
-     * @param searchByReadIndex object for searching facet 2D ranges tagged by mesh read index
+     * @param lineStringPoints input line string to drape on the mesh.
+     * @param polyfaceOrVisitor mesh, or mesh visitor to traverse only part of a mesh.
+     * @param searchByReadIndex object for searching facet 2D ranges tagged by mesh read index.
      * @example Using a 5x5 indexed search grid:
      * ```
      * const xyRange = Range2d.createFrom(myPolyface.range());
@@ -416,160 +463,157 @@ export declare class PolyfaceQuery {
      * }
      * const drapedLineStrings = PolyfaceQuery.sweepLineStringToFacetsXY(lineString, myPolyface, searcher);
      * ```
-     * @returns collected line strings
+     * @returns the collected line strings.
      */
     static sweepLineStringToFacetsXY(lineStringPoints: GrowableXYZArray | Point3d[], polyfaceOrVisitor: Polyface | PolyfaceVisitor, searchByReadIndex: Range2dSearchInterface<number>): LineString3d[];
-    /** Find segments (within the linestring) which project to facets.
+    /**
+     * Find segments (within the linestring) which project to facets.
       * * Return collected line segments.
       * * This calls [[sweepLineStringToFacets]] with options created by
-      *   `const options = SweepLineStringToFacetsOptions.create(Vector3d.unitZ(), Angle.createSmallAngle(),false, true, true, true);`
-      * @deprecated in 4.x. Use [[sweepLineStringToFacets]] to get further options.
+      *   `const options = SweepLineStringToFacetsOptions.create(Vector3d.unitZ(), Angle.createSmallAngle(), false, true, true, true);`
+      * @deprecated in 4.x. Use [[PolyfaceQuery.sweepLineStringToFacets]] to get further options.
       */
     static sweepLinestringToFacetsXYReturnLines(linestringPoints: GrowableXYZArray, polyface: Polyface): LineSegment3d[];
-    /** Find segments (within the linestring) which project to facets.
+    /**
+     * Find segments (within the linestring) which project to facets.
      * * Return chains.
      * * This calls [[sweepLineStringToFacets]] with options created by
      *   `const options = SweepLineStringToFacetsOptions.create(Vector3d.unitZ(), Angle.createSmallAngle(),true, true, true, true);`
-     * @deprecated in 4.x. Use [[sweepLineStringToFacets]] to get further options.
+     * @deprecated in 4.x. Use [[PolyfaceQuery.sweepLineStringToFacets]] to get further options.
      */
     static sweepLinestringToFacetsXYReturnChains(linestringPoints: GrowableXYZArray, polyface: Polyface): LineString3d[];
-    /** Find segments (within the linestring) which project to facets.
+    /**
+     * Find segments (within the linestring) which project to facets.
      * * This is done as a sequence of "await" steps.
-     * * Each "await" step deals with approximately PolyfaceQuery.asyncWorkLimit pairings of (linestring edge) with (facet edge)
-     * * PolyfaceQuery.setAsyncWorkLimit() to change work blocks from default
+     * * Each "await" step deals with approximately PolyfaceQuery.asyncWorkLimit pairings of "linestring edge"
+     * with "facet edge".
+     * * PolyfaceQuery.setAsyncWorkLimit() to change work blocks from default.
      * * Return chains.
      * * Facets are ASSUMED to be convex and planar, and not overlap in the z direction.
      */
     static asyncSweepLinestringToFacetsXYReturnChains(linestringPoints: GrowableXYZArray, polyface: Polyface): Promise<LineString3d[]>;
     /**
-     * * Examine ranges of facets.
+     * Examine ranges of facets.
      * * Return statistical summary of x,y,z ranges.
      */
     static collectRangeLengthData(polyface: Polyface | PolyfaceVisitor): RangeLengthData;
-    /** Clone the facets, inserting vertices (within edges) where points not part of each facet's vertex indices impinge within edges.
-     *
+    /**
+     * Clone the facets, inserting vertices (within edges) where points not part of each facet's vertex indices
+     * impinge within edges.
      */
     static cloneWithTVertexFixup(polyface: Polyface): IndexedPolyface;
     /**
+     * Compare index arrays formatted as follows. Return 0 if arrays are the same.
      * * Each array input structure is: [facetIndex, vertexIndex0, vertexIndex1, ....]
-     * * Vertex indices assumed reversed so it
-     *   * vertexIndex0 is the lowest index on the facet
-     *   * vertexIndex1 is the lowest neighbor of vertex0
+     * * Vertex indices assumed reversed so:
+     *   * vertexIndex0 is the lowest index on the facet.
+     *   * vertexIndex1 is the lowest neighbor of vertex0.
      *   * first different entry among vertex indices determines lexical result.
-     *   * Hence facets with duplicate indices (whether forward or reversed) are considered equal.
-     * @param arrayA
-     * @param arrayB
+     *   * hence facets with duplicate indices (whether forward or reversed) are considered equal.
      */
     private static compareFacetIndexAndVertexIndices;
     /**
-     * * Return an array of arrays describing facet duplication.
+     * Collect facet duplicates.
+     * @param polyface the polyface.
      * @param includeSingletons if true, non-duplicated facets are included in the output.
-     * * Each array `entry` in the output contains read indices of a cluster of facets with the same vertex indices.
+     * @returns an array of arrays describing facet duplication. Each array `entry` in the output contains read
+     * indices of a cluster of facets with the same vertex indices.
      */
     static collectDuplicateFacetIndices(polyface: Polyface, includeSingletons?: boolean): number[][];
     /**
-     * * Return an array of arrays describing facet duplication.
-     * @param includeSingletons if true, non-duplicated facets are included in the output.
-     * * Each array `entry` in the output contains read indices of a cluster of facets with the same vertex indices.
+     * Announce facet duplicates.
+     * @returns an array of arrays describing facet duplication. Each array `entry` in the output contains read
+     * indices of a cluster of facets with the same vertex indices.
      */
     static announceDuplicateFacetIndices(polyface: Polyface, announceCluster: (clusterFacetIndices: number[]) => void): void;
-    /** Return a new facet set with a subset of facets in source
+    /**
+     * Return a new facet set with a subset of facets in polyface.
+     * @param source the polyface.
      * @param includeSingletons true to copy facets that only appear once
-     * @param clusterSelector indicates whether duplicate clusters are to have 0, 1, or all facets included
+     * @param clusterSelector indicates whether duplicate clusters are to have 0, 1, or all facets included.
      */
     static cloneByFacetDuplication(source: Polyface, includeSingletons: boolean, clusterSelector: DuplicateFacetClusterSelector): Polyface;
-    /** Clone the facets, inserting removing points that are simply within colinear edges.
-     *
-     */
+    /** Clone the facets, removing points that are simply within colinear edges. */
     static cloneWithColinearEdgeFixup(polyface: Polyface): Polyface;
     /**
      * Set the edge visibility for specified edges in the polyface.
-     * @param polyface mesh to be edited
-     * @param clusters array of edge references
-     * @param value visibility value (true or false)
+     * @param polyface mesh to be edited.
+     * @param clusters array of edge references.
+     * @param value visibility value (true or false).
      */
     private static setEdgeVisibility;
     /**
      * Set the visibility of a particular edge of a particular facet.
-     * @param polyface containing polyface
-     * @param facetIndex facet index
-     * @param vertexIndex vertex index (in vertex array) at which the edge starts
+     * @param polyface containing polyface.
+     * @param facetIndex facet index.
+     * @param vertexIndex vertex index (in vertex array) at which the edge starts.
      * @param value visibility value.
      */
     static setSingleEdgeVisibility(polyface: IndexedPolyface, facetIndex: number, vertexIndex: number, value: boolean): void;
     /**
      * Get the visibility of a particular edge of a particular facet.
-     * @param polyface containing polyface
-     * @param facetIndex facet index
-     * @param vertexIndex vertex index (in vertex array) at which the edge starts
+     * @param polyface containing polyface.
+     * @param facetIndex facet index.
+     * @param vertexIndex vertex index (in vertex array) at which the edge starts.
      */
     static getSingleEdgeVisibility(polyface: IndexedPolyface, facetIndex: number, vertexIndex: number): boolean | undefined;
-    /** Load all half edges from a mesh to an IndexedEdgeMatcher.
-     * @param polyface a mesh, or a visitor assumed to have numWrap === 1
-    */
-    static createIndexedEdges(polyface: Polyface | PolyfaceVisitor): IndexedEdgeMatcher;
     /**
      * Return manifold edge pairs whose dihedral angle is bounded by the given angle.
      * * The dihedral angle of a manifold edge is measured between the normals of its two adjacent faces.
      * * Boundary edges are not returned as they are not manifold.
-     * @param mesh existing polyface or visitor
-     * @param maxSmoothEdgeAngle maximum dihedral angle of a smooth edge. If undefined, uses `Geometry.smallAngleRadians`.
-     * @param sharpEdges true to reverse the angle threshold test and return sharp edges; otherwise return smooth edges (default)
+     * @param mesh existing polyface or visitor.
+     * @param maxSmoothEdgeAngle maximum dihedral angle of a smooth edge. If `undefined`, uses `Geometry.smallAngleRadians`.
+     * @param sharpEdges true to reverse the angle threshold test and return sharp edges; otherwise return smooth edges (default).
      */
     static collectEdgesByDihedralAngle(mesh: Polyface | PolyfaceVisitor, maxSmoothEdgeAngle?: Angle, sharpEdges?: boolean): SortableEdgeCluster[];
     /**
+     * Make paired edges invisible.
     * * Find mated pairs among facet edges.
     * * Mated pairs have the same vertex indices appearing in opposite order.
     * * Mark all non-mated pairs visible.
     * * At mated pairs
     *    * if angle across the edge is larger than `sharpEdgeAngle`, mark visible
     *    * otherwise mark invisible.
-    * @param mesh mesh to be marked
     */
     static markPairedEdgesInvisible(mesh: IndexedPolyface, sharpEdgeAngle?: Angle): void;
-    /** Try to compute a unit normal for a facet accessible through a visitor.
+    /**
+     * Try to compute a unit normal for a facet accessible through a visitor.
      * * Unit normal is computed by `PolygonOps.unitNormal` with the points around the facet.
      */
     static computeFacetUnitNormal(visitor: PolyfaceVisitor, facetIndex: number, result?: Vector3d): Vector3d | undefined;
     /**
-    * * Mark all edge visibilities in the IndexedPolyface
-    * @param mesh mesh to be marked
-    * @param value true for visible, false for hidden
-    */
+     * * Mark all edge visibilities in the IndexedPolyface.
+     * @param mesh mesh to be marked.
+     * @param value true for visible, false for hidden.
+     */
     static markAllEdgeVisibility(mesh: IndexedPolyface, value: boolean): void;
     /**
-     * Create a HalfEdgeGraph with a face for each facet of the IndexedPolyface
-     * @param mesh mesh to convert
+     * Create a HalfEdgeGraph with a face for each facet of the IndexedPolyface.
+     * @param mesh mesh to convert.
      * @internal
      */
     static convertToHalfEdgeGraph(mesh: IndexedPolyface): HalfEdgeGraph;
-    /**
-     * * Examine adjacent facet orientations throughout the mesh
-     * * If possible, reverse a subset to achieve proper pairing.
-     * @param mesh
-     */
+    /** Examine adjacent facet orientations throughout the mesh. If possible, reverse a subset to achieve proper pairing. */
     static reorientVertexOrderAroundFacetsForConsistentOrientation(mesh: IndexedPolyface): boolean;
-    /**
-     * Set up indexed normals with one normal in the plane of each facet of the mesh.
-     * @param polyface
-     */
+    /** Set up indexed normals with one normal in the plane of each facet of the mesh. */
     static buildPerFaceNormals(polyface: IndexedPolyface): void;
     /**
-    * * At each vertex of the mesh
-    *   * Find clusters of almost parallel normals
-    *   * Compute simple average of those normals
-    *   * Index to the averages
+    * * At each vertex of the mesh:
+    *   * Find clusters of almost parallel normals.
+    *   * Compute simple average of those normals.
+    *   * Index to the averages.
     * * For typical meshes, this correctly clusters adjacent normals.
-    * * One can imagine a vertex with multiple "smooth cone-like" sets of incident facets such that averaging occurs among two nonadjacent cones.  But this does not seem to be a problem in practice.
+    * * One can imagine a vertex with multiple "smooth cone-like" sets of adjacent facets such that averaging occurs
+    * among two nonadjacent cones. But this does not seem to be a problem in practice.
     * @param polyface polyface to update.
     * @param toleranceAngle averaging is done between normals up to this angle.
     */
     static buildAverageNormals(polyface: IndexedPolyface, toleranceAngle?: Angle): void;
     /**
      * Offset the faces of the mesh.
-     * @param source original mesh
+     * @param source original mesh.
      * @param signedOffsetDistance distance to offset
-     * @param offsetOptions angle options.  The default options are recommended.
+     * @param offsetOptions angle options. The default options are recommended.
      * @returns shifted mesh.
      */
     static cloneOffset(source: IndexedPolyface, signedOffsetDistance: number, offsetOptions?: OffsetMeshOptions): IndexedPolyface;
@@ -579,28 +623,35 @@ export declare class PolyfaceQuery {
     private static _workFacetDetail3?;
     private static _workFacetDetailC?;
     private static _workFacetDetailNC?;
-    /** Search facets for the first one that intersects the infinite line.
-     * * To process _all_ intersections, callers can supply an `options.acceptIntersection` callback that always returns false.
-     * In this case, `intersectRay3d` will return undefined, but the callback will be invoked for each intersection.
+    /**
+     * Search facets for the first one that intersects the infinite line.
+     * * To process _all_ intersections, callers can supply an `options.acceptIntersection` callback that always
+     * returns `false`.
+     * In this case, `intersectRay3d` will return `undefined`, but the callback will be invoked for each intersection.
      * * Example callback logic:
      *    * Accept the first found facet that intersects the half-line specified by the ray: `return detail.a >= 0.0;`
-     *    * Collect all intersections: `myIntersections.push(detail.clone()); return false;` Then after `intersectRay3d` returns, sort along `ray` with `myIntersections.sort((d0, d1) => d0.a - d1.a);`
-     * @param visitor facet iterator
-     * @param ray infinite line parameterized as a ray. The returned `detail.a` is the intersection parameter on the ray, e.g., zero at `ray.origin` and increasing in `ray.direction`.
-     * @param options options for computing and populating an intersection detail, and an optional callback for accepting one
-     * @return detail for the (accepted) intersection with `detail.IsInsideOrOn === true`, or `undefined` if no (accepted) intersection
+     *    * Collect all intersections: `myIntersections.push(detail.clone()); return false;` Then after `intersectRay3d`
+     * returns, sort along `ray` with `myIntersections.sort((d0, d1) => d0.a - d1.a);`
+     * @param visitor facet iterator.
+     * @param ray infinite line parameterized as a ray. The returned `detail.a` is the intersection parameter on the
+     * ray, e.g., zero at `ray.origin` and increasing in `ray.direction`.
+     * @param options options for computing and populating an intersection detail, and an optional callback for
+     * accepting one.
+     * @return detail for the (accepted) intersection with `detail.IsInsideOrOn === true`, or `undefined` if no
+     * (accepted) intersection.
      * @see PolygonOps.intersectRay3d
     */
     static intersectRay3d(visitor: Polyface | PolyfaceVisitor, ray: Ray3d, options?: FacetIntersectOptions): FacetLocationDetail | undefined;
 }
-/** Announce the points on a drape panel.
+/**
+ * Announce the points on a drape panel.
  * * The first two points in the array are always along the draped line segment.
  * * The last two are always on the facet.
  * * If there are 4 points, those two pairs are distinct, i.e. both segment points are to the same side of the facet.
  * * If there are 3 points, those two pairs share an on-facet point.
  * * The panel is ordered so the outward normal is to the right of the draped segment.
- * @param indexAOnFacet index (in points) of the point that is the first facet point for moving forward along the linestring
- * @param indexBOnFacet index (in points) of the point that is the second facet point for moving forward along the linestring
+ * @param indexAOnFacet index (in points) of the point that is the first facet point for moving forward along the linestring.
+ * @param indexBOnFacet index (in points) of the point that is the second facet point for moving forward along the linestring.
  * @public
  */
 export type AnnounceDrapePanel = (linestring: GrowableXYZArray, segmentIndex: number, polyface: Polyface, facetIndex: number, points: Point3d[], indexAOnFacet: number, indexBOnFacet: number) => any;