@itwin/core-geometry 4.0.0-dev.70 → 4.0.0-dev.72

package/lib/cjs/geometry3d/BarycentricTriangle.js

@@ -15,17 +15,23 @@ const Point3dVector3d_1 = require("./Point3dVector3d");
 const Ray3d_1 = require("./Ray3d");
 /**
  * Carries data about a location in the plane of a triangle.
- * * Each instance carries both world and barycentric coordinates for the point, and provides query services on the latter.
- * * No tolerance is used when querying barycentric coordinates (e.g., `isInsideOrOn`, `classify`). Use `snapLocalToEdge`
- * to adjust the barycentric coordinates to a triangle edge if they lie within a parametric tolerance.
+ * * Each instance carries both world and barycentric coordinates for the point, and provides query
+ * services on the latter.
+ * * No tolerance is used when querying barycentric coordinates (e.g., `isInsideOrOn`, `classify`). Use
+ * [[BarycentricTriangle.snapLocationToEdge]] to adjust the barycentric coordinates to a triangle edge
+ * if they lie within a distance or parametric tolerance.
  *
- * Properties of the barycentric coordinates (b0, b1, b2) of a point p in the plane of a triangle T with vertices p0, p1, p2:
- * * 1 = b0 + b1 + b2
- * * p = b0 * p0 + b1 * p1 + b2 * p2
- * * If T is spanned by the vectors U=p1-p0 and V=p2-p0, then the vector P=p-p0 can be written P = b1 * U + b2 * V.
- * * The coordinates are all nonnegative if and only if p is inside or on T.
- * * Exactly one coordinate is zero if and only if p lies on an (infinitely extended) edge of T.
- * * Exactly two coordinates are zero if and only if p coincides with a vertex of T.
+ * Properties of the barycentric coordinates `(b0, b1, b2)` of a point `p` in the plane of a triangle
+ * `T` with vertices `v0, v1, v2`:
+ * * `1 = b0 + b1 + b2`
+ * * `p = b0 * v0 + b1 * v1 + b2 * v2`
+ * * If T is spanned by the vectors `U = v1 - v0` and `V = v2 - v0`, then the vector `P = p - v0` can
+ * be written `P = b1 * U + b2 * V`.
+ * * The coordinates are all nonnegative if and only if `p` is inside or on `T`.
+ * * Exactly one coordinate is zero if and only if `p` lies on an (infinitely extended) edge of `T`.
+ * * Exactly two coordinates are zero if and only if `p` coincides with a vertex of `T`.
+ * * Note that if `p` can be written as a linear combination of the vertices of `T` using scales that do
+ * NOT sum to 1, then `p` is not coplanar with `T`
  * @public
  */
 class TriangleLocationDetail {
@@ -36,7 +42,7 @@ class TriangleLocationDetail {
         this.closestEdgeIndex = 0;
         this.closestEdgeParam = 0.0;
     }
-    /** Invalidate this detail. */
+    /** Invalidate this detail (set all attributes to zero) . */
     invalidate() {
         this.world.setZero();
         this.local.setZero();
@@ -44,7 +50,8 @@ class TriangleLocationDetail {
         this.closestEdgeIndex = 0;
         this.closestEdgeParam = 0.0;
     }
-    /** Create an invalid detail.
+    /**
+     * Create an invalid detail.
      * @param result optional pre-allocated object to fill and return
      */
     static create(result) {
@@ -54,7 +61,8 @@ class TriangleLocationDetail {
             result.invalidate();
         return result;
     }
-    /** Set the instance contents from the other detail.
+    /**
+     * Set the instance contents from the `other` detail.
      * @param other detail to clone
      */
     copyContentsFrom(other) {
@@ -68,13 +76,16 @@ class TriangleLocationDetail {
     get isValid() {
         return !this.local.isZero;
     }
-    /** Queries the barycentric coordinates to determine whether this instance specifies a location inside or on the triangle.
+    /**
+     * Queries the barycentric coordinates to determine whether this instance specifies a location inside or
+     * on the triangle.
      * @see classify
      */
     get isInsideOrOn() {
         return this.isValid && this.local.x >= 0.0 && this.local.y >= 0.0 && this.local.z >= 0.0;
     }
-    /** Queries this detail to classify the location of this instance with respect to the triangle.
+    /**
+     * Queries this detail to classify the location of this instance with respect to the triangle.
      * @returns location code
      * @see isInsideOrOn
      */
@@ -95,7 +106,9 @@ class TriangleLocationDetail {
                 return Geometry_1.PolygonLocation.OnPolygonEdgeInterior;
             return Geometry_1.PolygonLocation.InsidePolygonProjectsToEdgeInterior;
         }
-        return (this.closestEdgeParam === 0.0) ? Geometry_1.PolygonLocation.OutsidePolygonProjectsToVertex : Geometry_1.PolygonLocation.OutsidePolygonProjectsToEdgeInterior;
+        return (this.closestEdgeParam === 0.0) ?
+            Geometry_1.PolygonLocation.OutsidePolygonProjectsToVertex :
+            Geometry_1.PolygonLocation.OutsidePolygonProjectsToEdgeInterior;
     }
 }
 exports.TriangleLocationDetail = TriangleLocationDetail;
@@ -104,7 +117,8 @@ exports.TriangleLocationDetail = TriangleLocationDetail;
  * @public
  */
 class BarycentricTriangle {
-    /** Constructor.
+    /**
+     * Constructor.
      * * Point references are CAPTURED
      */
     constructor(point0, point1, point2) {
@@ -118,7 +132,26 @@ class BarycentricTriangle {
         this.edgeLength2.push(point0.distanceSquared(point1));
     }
     /**
-     * Return a `BarycentricTriangle` with coordinates given by enumerated x,y,z of the 3 points.
+     * Copy contents of (not pointers to) the given points. A vertex is zeroed if its corresponding input point
+     * is undefined.
+     */
+    set(point0, point1, point2) {
+        this.points[0].setFromPoint3d(point0);
+        this.points[1].setFromPoint3d(point1);
+        this.points[2].setFromPoint3d(point2);
+        this.edgeLength2[0] = this.points[1].distanceSquared(this.points[2]);
+        this.edgeLength2[1] = this.points[0].distanceSquared(this.points[2]);
+        this.edgeLength2[2] = this.points[0].distanceSquared(this.points[1]);
+    }
+    /** Copy all values from `other` */
+    setFrom(other) {
+        for (let i = 0; i < 3; ++i) {
+            this.points[i].setFromPoint3d(other.points[i]);
+            this.edgeLength2[i] = other.edgeLength2[i];
+        }
+    }
+    /**
+     * Create a `BarycentricTriangle` with coordinates given by enumerated x,y,z of the 3 points.
      * @param result optional pre-allocated triangle.
      */
     static createXYZXYZXYZ(x0, y0, z0, x1, y1, z1, x2, y2, z2, result) {
@@ -129,7 +162,7 @@ class BarycentricTriangle {
         result.points[2].set(x2, y2, z2);
         return result;
     }
-    /** create a triangle with coordinates cloned from given points. */
+    /** Create a triangle with coordinates cloned from given points. */
     static create(point0, point1, point2, result) {
         if (!result)
             return new this(point0.clone(), point1.clone(), point2.clone());
@@ -140,46 +173,76 @@ class BarycentricTriangle {
     clone(result) {
         return BarycentricTriangle.create(this.points[0], this.points[1], this.points[2], result);
     }
-    /** Return area divided by sum of squared lengths. */
-    get aspectRatio() {
-        return Geometry_1.Geometry.safeDivideFraction(this.area, this.edgeLengthSquared(0) + this.edgeLengthSquared(1) + this.edgeLengthSquared(2), 0);
-    }
     /** Return the area of the triangle. */
     get area() {
+        // The magnitude of the cross product A × B is the area of the parallelogram spanned by A and B.
         return 0.5 * this.points[0].crossProductToPointsMagnitude(this.points[1], this.points[2]);
     }
-    /** Return the perimeter of the triangle */
+    /**
+     * Compute squared length of the triangle edge opposite the vertex with the given index.
+     * @see [[edgeStartVertexIndexToOppositeVertexIndex]]
+     */
+    edgeLengthSquared(oppositeVertexIndex) {
+        return this.edgeLength2[Geometry_1.Geometry.cyclic3dAxis(oppositeVertexIndex)];
+    }
+    /**
+     * Compute length of the triangle edge opposite the vertex with the given index.
+     * @see [[edgeStartVertexIndexToOppositeVertexIndex]]
+     */
+    edgeLength(oppositeVertexIndex) {
+        return Math.sqrt(this.edgeLengthSquared(oppositeVertexIndex));
+    }
+    /** Return area divided by sum of squared lengths. */
+    get aspectRatio() {
+        return Geometry_1.Geometry.safeDivideFraction(this.area, this.edgeLengthSquared(0) + this.edgeLengthSquared(1) + this.edgeLengthSquared(2), 0);
+    }
+    /** Return the perimeter of the triangle. */
     get perimeter() {
         return this.edgeLength(0) + this.edgeLength(1) + this.edgeLength(2);
     }
-    /** Sum the points with given scales.
-     * * If the scales sum to 1, they are barycentric coordinates, and hence the result point is in the plane of the triangle.
-     * * If the scales do not sum to 1, the point is in the triangle scaled (by the scale sum) from the origin.
+    /**
+     * Return the unit normal of the triangle.
+     * @param result optional pre-allocated vector to fill and return.
+     * @returns unit normal, or undefined if cross product length is too small.
+     */
+    normal(result) {
+        const cross = this.points[0].crossProductToPoints(this.points[1], this.points[2], result);
+        if (cross.tryNormalizeInPlace())
+            return cross;
+        return undefined;
+    }
+    /**
+     * Sum the triangle points with given scales.
+     * * If the scales sum to 1, they are barycentric coordinates, and hence the result point is in the plane of
+     * the triangle. If all coordinates are non-negative then the result point is inside the triangle.
+     * * If the scales do not sum to 1, the point is inside the triangle scaled (by the scale sum) from the origin.
      * @param b0 scale to apply to vertex 0
      * @param b1 scale to apply to vertex 1
      * @param b2 scale to apply to vertex 2
      * @param result optional pre-allocated point to fill and return
      * @return linear combination of the vertices of this triangle
-     * @see pointToFraction
+     * @see [[pointToFraction]]
      */
     fractionToPoint(b0, b1, b2, result) {
+        // p = b0 * v0 + b1 * v1 + b2 * v2
         return Point3dVector3d_1.Point3d.createAdd3Scaled(this.points[0], b0, this.points[1], b1, this.points[2], b2, result);
     }
-    /** Compute the projection of the given point onto the plane of this triangle.
+    /**
+     * Compute the projection of the given `point` onto the plane of this triangle.
      * @param point point p to project
      * @param result optional pre-allocated object to fill and return
-     * @returns details d of the projection point P = `d.point`:
+     * @returns details d of the projection point `P = d.world`:
      * * `d.isValid` returns true if and only if `this.normal()` is defined.
      * * `d.classify` can be used to determine where P lies with respect to the triangle.
-     * * `d.a` is the signed projection distance: P = p + a * `this.normal()`.
-     * @see fractionToPoint
+     * * `d.a` is the signed projection distance: `P = p + a * this.normal()`.
+     * @see [[fractionToPoint]]
      */
     pointToFraction(point, result) {
         const normal = BarycentricTriangle._workVector0 = this.normal(BarycentricTriangle._workVector0);
         if (undefined === normal)
             return TriangleLocationDetail.create(result);
         const ray = BarycentricTriangle._workRay = Ray3d_1.Ray3d.create(point, normal, BarycentricTriangle._workRay);
-        return this.intersectRay3d(ray, result); // is free to use workVector0
+        return this.intersectRay3d(ray, result); // intersectRay3d is free to use workVector0
     }
     /** Convert from opposite-vertex to start-vertex edge indexing. */
     static edgeOppositeVertexIndexToStartVertexIndex(edgeIndex) {
@@ -189,7 +252,8 @@ class BarycentricTriangle {
     static edgeStartVertexIndexToOppositeVertexIndex(startVertexIndex) {
         return Geometry_1.Geometry.cyclic3dAxis(startVertexIndex - 1);
     }
-    /** Examine a point's barycentric coordinates to determine if it lies inside the triangle but not on an edge/vertex.
+    /**
+     * Examine a point's barycentric coordinates to determine if it lies inside the triangle but not on an edge/vertex.
      * * No parametric tolerance is used.
      * * It is assumed b0 + b1 + b2 = 1.
      * @returns whether the point with barycentric coordinates is strictly inside the triangle.
@@ -197,7 +261,8 @@ class BarycentricTriangle {
     static isInsideTriangle(b0, b1, b2) {
         return b0 > 0 && b1 > 0 && b2 > 0;
     }
-    /** Examine a point's barycentric coordinates to determine if it lies inside the triangle or on an edge/vertex.
+    /**
+     * Examine a point's barycentric coordinates to determine if it lies inside the triangle or on an edge/vertex.
      * * No parametric tolerance is used.
      * * It is assumed b0 + b1 + b2 = 1.
      * @returns whether the point with barycentric coordinates is inside or on the triangle.
@@ -205,12 +270,15 @@ class BarycentricTriangle {
     static isInsideOrOnTriangle(b0, b1, b2) {
         return b0 >= 0 && b1 >= 0 && b2 >= 0;
     }
-    /** Examine a point's barycentric coordinates to determine if it lies "outside" an edge of the triangle.
+    /**
+     * Examine a point's barycentric coordinates to determine if it lies outside an edge of the triangle.
      * * No parametric tolerance is used.
      * * It is assumed b0 + b1 + b2 = 1.
-     * @returns index of vertex/edge i for which b_i < 0 and b_j >= 0 and b_k >= 0, or -1
+     * @returns edge index i (opposite vertex i) for which b_i < 0 and b_j >= 0, and b_k >= 0. Otherwise, returns -1.
      */
     static isInRegionBeyondEdge(b0, b1, b2) {
+        // Note: the 3 regions (specified by the following if statements) are defined by extending the triangle
+        // edges to infinity and not by perpendicular lines to the edges (which gives smaller regions)
         if (b0 < 0 && b1 >= 0 && b2 >= 0)
             return 0;
         if (b0 >= 0 && b1 < 0 && b2 >= 0)
@@ -219,12 +287,15 @@ class BarycentricTriangle {
             return 2;
         return -1;
     }
-    /** Examine a point's barycentric coordinates to determine if it lies "outside" a vertex of the triangle.
+    /**
+     * Examine a point's barycentric coordinates to determine if it lies outside a vertex of the triangle.
      * * No parametric tolerance is used.
      * * It is assumed b0 + b1 + b2 = 1.
-     * @returns index of vertex i for which and b_j < 0 and b_k < 0, or -1
+     * @returns index of vertex i for which b_j < 0 and b_k < 0. Otherwise, returns -1.
      */
     static isInRegionBeyondVertex(b0, b1, b2) {
+        // Note: the 3 regions (specified by the following if statements) are defined by extending the triangle
+        // edges to infinity and not by perpendicular lines to the edges (which gives larger regions)
         if (b1 < 0 && b2 < 0)
             return 0;
         if (b0 < 0 && b2 < 0)
@@ -233,10 +304,11 @@ class BarycentricTriangle {
             return 2;
         return -1;
     }
-    /** Examine a point's barycentric coordinates to determine if it lies on a vertex of the triangle.
+    /**
+     * Examine a point's barycentric coordinates to determine if it lies on a vertex of the triangle.
      * * No parametric tolerance is used.
      * * It is assumed b0 + b1 + b2 = 1.
-     * @returns index of vertex i for which b_i = 1 and b_j = b_k = 0, or -1
+     * @returns index of vertex i for which b_i = 1 and b_j = b_k = 0. Otherwise, returns -1.
      */
     static isOnVertex(b0, b1, b2) {
         if (b0 === 1 && b1 === 0 && b2 === 0)
@@ -247,10 +319,11 @@ class BarycentricTriangle {
             return 2;
         return -1;
     }
-    /** Examine a point's barycentric coordinates to determine if it lies on a bounded edge of the triangle.
+    /**
+     * Examine a point's barycentric coordinates to determine if it lies on a bounded edge of the triangle.
      * * No parametric tolerance is used.
      * * It is assumed b0 + b1 + b2 = 1.
-     * @returns index of vertex/edge i for which b_i = 0 and b_j > 0 and b_k > 0, or -1
+     * @returns edge index i (opposite vertex i) for which b_i = 0, b_j > 0, and b_k > 0. Otherwise, returns -1.
      */
     static isOnBoundedEdge(b0, b1, b2) {
         if (b0 === 0 && b1 > 0 && b2 > 0)
@@ -274,35 +347,70 @@ class BarycentricTriangle {
             i = 2;
         return i;
     }
+    /**
+     * Compute the squared distance between two points given by their barycentric coordinates.
+     * * It is assumed that a0 + a1 + a2 = b0 + b1 + b2 = 1.
+     */
+    distanceSquared(a0, a1, a2, b0, b1, b2) {
+        // The barycentric displacement vector distance formula
+        // More details can be found at https://web.evanchen.cc/handouts/bary/bary-full.pdf
+        return -this.edgeLengthSquared(0) * (b1 - a1) * (b2 - a2)
+            - this.edgeLengthSquared(1) * (b2 - a2) * (b0 - a0)
+            - this.edgeLengthSquared(2) * (b0 - a0) * (b1 - a1);
+    }
     /** Return the index of the closest triangle vertex to the point given by its barycentric coordinates. */
     closestVertexIndex(b0, b1, b2) {
         return BarycentricTriangle.indexOfMinimum((i) => {
             const a = BarycentricTriangle._workPoint = Point3dVector3d_1.Point3d.createZero(BarycentricTriangle._workPoint);
-            a.setAt(i, 1.0);
-            return this.distanceSquared(a.x, a.y, a.z, b0, b1, b2);
+            a.setAt(i, 1.0); // "a" is (1,0,0) or (0,1,0) or (0,0,1) so "a" represents vertex i
+            return this.distanceSquared(a.x, a.y, a.z, b0, b1, b2); // distance between the point and vertex i
         });
     }
-    /** Compute the projection of barycentric point p onto the (unbounded) edge e_k(v_i,v_j) of the triangle T(v_i,v_j,v_k).
+    /** Compute dot product of the edge vectors based at the vertex with the given index. */
+    dotProductOfEdgeVectorsAtVertex(baseVertexIndex) {
+        const i = Geometry_1.Geometry.cyclic3dAxis(baseVertexIndex);
+        const j = Geometry_1.Geometry.cyclic3dAxis(i + 1);
+        const k = Geometry_1.Geometry.cyclic3dAxis(j + 1);
+        return Geometry_1.Geometry.dotProductXYZXYZ(this.points[j].x - this.points[i].x, this.points[j].y - this.points[i].y, this.points[j].z - this.points[i].z, this.points[k].x - this.points[i].x, this.points[k].y - this.points[i].y, this.points[k].z - this.points[i].z);
+    }
+    /**
+     * Compute the projection of barycentric point p onto the (unbounded) edge e_k(v_i,v_j) of the triangle T(v_i,v_j,v_k).
      * @param k vertex v_k is opposite the edge e_k
      * @param b barycentric coordinates of point to project
-     * @returns parameter s along e_k, such that:
-     * * the projection point is q = v_i + s * (v_j - v_i)
-     * * the barycentric coords of the projection are q_ijk = (1 - s, s, 0)
+     * @returns parameter f along e_k, such that:
+     * * the projection point is q = v_i + f * (v_j - v_i)
+     * * the barycentric coords of the projection are q_ijk = (1 - f, f, 0)
      */
     computeProjectionToEdge(k, b) {
-        // Let U=v_j-v_i and V=v_k-v_i. Then
-        // 0 = (p-q).(v_j-v_i) = ((p-v_i)-(q-v_i)).(v_j-v_i) = (b[j]U + b[k]V - sU).U = b[j]U.U + b[k]U.V - sU.U
-        // Thus s = b[j] + b[k]U.V/U.U
+        /**
+         * We know p = (b_i*v_i) + (b_j*v_j) + (b_k*v_k) and 1 = b_i + b_j + b_k.
+         * Let U = v_j - v_i and V = v_k - v_i and P = p - v_i.
+         * First we prove P = b_jU + b_kV.
+         *       P = (b_i * v_i) + (b_j * v_j) + (b_k * v_k) - v_i
+         *         = (b_i * v_i) + (b_j * (v_j-v_i)) + (b_j * v_i) + (b_k * (v_k-v_i)) + (b_k * v_i) - v_i
+         *         = (b_i * v_i) + (b_j * U) + (b_j * v_i) + (b_k * V) + (b_k * v_i) - v_i
+         *         = (b_j * U) + (b_k * V) + ((b_i + b_j + b_k) * v_i) - v_i
+         *         = (b_j * U) + (b_k * V) + v_i - v_i
+         *         = (b_j * U) + (b_k * V)
+         * So we know p - v_i = b_jU + b_kV and q - v_i = fU
+         * Therefore, 0 = (p - q).(v_j - v_i)
+         *              = ((p-v_i) - (q-v_i)).(v_j - v_i)
+         *              = (b_jU + b_kV - fU).U
+         *              = b_jU.U + b_kU.V - fU.U
+         * Thus f = b_j + b_k(U.V/U.U)
+         */
         k = Geometry_1.Geometry.cyclic3dAxis(k);
         const i = Geometry_1.Geometry.cyclic3dAxis(k + 1);
         const j = Geometry_1.Geometry.cyclic3dAxis(i + 1);
         return b[j] + b[k] * this.dotProductOfEdgeVectorsAtVertex(i) / this.edgeLengthSquared(k);
     }
-    /** Compute the projection of a barycentric point p to the triangle T(v_0,v_1,v_2).
+    /**
+     * Compute the projection of a barycentric point p to the triangle T(v_0,v_1,v_2).
      * @param b0 barycentric coordinate of p corresponding to v_0
      * @param b1 barycentric coordinate of p corresponding to v_1
      * @param b2 barycentric coordinate of p corresponding to v_2
-     * @returns closest edge start vertex index i and projection parameter u such that the projection q = v_i + u * (v_j - v_i).
+     * @returns closest edge start vertex index i and projection parameter f such that the projection
+     * q = v_i + f * (v_j - v_i).
      */
     closestPoint(b0, b1, b2) {
         const b = [b0, b1, b2];
@@ -311,7 +419,7 @@ class BarycentricTriangle {
         if (BarycentricTriangle.isInsideTriangle(b0, b1, b2)) { // projects to any edge
             edgeIndex = BarycentricTriangle.indexOfMinimum((i) => {
                 // We want smallest projection distance d_i of p to e_i.
-                // Since b[i]=d_i|e_i|/2A we can compare quantities b[i]/|e_i|.
+                // Since b_i=d_i|e_i|/2A we can compare quantities b_i/|e_i|.
                 return b[i] * b[i] / this.edgeLengthSquared(i); // avoid sqrt
             });
             edgeParam = this.computeProjectionToEdge(edgeIndex, b);
@@ -352,20 +460,24 @@ class BarycentricTriangle {
             closestEdgeParam: edgeParam,
         };
     }
-    /** Compute the intersection of a line (parameterized as a ray) with the plane of this triangle.
+    /**
+     * Compute the intersection of a line (parameterized as a ray) with the plane of this triangle.
      * @param ray infinite line to intersect, as a ray
      * @param result optional pre-allocated object to fill and return
-     * @returns details d of the line-plane intersection `d.point`:
-     * * `d.isValid` returns true if and only if the line intersects the plane.
+     * @returns details d of the line-plane intersection point `d.world`:
+     * * `d.a` is the intersection parameter along the ray.
+     * * The line intersects the plane of the triangle if and only if `d.isValid` returns true.
+     * * The ray intersects the plane of the triangle if and only if `d.isValid` returns true and `d.a` >= 0.
+     * * The ray intersects the triangle if and only if `d.isValid` returns true, `d.a` >= 0, and `d.isInsideOrOn`
+     * returns true.
      * * `d.classify` can be used to determine where the intersection lies with respect to the triangle.
-     * * `d.a` is the intersection parameter. If `d.a` >= 0, the ray intersects the plane of the triangle.
-     * @see pointToFraction
+     * @see [[pointToFraction]]
     */
     intersectRay3d(ray, result) {
         result = TriangleLocationDetail.create(result);
         // Let r0 = ray.origin, d = ray.direction. Write intersection point p two ways for unknown scalars s,b0,b1,b2:
-        //    r0 + s*d = p = b0*p0 + b1*p1 + b2*p2
-        // Subtract p0 from both ends, let u=p1-p0, v=p2-p0, c=r0-p0, and enforce b0+b1+b2=1:
+        //    r0 + s*d = p = b0*v0 + b1*v1 + b2*v2
+        // Subtract v0 from both ends, let u=v1-v0, v=v2-v0, c=r0-v0, and enforce b0+b1+b2=1:
         //    b1*u + b2*v - s*d = c
         // This is a linear system Mx=c where M has columns u,v,d and solution x=(b1,b2,-s).
         const r0 = ray.origin;
@@ -385,22 +497,25 @@ class BarycentricTriangle {
         result.closestEdgeParam = proj.closestEdgeParam;
         return result;
     }
-    /** Compute the intersection of a line (parameterized as a line segment) with the plane of this triangle.
+    /**
+     * Compute the intersection of a line (parameterized as a line segment) with the plane of this triangle.
      * @param point0 start point of segment on line to intersect
      * @param point1 end point of segment on line to intersect
      * @param result optional pre-allocated object to fill and return
-     * @returns details d of the line-plane intersection `d.point`:
+     * @returns details d of the line-plane intersection point `d.world`:
      * * `d.isValid` returns true if and only if the line intersects the plane.
      * * `d.classify` can be used to determine where the intersection lies with respect to the triangle.
      * * `d.a` is the intersection parameter. If `d.a` is in [0,1], the segment intersects the plane of the triangle.
-     * @see intersectRay3d
+     * @see [[intersectRay3d]]
     */
     intersectSegment(point0, point1, result) {
         BarycentricTriangle._workRay = Ray3d_1.Ray3d.createStartEnd(point0, point1, BarycentricTriangle._workRay);
         return this.intersectRay3d(BarycentricTriangle._workRay, result);
     }
-    /** Adjust the location to an edge of the triangle if within either given tolerance.
-     * @param location details of a point in the plane of the triangle, `location.local` and `location.world` possibly updated to lie on a triangle edge
+    /**
+     * Adjust the location to the closest edge of the triangle if within either given tolerance.
+     * @param location details of a point in the plane of the triangle (note that `location.local` and
+     * `location.world` possibly updated to lie on the triangle closest edge)
      * @param distanceTolerance absolute distance tolerance (or zero to ignore)
      * @param parameterTolerance barycentric coordinate fractional tolerance (or zero to ignore)
      * @return whether the location was adjusted
@@ -451,26 +566,11 @@ class BarycentricTriangle {
         }
         return false;
     }
-    /** Copy all values from `other`
-     */
-    setFrom(other) {
-        for (let i = 0; i < 3; ++i) {
-            this.points[i].setFromPoint3d(other.points[i]);
-            this.edgeLength2[i] = other.edgeLength2[i];
-        }
-    }
-    /** Copy contents of (not pointers to) the given points. A vertex is zeroed if its corresponding input point is undefined. */
-    set(point0, point1, point2) {
-        this.points[0].setFromPoint3d(point0);
-        this.points[1].setFromPoint3d(point1);
-        this.points[2].setFromPoint3d(point2);
-        this.edgeLength2[0] = this.points[1].distanceSquared(this.points[2]);
-        this.edgeLength2[1] = this.points[0].distanceSquared(this.points[2]);
-        this.edgeLength2[2] = this.points[0].distanceSquared(this.points[1]);
-    }
     /**
-     * * For `this` and `other` BarycentricTriangles, compute cross products of vectors from point0 to point1 and from point0 to point2.
-     * * return the dot product of those two
+     * Return the dot product of the scaled normals of the two triangles.
+     * * The sign of the return value is useful for determining the triangles' relative orientation:
+     * positive (negative) means the normals point into the same (opposite) half-space determined by
+     * one of the triangles' planes; zero means the triangles are perpendicular.
      */
     dotProductOfCrossProductsFromOrigin(other) {
         BarycentricTriangle._workVector0 = this.points[0].crossProductToPoints(this.points[1], this.points[2], BarycentricTriangle._workVector0);
@@ -479,8 +579,7 @@ class BarycentricTriangle {
     }
     /** Return the centroid of the 3 points. */
     centroid(result) {
-        // write it out to get single scale application.
-        // Do the scale as true division (rather than multiply by precomputed 1/3).  This might protect one bit of result.
+        // Do the scale as true division (rather than multiply by precomputed 1/3). This might protect one bit of result.
         return Point3dVector3d_1.Point3d.create((this.points[0].x + this.points[1].x + this.points[2].x) / 3.0, (this.points[0].y + this.points[1].y + this.points[2].y) / 3.0, (this.points[0].z + this.points[1].z + this.points[2].z) / 3.0, result);
     }
     /** Return the incenter of the triangle. */
@@ -502,47 +601,11 @@ class BarycentricTriangle {
         const scale = Geometry_1.Geometry.safeDivideFraction(1.0, x + y + z, 0.0);
         return this.fractionToPoint(scale * x, scale * y, scale * z, result);
     }
-    /** Return the unit normal of the triangle.
-     * @param result optional pre-allocated vector to fill and return.
-     * @returns unit normal, or undefined if cross product length is too small.
-     */
-    normal(result) {
-        const cross = this.points[0].crossProductToPoints(this.points[1], this.points[2], result);
-        if (cross.tryNormalizeInPlace())
-            return cross;
-        return undefined;
-    }
-    /** test for point-by-point `isAlmostEqual` relationship. */
-    isAlmostEqual(other) {
-        return this.points[0].isAlmostEqual(other.points[0])
-            && this.points[1].isAlmostEqual(other.points[1])
-            && this.points[2].isAlmostEqual(other.points[2]);
-    }
-    /** Compute length of the triangle edge opposite the vertex with the given index.
-     * @see edgeStartVertexIndexToOppositeVertexIndex
-     */
-    edgeLength(oppositeVertexIndex) {
-        return Math.sqrt(this.edgeLengthSquared(oppositeVertexIndex));
-    }
-    /** Compute squared length of the triangle edge opposite the vertex with the given index.
-     * @see edgeStartVertexIndexToOppositeVertexIndex
-    */
-    edgeLengthSquared(oppositeVertexIndex) {
-        return this.edgeLength2[Geometry_1.Geometry.cyclic3dAxis(oppositeVertexIndex)];
-    }
-    /** Compute dot product of the edge vectors based at the vertex with the given index. */
-    dotProductOfEdgeVectorsAtVertex(baseVertexIndex) {
-        const i = Geometry_1.Geometry.cyclic3dAxis(baseVertexIndex);
-        const j = Geometry_1.Geometry.cyclic3dAxis(i + 1);
-        const k = Geometry_1.Geometry.cyclic3dAxis(j + 1);
-        return Geometry_1.Geometry.dotProductXYZXYZ(this.points[j].x - this.points[i].x, this.points[j].y - this.points[i].y, this.points[j].z - this.points[i].z, this.points[k].x - this.points[i].x, this.points[k].y - this.points[i].y, this.points[k].z - this.points[i].z);
-    }
-    /** Compute the squared distance between two points given by their barycentric coordinates.
-     * * It is assumed that a0 + a1 + a2 = b0 + b1 + b2 = 1.
-     */
-    distanceSquared(a0, a1, a2, b0, b1, b2) {
-        // the barycentric displacement vector distance formula
-        return -this.edgeLengthSquared(0) * (b1 - a1) * (b2 - a2) - this.edgeLengthSquared(1) * (b2 - a2) * (b0 - a0) - this.edgeLengthSquared(2) * (b0 - a0) * (b1 - a1);
+    /** Test for point-by-point `isAlmostEqual` relationship. */
+    isAlmostEqual(other, tol) {
+        return this.points[0].isAlmostEqual(other.points[0], tol)
+            && this.points[1].isAlmostEqual(other.points[1], tol)
+            && this.points[2].isAlmostEqual(other.points[2], tol);
     }
 }
 exports.BarycentricTriangle = BarycentricTriangle;