@itwin/core-geometry 5.5.0-dev.4 → 5.5.0-dev.6

package/lib/esm/geometry3d/PolygonOps.js

@@ -143,7 +143,7 @@ export class PolygonLocationDetailPair {
 export class CutLoop {
     /* All points of the loop */
     xyz;
-    /* ray within point of "on" edge */
+    /* ray within edge generated by clip */
     edge;
     sortCoordinate0;
     sortCoordinate1;
@@ -162,8 +162,11 @@ export class CutLoop {
      */
     static createCaptureWithReturnEdge(xyz) {
         const result = new CutLoop(xyz);
-        if (xyz.length >= 2)
-            result.edge = Ray3d.createStartEnd(xyz.front(), xyz.back());
+        if (xyz.length >= 2) {
+            const firstPoint = xyz.getPoint3dAtUncheckedPointIndex(0);
+            const lastPoint = xyz.getPoint3dAtUncheckedPointIndex(xyz.length - 1);
+            result.edge = Ray3d.createStartEnd(firstPoint, lastPoint);
+        }
         return result;
     }
     /**
@@ -173,6 +176,8 @@ export class CutLoop {
      * * Hence sorting on the coordinates puts loops in left-to-right order by the their edge vector leftmost point.
      */
     setSortCoordinates(ray) {
+        if (!this.edge)
+            return;
         this.sortDelta = this.edge.direction.dotProduct(ray.direction);
         const a = ray.dotProductToPoint(this.edge.origin);
         if (this.sortDelta >= 0) {
@@ -211,14 +216,6 @@ export class CutLoop {
         const q = loopA.sortCoordinate0 - loopB.sortCoordinate0;
         return q > 0 ? 1 : -1;
     }
-    /** Return first point coordinates.
-     * * For type checking, assume array is not empty.
-     */
-    front(result) { return this.xyz.front(result); }
-    /** Return last point coordinates.
-     * * For type checking, assume array is not empty.
-     */
-    back(result) { return this.xyz.back(result); }
 }
 /**
  * Context to hold an array of input loops and apply sort logic.
@@ -246,17 +243,19 @@ export class CutLoopMergeContext {
         resultPoint.setZero();
         let d;
         for (const loop of this.inputLoops) {
-            loop.front(workPoint);
-            d = workPoint.distanceSquared(point0);
-            if (d > dMax) {
-                dMax = d;
-                resultPoint.setFromPoint3d(workPoint);
+            if (loop.xyz.front(workPoint)) {
+                d = workPoint.distanceSquared(point0);
+                if (d > dMax) {
+                    dMax = d;
+                    resultPoint.setFromPoint3d(workPoint);
+                }
             }
-            loop.back(workPoint);
-            d = workPoint.distanceSquared(point0);
-            if (d > dMax) {
-                dMax = d;
-                resultPoint.setFromPoint3d(workPoint);
+            if (loop.xyz.back(workPoint)) {
+                d = workPoint.distanceSquared(point0);
+                if (d > dMax) {
+                    dMax = d;
+                    resultPoint.setFromPoint3d(workPoint);
+                }
             }
         }
     }
@@ -267,7 +266,7 @@ export class CutLoopMergeContext {
      */
     sortInputs() {
         if (this.inputLoops.length > 0 && this.inputLoops[0].xyz.length > 0) {
-            const point0 = this.inputLoops[0].xyz.front();
+            const point0 = this.inputLoops[0].xyz.getPoint3dAtUncheckedPointIndex(0);
             const workPoint = Point3d.create();
             const point1 = Point3d.create();
             // point0 could be in the middle.   Find the most distant point ...
@@ -534,9 +533,9 @@ export class PolygonOps {
         }
         const n = points.length;
         if (n === 3) {
-            const normal = points.crossProductIndexIndexIndex(0, 1, 2, result?.direction);
+            const normal = points.crossProductUncheckedIndexIndexIndex(0, 1, 2, result?.direction);
             const a = 0.5 * normal.magnitude();
-            const centroid = points.getPoint3dAtCheckedPointIndex(0, result?.origin);
+            const centroid = points.getPoint3dAtUncheckedPointIndex(0, result?.origin);
             points.accumulateScaledXYZ(1, 1.0, centroid);
             points.accumulateScaledXYZ(2, 1.0, centroid);
             centroid.scaleInPlace(1.0 / 3.0);
@@ -553,7 +552,7 @@ export class PolygonOps {
                 points.accumulateCrossProductIndexIndexIndex(0, i - 1, i, areaNormal);
             }
             areaNormal.normalizeInPlace();
-            const origin = points.getPoint3dAtCheckedPointIndex(0);
+            const origin = points.getPoint3dAtUncheckedPointIndex(0);
             const vector0 = Vector3d.create();
             const vector1 = Vector3d.create();
             points.vectorXYAndZIndex(origin, 1, vector0);
@@ -679,7 +678,7 @@ export class PolygonOps {
             const placement = PolygonOps._matrixA;
             const matrixAB = PolygonOps._matrixB;
             const matrixABC = PolygonOps._matrixC;
-            const vectorOrigin = points.vectorXYAndZIndex(origin, 0, PolygonOps._vectorOrigin);
+            const vectorOrigin = points.vectorXYAndZUncheckedIndex(origin, 0, PolygonOps._vectorOrigin);
             const numPoints = points.length;
             let detJ = 0;
             for (let i2 = 2; i2 < numPoints; i2++) {
@@ -708,14 +707,14 @@ export class PolygonOps {
     /**
      * Compute the signed volume of the truncated prism between a facet and a plane.
      * * Useful for parallel algorithms.
-     * @param facetPoints input 3D polygon; on return the points are projected onto the plane. Wraparound point is optional.
+     * @param facetPoints input 3D polygon, wraparound point optional. This array is mutated on return if `options.skipMoments === false`: each point is projected onto the plane.
      * @param plane infinite plane bounding volume between the facet and (virtual) side facets perpendicular to the plane (unmodified).
      * @param options optional flags and pre-allocated temporary storage.
-     * @returns computed data for this facet:
-     * * `volume6`: six times the signed volume of the truncated prism between the facet and the plane.
-     * * `area2`: two times the signed area of the facet's projection onto the plane.
-     * * `origin`: origin of the facet used to accumulate area moments.
-     * * `products`: raw accumulated second moment area products of the facet's projection onto the plane.
+     * @returns computed data for this facet, or defaults if `facetPoints.length < 3`:
+     * * `volume6`: six times the signed volume of the truncated prism between the facet and the plane (default 0).
+     * * `area2`: two times the signed area of the facet's projection onto the plane (default 0).
+     * * `origin`: origin of the facet used to accumulate area moments (default `undefined`).
+     * * `products`: raw accumulated second moment area products of the facet's projection onto the plane (default `undefined`).
      * @see [[PolyfaceQuery.sumVolumeBetweenFacetsAndPlane]]
      */
     static volumeBetweenPolygonAndPlane(facetPoints, plane, options) {
@@ -723,20 +722,22 @@ export class PolygonOps {
         let products;
         let singleProjectedFacetAreaTimes2 = 0.0;
         let signedTruncatedPrismVolumeTimes6 = 0.0;
-        const h0 = facetPoints.evaluateUncheckedIndexPlaneAltitude(0, plane);
-        for (let i = 1; i + 1 < facetPoints.length; i++) {
-            const triangleNormal = facetPoints.crossProductIndexIndexIndex(0, i, i + 1, options?.workVector);
-            const hA = facetPoints.evaluateUncheckedIndexPlaneAltitude(i, plane);
-            const hB = facetPoints.evaluateUncheckedIndexPlaneAltitude(i + 1, plane);
-            const signedProjectedTriangleAreaTimes2 = triangleNormal.dotProductXYZ(plane.normalX(), plane.normalY(), plane.normalZ());
-            singleProjectedFacetAreaTimes2 += signedProjectedTriangleAreaTimes2;
-            signedTruncatedPrismVolumeTimes6 += signedProjectedTriangleAreaTimes2 * (h0 + hA + hB);
-        }
-        if (!options?.skipMoments) {
-            origin = facetPoints.getPoint3dAtUncheckedPointIndex(0, options?.workPoint0);
-            products = Matrix4d.createZero(options?.workMatrix);
-            facetPoints.mapPoint((x, y, z) => plane.projectXYZToPlane(x, y, z, options?.workPoint1));
-            PolygonOps.addSecondMomentAreaProducts(facetPoints, origin, products);
+        if (facetPoints.length >= 3) {
+            const h0 = facetPoints.evaluateUncheckedIndexPlaneAltitude(0, plane);
+            for (let i = 1; i + 1 < facetPoints.length; i++) {
+                const triangleNormal = facetPoints.crossProductUncheckedIndexIndexIndex(0, i, i + 1, options?.workVector);
+                const hA = facetPoints.evaluateUncheckedIndexPlaneAltitude(i, plane);
+                const hB = facetPoints.evaluateUncheckedIndexPlaneAltitude(i + 1, plane);
+                const signedProjectedTriangleAreaTimes2 = triangleNormal.dotProductXYZ(plane.normalX(), plane.normalY(), plane.normalZ());
+                singleProjectedFacetAreaTimes2 += signedProjectedTriangleAreaTimes2;
+                signedTruncatedPrismVolumeTimes6 += signedProjectedTriangleAreaTimes2 * (h0 + hA + hB);
+            }
+            if (!options?.skipMoments) {
+                origin = facetPoints.getPoint3dAtUncheckedPointIndex(0, options?.workPoint0);
+                products = Matrix4d.createZero(options?.workMatrix);
+                facetPoints.mapPoint((x, y, z) => plane.projectXYZToPlane(x, y, z, options?.workPoint1));
+                PolygonOps.addSecondMomentAreaProducts(facetPoints, origin, products);
+            }
         }
         return { volume6: signedTruncatedPrismVolumeTimes6, area2: singleProjectedFacetAreaTimes2, origin, products };
     }
@@ -967,7 +968,7 @@ export class PolygonOps {
         const distTol2 = distTol * distTol;
         let numPoints = polygon.length;
         while (numPoints > 1) {
-            if (polygon.distanceSquaredIndexIndex(0, numPoints - 1) > distTol2)
+            if (polygon.distanceSquaredUncheckedIndexIndex(0, numPoints - 1) > distTol2)
                 break;
             --numPoints; // ignore closure point
         }
@@ -995,10 +996,10 @@ export class PolygonOps {
                 let iEdgeEnd = iEdgeStart + 1;
                 if (iEdgeEnd === numPoints)
                     iEdgeEnd = 0;
-                uDotU = polygon.distanceSquaredIndexIndex(iEdgeStart, iEdgeEnd);
+                uDotU = polygon.distanceSquaredUncheckedIndexIndex(iEdgeStart, iEdgeEnd);
                 if (uDotU > distTol2) { // nontrivial edge
-                    vDotV = polygon.distanceSquaredIndexXYAndZ(iEdgeStart, testPoint);
-                    const uDotV = polygon.dotProductIndexIndexXYAndZ(iEdgeStart, iEdgeEnd, testPoint);
+                    vDotV = polygon.distanceSquaredUncheckedIndexXYAndZ(iEdgeStart, testPoint);
+                    const uDotV = polygon.dotProductUncheckedIndexIndexXYAndZ(iEdgeStart, iEdgeEnd, testPoint);
                     edgeParam = uDotV / uDotU; // param of projection of testPoint onto edge [iEdgeStart, iEdgeEnd]
                     isValid = true;
                 }
@@ -1022,6 +1023,9 @@ export class PolygonOps {
             let iNext = iBase + 1;
             if (iNext === numPoints)
                 iNext = 0;
+            assert(() => iBase >= 0 && iBase < numPoints &&
+                iPrev >= 0 && iPrev < numPoints &&
+                iNext >= 0 && iNext < numPoints, "expect iBase, iPrev, iNext are valid indices");
             const projData = projectToEdge(iBase);
             if (!projData.isValid)
                 continue; // ignore trivial polygon edge (keep iPrev, projBeyondPrevEdge)
@@ -1041,7 +1045,7 @@ export class PolygonOps {
                     // update candidate (to edge start) only if testPoint projected beyond previous edge end
                     polygon.getPoint3dAtUncheckedPointIndex(iBase, result.point);
                     result.a = Math.sqrt(distToStart2);
-                    polygon.crossProductIndexIndexIndex(iBase, iPrev, iNext, result.v);
+                    polygon.crossProductUncheckedIndexIndexIndex(iBase, iPrev, iNext, result.v);
                     result.code = PolygonLocation.OnPolygonVertex;
                     result.closestEdgeIndex = iBase;
                     result.closestEdgeParam = 0.0;
@@ -1089,7 +1093,7 @@ export class PolygonOps {
                     // update candidate
                     polygon.interpolateIndexIndex(iBase, projData.edgeParam, iNext, result.point);
                     result.a = Math.sqrt(projDist2);
-                    polygon.crossProductIndexIndexXYAndZ(iBase, iNext, testPoint, result.v);
+                    polygon.crossProductUncheckedIndexIndexXYAndZ(iBase, iNext, testPoint, result.v);
                     result.code = projData.edgeParam < 1.0 ? PolygonLocation.OnPolygonEdgeInterior : PolygonLocation.OnPolygonVertex;
                     ;
                     result.closestEdgeIndex = iBase;
@@ -1124,6 +1128,7 @@ export class PolygonOps {
         if (!this.unitNormal(polygon, this._normal))
             return PolygonLocationDetail.create(result); // invalid
         const polygonPlane = this._workPlane = Plane3dByOriginAndUnitNormal.createXYZUVW(polygon.getXAtUncheckedPointIndex(0), polygon.getYAtUncheckedPointIndex(0), polygon.getZAtUncheckedPointIndex(0), this._normal.x, this._normal.y, this._normal.z, this._workPlane);
+        assert(polygonPlane !== undefined, "expect this._normal to be nonzero because unitNormal succeeded");
         const planePoint = this._workXYZ = polygonPlane.projectPointToPlane(testPoint, this._workXYZ);
         result = this.closestPointOnBoundary(polygon, planePoint, tolerance, result);
         if (result.isValid) {
@@ -1168,6 +1173,7 @@ export class PolygonOps {
         if (!this.unitNormal(polygon, this._normal))
             return PolygonLocationDetail.create(result); // invalid
         this._workPlane = Plane3dByOriginAndUnitNormal.createXYZUVW(polygon.getXAtUncheckedPointIndex(0), polygon.getYAtUncheckedPointIndex(0), polygon.getZAtUncheckedPointIndex(0), this._normal.x, this._normal.y, this._normal.z, this._workPlane);
+        assert(this._workPlane !== undefined, "expect this._normal to be nonzero because unitNormal succeeded");
         const intersectionPoint = this._workXYZ = Point3d.createZero(this._workXYZ);
         const rayParam = ray.intersectionWithPlane(this._workPlane, intersectionPoint);
         if (undefined === rayParam)
@@ -1226,7 +1232,7 @@ export class PolygonOps {
     static computeEdgeDataXY(polygon, edgeStartVertexIndex, point, edgeOutwardUnitNormal, tolerance = Geometry.smallMetricDistance, result) {
         const i0 = edgeStartVertexIndex % polygon.length;
         const i1 = (i0 + 1) % polygon.length;
-        polygon.vectorIndexIndex(i0, i1, edgeOutwardUnitNormal).unitPerpendicularXY(edgeOutwardUnitNormal).negate(edgeOutwardUnitNormal); // z is zero
+        polygon.vectorUncheckedIndexIndex(i0, i1, edgeOutwardUnitNormal).unitPerpendicularXY(edgeOutwardUnitNormal).negate(edgeOutwardUnitNormal); // z is zero
         const hypDeltaX = polygon.getXAtUncheckedPointIndex(i0) - point.x;
         const hypDeltaY = polygon.getYAtUncheckedPointIndex(i0) - point.y;
         let projDist = Geometry.dotProductXYXY(hypDeltaX, hypDeltaY, edgeOutwardUnitNormal.x, edgeOutwardUnitNormal.y);
@@ -1301,9 +1307,14 @@ export class PolygonOps {
             return undefined;
         const localToWorld = this._workMatrix3d = Matrix3d.createRigidHeadsUp(this._normal, AxisOrder.ZXY, this._workMatrix3d);
         const polygonXY = new GrowableXYZArray(n);
-        for (let i = 0; i < n; ++i)
-            polygonXY.push(localToWorld.multiplyInverseXYZAsPoint3d(polygon.getXAtUncheckedPointIndex(i), polygon.getYAtUncheckedPointIndex(i), polygon.getZAtUncheckedPointIndex(i), this._workXYZ));
-        const pointXY = this._workXYZ = localToWorld.multiplyInverseXYZAsPoint3d(point.x, point.y, point.z, this._workXYZ);
+        for (let i = 0; i < n; ++i) {
+            const pt = this._workXYZ = localToWorld.multiplyInverseXYZAsPoint3d(polygon.getXAtUncheckedPointIndex(i), polygon.getYAtUncheckedPointIndex(i), polygon.getZAtUncheckedPointIndex(i), this._workXYZ);
+            assert(pt !== undefined, "expect localToWorld is nonsingular because this._normal is nonzero");
+            polygonXY.push(pt);
+        }
+        assert(this._workXYZ !== undefined, "expect this._workXYZ is allocated because polygon is nonempty");
+        const pointXY = localToWorld.multiplyInverseXYZAsPoint3d(point.x, point.y, point.z, this._workXYZ);
+        assert(pointXY !== undefined, "expect localToWorld is nonsingular because this._normal is nonzero");
         // now we know polygon orientation is ccw, its last edge has positive length, and we can ignore z-coords
         let iPrev = n - 1;
         const outwardUnitNormalOfLastEdge = this._vector0;
@@ -1329,9 +1340,7 @@ export class PolygonOps {
                 continue; // point is on subsequent colinear edge (ASSUMING interior point, convex polygon!); coords[i] = 0; keep previous edge data
             const areaOfNormalParallelogram = Math.abs(outwardUnitNormalOfPrevEdge.crossProductXY(outwardUnitNormalOfEdge));
             const coord = Geometry.conditionalDivideCoordinate(areaOfNormalParallelogram, projToPrevEdge.x * projToEdge.x, largestResult);
-            if (undefined === coord) {
-                assert(false, "unexpectedly small projection distance to an edge"); // shouldn't happen due to chopping in computeEdgeDataXY: area/(dist*dist) <= 1/tol^2 = largestResult
-            }
+            assert(coord !== undefined, "unexpectedly small projection distance to an edge"); // shouldn't happen due to chopping in computeEdgeDataXY: area/(dist*dist) <= 1/tol^2 = largestResult
             coords[i] = coord;
             coordSum += coord;
             outwardUnitNormalOfPrevEdge.setFrom(outwardUnitNormalOfEdge);
@@ -1494,78 +1503,71 @@ export class IndexedXYZCollectionPolygonOps {
         }
     }
     /**
-     * Clip a polygon to one side of a plane.
-     * * Results with 2 or fewer points are ignored.
-     * * Other than ensuring capacity in the arrays, there are no object allocations during execution of this function.
+     * Clip a polygon to one side of a plane in place.
      * * For a convex input polygon, the output polygon is also convex.
      * * For non-convex input, the output polygon may have double-back edges along plane intersections. This is still a
      * valid clip in a parity sense (overlapping regions cancel).
-     * * This method returns only the piece of the input polygon on one side of the clipper.
-     * See [[splitConvexPolygonInsideOutsidePlane]] for a method that returns both sides.
-     * @param plane any type that has `plane.altitude`
-     * @param xyz input polygon, clipped on output
+     * * Output may also consist entirely of (colinear) polygon vertices that lie on the clip plane.
+     * No attempt is made to filter such zero-area output.
+     * * Other than ensuring capacity in the arrays, there are no object allocations during execution of this function.
+     * @param plane altitude evaluator
+     * @param xyz input polygon, clipped on output. Closure point, if present on input, is removed on output. Fewer than 3 input vertices results in empty output.
      * @param work optional work buffer
      * @param keepPositive whether the positive side of the plane survives (true, default), or negative side (false).
      * @param tolerance tolerance for "on plane" decision. This is a distance if `plane` has unit normal (e.g., [[ClipPlane]]).
      * Default value is [[Geometry.smallMetricDistance]].
-     * @return the number of crossings. If this is larger than 2, the input polygon was non-convex.
-     * @see splitConvexPolygonInsideOutsidePlane
+     * @return the number of on-plane vertices and maximal vertex intervals. If this is larger than 2, the input polygon was non-convex.
+     * @see [[splitConvexPolygonInsideOutsidePlane]] for a method that clips to both sides of the plane.
      */
     static clipConvexPolygonInPlace(plane, xyz, work, keepPositive = true, tolerance = Geometry.smallMetricDistance) {
-        if (!work)
-            work = new GrowableXYZArray();
-        work.clear();
-        const s = keepPositive ? 1.0 : -1.0;
+        while (xyz.length > 1 && xyz.getPoint3dAtUncheckedPointIndex(0).isExactEqual(xyz.getPoint3dAtUncheckedPointIndex(xyz.length - 1)))
+            xyz.pop(); // ignore closure point(s)
         const n = xyz.length;
-        let numNegative = 0;
+        if (n < 3) { // swallow degenerate polygon
+            xyz.clear();
+            return 0;
+        }
+        const s = keepPositive ? 1.0 : -1.0;
+        const computeAltitude = (i) => {
+            const a = s * xyz.evaluateUncheckedIndexPlaneAltitude(i, plane);
+            return (Math.abs(a) < tolerance) ? 0 : a;
+        };
         const fractionTol = 1.0e-8;
-        const b = -tolerance;
-        let numCrossings = 0;
-        if (xyz.length > 1) { // > 2 ??
-            let a1;
-            let index0 = xyz.length - 1;
-            let a0 = s * xyz.evaluateUncheckedIndexPlaneAltitude(index0, plane);
-            if (Math.abs(a0) < tolerance)
-                a0 = 0;
-            //    if (a0 >= 0.0)
-            //      work.push_back (xyz0);
-            for (let index1 = 0; index1 < n; a0 = a1, index0 = index1++) {
-                a1 = s * xyz.evaluateUncheckedIndexPlaneAltitude(index1, plane);
-                if (Math.abs(a1) < tolerance)
-                    a1 = 0;
-                if (a1 < 0)
-                    numNegative++;
-                if (a0 * a1 < 0.0) {
-                    // simple crossing . . .
-                    const f = -a0 / (a1 - a0);
-                    if (f > 1.0 - fractionTol && a1 >= 0.0) {
-                        // the endpoint will be saved -- avoid the duplicate
-                    }
-                    else {
-                        work.pushInterpolatedFromGrowableXYZArray(xyz, index0, f, index1);
-                        if (a1 > 0)
-                            numCrossings++; // "out to in"
-                    }
+        let numClippedVertices = 0;
+        let numSimpleCrossings = 0; // # new surviving vertices, each at intersection of plane with polygon edge interior
+        let numTangentRuns = 0; // # on-plane vertices (or maximal runs of such consecutive vertices) whose entrance/exit edges lie on same side of plane
+        const surviving = work ? work : new GrowableXYZArray();
+        surviving.clear();
+        let a1, a0 = computeAltitude(n - 1);
+        for (let index0 = n - 1, index1 = 0; index1 < n; a0 = a1, index0 = index1++) {
+            a1 = computeAltitude(index1);
+            if (a1 < 0)
+                numClippedVertices++;
+            if (a0 * a1 < 0.0) { // simple crossing
+                const f = -a0 / (a1 - a0);
+                if (f > 1.0 - fractionTol && a1 > 0.0) {
+                    // don't push end vertex of this edge; it will be pushed later
                 }
-                if (a1 >= b) {
-                    work.pushFromGrowableXYZArray(xyz, index1);
-                    if (a0 < -b) {
-                        numCrossings++; // "in to out"
-                    }
+                else {
+                    const crossing = xyz.interpolateUncheckedIndexIndex(index0, f, index1, this._xyz0Work);
+                    surviving.pushXYZ(crossing.x, crossing.y, crossing.z);
+                    numSimpleCrossings++;
                 }
-                index0 = index1;
-                a0 = a1;
             }
+            if (a1 >= 0) {
+                surviving.pushXYZ(xyz.getXAtUncheckedPointIndex(index1), xyz.getYAtUncheckedPointIndex(index1), xyz.getZAtUncheckedPointIndex(index1));
+                if (a1 === 0 && a0 !== 0)
+                    numTangentRuns++; // on-plane vertex, or start of on-plane interval
+            }
+            index0 = index1;
+            a0 = a1;
         }
-        if (work.length <= 2) {
-            xyz.clear();
-        }
-        else if (numNegative > 0) {
+        if (numClippedVertices > 0) {
             xyz.clear();
-            xyz.pushFromGrowableXYZArray(work);
+            xyz.pushIndexedXYZCollection(surviving);
         }
-        work.clear();
-        return numCrossings;
+        surviving.clear();
+        return numSimpleCrossings + numTangentRuns;
     }
     /** Return an array containing
      * * All points that are exactly on the plane.
@@ -1638,38 +1640,42 @@ export class IndexedXYZCollectionPolygonOps {
         return result;
     }
     /**
-     * * Input the loops from `gatherCutLoopsFromClipPlane`
+     * * Input the loops from [[gatherCutLoopsFromPlaneClip]].
      * * Consolidate loops for reentrant configurations.
      * * WARNING: The output reuses and modifies input loops whenever possible.
      * @internal
      */
     static reorderCutLoops(loops) {
-        // Simple case: all loops have common orientation
-        if (loops.inputLoops.length === 1)
+        if (loops.inputLoops.length <= 1)
             return;
         // Simple cases: 2 loops . . .
         if (loops.inputLoops.length === 2) {
-            // if edges are in the same direction, it must be a pair of unrelated loop . . .
-            if (loops.inputLoops[0].edge.direction.dotProduct(loops.inputLoops[1].edge.direction) > 0) {
-                loops.outputLoops.push(loops.inputLoops[0]);
-                loops.outputLoops.push(loops.inputLoops[1]);
-                return;
+            const edge0 = loops.inputLoops[0].edge;
+            const edge1 = loops.inputLoops[1].edge;
+            if (edge0 && edge1) {
+                if (edge0.direction.dotProduct(edge1.direction) > 0) {
+                    // if edges are in the same direction, it must be a pair of unrelated loops
+                    loops.outputLoops.push(loops.inputLoops[0]);
+                    loops.outputLoops.push(loops.inputLoops[1]);
+                }
+                else {
+                    // 2 loops on opposite sides of the plane; twist into 1
+                    const source = loops.inputLoops[1].xyz;
+                    const dest = loops.inputLoops[0].xyz;
+                    dest.pushFromGrowableXYZArray(source);
+                    loops.outputLoops.push(loops.inputLoops[0]);
+                }
             }
-            // twist the two loops into 1,
-            const source = loops.inputLoops[1].xyz;
-            const dest = loops.inputLoops[0].xyz;
-            dest.pushFromGrowableXYZArray(source);
-            loops.outputLoops.push(loops.inputLoops[0]);
-            return;
         }
-        // 3 or more loops.
-        loops.sortAndMergeLoops();
-        //
+        else {
+            // 3 or more loops.
+            loops.sortAndMergeLoops();
+        }
     }
     /**
-     * Return the intersection of the plane with a range cube.
-     * @param range
-     * @param xyzOut intersection polygon.  This is convex.
+     * Clip a convex polygon in place by a range box.
+     * @param range six clipping planes
+     * @param xyz convex polygon, clipped in place
      * @return reference to xyz if the polygon still has points; undefined if all points are clipped away.
      */
     static intersectRangeConvexPolygonInPlace(range, xyz) {
@@ -1709,9 +1715,6 @@ export class IndexedXYZCollectionPolygonOps {
  * @public
  */
 export class Point3dArrayPolygonOps {
-    static _xyz0Work = Point3d.create();
-    //  private static _xyz1Work: Point3d = Point3d.create();
-    //  private static _xyz2Work: Point3d = Point3d.create();
     /**
      * Split a (convex) polygon into 2 parts.
      * @param xyz original polygon
@@ -1734,53 +1737,17 @@ export class Point3dArrayPolygonOps {
         return IndexedXYZCollectionPolygonOps.polygonPlaneCrossings(plane, xyzSource, crossings);
     }
     /**
-     * Clip a polygon, returning the clip result in the same object.
+     * Clip a polygon to one side of a plane in place.
+     * @param plane altitude evaluator
      * @param xyz input/output polygon
-     * @param work scratch object
+     * @param work optional scratch object
      * @param tolerance tolerance for on-plane decision.
+     * @see [[IndexedXYZCollectionPolygonOps.clipConvexPolygonInPlace]]
      */
     static convexPolygonClipInPlace(plane, xyz, work, tolerance = Geometry.smallMetricDistance) {
-        if (work === undefined)
-            work = [];
-        work.length = 0;
-        let numNegative = 0;
-        const fractionTol = 1.0e-8;
-        const b = -tolerance;
-        if (xyz.length > 2) {
-            let xyz0 = xyz[xyz.length - 1];
-            let a0 = plane.altitude(xyz0);
-            //    if (a0 >= 0.0)
-            //      work.push_back (xyz0);
-            for (const xyz1 of xyz) {
-                const a1 = plane.altitude(xyz1);
-                if (a1 < 0)
-                    numNegative++;
-                if (a0 * a1 < 0.0) {
-                    // simple crossing . . .
-                    const f = -a0 / (a1 - a0);
-                    if (f > 1.0 - fractionTol && a1 >= 0.0) {
-                        // the endpoint will be saved -- avoid the duplicate
-                    }
-                    else {
-                        work.push(xyz0.interpolate(f, xyz1));
-                    }
-                }
-                if (a1 >= b)
-                    work.push(xyz1);
-                xyz0 = Point3d.createFrom(xyz1);
-                a0 = a1;
-            }
-        }
-        if (work.length <= 2) {
-            xyz.length = 0;
-        }
-        else if (numNegative > 0) {
-            xyz.length = 0;
-            for (const xyzI of work) {
-                xyz.push(xyzI);
-            }
-            work.length = 0;
-        }
+        const xyzSource = new Point3dArrayCarrier(xyz);
+        const workSource = work ? new Point3dArrayCarrier(work) : undefined;
+        return IndexedXYZCollectionPolygonOps.clipConvexPolygonInPlace(plane, xyzSource, workSource, true, tolerance);
     }
 }
 //# sourceMappingURL=PolygonOps.js.map