@itwin/core-geometry 4.1.0-dev.3 → 4.1.0-dev.5

package/lib/esm/curve/LineString3d.js

@@ -18,11 +18,12 @@ import { OffsetOptions } from "./internalContexts/PolygonOffsetContext";
 import { LineSegment3d } from "./LineSegment3d";
 import { StrokeCountMap } from "./Query/StrokeCountMap";
 /* eslint-disable @typescript-eslint/naming-convention, no-empty */
-/* Starting with baseIndex and moving index by stepDirection:
-If the vector from baseIndex to baseIndex +1 crossed with vectorA can be normalized, accumulate it (scaled) to normal.
-Return when successful.
-(Do nothing if everything is parallel through limits of the array)
-*/
+/**
+ * Starting with baseIndex and moving index by stepDirection:
+ * If the vector from baseIndex to baseIndex +1 crossed with vectorA can be normalized, accumulate it (scaled) to normal.
+ * Return when successful.
+ * (Do nothing if everything is parallel through limits of the array)
+ */
 function accumulateGoodUnitPerpendicular(points, vectorA, baseIndex, stepDirection, weight, normal, workVector) {
     const n = points.length;
     if (stepDirection > 0) {
@@ -50,43 +51,67 @@ function accumulateGoodUnitPerpendicular(points, vectorA, baseIndex, stepDirecti
     return false;
 }
 /**
- * * A LineString3d (sometimes called a PolyLine) is a sequence of xyz coordinates that are to be joined by line segments.
- * * The point coordinates are stored in a GrowableXYZArray, not as full point objects
+ * * A LineString3d (sometimes called a PolyLine) is a sequence of xyz coordinates that are to be joined by line
+ * segments.
+ * * The point coordinates are stored in a GrowableXYZArray, not as full point objects.
  * * The parameterization of "fraction along" is
- *    * In a linestring with `N` segments (i.e. `N+1` points), each segment (regardless of physical length) occupies the same fraction (1/N) of the 0-to-1 fraction space.
+ *    * In a linestring with `N` segments (i.e. `N+1` points), each segment (regardless of physical length) occupies
+ * the same fraction (1/N) of the 0-to-1 fraction space.
  *    * Within segment `i`, the fraction interval `i/N` to `(i+1)/N` is mapped proportionally to the segment
  *    * Note that this `fraction` is therefore NOT fraction of true distance along.
- *       * Use `moveSignedDistanceFromFraction` to do true-length evaluations.
+ *    * Use `moveSignedDistanceFromFraction` to do true-length evaluations.
  * @public
  */
 class LineString3d extends CurvePrimitive {
     /** test if `other` is an instance of `LineString3d` */
-    isSameGeometryClass(other) { return other instanceof LineString3d; }
-    /**
-     * A LineString3d extends along its first and final segments.
-     */
-    get isExtensibleFractionSpace() { return true; }
-    /** return the points array (cloned). */
-    get points() { return this._points.getPoint3dArray(); }
+    isSameGeometryClass(other) {
+        return other instanceof LineString3d;
+    }
+    /** A LineString3d extends along its first and final segments. */
+    get isExtensibleFractionSpace() {
+        return true;
+    }
+    /** Return the points array (cloned). */
+    get points() {
+        return this._points.getPoint3dArray();
+    }
     /** Return (reference to) point data in packed GrowableXYZArray. */
-    get packedPoints() { return this._points; }
-    /** Return array of fraction parameters.
+    get packedPoints() {
+        return this._points;
+    }
+    /**
+     * Return array of fraction parameters.
      * * These Are only present during certain constructions such as faceting.
-     * * When present, these fractions are fractions of some other curve being stroked, and are NOT related to the linestring fraction parameters.
+     * * When present, these fractions are fractions of some other curve being stroked, and are NOT related to the
+     * linestring fraction parameters.
      */
-    get fractions() { return this._fractions; }
+    get fractions() {
+        return this._fractions;
+    }
     /** Return the (optional) array of derivatives. These Are only present during certain constructions such as faceting. */
-    get packedDerivatives() { return this._derivatives; }
+    get packedDerivatives() {
+        return this._derivatives;
+    }
     /** Return the (optional) array of uv params. These Are only present during certain constructions such as faceting. */
-    get packedUVParams() { return this._uvParams; }
+    get packedUVParams() {
+        return this._uvParams;
+    }
     /** Return the (optional) array of surface normals. These Are only present during certain constructions such as faceting. */
-    get packedSurfaceNormals() { return this._surfaceNormals; }
+    get packedSurfaceNormals() {
+        return this._surfaceNormals;
+    }
     /** Return the (optional) array of normal indices. These Are only present during certain constructions such as faceting. */
-    get normalIndices() { return this._normalIndices; }
+    get normalIndices() {
+        return this._normalIndices;
+    }
     /** Return the (optional) array of param indices. These Are only present during certain constructions such as faceting. */
-    get paramIndices() { return this._uvIndices; }
+    get paramIndices() {
+        return this._uvIndices;
+    }
     /** Return the (optional) array of point indices. These Are only present during certain constructions such as faceting. */
-    get pointIndices() { return this._pointIndices; }
+    get pointIndices() {
+        return this._pointIndices;
+    }
     constructor(points) {
         super();
         /** String name for schema properties */
@@ -102,7 +127,8 @@ class LineString3d extends CurvePrimitive {
         c.tryTransformInPlace(transform);
         return c;
     }
-    /** Create a linestring, using flex length arg list and any typical combination of points such as
+    /**
+     * Create a linestring, using flex length arg list and any typical combination of points such as
      * Point3d, Point2d, `[1,2,3]', array of any of those, or GrowableXYZArray
      */
     static create(...points) {
@@ -110,7 +136,8 @@ class LineString3d extends CurvePrimitive {
         result.addPoints(points);
         return result;
     }
-    /** Create a linestring, capturing the given GrowableXYZArray as the points.
+    /**
+     * Create a linestring, capturing the given GrowableXYZArray as the points.
      * Point3d, Point2d, `[1,2,3]', array of any of those, or GrowableXYZArray
      */
     static createCapture(points) {
@@ -135,7 +162,8 @@ class LineString3d extends CurvePrimitive {
         }
         return result;
     }
-    /** Add points to the linestring.
+    /**
+     * Add points to the linestring.
      * Valid inputs are:
      * * a Point2d
      * * a point3d
@@ -287,9 +315,7 @@ class LineString3d extends CurvePrimitive {
             this._surfaceNormals = new GrowableXYZArray();
         this._surfaceNormals.push(vector);
     }
-    /**
-     * If the linestring is not already closed, add a closure point.
-     */
+    /** If the linestring is not already closed, add a closure point. */
     addClosurePoint() {
         const distance = this._points.distanceIndexIndex(0, this._points.length - 1);
         if (distance !== undefined && !Geometry.isSameCoordinate(distance, 0))
@@ -303,7 +329,8 @@ class LineString3d extends CurvePrimitive {
     computeUVFromXYZTransform(transform) {
         this._uvParams = GrowableXYArray.createFromGrowableXYZArray(this._points, transform);
     }
-    /** Create the linestring for a rectangle parallel to the xy plane.
+    /**
+     * Create the linestring for a rectangle parallel to the xy plane.
      * * The z coordinate from `point0` is used for all points.
      * * `ax` and `ay` are signed.
      * * The point sequence is:
@@ -334,7 +361,8 @@ class LineString3d extends CurvePrimitive {
      * @param center center of the polygon.
      * @param edgeCount number of edges.
      * @param radius distance to vertex or edge (see `radiusToVertices`)
-     * @param radiusToVertices true if polygon is inscribed in circle (radius measured to vertices); false if polygon is outside circle (radius to edges)
+     * @param radiusToVertices true if polygon is inscribed in circle (radius measured to vertices); false if polygon
+     * is outside circle (radius to edges)
      */
     static createRegularPolygonXY(center, edgeCount, radius, radiusToVertices = true) {
         if (edgeCount < 3)
@@ -416,7 +444,8 @@ class LineString3d extends CurvePrimitive {
         retVal.setFrom(this);
         return retVal;
     }
-    /** Set point coordinates from a json array, e.g. `[[1,2,3],[4,5,6] . . .]`
+    /**
+     * Set point coordinates from a json array, e.g. `[[1,2,3],[4,5,6] . . .]`
      * * The `json` parameter must be an array.
      * * Each member `i` of the array is converted to a point with `Point3d.fromJSON(json[i]`)
      */
@@ -441,7 +470,8 @@ class LineString3d extends CurvePrimitive {
         }
         return value;
     }
-    /** construct a new linestring.
+    /**
+     * Construct a new linestring.
      * * See `LineString3d.setFromJSON ()` for remarks on `json` structure.
      */
     static fromJSON(json) {
@@ -531,7 +561,8 @@ class LineString3d extends CurvePrimitive {
     }
     /**
      * Convert a global fraction to a segment index and local fraction.
-     * @param globalFraction a fraction f in [0,1] in the linestring parameterization, where the i_th segment (0 <= i < N) is parameterized by i/N <= f <= (i+1)/N.
+     * @param globalFraction a fraction f in [0,1] in the linestring parameterization, where the i_th segment
+     * (0 <= i < N) is parameterized by i/N <= f <= (i+1)/N.
      */
     globalFractionToSegmentIndexAndLocalFraction(globalFraction) {
         const numSegment = this._points.length - 1;
@@ -595,7 +626,7 @@ class LineString3d extends CurvePrimitive {
             return Transform.createOriginAndMatrix(origin, matrix, result);
         return Transform.createTranslation(origin, result);
     }
-    /** evaluate the start point of the linestring. */
+    /** Evaluate the start point of the linestring. */
     startPoint() {
         if (this._points.length === 0)
             return Point3d.createZero();
@@ -607,8 +638,7 @@ class LineString3d extends CurvePrimitive {
             return this._points.getPoint3dAtUncheckedPointIndex(i, result);
         return undefined;
     }
-    /** If i and j are both valid indices, return the vector from point i to point j
-     */
+    /** If i and j are both valid indices, return the vector from point i to point j */
     vectorBetween(i, j, result) {
         return this._points.vectorIndexIndex(i, j, result);
     }
@@ -625,8 +655,10 @@ class LineString3d extends CurvePrimitive {
         return undefined;
     }
     /** Return the number of points in this linestring. */
-    numPoints() { return this._points.length; }
-    /** evaluate the end point of the linestring. */
+    numPoints() {
+        return this._points.length;
+    }
+    /** Evaluate the end point of the linestring. */
     endPoint() {
         if (this._points.length === 0)
             return Point3d.createZero();
@@ -650,7 +682,9 @@ class LineString3d extends CurvePrimitive {
         return true;
     }
     /** Sum the lengths of segments within the linestring */
-    curveLength() { return this._points.sumLengths(); }
+    curveLength() {
+        return this._points.sumLengths();
+    }
     /** Sum the lengths of segments between fractional positions on a linestring. */
     curveLengthBetweenFractions(fraction0, fraction1) {
         const numSegments = this._points.length - 1;
@@ -749,10 +783,10 @@ class LineString3d extends CurvePrimitive {
             return CurveLocationDetail.createCurveFractionPointDistanceCurveSearchStatus(this, context.fraction0, context.point0, -context.distance0, context.distanceStatus(), result);
         }
     }
-    /** sum lengths of segments in the linestring.  (This is a true length.) */
+    /** Sum lengths of segments in the linestring.  (This is a true length.) */
     quickLength() { return this.curveLength(); }
     /**
-     * compute and normalize cross product among 3 points on the linestring.
+     * Compute and normalize cross product among 3 points on the linestring.
      * * "any" 3 points are acceptable -- no test for positive overall sense.
      * * This is appropriate for polygon known to be convex.
      * * use points spread at index step n/3, hopefully avoiding colinear points.
@@ -791,7 +825,8 @@ class LineString3d extends CurvePrimitive {
                         if (!extend1 || i < lastIndex)
                             segmentFraction = 1.0;
                     }
-                    this._points.getPoint3dAtUncheckedPointIndex(i - 1).interpolate(segmentFraction, this._points.getPoint3dAtUncheckedPointIndex(i), result.pointQ);
+                    this._points.getPoint3dAtUncheckedPointIndex(i - 1)
+                        .interpolate(segmentFraction, this._points.getPoint3dAtUncheckedPointIndex(i), result.pointQ);
                     d = result.pointQ.distance(spacePoint);
                     if (d < result.a) {
                         result.setFP(this.segmentIndexAndLocalFractionToGlobalFraction(i - 1, segmentFraction), result.pointQ, undefined, d);
@@ -805,8 +840,9 @@ class LineString3d extends CurvePrimitive {
     isInPlane(plane) {
         return this._points.isCloseToPlane(plane, Geometry.smallMetricDistance);
     }
-    /** push a hit, fixing up the prior entry if needed.
-     * return the incremented counter.
+    /**
+     * Push a hit, fixing up the prior entry if needed.
+     * Return the incremented counter.
      */
     static pushVertexHit(result, counter, cp, fraction, point) {
         const detail = CurveLocationDetail.createCurveFractionPoint(cp, fraction, point);
@@ -823,7 +859,8 @@ class LineString3d extends CurvePrimitive {
             detail.setIntervalRole(CurveIntervalRole.intervalEnd);
         }
     }
-    /** find intersections with a plane.
+    /**
+     * Find intersections with a plane.
      *  Intersections within segments are recorded as CurveIntervalRole.isolated
      *   Intersections at isolated "on" vertex are recoded as CurveIntervalRole.isolatedAtVertex.
      */
@@ -860,7 +897,9 @@ class LineString3d extends CurvePrimitive {
         return result.length - initialLength;
     }
     /** Extend `rangeToExtend` to include all points of this linestring. */
-    extendRange(rangeToExtend, transform) { this._points.extendRange(rangeToExtend, transform); }
+    extendRange(rangeToExtend, transform) {
+        this._points.extendRange(rangeToExtend, transform);
+    }
     /** Test if each point of this linestring isAlmostEqual with corresponding point in `other`. */
     isAlmostEqual(other) {
         if (!(other instanceof LineString3d))
@@ -869,7 +908,8 @@ class LineString3d extends CurvePrimitive {
             return false;
         return true;
     }
-    /** Append (clone of) one point.
+    /**
+     * Append (clone of) one point.
      * * BUT ... skip if duplicates the tail of prior points.
      * * if fraction is given, "duplicate" considers both point and fraction.
      */
@@ -889,8 +929,7 @@ class LineString3d extends CurvePrimitive {
                 this.addFraction(fraction);
         }
     }
-    /** Compress out duplicate points (according to point.isAlmostEqual)
-     */
+    /** Compress out duplicate points (according to point.isAlmostEqual) */
     removeDuplicatePoints(tolerance = Geometry.smallMetricDistance) {
         const n = this._points.length;
         if (n < 2)
@@ -913,7 +952,8 @@ class LineString3d extends CurvePrimitive {
         if (this._derivatives)
             this._derivatives.resize(n1);
     }
-    /** Append a suitable evaluation of a curve ..
+    /**
+     * Append a suitable evaluation of a curve ..
      * * always append the curve point
      * * if fraction array is present, append the fraction
      * * if derivative array is present, append the derivative
@@ -936,7 +976,7 @@ class LineString3d extends CurvePrimitive {
         }
     }
     /**
-     * clear all array data:
+     * Clear all array data:
      * * points
      * * optional fractions.
      * * optional derivatives.
@@ -970,7 +1010,8 @@ class LineString3d extends CurvePrimitive {
         }
         return ls;
     }
-    /** Evaluate a curve at uniform fractions.  Append the evaluations to this linestring.
+    /**
+     * Evaluate a curve at uniform fractions.  Append the evaluations to this linestring.
      * @param curve primitive to evaluate.
      * @param numStrokes number of strokes (edges).
      * @param fraction0 starting fraction coordinate
@@ -990,7 +1031,8 @@ class LineString3d extends CurvePrimitive {
                 this.appendFractionToPoint(curve, fraction0 + i * df);
         }
     }
-    /** Append points constructed as interpolation between two points.
+    /**
+     * Append points constructed as interpolation between two points.
      * @param numStrokes number of strokes.
      * @param point0 first point
      * @param point1 last point
@@ -1036,7 +1078,8 @@ class LineString3d extends CurvePrimitive {
             }
         }
     }
-    /** Emit strokable parts of the curve to a caller-supplied handler.
+    /**
+     * Emit strokable parts of the curve to a caller-supplied handler.
      * If the stroke options does not have a maxEdgeLength, one stroke is emitted for each segment of the linestring.
      * If the stroke options has a maxEdgeLength, smaller segments are emitted as needed.
      */
@@ -1063,7 +1106,7 @@ class LineString3d extends CurvePrimitive {
         handler.endCurvePrimitive(this);
     }
     /**
-     * return the stroke count required for given options.
+     * Return the stroke count required for given options.
      * @param options StrokeOptions that determine count
      */
     computeStrokeCountForOptions(options) {
@@ -1102,7 +1145,8 @@ class LineString3d extends CurvePrimitive {
     /**
      * Find intervals of this CurvePrimitive that are interior to a clipper
      * @param clipper clip structure (e.g. clip planes)
-     * @param announce (optional) function to be called announcing fractional intervals"  ` announce(fraction0, fraction1, curvePrimitive)`
+     * @param announce (optional) function to be called announcing fractional intervals"
+     * ` announce(fraction0, fraction1, curvePrimitive)`
      * @returns true if any "in" segments are announced.
      */
     announceClipIntervals(clipper, announce) {
@@ -1146,7 +1190,8 @@ class LineString3d extends CurvePrimitive {
         this._points.interpolate(index, fraction, index + 1, LineString3d._indexPoint);
         dest.push(LineString3d._indexPoint);
     }
-    /** Return a LineString which is a portion of this curve.
+    /**
+     * Return a LineString which is a portion of this curve.
      * * Fractions outside [0,1] extend the relevant end segment.
      * @param fractionA [in] start fraction
      * @param fractionB [in] end fraction
@@ -1206,14 +1251,12 @@ class LineString3d extends CurvePrimitive {
             return LineSegment3d.create(this._points.getPoint3dAtCheckedPointIndex(index), this._points.getPoint3dAtCheckedPointIndex(index + 1));
         return undefined;
     }
-    /**
-     * Returns true if first and last points are within metric tolerance.
-     */
+    /** Returns true if first and last points are within metric tolerance. */
     get isPhysicallyClosed() {
         return this._points.length > 0 && Geometry.isSmallMetricDistance(this._points.distanceIndexIndex(0, this._points.length - 1));
     }
     /**
-     * evaluate strokes at fractions indicated in a StrokeCountMap.
+     * Evaluate strokes at fractions indicated in a StrokeCountMap.
      * * The map must have an array of component counts corresponding to the segment of this linestring.
      * * "fractions" in the output are mapped within a0,a1 of the map.componentData
      * @param map = stroke count data.
@@ -1250,7 +1293,8 @@ class LineString3d extends CurvePrimitive {
         }
         return destLinestring.numPoints() - numPoint0;
     }
-    /** convert variant point data to a single level array of linestrings.
+    /**
+     * Convert variant point data to a single level array of linestrings.
      * * The result is always an array of LineString3d.
      *   * Single linestring is NOT bubbled out as a special case.
      *   * data with no point is an empty array.
@@ -1285,7 +1329,8 @@ class LineString3d extends CurvePrimitive {
     }
     /**
      * Construct an offset of each segment as viewed in the xy-plane (ignoring z).
-     * * No attempt is made to join the offset segments. Use RegionOps.constructCurveXYOffset() to return a fully joined offset.
+     * * No attempt is made to join the offset segments. Use RegionOps.constructCurveXYOffset() to return a fully
+     * joined offset.
      * @param offsetDistanceOrOptions offset distance (positive to left of the instance curve), or options object
      */
     constructOffsetXY(offsetDistanceOrOptions) {
@@ -1302,10 +1347,13 @@ class LineString3d extends CurvePrimitive {
         }
         return offsets;
     }
-    /** Project instance geometry (via dispatch) onto the given ray, and return the extreme fractional parameters of projection.
+    /**
+     * Project instance geometry (via dispatch) onto the given ray, and return the extreme fractional parameters
+     * of projection.
      * @param ray ray onto which the instance is projected. A `Vector3d` is treated as a `Ray3d` with zero origin.
      * @param lowHigh optional receiver for output
-     * @returns range of fractional projection parameters onto the ray, where 0.0 is start of the ray and 1.0 is the end of the ray.
+     * @returns range of fractional projection parameters onto the ray, where 0.0 is start of the ray and 1.0 is
+     * the end of the ray.
      */
     projectedParameterRange(ray, lowHigh) {
         return PlaneAltitudeRangeContext.findExtremeFractionsAlongDirection(this, ray, lowHigh);
@@ -1317,14 +1365,15 @@ LineString3d._workPointC = Point3d.create();
 LineString3d._workRay = Ray3d.createXAxis();
 LineString3d._indexPoint = Point3d.create(); // private point for addResolvedPoint
 export { LineString3d };
-/** An AnnotatedLineString3d is a linestring with additional surface-related data attached to each point
+/**
+ * An AnnotatedLineString3d is a linestring with additional surface-related data attached to each point
  * * This is useful in facet construction.
  * @internal
  */
 export class AnnotatedLineString3d {
 }
 /**
- * context to be called to incrementally accumulate distance along line segments.
+ * Context to be called to incrementally accumulate distance along line segments.
  */
 class MoveByDistanceContext {
     /** CAPTURE point0, fraction0, targetDistance */