@itwin/core-geometry 3.0.0-dev.76 → 3.0.0-dev.80

package/lib/esm/geometry3d/AngleSweep.js

@@ -0,0 +1,325 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module CartesianGeometry
+ */
+import { Geometry } from "../Geometry";
+import { Angle } from "./Angle";
+/**
+ * An `AngleSweep` is a pair of angles at start and end of an interval.
+ *
+ * *  For stroking purposes, the "included interval" is all angles numerically reached by theta = start + f*(end-start), where f is between 0 and 1.
+ * *  This stroking formula is simple numbers -- 2PI shifts are not involved.
+ * *  2PI shifts do become important in the reverse mapping of an angle to a fraction.
+ * *  If (start < end) the angle proceeds CCW around the unit circle.
+ * *  If (end < start) the angle proceeds CW around the unit circle.
+ * *  Angles beyond 360 are fine as endpoints.
+ *   *  (350,370) covers the same unit angles as (-10,10).
+ *   *  (370,350) covers the same unit angles as (10,-10).
+ * @public
+ */
+export class AngleSweep {
+    /** (private) constructor with start and end angles in radians.
+     *  * Use explicitly named static methods to clarify intent and units of inputs:
+     *
+     * * createStartEndRadians (startRadians:number, endRadians:number)
+     * * createStartEndDegrees (startDegrees:number, endDegrees:number)
+     * * createStartEnd (startAngle:Angle, endAngle:Angle)
+     * * createStartSweepRadians (startRadians:number, sweepRadians:number)
+     * * createStartSweepDegrees (startDegrees:number, sweepDegrees:number)
+     * * createStartSweep (startAngle:Angle, sweepAngle:Angle)
+     */
+    constructor(startRadians = 0, endRadians = 0) { this._radians0 = startRadians; this._radians1 = endRadians; }
+    /** Read-property for degrees at the start of this AngleSweep. */
+    get startDegrees() { return Angle.radiansToDegrees(this._radians0); }
+    /** Read-property for degrees at the end of this AngleSweep. */
+    get endDegrees() { return Angle.radiansToDegrees(this._radians1); }
+    /** Read-property for signed start-to-end sweep in degrees. */
+    get sweepDegrees() { return Angle.radiansToDegrees(this._radians1 - this._radians0); }
+    /** Read-property for degrees at the start of this AngleSweep. */
+    get startRadians() { return this._radians0; }
+    /** Read-property for degrees at the end of this AngleSweep. */
+    get endRadians() { return this._radians1; }
+    /** Read-property for signed start-to-end sweep in radians. */
+    get sweepRadians() { return this._radians1 - this._radians0; }
+    /** Return the (strongly typed) start angle */
+    get startAngle() { return Angle.createRadians(this._radians0); }
+    /** Return the (strongly typed) end angle */
+    get endAngle() { return Angle.createRadians(this._radians1); }
+    /** Create a sweep as one of
+     * * A clone of a given sweep
+     * * 0 to given angle
+     * * full circle if no arg given (sweep 0 to 360 degrees)
+     */
+    static create(data) {
+        if (data instanceof AngleSweep)
+            return data.clone();
+        if (data instanceof Angle)
+            return new AngleSweep(0, data.radians);
+        return AngleSweep.create360();
+    }
+    /** create an AngleSweep from start and end angles given in radians. */
+    static createStartEndRadians(startRadians = 0, endRadians = 2.0 * Math.PI, result) {
+        result = result ? result : new AngleSweep();
+        result.setStartEndRadians(startRadians, endRadians);
+        return result;
+    }
+    /** Return the angle obtained by subtracting radians from this angle. */
+    cloneMinusRadians(radians) { return new AngleSweep(this._radians0 - radians, this._radians1 - radians); }
+    /** create an AngleSweep from start and end angles given in degrees. */
+    static createStartEndDegrees(startDegrees = 0, endDegrees = 360, result) {
+        return AngleSweep.createStartEndRadians(Angle.degreesToRadians(startDegrees), Angle.degreesToRadians(endDegrees), result);
+    }
+    /** create an angle sweep from strongly typed start and end angles */
+    static createStartEnd(startAngle, endAngle, result) {
+        result = result ? result : new AngleSweep();
+        result.setStartEndRadians(startAngle.radians, endAngle.radians);
+        return result;
+    }
+    /** Create an angle sweep with limits given as (strongly typed) angles for start and sweep */
+    static createStartSweep(startAngle, sweepAngle, result) {
+        return AngleSweep.createStartSweepRadians(startAngle.radians, sweepAngle.radians, result);
+    }
+    /** Return a sweep with limits interpolated between this and other. */
+    interpolate(fraction, other) {
+        return new AngleSweep(Geometry.interpolate(this._radians0, fraction, other._radians0), Geometry.interpolate(this._radians1, fraction, other._radians1));
+    }
+    /** create an AngleSweep from start and end angles given in radians. */
+    static createStartSweepRadians(startRadians = 0, sweepRadians = Math.PI, result) {
+        result = result ? result : new AngleSweep();
+        result.setStartEndRadians(startRadians, startRadians + sweepRadians);
+        return result;
+    }
+    /** create an AngleSweep from start and sweep given in degrees.  */
+    static createStartSweepDegrees(startDegrees = 0, sweepDegrees = 360, result) {
+        return AngleSweep.createStartEndRadians(Angle.degreesToRadians(startDegrees), Angle.degreesToRadians(startDegrees + sweepDegrees), result);
+    }
+    /** directly set the start and end angles in radians */
+    setStartEndRadians(startRadians = 0, endRadians = 2.0 * Math.PI) {
+        const delta = endRadians - startRadians;
+        if (Angle.isFullCircleRadians(delta)) {
+            endRadians = startRadians + (delta > 0 ? 2.0 : -2.0) * Math.PI;
+        }
+        this._radians0 = startRadians;
+        this._radians1 = endRadians;
+    }
+    /** directly set the start and end angles in degrees */
+    setStartEndDegrees(startDegrees = 0, endDegrees = 360.0) {
+        this.setStartEndRadians(Angle.degreesToRadians(startDegrees), Angle.degreesToRadians(endDegrees));
+    }
+    /** copy from other AngleSweep. */
+    setFrom(other) { this._radians0 = other._radians0; this._radians1 = other._radians1; }
+    /** create a full circle sweep (CCW). startRadians defaults to 0 */
+    static create360(startRadians) {
+        startRadians = startRadians ? startRadians : 0.0;
+        return new AngleSweep(startRadians, startRadians + 2.0 * Math.PI);
+    }
+    /** create a sweep from the south pole to the north pole. */
+    static createFullLatitude() { return AngleSweep.createStartEndRadians(-0.5 * Math.PI, 0.5 * Math.PI); }
+    /** Reverse the start and end angle in place. */
+    reverseInPlace() { const a = this._radians0; this._radians0 = this._radians1; this._radians1 = a; }
+    /**  return a sweep for the "other" part of the circe.
+     * @param reverse true to retain the start and move backwards, false to more forwards.
+     */
+    cloneComplement(reverseDirection = false, result) {
+        const s = this.sweepRadians >= 0 ? 2.0 : -2.0;
+        if (reverseDirection)
+            return AngleSweep.createStartEndRadians(this.startRadians, this.endRadians - s * Math.PI, result);
+        else
+            return AngleSweep.createStartEndRadians(this.endRadians, this.startRadians + s * Math.PI, result);
+    }
+    /** Restrict start and end angles into the range (-90,+90) in degrees. */
+    capLatitudeInPlace() {
+        const limit = 0.5 * Math.PI;
+        this._radians0 = Geometry.clampToStartEnd(this._radians0, -limit, limit);
+        this._radians1 = Geometry.clampToStartEnd(this._radians1, -limit, limit);
+    }
+    /** Ask if the sweep is counterclockwise, i.e. positive sweep */
+    get isCCW() { return this._radians1 >= this._radians0; }
+    /** Ask if the sweep is a full circle. */
+    get isFullCircle() { return Angle.isFullCircleRadians(this.sweepRadians); }
+    /** Ask if the sweep is a full sweep from south pole to north pole. */
+    get isFullLatitudeSweep() {
+        const a = Math.PI * 0.5;
+        return Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, -a)
+            && Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1, a);
+    }
+    /** return a clone of this sweep. */
+    clone() { return new AngleSweep(this._radians0, this._radians1); }
+    /** Convert fractional position in the sweep to radians. */
+    fractionToRadians(fraction) {
+        return fraction < 0.5 ?
+            this._radians0 + fraction * (this._radians1 - this._radians0)
+            : this._radians1 + (fraction - 1.0) * (this._radians1 - this._radians0);
+    }
+    /** Convert fractional position in the sweep to strongly typed Angle object. */
+    fractionToAngle(fraction) {
+        return Angle.createRadians(this.fractionToRadians(fraction));
+    }
+    /** return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
+     * This is the number of fractional intervals required to cover a whole circle.
+     */
+    fractionPeriod() {
+        return Geometry.safeDivideFraction(Math.PI * 2.0, Math.abs(this._radians1 - this._radians0), 1.0);
+    }
+    /** return the fractionalized position of the angle,
+     * computed without consideration of 2PI period.
+     * That is, an angle that is numerically much beyond than the end angle
+     * will produce a large fraction and an angle much beyond the start angle
+     * will produce a large negative fraction.
+     *
+     */
+    angleToUnboundedFraction(theta) {
+        return Geometry.safeDivideFraction(theta.radians - this._radians0, this._radians1 - this._radians0, 1.0);
+    }
+    /** map an angle to a fractional coordinate which is:
+     *
+     * *  the start angle is at fraction 0
+     * *  the end angle is at fraction 1
+     * *  interior angles are between 0 and 1
+     * *  all exterior angles are at fractions greater than 1
+     * *  the periodic jump is at full wraparound to the start angle
+     */
+    angleToPositivePeriodicFraction(theta) { return this.radiansToPositivePeriodicFraction(theta.radians); }
+    /**
+     * Convert each value in an array from radians to fraction.
+     * @param data array that is input as radians, output as fractions
+     */
+    radiansArrayToPositivePeriodicFractions(data) {
+        const n = data.length;
+        for (let i = 0; i < n; i++) {
+            data.reassign(i, this.radiansToPositivePeriodicFraction(data.atUncheckedIndex(i)));
+        }
+    }
+    /**
+     * Convert a radians value to a fraction that is always positive and can wrap.  See `angleToPositivePeriodicFraction` for detailed description.
+     * @param radians
+     */
+    radiansToPositivePeriodicFraction(radians, zeroSweepDefault = 0.0) {
+        return AngleSweep.radiansToPositivePeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);
+    }
+    /**
+     * Convert a radians value to a fraction that is always positive and can wrap.  See `angleToPositivePeriodicFraction` for detailed description.
+     * @param radians
+     */
+    static radiansToPositivePeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepDefault = 0.0) {
+        if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians0))
+            return 0.0;
+        if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians1))
+            return 1.0;
+        const sweep = radians1 - radians0;
+        const delta = radians - radians0;
+        if (sweep > 0) {
+            const delta1 = Angle.adjustRadians0To2Pi(delta);
+            const fraction1 = Geometry.safeDivideFraction(delta1, sweep, zeroSweepDefault);
+            return fraction1;
+        }
+        const delta2 = Angle.adjustRadians0To2Pi(-delta);
+        const fraction2 = Geometry.safeDivideFraction(delta2, -sweep, zeroSweepDefault);
+        return fraction2;
+    }
+    /** map an angle to a fractional coordinate which is:
+     *
+     * *  the start angle is at fraction 0
+     * *  the end angle is at fraction 1
+     * *  interior angles are between 0 and 1
+     * *  small negative for angles just "before" the start angle
+     * *  more than one for angles just "after" the end angle
+     * *  the periodic jump is at the middle of the "outside" interval
+     */
+    angleToSignedPeriodicFraction(theta) {
+        return this.radiansToSignedPeriodicFraction(theta.radians);
+    }
+    /**
+     * Convert a radians value to a fraction, allowing wraparound.  See `angleToSignedPeriodicFraction` for detailed description.
+     */
+    radiansToSignedPeriodicFraction(radians) {
+        if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, this._radians0))
+            return 0.0;
+        if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, this._radians1))
+            return 1.0;
+        const sweep = this._radians1 - this._radians0;
+        // measure from middle of interval ...
+        const delta = radians - this._radians0 - 0.5 * sweep;
+        if (sweep > 0) {
+            const delta1 = Angle.adjustRadiansMinusPiPlusPi(delta);
+            const fraction1 = 0.5 + Geometry.safeDivideFraction(delta1, sweep, 0.0);
+            return fraction1;
+        }
+        const delta2 = Angle.adjustRadiansMinusPiPlusPi(-delta);
+        const fraction = 0.5 + Geometry.safeDivideFraction(delta2, -sweep, 0.0);
+        return fraction;
+    }
+    /** test if an angle is within the sweep */
+    isAngleInSweep(angle) { return this.isRadiansInSweep(angle.radians); }
+    /** test if radians are within sweep  */
+    isRadiansInSweep(radians, allowPeriodShift = true) {
+        return AngleSweep.isRadiansInStartEnd(radians, this.startRadians, this.endRadians, allowPeriodShift);
+    }
+    /** test if radians are within sweep  */
+    static isRadiansInStartEnd(radians, radians0, radians1, allowPeriodShift = true) {
+        // quick out for simple inside ...
+        const delta0 = radians - radians0;
+        const delta1 = radians - radians1;
+        if (delta0 * delta1 <= 0.0)
+            return true;
+        if (radians0 === radians1)
+            return allowPeriodShift ? Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians0) : Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0);
+        return allowPeriodShift ? this.radiansToPositivePeriodicFractionStartEnd(radians, radians0, radians1, 1000.0) <= 1.0 : false;
+    }
+    /** set this AngleSweep from various sources:
+     *
+     * * if json is undefined, a full-circle sweep is returned.
+     * * If json is an AngleSweep object it is cloned
+     * * If json is an array of 2 numbers, those numbers are start and end angles in degrees.
+     * * If `json.degrees` is an array of 2 numbers, those numbers are start and end angles in degrees.
+     * * If `json.radians` is an array of 2 numbers, those numbers are start and end angles in radians.
+     */
+    setFromJSON(json) {
+        if (!json)
+            this.setStartEndRadians(); // default full circle
+        else if (json instanceof AngleSweep)
+            this.setFrom(json);
+        else if (Geometry.isNumberArray(json.degrees, 2))
+            this.setStartEndDegrees(json.degrees[0], json.degrees[1]);
+        else if (Geometry.isNumberArray(json.radians, 2))
+            this.setStartEndRadians(json.radians[0], json.radians[1]);
+        else if (Geometry.isNumberArray(json, 2))
+            this.setStartEndDegrees(json[0], json[1]);
+    }
+    /** create an AngleSweep from a json object. */
+    static fromJSON(json) {
+        const result = AngleSweep.create360();
+        result.setFromJSON(json);
+        return result;
+    }
+    /**
+     * Convert an AngleSweep to a JSON object.
+     * @return {*} {degrees: [startAngleInDegrees, endAngleInDegrees}
+     */
+    toJSON() {
+        // return { degrees: [this.startDegrees, this.endDegrees] };
+        return [this.startDegrees, this.endDegrees];
+    }
+    /** test if start and end angles match, with explicit name to clarify that there is no test for 360-degree shifts. */
+    isAlmostEqualAllowPeriodShift(other) {
+        return Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians0, other._radians0)
+            && Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
+    }
+    /** test if start and end angles match, explicit name to clarify that 360-degree shifts are allowed. */
+    isAlmostEqualNoPeriodShift(other) {
+        return Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, other._radians0)
+            && Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
+    }
+    /** test if start and end angles match with radians tolerance.
+     * * This is equivalent to isAlmostEqualNoPeriodShift.
+     * * it is present for consistency with other classes
+     * * It is recommended that all callers use one of he longer names to be clear of their intentions:
+     * * * isAlmostEqualAllowPeriodShift
+     * * * isAlmostEqualRadiansNoPeriodShift
+     */
+    isAlmostEqual(other) { return this.isAlmostEqualNoPeriodShift(other); }
+}
+//# sourceMappingURL=AngleSweep.js.map

package/lib/esm/geometry3d/AngleSweep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AngleSweep.js","sourceRoot":"","sources":["../../../src/geometry3d/AngleSweep.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module CartesianGeometry\r\n */\r\n\r\nimport { AngleSweepProps, BeJSONFunctions, Geometry } from \"../Geometry\";\r\nimport { Angle } from \"./Angle\";\r\nimport { GrowableFloat64Array } from \"./GrowableFloat64Array\";\r\n\r\n/**\r\n * An `AngleSweep` is a pair of angles at start and end of an interval.\r\n *\r\n * *  For stroking purposes, the \"included interval\" is all angles numerically reached by theta = start + f*(end-start), where f is between 0 and 1.\r\n * *  This stroking formula is simple numbers -- 2PI shifts are not involved.\r\n * *  2PI shifts do become important in the reverse mapping of an angle to a fraction.\r\n * *  If (start < end) the angle proceeds CCW around the unit circle.\r\n * *  If (end < start) the angle proceeds CW around the unit circle.\r\n * *  Angles beyond 360 are fine as endpoints.\r\n *   *  (350,370) covers the same unit angles as (-10,10).\r\n *   *  (370,350) covers the same unit angles as (10,-10).\r\n * @public\r\n */\r\nexport class AngleSweep implements BeJSONFunctions {\r\n  private _radians0: number;\r\n  private _radians1: number;\r\n  /** Read-property for degrees at the start of this AngleSweep. */\r\n  public get startDegrees() { return Angle.radiansToDegrees(this._radians0); }\r\n  /** Read-property for degrees at the end of this AngleSweep. */\r\n  public get endDegrees() { return Angle.radiansToDegrees(this._radians1); }\r\n  /** Read-property for signed start-to-end sweep in degrees. */\r\n  public get sweepDegrees() { return Angle.radiansToDegrees(this._radians1 - this._radians0); }\r\n  /** Read-property for degrees at the start of this AngleSweep. */\r\n  public get startRadians() { return this._radians0; }\r\n  /** Read-property for degrees at the end of this AngleSweep. */\r\n  public get endRadians() { return this._radians1; }\r\n  /** Read-property for signed start-to-end sweep in radians. */\r\n  public get sweepRadians() { return this._radians1 - this._radians0; }\r\n  /** Return the (strongly typed) start angle */\r\n  public get startAngle() { return Angle.createRadians(this._radians0); }\r\n  /** Return the (strongly typed) end angle */\r\n  public get endAngle() { return Angle.createRadians(this._radians1); }\r\n  /** Create a sweep as one of\r\n   * * A clone of a given sweep\r\n   * * 0 to given angle\r\n   * * full circle if no arg given (sweep 0 to 360 degrees)\r\n   */\r\n  public static create(data?: AngleSweep | Angle): AngleSweep {\r\n    if (data instanceof AngleSweep)\r\n      return data.clone();\r\n    if (data instanceof Angle)\r\n      return new AngleSweep(0, data.radians);\r\n    return AngleSweep.create360();\r\n  }\r\n  /** (private) constructor with start and end angles in radians.\r\n   *  * Use explicitly named static methods to clarify intent and units of inputs:\r\n   *\r\n   * * createStartEndRadians (startRadians:number, endRadians:number)\r\n   * * createStartEndDegrees (startDegrees:number, endDegrees:number)\r\n   * * createStartEnd (startAngle:Angle, endAngle:Angle)\r\n   * * createStartSweepRadians (startRadians:number, sweepRadians:number)\r\n   * * createStartSweepDegrees (startDegrees:number, sweepDegrees:number)\r\n   * * createStartSweep (startAngle:Angle, sweepAngle:Angle)\r\n   */\r\n  private constructor(startRadians: number = 0, endRadians: number = 0) { this._radians0 = startRadians; this._radians1 = endRadians; }\r\n  /** create an AngleSweep from start and end angles given in radians. */\r\n  public static createStartEndRadians(startRadians: number = 0, endRadians: number = 2.0 * Math.PI, result?: AngleSweep): AngleSweep {\r\n    result = result ? result : new AngleSweep();\r\n    result.setStartEndRadians(startRadians, endRadians);\r\n    return result;\r\n  }\r\n  /** Return the angle obtained by subtracting radians from this angle. */\r\n  public cloneMinusRadians(radians: number): AngleSweep { return new AngleSweep(this._radians0 - radians, this._radians1 - radians); }\r\n  /** create an AngleSweep from start and end angles given in degrees. */\r\n  public static createStartEndDegrees(startDegrees: number = 0, endDegrees: number = 360, result?: AngleSweep): AngleSweep {\r\n    return AngleSweep.createStartEndRadians(Angle.degreesToRadians(startDegrees), Angle.degreesToRadians(endDegrees), result);\r\n  }\r\n  /** create an angle sweep from strongly typed start and end angles */\r\n  public static createStartEnd(startAngle: Angle, endAngle: Angle, result?: AngleSweep): AngleSweep {\r\n    result = result ? result : new AngleSweep();\r\n    result.setStartEndRadians(startAngle.radians, endAngle.radians);\r\n    return result;\r\n  }\r\n  /** Create an angle sweep with limits given as (strongly typed) angles for start and sweep */\r\n  public static createStartSweep(startAngle: Angle, sweepAngle: Angle, result?: AngleSweep): AngleSweep {\r\n    return AngleSweep.createStartSweepRadians(startAngle.radians, sweepAngle.radians, result);\r\n  }\r\n  /** Return a sweep with limits interpolated between this and other. */\r\n  public interpolate(fraction: number, other: AngleSweep): AngleSweep {\r\n    return new AngleSweep(Geometry.interpolate(this._radians0, fraction, other._radians0), Geometry.interpolate(this._radians1, fraction, other._radians1));\r\n  }\r\n  /** create an AngleSweep from start and end angles given in radians. */\r\n  public static createStartSweepRadians(startRadians: number = 0, sweepRadians: number = Math.PI, result?: AngleSweep): AngleSweep {\r\n    result = result ? result : new AngleSweep();\r\n    result.setStartEndRadians(startRadians, startRadians + sweepRadians);\r\n    return result;\r\n  }\r\n  /** create an AngleSweep from start and sweep given in degrees.  */\r\n  public static createStartSweepDegrees(startDegrees: number = 0, sweepDegrees: number = 360, result?: AngleSweep): AngleSweep {\r\n    return AngleSweep.createStartEndRadians(Angle.degreesToRadians(startDegrees), Angle.degreesToRadians(startDegrees + sweepDegrees), result);\r\n  }\r\n  /** directly set the start and end angles in radians */\r\n  public setStartEndRadians(startRadians: number = 0, endRadians: number = 2.0 * Math.PI) {\r\n    const delta = endRadians - startRadians;\r\n    if (Angle.isFullCircleRadians(delta)) {\r\n      endRadians = startRadians + (delta > 0 ? 2.0 : -2.0) * Math.PI;\r\n    }\r\n    this._radians0 = startRadians;\r\n    this._radians1 = endRadians;\r\n  }\r\n  /** directly set the start and end angles in degrees */\r\n  public setStartEndDegrees(startDegrees: number = 0, endDegrees: number = 360.0) {\r\n    this.setStartEndRadians(Angle.degreesToRadians(startDegrees), Angle.degreesToRadians(endDegrees));\r\n  }\r\n  /** copy from other AngleSweep. */\r\n  public setFrom(other: AngleSweep) { this._radians0 = other._radians0; this._radians1 = other._radians1; }\r\n  /** create a full circle sweep (CCW). startRadians defaults to 0 */\r\n  public static create360(startRadians?: number): AngleSweep {\r\n    startRadians = startRadians ? startRadians : 0.0;\r\n    return new AngleSweep(startRadians, startRadians + 2.0 * Math.PI);\r\n  }\r\n  /** create a sweep from the south pole to the north pole. */\r\n  public static createFullLatitude() { return AngleSweep.createStartEndRadians(-0.5 * Math.PI, 0.5 * Math.PI); }\r\n  /** Reverse the start and end angle in place. */\r\n  public reverseInPlace() { const a = this._radians0; this._radians0 = this._radians1; this._radians1 = a; }\r\n  /**  return a sweep for the \"other\" part of the circe.\r\n   * @param reverse true to retain the start and move backwards, false to more forwards.\r\n   */\r\n  public cloneComplement(reverseDirection: boolean = false, result?: AngleSweep): AngleSweep {\r\n    const s = this.sweepRadians >= 0 ? 2.0 : -2.0;\r\n    if (reverseDirection)\r\n      return AngleSweep.createStartEndRadians(this.startRadians, this.endRadians - s * Math.PI, result);\r\n    else\r\n      return AngleSweep.createStartEndRadians(this.endRadians, this.startRadians + s * Math.PI, result);\r\n  }\r\n  /** Restrict start and end angles into the range (-90,+90) in degrees. */\r\n  public capLatitudeInPlace() {\r\n    const limit = 0.5 * Math.PI;\r\n    this._radians0 = Geometry.clampToStartEnd(this._radians0, -limit, limit);\r\n    this._radians1 = Geometry.clampToStartEnd(this._radians1, -limit, limit);\r\n  }\r\n  /** Ask if the sweep is counterclockwise, i.e. positive sweep */\r\n  public get isCCW(): boolean { return this._radians1 >= this._radians0; }\r\n  /** Ask if the sweep is a full circle. */\r\n  public get isFullCircle(): boolean { return Angle.isFullCircleRadians(this.sweepRadians); }\r\n  /** Ask if the sweep is a full sweep from south pole to north pole. */\r\n  public get isFullLatitudeSweep(): boolean {\r\n    const a = Math.PI * 0.5;\r\n    return Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, -a)\r\n      && Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1, a);\r\n  }\r\n  /** return a clone of this sweep. */\r\n  public clone(): AngleSweep { return new AngleSweep(this._radians0, this._radians1); }\r\n  /** Convert fractional position in the sweep to radians. */\r\n  public fractionToRadians(fraction: number) {\r\n    return fraction < 0.5 ?\r\n      this._radians0 + fraction * (this._radians1 - this._radians0)\r\n      : this._radians1 + (fraction - 1.0) * (this._radians1 - this._radians0);\r\n  }\r\n  /** Convert fractional position in the sweep to strongly typed Angle object. */\r\n  public fractionToAngle(fraction: number) {\r\n    return Angle.createRadians(this.fractionToRadians(fraction));\r\n  }\r\n  /** return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).\r\n   * This is the number of fractional intervals required to cover a whole circle.\r\n   */\r\n  public fractionPeriod(): number {\r\n    return Geometry.safeDivideFraction(Math.PI * 2.0, Math.abs(this._radians1 - this._radians0), 1.0);\r\n  }\r\n  /** return the fractionalized position of the angle,\r\n   * computed without consideration of 2PI period.\r\n   * That is, an angle that is numerically much beyond than the end angle\r\n   * will produce a large fraction and an angle much beyond the start angle\r\n   * will produce a large negative fraction.\r\n   *\r\n   */\r\n  public angleToUnboundedFraction(theta: Angle): number {\r\n    return Geometry.safeDivideFraction(theta.radians - this._radians0, this._radians1 - this._radians0, 1.0);\r\n  }\r\n  /** map an angle to a fractional coordinate which is:\r\n   *\r\n   * *  the start angle is at fraction 0\r\n   * *  the end angle is at fraction 1\r\n   * *  interior angles are between 0 and 1\r\n   * *  all exterior angles are at fractions greater than 1\r\n   * *  the periodic jump is at full wraparound to the start angle\r\n   */\r\n  public angleToPositivePeriodicFraction(theta: Angle): number { return this.radiansToPositivePeriodicFraction(theta.radians); }\r\n  /**\r\n   * Convert each value in an array from radians to fraction.\r\n   * @param data array that is input as radians, output as fractions\r\n   */\r\n  public radiansArrayToPositivePeriodicFractions(data: GrowableFloat64Array) {\r\n    const n = data.length;\r\n    for (let i = 0; i < n; i++) {\r\n      data.reassign(i, this.radiansToPositivePeriodicFraction(data.atUncheckedIndex(i)));\r\n    }\r\n  }\r\n  /**\r\n   * Convert a radians value to a fraction that is always positive and can wrap.  See `angleToPositivePeriodicFraction` for detailed description.\r\n   * @param radians\r\n   */\r\n  public radiansToPositivePeriodicFraction(radians: number, zeroSweepDefault: number = 0.0): number {\r\n    return AngleSweep.radiansToPositivePeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);\r\n  }\r\n  /**\r\n   * Convert a radians value to a fraction that is always positive and can wrap.  See `angleToPositivePeriodicFraction` for detailed description.\r\n   * @param radians\r\n   */\r\n  public static radiansToPositivePeriodicFractionStartEnd(radians: number, radians0: number, radians1: number, zeroSweepDefault: number = 0.0): number {\r\n    if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians0))\r\n      return 0.0;\r\n    if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians1))\r\n      return 1.0;\r\n    const sweep = radians1 - radians0;\r\n    const delta = radians - radians0;\r\n    if (sweep > 0) {\r\n      const delta1 = Angle.adjustRadians0To2Pi(delta);\r\n      const fraction1 = Geometry.safeDivideFraction(delta1, sweep, zeroSweepDefault);\r\n      return fraction1;\r\n    }\r\n    const delta2 = Angle.adjustRadians0To2Pi(-delta);\r\n    const fraction2 = Geometry.safeDivideFraction(delta2, -sweep, zeroSweepDefault);\r\n    return fraction2;\r\n  }\r\n  /** map an angle to a fractional coordinate which is:\r\n   *\r\n   * *  the start angle is at fraction 0\r\n   * *  the end angle is at fraction 1\r\n   * *  interior angles are between 0 and 1\r\n   * *  small negative for angles just \"before\" the start angle\r\n   * *  more than one for angles just \"after\" the end angle\r\n   * *  the periodic jump is at the middle of the \"outside\" interval\r\n   */\r\n  public angleToSignedPeriodicFraction(theta: Angle): number {\r\n    return this.radiansToSignedPeriodicFraction(theta.radians);\r\n  }\r\n  /**\r\n   * Convert a radians value to a fraction, allowing wraparound.  See `angleToSignedPeriodicFraction` for detailed description.\r\n   */\r\n  public radiansToSignedPeriodicFraction(radians: number): number {\r\n    if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, this._radians0))\r\n      return 0.0;\r\n    if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, this._radians1))\r\n      return 1.0;\r\n    const sweep = this._radians1 - this._radians0;\r\n    // measure from middle of interval ...\r\n    const delta = radians - this._radians0 - 0.5 * sweep;\r\n    if (sweep > 0) {\r\n      const delta1 = Angle.adjustRadiansMinusPiPlusPi(delta);\r\n      const fraction1 = 0.5 + Geometry.safeDivideFraction(delta1, sweep, 0.0);\r\n      return fraction1;\r\n    }\r\n    const delta2 = Angle.adjustRadiansMinusPiPlusPi(-delta);\r\n    const fraction = 0.5 + Geometry.safeDivideFraction(delta2, -sweep, 0.0);\r\n    return fraction;\r\n  }\r\n  /** test if an angle is within the sweep */\r\n  public isAngleInSweep(angle: Angle): boolean { return this.isRadiansInSweep(angle.radians); }\r\n  /** test if radians are within sweep  */\r\n  public isRadiansInSweep(radians: number, allowPeriodShift: boolean = true): boolean {\r\n    return AngleSweep.isRadiansInStartEnd(radians, this.startRadians, this.endRadians, allowPeriodShift);\r\n  }\r\n  /** test if radians are within sweep  */\r\n  public static isRadiansInStartEnd(radians: number, radians0: number, radians1: number, allowPeriodShift: boolean = true): boolean {\r\n    // quick out for simple inside ...\r\n    const delta0 = radians - radians0;\r\n    const delta1 = radians - radians1;\r\n    if (delta0 * delta1 <= 0.0)\r\n      return true;\r\n\r\n    if (radians0 === radians1)\r\n      return allowPeriodShift ? Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians0) : Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0);\r\n    return allowPeriodShift ? this.radiansToPositivePeriodicFractionStartEnd(radians, radians0, radians1, 1000.0) <= 1.0 : false;\r\n  }\r\n\r\n  /** set this AngleSweep from various sources:\r\n   *\r\n   * * if json is undefined, a full-circle sweep is returned.\r\n   * * If json is an AngleSweep object it is cloned\r\n   * * If json is an array of 2 numbers, those numbers are start and end angles in degrees.\r\n   * * If `json.degrees` is an array of 2 numbers, those numbers are start and end angles in degrees.\r\n   * * If `json.radians` is an array of 2 numbers, those numbers are start and end angles in radians.\r\n   */\r\n  public setFromJSON(json?: any) {\r\n    if (!json)\r\n      this.setStartEndRadians(); // default full circle\r\n    else if (json instanceof AngleSweep)\r\n      this.setFrom(json);\r\n    else if (Geometry.isNumberArray(json.degrees, 2))\r\n      this.setStartEndDegrees(json.degrees[0], json.degrees[1]);\r\n    else if (Geometry.isNumberArray(json.radians, 2))\r\n      this.setStartEndRadians(json.radians[0], json.radians[1]);\r\n    else if (Geometry.isNumberArray(json, 2))\r\n      this.setStartEndDegrees(json[0], json[1]);\r\n  }\r\n  /** create an AngleSweep from a json object. */\r\n  public static fromJSON(json?: AngleSweepProps) {\r\n    const result = AngleSweep.create360();\r\n    result.setFromJSON(json);\r\n    return result;\r\n  }\r\n  /**\r\n   * Convert an AngleSweep to a JSON object.\r\n   * @return {*} {degrees: [startAngleInDegrees, endAngleInDegrees}\r\n   */\r\n  public toJSON(): any {\r\n    // return { degrees: [this.startDegrees, this.endDegrees] };\r\n    return [this.startDegrees, this.endDegrees];\r\n  }\r\n  /** test if start and end angles match, with explicit name to clarify that there is no test for 360-degree shifts. */\r\n  public isAlmostEqualAllowPeriodShift(other: AngleSweep): boolean {\r\n    return Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians0, other._radians0)\r\n      && Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);\r\n  }\r\n  /** test if start and end angles match, explicit name to clarify that 360-degree shifts are allowed. */\r\n  public isAlmostEqualNoPeriodShift(other: AngleSweep): boolean {\r\n    return Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, other._radians0)\r\n      && Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);\r\n  }\r\n  /** test if start and end angles match with radians tolerance.\r\n   * * This is equivalent to isAlmostEqualNoPeriodShift.\r\n   * * it is present for consistency with other classes\r\n   * * It is recommended that all callers use one of he longer names to be clear of their intentions:\r\n   * * * isAlmostEqualAllowPeriodShift\r\n   * * * isAlmostEqualRadiansNoPeriodShift\r\n   */\r\n  public isAlmostEqual(other: AngleSweep): boolean { return this.isAlmostEqualNoPeriodShift(other); }\r\n}\r\n"]}

package/lib/esm/geometry3d/BarycentricTriangle.d.ts

@@ -0,0 +1,51 @@
+/** @packageDocumentation
+ * @module CartesianGeometry
+ */
+import { Point3d } from "./Point3dVector3d";
+/**
+ * 3 points defining a triangle to be evaluated with Barycentric coordinates.
+ * @public
+ */
+export declare class BarycentricTriangle {
+    /** Array of 3 point coordinates for the triangle. */
+    points: Point3d[];
+    /** Constructor.
+     * * Point references are CAPTURED
+     */
+    protected constructor(point0: Point3d, point1: Point3d, point2: Point3d);
+    /**
+     * Return a `BarycentricTriangle` with coordinates given by enumerated x,y,z of the 3 points.
+     * @param result optional pre-allocated triangle.
+     */
+    static createXYZXYZXYZ(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, result?: BarycentricTriangle): BarycentricTriangle;
+    /** create a triangle with coordinates cloned from given points. */
+    static create(point0: Point3d, point1: Point3d, point2: Point3d, result?: BarycentricTriangle): BarycentricTriangle;
+    /** Return a new `BarycentricTriangle` with the same coordinates. */
+    clone(result?: BarycentricTriangle): BarycentricTriangle;
+    /** Return area divided by sum of squared lengths. */
+    get aspectRatio(): number;
+    /** Return the area of the triangle. */
+    get area(): number;
+    /** Sum the points with given scales.
+     * * In normal use, the scales will add to 1 and the result point is in the plane of the triangle.
+     * * If scales do not add to 1, the point is in the triangle scaled (by the scale sum) from the origin.
+     */
+    fractionToPoint(a0: number, a1: number, a2: number, result?: Point3d): Point3d;
+    /** Copy all values from `other`
+     */
+    setFrom(other: BarycentricTriangle): void;
+    /** copy contents of (not pointers to) the given points. */
+    set(point0: Point3d | undefined, point1: Point3d | undefined, point2: Point3d | undefined): void;
+    private static _workVector0?;
+    private static _workVector1?;
+    /**
+     * * 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
+     */
+    dotProductOfCrossProductsFromOrigin(other: BarycentricTriangle): number;
+    /** Return the centroid of the 3 points. */
+    centroid(result?: Point3d): Point3d;
+    /** test for point-by-point `isAlmostEqual` relationship. */
+    isAlmostEqual(other: BarycentricTriangle): boolean;
+}
+//# sourceMappingURL=BarycentricTriangle.d.ts.map

package/lib/esm/geometry3d/BarycentricTriangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BarycentricTriangle.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/BarycentricTriangle.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAE,OAAO,EAAY,MAAM,mBAAmB,CAAC;AAEtD;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B,qDAAqD;IAC9C,MAAM,EAAE,OAAO,EAAE,CAAC;IACzB;;OAEG;IACH,SAAS,aAAa,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO;IAOvE;;;OAGG;WACW,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,mBAAmB,GAAG,mBAAmB;IAO5L,mEAAmE;WACrD,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,mBAAmB,GAAG,mBAAmB;IAM1H,oEAAoE;IAC7D,KAAK,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,mBAAmB;IAI/D,qDAAqD;IACrD,IAAW,WAAW,IAAI,MAAM,CAG/B;IACD,uCAAuC;IACvC,IAAW,IAAI,IAAI,MAAM,CAExB;IACD;;;OAGG;IACI,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAIrF;OACG;IACI,OAAO,CAAC,KAAK,EAAE,mBAAmB;IAKzC,2DAA2D;IACpD,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS;IAMhG,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAW;IACvC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAW;IACvC;;;OAGG;IACI,mCAAmC,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM;IAK9E,2CAA2C;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAS1C,4DAA4D;IACrD,aAAa,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO;CAK1D"}

package/lib/esm/geometry3d/BarycentricTriangle.js

@@ -0,0 +1,97 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module CartesianGeometry
+ */
+import { Geometry } from "../Geometry";
+import { Point3d } from "./Point3dVector3d";
+/**
+ * 3 points defining a triangle to be evaluated with Barycentric coordinates.
+ * @public
+ */
+export class BarycentricTriangle {
+    /** Constructor.
+     * * Point references are CAPTURED
+     */
+    constructor(point0, point1, point2) {
+        this.points = [];
+        this.points.push(point0);
+        this.points.push(point1);
+        this.points.push(point2);
+    }
+    /**
+     * Return 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) {
+        if (!result)
+            return new this(Point3d.create(x0, y0, z0), Point3d.create(x1, y1, z1), Point3d.create(x2, y2, z2));
+        result.points[0].set(x0, y0, z0);
+        result.points[1].set(x1, y1, z1);
+        result.points[2].set(x2, y2, z2);
+        return result;
+    }
+    /** 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());
+        result.set(point0, point1, point2);
+        return result;
+    }
+    /** Return a new `BarycentricTriangle` with the same coordinates. */
+    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.safeDivideFraction(0.5 * this.points[0].crossProductToPointsMagnitude(this.points[1], this.points[2]), (this.points[0].distanceSquared(this.points[1]) + this.points[1].distanceSquared(this.points[2]) + this.points[2].distanceSquared(this.points[0])), 0);
+    }
+    /** Return the area of the triangle. */
+    get area() {
+        return 0.5 * this.points[0].crossProductToPointsMagnitude(this.points[1], this.points[2]);
+    }
+    /** Sum the points with given scales.
+     * * In normal use, the scales will add to 1 and the result point is in the plane of the triangle.
+     * * If scales do not add to 1, the point is in the triangle scaled (by the scale sum) from the origin.
+     */
+    fractionToPoint(a0, a1, a2, result) {
+        return Point3d.createAdd3Scaled(this.points[0], a0, this.points[1], a1, this.points[2], a2, result);
+    }
+    /** Copy all values from `other`
+     */
+    setFrom(other) {
+        this.points[0].setFromPoint3d(other.points[0]);
+        this.points[1].setFromPoint3d(other.points[1]);
+        this.points[2].setFromPoint3d(other.points[2]);
+    }
+    /** copy contents of (not pointers to) the given points. */
+    set(point0, point1, point2) {
+        this.points[0].setFromPoint3d(point0);
+        this.points[1].setFromPoint3d(point1);
+        this.points[2].setFromPoint3d(point2);
+    }
+    /**
+     * * 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
+     */
+    dotProductOfCrossProductsFromOrigin(other) {
+        BarycentricTriangle._workVector0 = this.points[0].crossProductToPoints(this.points[1], this.points[2], BarycentricTriangle._workVector0);
+        BarycentricTriangle._workVector1 = other.points[0].crossProductToPoints(other.points[1], other.points[2], BarycentricTriangle._workVector1);
+        return BarycentricTriangle._workVector0.dotProduct(BarycentricTriangle._workVector1);
+    }
+    /** 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.
+        return 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);
+    }
+    /** 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]);
+    }
+}
+//# sourceMappingURL=BarycentricTriangle.js.map

package/lib/esm/geometry3d/BarycentricTriangle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BarycentricTriangle.js","sourceRoot":"","sources":["../../../src/geometry3d/BarycentricTriangle.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module CartesianGeometry\r\n */\r\n\r\nimport { Geometry } from \"../Geometry\";\r\nimport { Point3d, Vector3d } from \"./Point3dVector3d\";\r\n\r\n/**\r\n * 3 points defining a triangle to be evaluated with Barycentric coordinates.\r\n * @public\r\n */\r\nexport class BarycentricTriangle {\r\n  /** Array of 3 point coordinates for the triangle. */\r\n  public points: Point3d[];\r\n  /** Constructor.\r\n   * * Point references are CAPTURED\r\n   */\r\n  protected constructor(point0: Point3d, point1: Point3d, point2: Point3d) {\r\n    this.points = [];\r\n    this.points.push(point0);\r\n    this.points.push(point1);\r\n    this.points.push(point2);\r\n  }\r\n\r\n  /**\r\n   * Return a `BarycentricTriangle` with coordinates given by enumerated x,y,z of the 3 points.\r\n   * @param result optional pre-allocated triangle.\r\n   */\r\n  public static createXYZXYZXYZ(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, result?: BarycentricTriangle): BarycentricTriangle {\r\n    if (!result) return new this(Point3d.create(x0, y0, z0), Point3d.create(x1, y1, z1), Point3d.create(x2, y2, z2));\r\n    result.points[0].set(x0, y0, z0);\r\n    result.points[1].set(x1, y1, z1);\r\n    result.points[2].set(x2, y2, z2);\r\n    return result;\r\n  }\r\n  /** create a triangle with coordinates cloned from given points. */\r\n  public static create(point0: Point3d, point1: Point3d, point2: Point3d, result?: BarycentricTriangle): BarycentricTriangle {\r\n    if (!result)\r\n      return new this(point0.clone(), point1.clone(), point2.clone());\r\n    result.set(point0, point1, point2);\r\n    return result;\r\n  }\r\n  /** Return a new `BarycentricTriangle` with the same coordinates. */\r\n  public clone(result?: BarycentricTriangle): BarycentricTriangle {\r\n    return BarycentricTriangle.create(this.points[0], this.points[1], this.points[2], result);\r\n  }\r\n\r\n  /** Return area divided by sum of squared lengths. */\r\n  public get aspectRatio(): number {\r\n    return Geometry.safeDivideFraction(0.5 * this.points[0].crossProductToPointsMagnitude(this.points[1], this.points[2]),\r\n      (this.points[0].distanceSquared(this.points[1]) + this.points[1].distanceSquared(this.points[2]) + this.points[2].distanceSquared(this.points[0])), 0);\r\n  }\r\n  /** Return the area of the triangle. */\r\n  public get area(): number {\r\n    return 0.5 * this.points[0].crossProductToPointsMagnitude(this.points[1], this.points[2]);\r\n  }\r\n  /** Sum the points with given scales.\r\n   * * In normal use, the scales will add to 1 and the result point is in the plane of the triangle.\r\n   * * If scales do not add to 1, the point is in the triangle scaled (by the scale sum) from the origin.\r\n   */\r\n  public fractionToPoint(a0: number, a1: number, a2: number, result?: Point3d): Point3d {\r\n    return Point3d.createAdd3Scaled(this.points[0], a0, this.points[1], a1, this.points[2], a2, result);\r\n  }\r\n\r\n  /** Copy all values from `other`\r\n   */\r\n  public setFrom(other: BarycentricTriangle) {\r\n    this.points[0].setFromPoint3d(other.points[0]);\r\n    this.points[1].setFromPoint3d(other.points[1]);\r\n    this.points[2].setFromPoint3d(other.points[2]);\r\n  }\r\n  /** copy contents of (not pointers to) the given points. */\r\n  public set(point0: Point3d | undefined, point1: Point3d | undefined, point2: Point3d | undefined) {\r\n    this.points[0].setFromPoint3d(point0);\r\n    this.points[1].setFromPoint3d(point1);\r\n    this.points[2].setFromPoint3d(point2);\r\n\r\n  }\r\n  private static _workVector0?: Vector3d;\r\n  private static _workVector1?: Vector3d;\r\n  /**\r\n   * * For `this` and `other` BarycentricTriangles, compute cross products of vectors from point0 to point1 and from point0 to point2.\r\n   * * return the dot product of those two\r\n   */\r\n  public dotProductOfCrossProductsFromOrigin(other: BarycentricTriangle): number {\r\n    BarycentricTriangle._workVector0 = this.points[0].crossProductToPoints(this.points[1], this.points[2], BarycentricTriangle._workVector0);\r\n    BarycentricTriangle._workVector1 = other.points[0].crossProductToPoints(other.points[1], other.points[2], BarycentricTriangle._workVector1);\r\n    return BarycentricTriangle._workVector0.dotProduct(BarycentricTriangle._workVector1);\r\n  }\r\n  /** Return the centroid of the 3 points. */\r\n  public centroid(result?: Point3d): Point3d {\r\n    // write it out to get single scale application.\r\n    // Do the scale as true division (rather than multiply by precomputed 1/3).  This might protect one bit of result.\r\n    return Point3d.create(\r\n      (this.points[0].x + this.points[1].x + this.points[2].x) / 3.0,\r\n      (this.points[0].y + this.points[1].y + this.points[2].y) / 3.0,\r\n      (this.points[0].z + this.points[1].z + this.points[2].z) / 3.0,\r\n      result);\r\n  }\r\n  /** test for point-by-point `isAlmostEqual` relationship. */\r\n  public isAlmostEqual(other: BarycentricTriangle): boolean {\r\n    return this.points[0].isAlmostEqual(other.points[0])\r\n      && this.points[1].isAlmostEqual(other.points[1])\r\n      && this.points[2].isAlmostEqual(other.points[2]);\r\n  }\r\n}\r\n"]}