@itwin/core-geometry 4.10.0-dev.3 → 4.10.0-dev.31

package/lib/cjs/geometry3d/AngleSweep.js

@@ -216,9 +216,10 @@ class AngleSweep {
     /**
      * 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.
+     * @returns period of the sweep, or 1 if sweep is empty.
      */
     fractionPeriod() {
-        return Geometry_1.Geometry.safeDivideFraction(Math.PI * 2.0, Math.abs(this._radians1 - this._radians0), 1.0);
+        return this.isEmpty ? 1.0 : Angle_1.Angle.pi2Radians / Math.abs(this._radians1 - this._radians0);
     }
     /**
      * Return the fractionalized position of the given angle (as Angle) computed without consideration of
@@ -231,68 +232,100 @@ class AngleSweep {
      * *  fraction larger than one for angles "before" the start angle if start > end
      * *  negative fraction for angles "after" the end angle if start > end
      * *  does not allow period shift
+     * @returns unbounded fraction, or 1 if sweep is empty.
      */
     angleToUnboundedFraction(theta) {
-        return Geometry_1.Geometry.safeDivideFraction(theta.radians - this._radians0, this._radians1 - this._radians0, 1.0);
+        return this.isEmpty ? 1.0 : (theta.radians - this._radians0) / (this._radians1 - this._radians0);
+    }
+    /**
+     * Convert a sweep fraction to the equivalent period-shifted fraction inside the sweep, or within one period of zero
+     * on the desired side.
+     * @param fraction fraction of the sweep.
+     * @param radians0 start angle of sweep (in radians).
+     * @param radians1 end angle of sweep (in radians).
+     * @param toNegativeFraction return an exterior fraction period-shifted to within one period of the start (true) or
+     * end (false) of the sweep.
+     * @returns period-shifted fraction. If `fraction` is already in [0,1], or the sweep is empty, then `fraction` is
+     * returned unchanged.
+     */
+    static fractionToSignedPeriodicFractionStartEnd(fraction, radians0, radians1, toNegativeFraction) {
+        const sweep = radians1 - radians0;
+        if (Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(0, sweep))
+            return fraction; // empty sweep
+        if (Geometry_1.Geometry.isIn01(fraction))
+            return fraction;
+        const period = Angle_1.Angle.pi2Radians / Math.abs(sweep);
+        fraction = fraction % period; // period-shifted equivalent fraction closest to 0 with same sign as fraction
+        if (fraction + period < 1)
+            fraction += period; // it's really an interior fraction
+        if (Geometry_1.Geometry.isIn01(fraction) || (toNegativeFraction && fraction < 0) || (!toNegativeFraction && fraction > 1))
+            return fraction;
+        return toNegativeFraction ? fraction - period : fraction + period; // shift to other side of sweep
+    }
+    /**
+     * Convert a sweep fraction to the equivalent period-shifted fraction inside this sweep, or within one period of
+     * zero on the desired side.
+     * @param fraction fraction of the sweep.
+     * @param toNegativeFraction return an exterior fraction period-shifted to within one period of the start (true) or
+     * end (false) of the sweep.
+     * @returns period-shifted fraction. If `fraction` is already in [0,1], or the sweep is empty, then `fraction` is
+     * returned unchanged.
+     */
+    fractionToSignedPeriodicFraction(fraction, toNegativeFraction) {
+        return AngleSweep.fractionToSignedPeriodicFractionStartEnd(fraction, this._radians0, this._radians1, toNegativeFraction);
     }
     /**
      * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  consider radians0 as `start` angle of the sweep and radians1 as `end` angle of the sweep
-     * *  fraction is always positive
      * *  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
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param radians0 start angle of sweep (in radians)
+     * @param radians1 end angle of sweep (in radians)
+     * @param zeroSweepDefault return value when the sweep is empty (default 0)
+     * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.
      */
     static radiansToPositivePeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepDefault = 0.0) {
-        if (Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(radians0, radians1)) {
-            // for 2nPi sweep, allow matching without period shift, else we never return 1.0
-            if (Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0))
-                return 0.0;
-            if (Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians1))
-                return 1.0;
-        }
-        else {
-            if (Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians0))
-                return 0.0;
-            if (Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians1))
-                return 1.0;
+        const zeroSweepMarker = Geometry_1.Geometry.largeCoordinateResult;
+        let fraction = this.radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepMarker);
+        if (fraction === zeroSweepMarker)
+            return zeroSweepDefault;
+        if (fraction < 0) {
+            const period = Angle_1.Angle.pi2Radians / Math.abs(radians1 - radians0);
+            fraction += period;
         }
-        const sweep = radians1 - radians0;
-        const delta = radians - radians0;
-        if (sweep > 0) {
-            const delta1 = Angle_1.Angle.adjustRadians0To2Pi(delta);
-            const fraction1 = Geometry_1.Geometry.safeDivideFraction(delta1, sweep, zeroSweepDefault);
-            return fraction1;
-        }
-        const delta2 = Angle_1.Angle.adjustRadians0To2Pi(-delta);
-        const fraction2 = Geometry_1.Geometry.safeDivideFraction(delta2, -sweep, zeroSweepDefault);
-        return fraction2;
+        return fraction;
     }
     /**
      * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     * *  fraction is always positive
      * *  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
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.
      */
     radiansToPositivePeriodicFraction(radians, zeroSweepDefault = 0.0) {
         return AngleSweep.radiansToPositivePeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);
     }
     /**
      * Return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
-     * *  fraction is always positive
      * *  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
      * *  allows period shift
+     * @param theta input angle
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.
      */
-    angleToPositivePeriodicFraction(theta) {
-        return this.radiansToPositivePeriodicFraction(theta.radians);
+    angleToPositivePeriodicFraction(theta, zeroSweepDefault = 0.0) {
+        return this.radiansToPositivePeriodicFraction(theta.radians, zeroSweepDefault);
     }
     /**
      * Return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
@@ -318,10 +351,18 @@ class AngleSweep {
      * *  negative fraction for angles "before" the start angle
      * *  fraction larger than one for angles "after" the end angle
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param radians0 start angle of sweep (in radians)
+     * @param radians1 end angle of sweep (in radians)
+     * @param zeroSweepDefault return value when the sweep is empty (default 0)
+     * @returns fraction, or `zeroSweepDefault` if the sweep is empty.
      */
-    static radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1) {
+    static radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepDefault = 0.0) {
+        const sweep = radians1 - radians0;
+        if (Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(0, sweep))
+            return zeroSweepDefault;
         if (Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(radians0, radians1)) {
-            // for 2nPi sweep, allow matching without period shift, else we never return 1.0
+            // for sweep = 2nPi !== 0, allow matching without period shift, else we never return 1.0
             if (Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0))
                 return 0.0;
             if (Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians1))
@@ -333,16 +374,8 @@ class AngleSweep {
             if (Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians1))
                 return 1.0;
         }
-        const sweep = radians1 - radians0;
-        const delta = radians - radians0 - 0.5 * sweep; // measure from middle of interval
-        if (sweep > 0) {
-            const delta1 = Angle_1.Angle.adjustRadiansMinusPiPlusPi(delta);
-            const fraction1 = 0.5 + Geometry_1.Geometry.safeDivideFraction(delta1, sweep, 0.0);
-            return fraction1;
-        }
-        const delta2 = Angle_1.Angle.adjustRadiansMinusPiPlusPi(-delta);
-        const fraction = 0.5 + Geometry_1.Geometry.safeDivideFraction(delta2, -sweep, 0.0);
-        return fraction;
+        const fraction = (radians - radians0) / sweep;
+        return this.fractionToSignedPeriodicFractionStartEnd(fraction, radians0, radians1, fraction < 0);
     }
     /**
      * Return the fractionalized position of the given angle (as radians) computed with consideration of
@@ -353,9 +386,12 @@ class AngleSweep {
      * *  negative fraction for angles "before" the start angle
      * *  fraction larger than one for angles "after" the end angle
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty.
      */
-    radiansToSignedPeriodicFraction(radians) {
-        return AngleSweep.radiansToSignedPeriodicFractionStartEnd(radians, this._radians0, this._radians1);
+    radiansToSignedPeriodicFraction(radians, zeroSweepDefault = 0.0) {
+        return AngleSweep.radiansToSignedPeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);
     }
     /**
      * Return the fractionalized position of the given angle (as Angle) computed with consideration of
@@ -366,9 +402,69 @@ class AngleSweep {
      * *  negative fraction for angles "before" the start angle
      * *  fraction larger than one for angles "after" the end angle
      * *  allows period shift
+     * @param theta input angle
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty.
+     */
+    angleToSignedPeriodicFraction(theta, zeroSweepDefault = 0.0) {
+        return this.radiansToSignedPeriodicFraction(theta.radians, zeroSweepDefault);
+    }
+    /**
+     * Return the fractionalized position of the given radian angle with respect to the sweep.
+     * * The start angle returns fraction 0
+     * * The end angle returns fraction 1
+     * * Interior angles (and their multiples of 2PI) return fractions in [0,1].
+     * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.
+     * @param radians input angle (in radians)
+     * @param radians0 start angle of sweep (in radians)
+     * @param radians1 end angle of sweep (in radians)
+     * @param toNegativeFraction convert an exterior angle to a negative number (true), or to
+     * a number greater than one (false, default). If false, this is just [[radiansToPositivePeriodicFractionStartEnd]].
+     * @param zeroSweepDefault return value when the sweep is empty (default 0).
+     * @returns fraction, or `zeroSweepDefault` if the sweep is empty
+     */
+    static radiansToSignedFractionStartEnd(radians, radians0, radians1, toNegativeFraction = false, zeroSweepDefault = 0.0) {
+        const zeroSweepMarker = Geometry_1.Geometry.largeCoordinateResult;
+        let fraction = this.radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepMarker);
+        if (fraction === zeroSweepMarker)
+            return zeroSweepDefault;
+        if ((toNegativeFraction && fraction > 1) || (!toNegativeFraction && fraction < 0)) {
+            let period = Angle_1.Angle.pi2Radians / Math.abs(radians1 - radians0);
+            if (toNegativeFraction)
+                period = -period;
+            fraction += period;
+        }
+        return fraction;
+    }
+    /**
+     * Return the fractionalized position of the given radian angle with respect to this sweep.
+     * * The start angle returns fraction 0
+     * * The end angle returns fraction 1
+     * * Interior angles (and their multiples of 2PI) return fractions in [0,1].
+     * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.
+     * @param radians input angle (in radians)
+     * @param toNegativeFraction convert an exterior angle to a negative number (true), or to
+     * a number greater than one (false, default). If false, this is just [[radiansToPositivePeriodicFraction]].
+     * @param zeroSweepDefault return value when this sweep is empty (default 0).
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty
+     */
+    radiansToSignedFraction(radians, toNegativeFraction = false, zeroSweepDefault = 0.0) {
+        return AngleSweep.radiansToSignedFractionStartEnd(radians, this._radians0, this._radians1, toNegativeFraction, zeroSweepDefault);
+    }
+    /**
+     * Return the fractionalized position of the given angle with respect to this sweep.
+     * * The start angle returns fraction 0
+     * * The end angle returns fraction 1
+     * * Interior angles (and their multiples of 2PI) return fractions in [0,1].
+     * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.
+     * @param theta input angle
+     * @param toNegativeFraction convert an exterior angle to a negative number (true), or to
+     * a number greater than one (false, default). If false, this is just [[angleToPositivePeriodicFraction]].
+     * @param zeroSweepDefault return value when this sweep is empty (default 0).
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty
      */
-    angleToSignedPeriodicFraction(theta) {
-        return this.radiansToSignedPeriodicFraction(theta.radians);
+    angleToSignedFraction(theta, toNegativeFraction = false, zeroSweepDefault = 0.0) {
+        return this.radiansToSignedFraction(theta.radians, toNegativeFraction, zeroSweepDefault);
     }
     /** Test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
     static isRadiansInStartEnd(radians, radians0, radians1, allowPeriodShift = true) {
@@ -419,28 +515,31 @@ class AngleSweep {
     }
     /**
      * Convert an AngleSweep to a JSON object.
-     * @return {*} {degrees: [startAngleInDegrees, endAngleInDegrees}
+     * @return {*} [startAngleInDegrees, endAngleInDegrees]
      */
     toJSON() {
         return [this.startDegrees, this.endDegrees];
     }
     /**
-     * Test if this angle sweep and other angle sweep match with radians tolerance.
-     * * Period shifts are allowed.
+     * Test if two angle sweeps match within the given tolerance.
+     * * Period shifts are allowed, but orientations must be the same.
+     * @param other sweep to compare to this instance
+     * @param radianTol optional radian tolerance, default value `Geometry.smallAngleRadians`
      */
-    isAlmostEqualAllowPeriodShift(other) {
-        // We compare angle sweeps by checking if start angle and sweep match. We cannot compare start and end because for
-        // example (0, 90) and (360, 90) have the same start (we allow period shift) and end but are not same angle sweeps.
-        return Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians0, other._radians0)
-            && Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
+    isAlmostEqualAllowPeriodShift(other, radianTol = Geometry_1.Geometry.smallAngleRadians) {
+        return this.isCCW === other.isCCW // this rules out equating opposite sweeps like [0,-100] and [0,260]
+            && Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians0, other._radians0, radianTol)
+            && Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0, radianTol);
     }
     /**
-     * Test if this angle sweep and other angle sweep match with radians tolerance.
+     * Test if two angle sweeps match within the given tolerance.
      * * Period shifts are not allowed.
+     * @param other sweep to compare to this instance
+     * @param radianTol optional radian tolerance, default value `Geometry.smallAngleRadians`
      */
-    isAlmostEqualNoPeriodShift(other) {
-        return Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, other._radians0)
-            && Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
+    isAlmostEqualNoPeriodShift(other, radianTol = Geometry_1.Geometry.smallAngleRadians) {
+        return Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, other._radians0, radianTol)
+            && Angle_1.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0, radianTol);
     }
     /**
      * Test if start and end angles match with radians tolerance.

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

@@ -1 +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\r\n * 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 * *  math details related fraction API can be found at docs/learning/geometry/Angle.md\r\n *  * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/AngleSweep\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() {\r\n    return Angle.radiansToDegrees(this._radians0);\r\n  }\r\n  /** Read-property for degrees at the end of this AngleSweep. */\r\n  public get endDegrees() {\r\n    return Angle.radiansToDegrees(this._radians1);\r\n  }\r\n  /** Read-property for signed start-to-end sweep in degrees. */\r\n  public get sweepDegrees() {\r\n    return Angle.radiansToDegrees(this._radians1 - this._radians0);\r\n  }\r\n  /** Read-property for degrees at the start of this AngleSweep. */\r\n  public get startRadians() {\r\n    return this._radians0;\r\n  }\r\n  /** Read-property for degrees at the end of this AngleSweep. */\r\n  public get endRadians() {\r\n    return this._radians1;\r\n  }\r\n  /** Read-property for signed start-to-end sweep in radians. */\r\n  public get sweepRadians() {\r\n    return this._radians1 - this._radians0;\r\n  }\r\n  /** Whether the sweep angles are within smallAngle tolerance, without period shift. */\r\n  public get isEmpty() {\r\n    return Angle.isAlmostEqualRadiansNoPeriodShift(0, this.sweepRadians);\r\n  }\r\n  /** Return the (strongly typed) start angle */\r\n  public get startAngle() {\r\n    return Angle.createRadians(this._radians0);\r\n  }\r\n  /** Return the (strongly typed) end angle */\r\n  public get endAngle() {\r\n    return Angle.createRadians(this._radians1);\r\n  }\r\n  /**\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  /**\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) {\r\n    this._radians0 = startRadians;\r\n    this._radians1 = endRadians;\r\n  }\r\n  /**\r\n   * Directly set the start and end angles in radians\r\n   * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.\r\n   */\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  /**\r\n   * Create an AngleSweep from start and end angles given in radians.\r\n   * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.\r\n   */\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 {\r\n    return new AngleSweep(this._radians0 - radians, this._radians1 - radians);\r\n  }\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 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  /** 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(\r\n      Geometry.interpolate(this._radians0, fraction, other._radians0),\r\n      Geometry.interpolate(this._radians1, fraction, other._radians1),\r\n    );\r\n  }\r\n  /** Copy from other AngleSweep. */\r\n  public setFrom(other: AngleSweep) {\r\n    this._radians0 = other._radians0;\r\n    this._radians1 = other._radians1;\r\n  }\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 (-90 to +90). */\r\n  public static createFullLatitude() {\r\n    return AngleSweep.createStartEndRadians(-0.5 * Math.PI, 0.5 * Math.PI);\r\n  }\r\n  /** Reverse the start and end angle in place. */\r\n  public reverseInPlace() {\r\n    const tmp = this._radians0;\r\n    this._radians0 = this._radians1;\r\n    this._radians1 = tmp;\r\n  }\r\n  /**\r\n   * Return a sweep for the \"other\" part of the circle.\r\n   * @param reverseDirection true to move backwards (CW) from start to end, false to more forwards (CCW) from start to end.\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 {\r\n    return this._radians1 >= this._radians0;\r\n  }\r\n  /** Ask if the sweep is a full circle. */\r\n  public get isFullCircle(): boolean {\r\n    return Angle.isFullCircleRadians(this.sweepRadians);\r\n  }\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 {\r\n    return new AngleSweep(this._radians0, this._radians1);\r\n  }\r\n  /** Convert fractional position in the sweep to radians. */\r\n  public fractionToRadians(fraction: number): 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  /**\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  /**\r\n   * Return the fractionalized position of the given angle (as Angle) computed without consideration of\r\n   * 2PI period and without consideration of angle sweep direction (CW or CCW).\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   * *  negative fraction for angles \"before\" the start angle if start < end\r\n   * *  fraction larger than one for angles \"after\" the end angle if start < end\r\n   * *  fraction larger than one for angles \"before\" the start angle if start > end\r\n   * *  negative fraction for angles \"after\" the end angle if start > end\r\n   * *  does not allow period shift\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  /**\r\n   * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.\r\n   * *  consider radians0 as `start` angle of the sweep and radians1 as `end` angle of the sweep\r\n   * *  fraction is always positive\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   * *  allows period shift\r\n   */\r\n  public static radiansToPositivePeriodicFractionStartEnd(radians: number, radians0: number, radians1: number, zeroSweepDefault: number = 0.0): number {\r\n    if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians0, radians1)) {\r\n      // for 2nPi sweep, allow matching without period shift, else we never return 1.0\r\n      if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0))\r\n        return 0.0;\r\n      if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians1))\r\n        return 1.0;\r\n    } else {\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    }\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  /**\r\n   * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.\r\n   * *  fraction is always positive\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   * *  allows period shift\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   * Return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.\r\n   * *  fraction is always positive\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   * *  allows period shift\r\n   */\r\n  public angleToPositivePeriodicFraction(theta: Angle): number {\r\n    return this.radiansToPositivePeriodicFraction(theta.radians);\r\n  }\r\n  /**\r\n   * Return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.\r\n   * *  fraction is always positive\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   * *  allows period shift\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   * Return the fractionalized position of the given angle (as radians) computed with consideration of\r\n   * 2PI period and with consideration of angle sweep direction (CW or CCW).\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   * *  negative fraction for angles \"before\" the start angle\r\n   * *  fraction larger than one for angles \"after\" the end angle\r\n   * *  allows period shift\r\n   */\r\n  public static radiansToSignedPeriodicFractionStartEnd(radians: number, radians0: number, radians1: number): number {\r\n    if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians0, radians1)) {\r\n      // for 2nPi sweep, allow matching without period shift, else we never return 1.0\r\n      if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0))\r\n        return 0.0;\r\n      if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians1))\r\n        return 1.0;\r\n    } else {\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    }\r\n    const sweep = radians1 - radians0;\r\n    const delta = radians - radians0 - 0.5 * sweep; // measure from middle of interval\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  /**\r\n   * Return the fractionalized position of the given angle (as radians) computed with consideration of\r\n   * 2PI period and with consideration of angle sweep direction (CW or CCW).\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   * *  negative fraction for angles \"before\" the start angle\r\n   * *  fraction larger than one for angles \"after\" the end angle\r\n   * *  allows period shift\r\n   */\r\n  public radiansToSignedPeriodicFraction(radians: number): number {\r\n    return AngleSweep.radiansToSignedPeriodicFractionStartEnd(radians, this._radians0, this._radians1);\r\n  }\r\n  /**\r\n   * Return the fractionalized position of the given angle (as Angle) computed with consideration of\r\n   * 2PI period and with consideration of angle sweep direction (CW or CCW).\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   * *  negative fraction for angles \"before\" the start angle\r\n   * *  fraction larger than one for angles \"after\" the end angle\r\n   * *  allows period shift\r\n   */\r\n  public angleToSignedPeriodicFraction(theta: Angle): number {\r\n    return this.radiansToSignedPeriodicFraction(theta.radians);\r\n  }\r\n  /** Test if the given angle (as radians) is within sweep (between radians0 and radians1)   */\r\n  public static isRadiansInStartEnd(radians: number, radians0: number, radians1: number, allowPeriodShift: boolean = true): boolean {\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    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  /** Test if the given angle (as radians) is 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 the given angle (as Angle) is within the sweep */\r\n  public isAngleInSweep(angle: Angle): boolean {\r\n    return this.isRadiansInSweep(angle.radians);\r\n  }\r\n  /**\r\n   * Set this AngleSweep from various sources:\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   * * Otherwise, a full-circle sweep is returned.\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    else\r\n      this.setStartEndRadians(); // default full circle\r\n  }\r\n  /** Create an AngleSweep from a json object. */\r\n  public static fromJSON(json?: AngleSweepProps): AngleSweep {\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 [this.startDegrees, this.endDegrees];\r\n  }\r\n  /**\r\n   * Test if this angle sweep and other angle sweep match with radians tolerance.\r\n   * * Period shifts are allowed.\r\n   */\r\n  public isAlmostEqualAllowPeriodShift(other: AngleSweep): boolean {\r\n    // We compare angle sweeps by checking if start angle and sweep match. We cannot compare start and end because for\r\n    // example (0, 90) and (360, 90) have the same start (we allow period shift) and end but are not same angle sweeps.\r\n    return Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians0, other._radians0)\r\n      && Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);\r\n  }\r\n  /**\r\n   * Test if this angle sweep and other angle sweep match with radians tolerance.\r\n   * * Period shifts are not allowed.\r\n   */\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  /**\r\n   * Test if start and end angles match with radians tolerance.\r\n   * * Period shifts are not allowed.\r\n   * * This function is equivalent to isAlmostEqualNoPeriodShift. It is present for consistency with other classes.\r\n   * However, it is recommended to use isAlmostEqualNoPeriodShift which has a clearer name.\r\n   */\r\n  public isAlmostEqual(other: AngleSweep): boolean {\r\n    return this.isAlmostEqualNoPeriodShift(other);\r\n  }\r\n}\r\n"]}
+{"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\r\n * 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 * *  math details related fraction API can be found at docs/learning/geometry/Angle.md\r\n *  * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/AngleSweep\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() {\r\n    return Angle.radiansToDegrees(this._radians0);\r\n  }\r\n  /** Read-property for degrees at the end of this AngleSweep. */\r\n  public get endDegrees() {\r\n    return Angle.radiansToDegrees(this._radians1);\r\n  }\r\n  /** Read-property for signed start-to-end sweep in degrees. */\r\n  public get sweepDegrees() {\r\n    return Angle.radiansToDegrees(this._radians1 - this._radians0);\r\n  }\r\n  /** Read-property for degrees at the start of this AngleSweep. */\r\n  public get startRadians() {\r\n    return this._radians0;\r\n  }\r\n  /** Read-property for degrees at the end of this AngleSweep. */\r\n  public get endRadians() {\r\n    return this._radians1;\r\n  }\r\n  /** Read-property for signed start-to-end sweep in radians. */\r\n  public get sweepRadians() {\r\n    return this._radians1 - this._radians0;\r\n  }\r\n  /** Whether the sweep angles are within smallAngle tolerance, without period shift. */\r\n  public get isEmpty() {\r\n    return Angle.isAlmostEqualRadiansNoPeriodShift(0, this.sweepRadians);\r\n  }\r\n  /** Return the (strongly typed) start angle */\r\n  public get startAngle() {\r\n    return Angle.createRadians(this._radians0);\r\n  }\r\n  /** Return the (strongly typed) end angle */\r\n  public get endAngle() {\r\n    return Angle.createRadians(this._radians1);\r\n  }\r\n  /**\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  /**\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) {\r\n    this._radians0 = startRadians;\r\n    this._radians1 = endRadians;\r\n  }\r\n  /**\r\n   * Directly set the start and end angles in radians\r\n   * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.\r\n   */\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  /**\r\n   * Create an AngleSweep from start and end angles given in radians.\r\n   * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.\r\n   */\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 {\r\n    return new AngleSweep(this._radians0 - radians, this._radians1 - radians);\r\n  }\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 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  /** 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(\r\n      Geometry.interpolate(this._radians0, fraction, other._radians0),\r\n      Geometry.interpolate(this._radians1, fraction, other._radians1),\r\n    );\r\n  }\r\n  /** Copy from other AngleSweep. */\r\n  public setFrom(other: AngleSweep) {\r\n    this._radians0 = other._radians0;\r\n    this._radians1 = other._radians1;\r\n  }\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 (-90 to +90). */\r\n  public static createFullLatitude() {\r\n    return AngleSweep.createStartEndRadians(-0.5 * Math.PI, 0.5 * Math.PI);\r\n  }\r\n  /** Reverse the start and end angle in place. */\r\n  public reverseInPlace() {\r\n    const tmp = this._radians0;\r\n    this._radians0 = this._radians1;\r\n    this._radians1 = tmp;\r\n  }\r\n  /**\r\n   * Return a sweep for the \"other\" part of the circle.\r\n   * @param reverseDirection true to move backwards (CW) from start to end, false to more forwards (CCW) from start to end.\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 {\r\n    return this._radians1 >= this._radians0;\r\n  }\r\n  /** Ask if the sweep is a full circle. */\r\n  public get isFullCircle(): boolean {\r\n    return Angle.isFullCircleRadians(this.sweepRadians);\r\n  }\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 {\r\n    return new AngleSweep(this._radians0, this._radians1);\r\n  }\r\n  /** Convert fractional position in the sweep to radians. */\r\n  public fractionToRadians(fraction: number): 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  /**\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   * @returns period of the sweep, or 1 if sweep is empty.\r\n   */\r\n  public fractionPeriod(): number {\r\n    return this.isEmpty ? 1.0 : Angle.pi2Radians / Math.abs(this._radians1 - this._radians0);\r\n  }\r\n  /**\r\n   * Return the fractionalized position of the given angle (as Angle) computed without consideration of\r\n   * 2PI period and without consideration of angle sweep direction (CW or CCW).\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   * *  negative fraction for angles \"before\" the start angle if start < end\r\n   * *  fraction larger than one for angles \"after\" the end angle if start < end\r\n   * *  fraction larger than one for angles \"before\" the start angle if start > end\r\n   * *  negative fraction for angles \"after\" the end angle if start > end\r\n   * *  does not allow period shift\r\n   * @returns unbounded fraction, or 1 if sweep is empty.\r\n   */\r\n  public angleToUnboundedFraction(theta: Angle): number {\r\n    return this.isEmpty ? 1.0 : (theta.radians - this._radians0) / (this._radians1 - this._radians0);\r\n  }\r\n\r\n  /**\r\n   * Convert a sweep fraction to the equivalent period-shifted fraction inside the sweep, or within one period of zero\r\n   * on the desired side.\r\n   * @param fraction fraction of the sweep.\r\n   * @param radians0 start angle of sweep (in radians).\r\n   * @param radians1 end angle of sweep (in radians).\r\n   * @param toNegativeFraction return an exterior fraction period-shifted to within one period of the start (true) or\r\n   * end (false) of the sweep.\r\n   * @returns period-shifted fraction. If `fraction` is already in [0,1], or the sweep is empty, then `fraction` is\r\n   * returned unchanged.\r\n   */\r\n  public static fractionToSignedPeriodicFractionStartEnd(fraction: number, radians0: number, radians1: number, toNegativeFraction: boolean): number {\r\n    const sweep = radians1 - radians0;\r\n    if (Angle.isAlmostEqualRadiansNoPeriodShift(0, sweep))\r\n      return fraction; // empty sweep\r\n    if (Geometry.isIn01(fraction))\r\n      return fraction;\r\n    const period = Angle.pi2Radians / Math.abs(sweep);\r\n    fraction = fraction % period; // period-shifted equivalent fraction closest to 0 with same sign as fraction\r\n    if (fraction + period < 1)\r\n      fraction += period; // it's really an interior fraction\r\n    if (Geometry.isIn01(fraction) || (toNegativeFraction && fraction < 0) || (!toNegativeFraction && fraction > 1))\r\n      return fraction;\r\n    return toNegativeFraction ? fraction - period : fraction + period; // shift to other side of sweep\r\n  }\r\n  /**\r\n   * Convert a sweep fraction to the equivalent period-shifted fraction inside this sweep, or within one period of\r\n   * zero on the desired side.\r\n   * @param fraction fraction of the sweep.\r\n   * @param toNegativeFraction return an exterior fraction period-shifted to within one period of the start (true) or\r\n   * end (false) of the sweep.\r\n   * @returns period-shifted fraction. If `fraction` is already in [0,1], or the sweep is empty, then `fraction` is\r\n   * returned unchanged.\r\n   */\r\n  public fractionToSignedPeriodicFraction(fraction: number, toNegativeFraction: boolean): number {\r\n    return AngleSweep.fractionToSignedPeriodicFractionStartEnd(fraction, this._radians0, this._radians1, toNegativeFraction);\r\n  }\r\n\r\n  /**\r\n   * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.\r\n   * *  consider radians0 as `start` angle of the sweep and radians1 as `end` angle of the sweep\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   * *  allows period shift\r\n   * @param radians input angle (in radians)\r\n   * @param radians0 start angle of sweep (in radians)\r\n   * @param radians1 end angle of sweep (in radians)\r\n   * @param zeroSweepDefault return value when the sweep is empty (default 0)\r\n   * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.\r\n   */\r\n  public static radiansToPositivePeriodicFractionStartEnd(radians: number, radians0: number, radians1: number, zeroSweepDefault: number = 0.0): number {\r\n    const zeroSweepMarker = Geometry.largeCoordinateResult;\r\n    let fraction = this.radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepMarker);\r\n    if (fraction === zeroSweepMarker)\r\n      return zeroSweepDefault;\r\n    if (fraction < 0) {\r\n      const period = Angle.pi2Radians / Math.abs(radians1 - radians0);\r\n      fraction += period;\r\n    }\r\n    return fraction;\r\n  }\r\n  /**\r\n   * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.\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   * *  allows period shift\r\n   * @param radians input angle (in radians)\r\n   * @param zeroSweepDefault return value when this sweep is empty (default 0)\r\n   * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.\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   * Return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.\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   * *  allows period shift\r\n   * @param theta input angle\r\n   * @param zeroSweepDefault return value when this sweep is empty (default 0)\r\n   * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.\r\n   */\r\n  public angleToPositivePeriodicFraction(theta: Angle, zeroSweepDefault: number = 0.0): number {\r\n    return this.radiansToPositivePeriodicFraction(theta.radians, zeroSweepDefault);\r\n  }\r\n  /**\r\n   * Return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.\r\n   * *  fraction is always positive\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   * *  allows period shift\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   * Return the fractionalized position of the given angle (as radians) computed with consideration of\r\n   * 2PI period and with consideration of angle sweep direction (CW or CCW).\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   * *  negative fraction for angles \"before\" the start angle\r\n   * *  fraction larger than one for angles \"after\" the end angle\r\n   * *  allows period shift\r\n   * @param radians input angle (in radians)\r\n   * @param radians0 start angle of sweep (in radians)\r\n   * @param radians1 end angle of sweep (in radians)\r\n   * @param zeroSweepDefault return value when the sweep is empty (default 0)\r\n   * @returns fraction, or `zeroSweepDefault` if the sweep is empty.\r\n   */\r\n  public static radiansToSignedPeriodicFractionStartEnd(radians: number, radians0: number, radians1: number, zeroSweepDefault: number = 0.0): number {\r\n    const sweep = radians1 - radians0;\r\n    if (Angle.isAlmostEqualRadiansNoPeriodShift(0, sweep))\r\n      return zeroSweepDefault;\r\n    if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians0, radians1)) {\r\n      // for sweep = 2nPi !== 0, allow matching without period shift, else we never return 1.0\r\n      if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0))\r\n        return 0.0;\r\n      if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians1))\r\n        return 1.0;\r\n    } else {\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    }\r\n    const fraction = (radians - radians0) / sweep;\r\n    return this.fractionToSignedPeriodicFractionStartEnd(fraction, radians0, radians1, fraction < 0);\r\n  }\r\n  /**\r\n   * Return the fractionalized position of the given angle (as radians) computed with consideration of\r\n   * 2PI period and with consideration of angle sweep direction (CW or CCW).\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   * *  negative fraction for angles \"before\" the start angle\r\n   * *  fraction larger than one for angles \"after\" the end angle\r\n   * *  allows period shift\r\n   * @param radians input angle (in radians)\r\n   * @param zeroSweepDefault return value when this sweep is empty (default 0)\r\n   * @returns fraction, or `zeroSweepDefault` if this sweep is empty.\r\n   */\r\n  public radiansToSignedPeriodicFraction(radians: number, zeroSweepDefault: number = 0.0): number {\r\n    return AngleSweep.radiansToSignedPeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);\r\n  }\r\n  /**\r\n   * Return the fractionalized position of the given angle (as Angle) computed with consideration of\r\n   * 2PI period and with consideration of angle sweep direction (CW or CCW).\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   * *  negative fraction for angles \"before\" the start angle\r\n   * *  fraction larger than one for angles \"after\" the end angle\r\n   * *  allows period shift\r\n   * @param theta input angle\r\n   * @param zeroSweepDefault return value when this sweep is empty (default 0)\r\n   * @returns fraction, or `zeroSweepDefault` if this sweep is empty.\r\n   */\r\n  public angleToSignedPeriodicFraction(theta: Angle, zeroSweepDefault: number = 0.0): number {\r\n    return this.radiansToSignedPeriodicFraction(theta.radians, zeroSweepDefault);\r\n  }\r\n\r\n  /**\r\n   * Return the fractionalized position of the given radian angle with respect to the sweep.\r\n   * * The start angle returns fraction 0\r\n   * * The end angle returns fraction 1\r\n   * * Interior angles (and their multiples of 2PI) return fractions in [0,1].\r\n   * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.\r\n   * @param radians input angle (in radians)\r\n   * @param radians0 start angle of sweep (in radians)\r\n   * @param radians1 end angle of sweep (in radians)\r\n   * @param toNegativeFraction convert an exterior angle to a negative number (true), or to\r\n   * a number greater than one (false, default). If false, this is just [[radiansToPositivePeriodicFractionStartEnd]].\r\n   * @param zeroSweepDefault return value when the sweep is empty (default 0).\r\n   * @returns fraction, or `zeroSweepDefault` if the sweep is empty\r\n   */\r\n  public static radiansToSignedFractionStartEnd(radians: number, radians0: number, radians1: number, toNegativeFraction: boolean = false, zeroSweepDefault: number = 0.0): number {\r\n    const zeroSweepMarker = Geometry.largeCoordinateResult;\r\n    let fraction = this.radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepMarker);\r\n    if (fraction === zeroSweepMarker)\r\n      return zeroSweepDefault;\r\n    if ((toNegativeFraction && fraction > 1) || (!toNegativeFraction && fraction < 0)) {\r\n      let period = Angle.pi2Radians / Math.abs(radians1 - radians0);\r\n      if (toNegativeFraction)\r\n        period = -period;\r\n      fraction += period;\r\n    }\r\n    return fraction;\r\n  }\r\n  /**\r\n   * Return the fractionalized position of the given radian angle with respect to this sweep.\r\n   * * The start angle returns fraction 0\r\n   * * The end angle returns fraction 1\r\n   * * Interior angles (and their multiples of 2PI) return fractions in [0,1].\r\n   * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.\r\n   * @param radians input angle (in radians)\r\n   * @param toNegativeFraction convert an exterior angle to a negative number (true), or to\r\n   * a number greater than one (false, default). If false, this is just [[radiansToPositivePeriodicFraction]].\r\n   * @param zeroSweepDefault return value when this sweep is empty (default 0).\r\n   * @returns fraction, or `zeroSweepDefault` if this sweep is empty\r\n   */\r\n  public radiansToSignedFraction(radians: number, toNegativeFraction: boolean = false, zeroSweepDefault: number = 0.0): number {\r\n    return AngleSweep.radiansToSignedFractionStartEnd(radians, this._radians0, this._radians1, toNegativeFraction, zeroSweepDefault);\r\n  }\r\n  /**\r\n   * Return the fractionalized position of the given angle with respect to this sweep.\r\n   * * The start angle returns fraction 0\r\n   * * The end angle returns fraction 1\r\n   * * Interior angles (and their multiples of 2PI) return fractions in [0,1].\r\n   * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.\r\n   * @param theta input angle\r\n   * @param toNegativeFraction convert an exterior angle to a negative number (true), or to\r\n   * a number greater than one (false, default). If false, this is just [[angleToPositivePeriodicFraction]].\r\n   * @param zeroSweepDefault return value when this sweep is empty (default 0).\r\n   * @returns fraction, or `zeroSweepDefault` if this sweep is empty\r\n   */\r\n  public angleToSignedFraction(theta: Angle, toNegativeFraction: boolean = false, zeroSweepDefault: number = 0.0): number {\r\n    return this.radiansToSignedFraction(theta.radians, toNegativeFraction, zeroSweepDefault);\r\n  }\r\n\r\n  /** Test if the given angle (as radians) is within sweep (between radians0 and radians1)   */\r\n  public static isRadiansInStartEnd(radians: number, radians0: number, radians1: number, allowPeriodShift: boolean = true): boolean {\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    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  /** Test if the given angle (as radians) is 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 the given angle (as Angle) is within the sweep */\r\n  public isAngleInSweep(angle: Angle): boolean {\r\n    return this.isRadiansInSweep(angle.radians);\r\n  }\r\n  /**\r\n   * Set this AngleSweep from various sources:\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   * * Otherwise, a full-circle sweep is returned.\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    else\r\n      this.setStartEndRadians(); // default full circle\r\n  }\r\n  /** Create an AngleSweep from a json object. */\r\n  public static fromJSON(json?: AngleSweepProps): AngleSweep {\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 {*} [startAngleInDegrees, endAngleInDegrees]\r\n   */\r\n  public toJSON(): any {\r\n    return [this.startDegrees, this.endDegrees];\r\n  }\r\n  /**\r\n   * Test if two angle sweeps match within the given tolerance.\r\n   * * Period shifts are allowed, but orientations must be the same.\r\n   * @param other sweep to compare to this instance\r\n   * @param radianTol optional radian tolerance, default value `Geometry.smallAngleRadians`\r\n   */\r\n  public isAlmostEqualAllowPeriodShift(other: AngleSweep, radianTol: number = Geometry.smallAngleRadians): boolean {\r\n    return this.isCCW === other.isCCW // this rules out equating opposite sweeps like [0,-100] and [0,260]\r\n      && Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians0, other._radians0, radianTol)\r\n      && Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0, radianTol);\r\n  }\r\n  /**\r\n   * Test if two angle sweeps match within the given tolerance.\r\n   * * Period shifts are not allowed.\r\n   * @param other sweep to compare to this instance\r\n   * @param radianTol optional radian tolerance, default value `Geometry.smallAngleRadians`\r\n   */\r\n  public isAlmostEqualNoPeriodShift(other: AngleSweep, radianTol: number = Geometry.smallAngleRadians): boolean {\r\n    return Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, other._radians0, radianTol)\r\n      && Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0, radianTol);\r\n  }\r\n  /**\r\n   * Test if start and end angles match with radians tolerance.\r\n   * * Period shifts are not allowed.\r\n   * * This function is equivalent to isAlmostEqualNoPeriodShift. It is present for consistency with other classes.\r\n   * However, it is recommended to use isAlmostEqualNoPeriodShift which has a clearer name.\r\n   */\r\n  public isAlmostEqual(other: AngleSweep): boolean {\r\n    return this.isAlmostEqualNoPeriodShift(other);\r\n  }\r\n}\r\n"]}

package/lib/cjs/geometry3d/BilinearPatch.js

@@ -11,7 +11,7 @@ exports.BilinearPatch = void 0;
 const SurfaceLocationDetail_1 = require("../bspline/SurfaceLocationDetail");
 const CurveLocationDetail_1 = require("../curve/CurveLocationDetail");
 const Geometry_1 = require("../Geometry");
-const Polynomials_1 = require("../numerics/Polynomials");
+const SmallSystem_1 = require("../numerics/SmallSystem");
 const Plane3dByOriginAndVectors_1 = require("./Plane3dByOriginAndVectors");
 const Point3dVector3d_1 = require("./Point3dVector3d");
 // cspell:word uparrow, rightarrow
@@ -173,9 +173,9 @@ class BilinearPatch {
         // swap rows so that the equation with largest ray.direction coefficient is first.
         BilinearPatch.conditionalPivot(0, coffs, 0, 1);
         BilinearPatch.conditionalPivot(0, coffs, 0, 2);
-        Polynomials_1.SmallSystem.eliminateFromPivot(coffs[0], 0, coffs[1], -1.0);
-        Polynomials_1.SmallSystem.eliminateFromPivot(coffs[0], 0, coffs[2], -1.0);
-        const uvArray = Polynomials_1.SmallSystem.solveBilinearPair(coffs[1][1], coffs[1][2], coffs[1][3], coffs[1][4], coffs[2][1], coffs[2][2], coffs[2][3], coffs[2][4]);
+        SmallSystem_1.SmallSystem.eliminateFromPivot(coffs[0], 0, coffs[1], -1.0);
+        SmallSystem_1.SmallSystem.eliminateFromPivot(coffs[0], 0, coffs[2], -1.0);
+        const uvArray = SmallSystem_1.SmallSystem.solveBilinearPair(coffs[1][1], coffs[1][2], coffs[1][3], coffs[1][4], coffs[2][1], coffs[2][2], coffs[2][3], coffs[2][4]);
         if (uvArray) {
             const result = [];
             for (const uv of uvArray) {

package/lib/cjs/geometry3d/BilinearPatch.js.map

@@ -1 +1 @@
-{"version":3,"file":"BilinearPatch.js","sourceRoot":"","sources":["../../../src/geometry3d/BilinearPatch.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\r\n/** @packageDocumentation\r\n * @module Solid\r\n */\r\n\r\nimport { CurveAndSurfaceLocationDetail, UVSurfaceLocationDetail } from \"../bspline/SurfaceLocationDetail\";\r\nimport { CurveLocationDetail } from \"../curve/CurveLocationDetail\";\r\nimport { Geometry } from \"../Geometry\";\r\nimport { SmallSystem } from \"../numerics/Polynomials\";\r\nimport { UVSurface } from \"./GeometryHandler\";\r\nimport { Plane3dByOriginAndVectors } from \"./Plane3dByOriginAndVectors\";\r\nimport { Point3d } from \"./Point3dVector3d\";\r\nimport { Range3d } from \"./Range\";\r\nimport { Ray3d } from \"./Ray3d\";\r\nimport { Transform } from \"./Transform\";\r\n\r\n// cspell:word uparrow, rightarrow\r\n\r\n/**\r\n * A bilinear patch is a surface defined by its 4 corner points.\r\n * * The corner points do not have to be coplanar, but if they are, the quadrilateral should be convex to avoid a self-intersecting surface.\r\n * ```\r\n * equation\r\n * \\begin{matrix}\r\n * v\\text{-direction}\\\\\r\n * \\uparrow\\\\\r\n * \\text{point01} &\\cdots &\\text{A1} &\\cdots &\\text{point11}\\\\\r\n * \\vdots &&\\vdots &&\\vdots\\\\\r\n * \\text{B0} &\\cdots &\\text{X} &\\cdots &\\text{B1}\\\\\r\n * \\vdots &&\\vdots &&\\vdots\\\\\r\n * \\text{point00} &\\cdots &\\text{A0} &\\cdots &\\text{point10} &\\rightarrow~u\\text{-direction}\r\n * \\end{matrix}\r\n * ```\r\n * * To evaluate the point at (u,v), the following are equivalent:\r\n *   * interpolate first with u then with v:\r\n *      * A0 = interpolate between point00 and point10 at fraction u\r\n *      * A1 = interpolate between point01 and point11 at fraction u\r\n *      * X = interpolate between A0 and A1 at fraction v\r\n *   * interpolate first with v then with u:\r\n *      * B0 = interpolate between point00 and point01 at fraction v\r\n *      * B1 = interpolate between point10 and point11 at fraction v\r\n *      * X = interpolate between B0 and B1 at fraction u\r\n *   * sum all at once:\r\n *      * X = (1-u)(1-v)point00 + (1-u)(v)point01 + (u)(1-v)point10 + (u)(v)point11\r\n * @public\r\n */\r\nexport class BilinearPatch implements UVSurface {\r\n  /** corner at parametric coordinate (0,0) */\r\n  public point00: Point3d;\r\n  /** corner at parametric coordinate (1,0) */\r\n  public point10: Point3d;\r\n  /** corner at parametric coordinate (0,1) */\r\n  public point01: Point3d;\r\n  /** corner at parametric coordinate (1,1) */\r\n  public point11: Point3d;\r\n  /**\r\n   * Capture (not clone) corners to create a new BilinearPatch.\r\n   * @param point00 Point at uv=0,0\r\n   * @param point10 Point at uv=1,0\r\n   * @param point10 Point at uv=0,1\r\n   * @param point11 Point at uv=1,1\r\n   */\r\n  public constructor(point00: Point3d, point10: Point3d, point01: Point3d, point11: Point3d) {\r\n    this.point00 = point00;\r\n    this.point10 = point10;\r\n    this.point01 = point01;\r\n    this.point11 = point11;\r\n  }\r\n  /**\r\n   * Clone (not capture) corners to create a new BilinearPatch.\r\n   * @param point00 Point at uv=0,0\r\n   * @param point10 Point at uv=1,0\r\n   * @param point10 Point at uv=0,1\r\n   * @param point11 Point at uv=1,1\r\n   */\r\n  public static create(point00: Point3d, point10: Point3d, point01: Point3d, point11: Point3d) {\r\n    return new BilinearPatch(point00.clone(), point10.clone(), point01.clone(), point11.clone());\r\n  }\r\n  /** Create a patch from xyz values of the 4 corners. */\r\n  public static createXYZ(\r\n    x00: number, y00: number, z00: number,\r\n    x10: number, y10: number, z10: number,\r\n    x01: number, y01: number, z01: number,\r\n    x11: number, y11: number, z11: number,\r\n  ) {\r\n    return new BilinearPatch(\r\n      Point3d.create(x00, y00, z00),\r\n      Point3d.create(x10, y10, z10),\r\n      Point3d.create(x01, y01, z01),\r\n      Point3d.create(x11, y11, z11),\r\n    );\r\n  }\r\n  /** Return a cloned patch. */\r\n  public clone(): BilinearPatch {\r\n    return new BilinearPatch(\r\n      this.point00.clone(),\r\n      this.point10.clone(),\r\n      this.point01.clone(),\r\n      this.point11.clone(),\r\n    );\r\n  }\r\n  /** Test equality of the 4 points. */\r\n  public isAlmostEqual(other: BilinearPatch): boolean {\r\n    return this.point00.isAlmostEqual(other.point00)\r\n      && this.point10.isAlmostEqual(other.point10)\r\n      && this.point01.isAlmostEqual(other.point01)\r\n      && this.point11.isAlmostEqual(other.point11);\r\n  }\r\n  /** Apply the transform to each point. */\r\n  public tryTransformInPlace(transform: Transform): boolean {\r\n    transform.multiplyPoint3d(this.point00, this.point00);\r\n    transform.multiplyPoint3d(this.point10, this.point10);\r\n    transform.multiplyPoint3d(this.point01, this.point01);\r\n    transform.multiplyPoint3d(this.point11, this.point11);\r\n    return true;\r\n  }\r\n  /** Return a cloned and transformed patch. */\r\n  public cloneTransformed(transform: Transform): BilinearPatch | undefined {\r\n    const result = this.clone();\r\n    result.tryTransformInPlace(transform);\r\n    return result;\r\n  }\r\n  /** Extend a range by the range of the (optionally transformed) patch. */\r\n  public extendRange(range: Range3d, transform?: Transform) {\r\n    if (transform) {\r\n      range.extendTransformedPoint(transform, this.point00);\r\n      range.extendTransformedPoint(transform, this.point10);\r\n      range.extendTransformedPoint(transform, this.point01);\r\n      range.extendTransformedPoint(transform, this.point11);\r\n    } else {\r\n      range.extendPoint(this.point00);\r\n      range.extendPoint(this.point10);\r\n      range.extendPoint(this.point01);\r\n      range.extendPoint(this.point11);\r\n    }\r\n  }\r\n  /**\r\n   * Convert fractional u and v coordinates to surface point\r\n   * @param u fractional coordinate in u direction\r\n   * @param v fractional coordinate in v direction\r\n   * @param result optional pre-allocated point\r\n   */\r\n  public uvFractionToPoint(u: number, v: number, result?: Point3d): Point3d {\r\n    const f00 = (1.0 - u) * (1.0 - v);\r\n    const f10 = u * (1.0 - v);\r\n    const f01 = (1.0 - u) * v;\r\n    const f11 = u * v;\r\n    return Point3d.create(\r\n      f00 * this.point00.x + f10 * this.point10.x + f01 * this.point01.x + f11 * this.point11.x,\r\n      f00 * this.point00.y + f10 * this.point10.y + f01 * this.point01.y + f11 * this.point11.y,\r\n      f00 * this.point00.z + f10 * this.point10.z + f01 * this.point01.z + f11 * this.point11.z,\r\n      result,\r\n    );\r\n  }\r\n  /** Evaluate as a uv surface, returning point and two derivative vectors.\r\n   * @param u fractional coordinate in u direction\r\n   * @param v fractional coordinate in v direction\r\n   * @param result optional pre-allocated carrier for point and vectors\r\n   */\r\n  public uvFractionToPointAndTangents(u: number, v: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors {\r\n    const u0 = 1.0 - u;\r\n    const v0 = 1.0 - v;\r\n    const f00 = u0 * v0;\r\n    const f10 = u * v0;\r\n    const f01 = u0 * v;\r\n    const f11 = u * v;\r\n    return Plane3dByOriginAndVectors.createOriginAndVectorsXYZ(\r\n      f00 * this.point00.x + f10 * this.point10.x + f01 * this.point01.x + f11 * this.point11.x,\r\n      f00 * this.point00.y + f10 * this.point10.y + f01 * this.point01.y + f11 * this.point11.y,\r\n      f00 * this.point00.z + f10 * this.point10.z + f01 * this.point01.z + f11 * this.point11.z,\r\n      // u derivative ..\r\n      v0 * (this.point10.x - this.point00.x) + v * (this.point11.x - this.point01.x),\r\n      v0 * (this.point10.y - this.point00.y) + v * (this.point11.y - this.point01.y),\r\n      v0 * (this.point10.z - this.point00.z) + v * (this.point11.z - this.point01.z),\r\n      // v derivative ..\r\n      u0 * (this.point01.x - this.point00.x) + u * (this.point11.x - this.point10.x),\r\n      u0 * (this.point01.y - this.point00.y) + u * (this.point11.y - this.point10.y),\r\n      u0 * (this.point01.z - this.point00.z) + u * (this.point11.z - this.point10.z),\r\n      result,\r\n    );\r\n  }\r\n  /** If data[iB][pivotColumn] is larger in absolute value than data[iA][pivotColumn], then swap rows iA and iB. */\r\n  private static conditionalPivot(pivotColumn: number, data: Float64Array[], iA: number, iB: number) {\r\n    if (Math.abs(data[iB][pivotColumn]) > Math.abs(data[iA][pivotColumn])) {\r\n      const q = data[iA];\r\n      data[iA] = data[iB];\r\n      data[iB] = q;\r\n    }\r\n  }\r\n  /**\r\n   * Compute the points of intersection with a ray.\r\n   * @param ray ray in space\r\n   * @returns 1 or 2 points if there are intersections, undefined if no intersections\r\n   */\r\n  public intersectRay(ray: Ray3d): CurveAndSurfaceLocationDetail[] | undefined {\r\n    const vectorU = this.point10.minus(this.point00);\r\n    const vectorV = this.point01.minus(this.point00);\r\n    const vectorW = this.point11.minus(this.point10);\r\n    vectorW.subtractInPlace(vectorV);\r\n    // We seek t, u, v such that:\r\n    //    `ray.origin + t*ray.direction = point00 + u*vectorU + v*vectorV + u*v*vectorW`\r\n    // For typical direction as x, the scalar equation with coefficient order for arrays is:\r\n    //    `0 = -t*ray.direction.x + (point00.x - ray.origin.x) + u*vectorU.x + v*vectorV.x + u*v*vectorW.x`\r\n    // and this particular equation is invoked to compute t when u and v are known.\r\n    const coffs = [\r\n      new Float64Array([-ray.direction.x, this.point00.x - ray.origin.x, vectorU.x, vectorV.x, vectorW.x]),\r\n      new Float64Array([-ray.direction.y, this.point00.y - ray.origin.y, vectorU.y, vectorV.y, vectorW.y]),\r\n      new Float64Array([-ray.direction.z, this.point00.z - ray.origin.z, vectorU.z, vectorV.z, vectorW.z]),\r\n    ];\r\n    // swap rows so that the equation with largest ray.direction coefficient is first.\r\n    BilinearPatch.conditionalPivot(0, coffs, 0, 1);\r\n    BilinearPatch.conditionalPivot(0, coffs, 0, 2);\r\n    SmallSystem.eliminateFromPivot(coffs[0], 0, coffs[1], -1.0);\r\n    SmallSystem.eliminateFromPivot(coffs[0], 0, coffs[2], -1.0);\r\n    const uvArray = SmallSystem.solveBilinearPair(\r\n      coffs[1][1], coffs[1][2], coffs[1][3], coffs[1][4],\r\n      coffs[2][1], coffs[2][2], coffs[2][3], coffs[2][4],\r\n    );\r\n    if (uvArray) {\r\n      const result: CurveAndSurfaceLocationDetail[] = [];\r\n      for (const uv of uvArray) {\r\n        const t = -(coffs[0][1] + coffs[0][2] * uv.x + (coffs[0][3] + coffs[0][4] * uv.x) * uv.y) / coffs[0][0];\r\n        const point = ray.fractionToPoint(t);\r\n        result.push(new CurveAndSurfaceLocationDetail(\r\n          CurveLocationDetail.createRayFractionPoint(ray, t, point),\r\n          UVSurfaceLocationDetail.createSurfaceUVPoint(this, uv, point)),\r\n        );\r\n      }\r\n      return result;\r\n    }\r\n    return undefined;\r\n  }\r\n  /** Returns the larger of the u-direction edge lengths at v=0 and v=1. */\r\n  public maxUEdgeLength(): number {\r\n    return Geometry.maxXY(this.point00.distance(this.point10), this.point01.distance(this.point11));\r\n  }\r\n  /** Returns the larger of the v-direction edge lengths at u=0 and u=1. */\r\n  public maxVEdgeLength(): number {\r\n    return Geometry.maxXY(this.point00.distance(this.point01), this.point10.distance(this.point11));\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"BilinearPatch.js","sourceRoot":"","sources":["../../../src/geometry3d/BilinearPatch.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\r\n/** @packageDocumentation\r\n * @module Solid\r\n */\r\n\r\nimport { CurveAndSurfaceLocationDetail, UVSurfaceLocationDetail } from \"../bspline/SurfaceLocationDetail\";\r\nimport { CurveLocationDetail } from \"../curve/CurveLocationDetail\";\r\nimport { Geometry } from \"../Geometry\";\r\nimport { SmallSystem } from \"../numerics/SmallSystem\";\r\nimport { UVSurface } from \"./GeometryHandler\";\r\nimport { Plane3dByOriginAndVectors } from \"./Plane3dByOriginAndVectors\";\r\nimport { Point3d } from \"./Point3dVector3d\";\r\nimport { Range3d } from \"./Range\";\r\nimport { Ray3d } from \"./Ray3d\";\r\nimport { Transform } from \"./Transform\";\r\n\r\n// cspell:word uparrow, rightarrow\r\n\r\n/**\r\n * A bilinear patch is a surface defined by its 4 corner points.\r\n * * The corner points do not have to be coplanar, but if they are, the quadrilateral should be convex to avoid a self-intersecting surface.\r\n * ```\r\n * equation\r\n * \\begin{matrix}\r\n * v\\text{-direction}\\\\\r\n * \\uparrow\\\\\r\n * \\text{point01} &\\cdots &\\text{A1} &\\cdots &\\text{point11}\\\\\r\n * \\vdots &&\\vdots &&\\vdots\\\\\r\n * \\text{B0} &\\cdots &\\text{X} &\\cdots &\\text{B1}\\\\\r\n * \\vdots &&\\vdots &&\\vdots\\\\\r\n * \\text{point00} &\\cdots &\\text{A0} &\\cdots &\\text{point10} &\\rightarrow~u\\text{-direction}\r\n * \\end{matrix}\r\n * ```\r\n * * To evaluate the point at (u,v), the following are equivalent:\r\n *   * interpolate first with u then with v:\r\n *      * A0 = interpolate between point00 and point10 at fraction u\r\n *      * A1 = interpolate between point01 and point11 at fraction u\r\n *      * X = interpolate between A0 and A1 at fraction v\r\n *   * interpolate first with v then with u:\r\n *      * B0 = interpolate between point00 and point01 at fraction v\r\n *      * B1 = interpolate between point10 and point11 at fraction v\r\n *      * X = interpolate between B0 and B1 at fraction u\r\n *   * sum all at once:\r\n *      * X = (1-u)(1-v)point00 + (1-u)(v)point01 + (u)(1-v)point10 + (u)(v)point11\r\n * @public\r\n */\r\nexport class BilinearPatch implements UVSurface {\r\n  /** corner at parametric coordinate (0,0) */\r\n  public point00: Point3d;\r\n  /** corner at parametric coordinate (1,0) */\r\n  public point10: Point3d;\r\n  /** corner at parametric coordinate (0,1) */\r\n  public point01: Point3d;\r\n  /** corner at parametric coordinate (1,1) */\r\n  public point11: Point3d;\r\n  /**\r\n   * Capture (not clone) corners to create a new BilinearPatch.\r\n   * @param point00 Point at uv=0,0\r\n   * @param point10 Point at uv=1,0\r\n   * @param point10 Point at uv=0,1\r\n   * @param point11 Point at uv=1,1\r\n   */\r\n  public constructor(point00: Point3d, point10: Point3d, point01: Point3d, point11: Point3d) {\r\n    this.point00 = point00;\r\n    this.point10 = point10;\r\n    this.point01 = point01;\r\n    this.point11 = point11;\r\n  }\r\n  /**\r\n   * Clone (not capture) corners to create a new BilinearPatch.\r\n   * @param point00 Point at uv=0,0\r\n   * @param point10 Point at uv=1,0\r\n   * @param point10 Point at uv=0,1\r\n   * @param point11 Point at uv=1,1\r\n   */\r\n  public static create(point00: Point3d, point10: Point3d, point01: Point3d, point11: Point3d) {\r\n    return new BilinearPatch(point00.clone(), point10.clone(), point01.clone(), point11.clone());\r\n  }\r\n  /** Create a patch from xyz values of the 4 corners. */\r\n  public static createXYZ(\r\n    x00: number, y00: number, z00: number,\r\n    x10: number, y10: number, z10: number,\r\n    x01: number, y01: number, z01: number,\r\n    x11: number, y11: number, z11: number,\r\n  ) {\r\n    return new BilinearPatch(\r\n      Point3d.create(x00, y00, z00),\r\n      Point3d.create(x10, y10, z10),\r\n      Point3d.create(x01, y01, z01),\r\n      Point3d.create(x11, y11, z11),\r\n    );\r\n  }\r\n  /** Return a cloned patch. */\r\n  public clone(): BilinearPatch {\r\n    return new BilinearPatch(\r\n      this.point00.clone(),\r\n      this.point10.clone(),\r\n      this.point01.clone(),\r\n      this.point11.clone(),\r\n    );\r\n  }\r\n  /** Test equality of the 4 points. */\r\n  public isAlmostEqual(other: BilinearPatch): boolean {\r\n    return this.point00.isAlmostEqual(other.point00)\r\n      && this.point10.isAlmostEqual(other.point10)\r\n      && this.point01.isAlmostEqual(other.point01)\r\n      && this.point11.isAlmostEqual(other.point11);\r\n  }\r\n  /** Apply the transform to each point. */\r\n  public tryTransformInPlace(transform: Transform): boolean {\r\n    transform.multiplyPoint3d(this.point00, this.point00);\r\n    transform.multiplyPoint3d(this.point10, this.point10);\r\n    transform.multiplyPoint3d(this.point01, this.point01);\r\n    transform.multiplyPoint3d(this.point11, this.point11);\r\n    return true;\r\n  }\r\n  /** Return a cloned and transformed patch. */\r\n  public cloneTransformed(transform: Transform): BilinearPatch | undefined {\r\n    const result = this.clone();\r\n    result.tryTransformInPlace(transform);\r\n    return result;\r\n  }\r\n  /** Extend a range by the range of the (optionally transformed) patch. */\r\n  public extendRange(range: Range3d, transform?: Transform) {\r\n    if (transform) {\r\n      range.extendTransformedPoint(transform, this.point00);\r\n      range.extendTransformedPoint(transform, this.point10);\r\n      range.extendTransformedPoint(transform, this.point01);\r\n      range.extendTransformedPoint(transform, this.point11);\r\n    } else {\r\n      range.extendPoint(this.point00);\r\n      range.extendPoint(this.point10);\r\n      range.extendPoint(this.point01);\r\n      range.extendPoint(this.point11);\r\n    }\r\n  }\r\n  /**\r\n   * Convert fractional u and v coordinates to surface point\r\n   * @param u fractional coordinate in u direction\r\n   * @param v fractional coordinate in v direction\r\n   * @param result optional pre-allocated point\r\n   */\r\n  public uvFractionToPoint(u: number, v: number, result?: Point3d): Point3d {\r\n    const f00 = (1.0 - u) * (1.0 - v);\r\n    const f10 = u * (1.0 - v);\r\n    const f01 = (1.0 - u) * v;\r\n    const f11 = u * v;\r\n    return Point3d.create(\r\n      f00 * this.point00.x + f10 * this.point10.x + f01 * this.point01.x + f11 * this.point11.x,\r\n      f00 * this.point00.y + f10 * this.point10.y + f01 * this.point01.y + f11 * this.point11.y,\r\n      f00 * this.point00.z + f10 * this.point10.z + f01 * this.point01.z + f11 * this.point11.z,\r\n      result,\r\n    );\r\n  }\r\n  /** Evaluate as a uv surface, returning point and two derivative vectors.\r\n   * @param u fractional coordinate in u direction\r\n   * @param v fractional coordinate in v direction\r\n   * @param result optional pre-allocated carrier for point and vectors\r\n   */\r\n  public uvFractionToPointAndTangents(u: number, v: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors {\r\n    const u0 = 1.0 - u;\r\n    const v0 = 1.0 - v;\r\n    const f00 = u0 * v0;\r\n    const f10 = u * v0;\r\n    const f01 = u0 * v;\r\n    const f11 = u * v;\r\n    return Plane3dByOriginAndVectors.createOriginAndVectorsXYZ(\r\n      f00 * this.point00.x + f10 * this.point10.x + f01 * this.point01.x + f11 * this.point11.x,\r\n      f00 * this.point00.y + f10 * this.point10.y + f01 * this.point01.y + f11 * this.point11.y,\r\n      f00 * this.point00.z + f10 * this.point10.z + f01 * this.point01.z + f11 * this.point11.z,\r\n      // u derivative ..\r\n      v0 * (this.point10.x - this.point00.x) + v * (this.point11.x - this.point01.x),\r\n      v0 * (this.point10.y - this.point00.y) + v * (this.point11.y - this.point01.y),\r\n      v0 * (this.point10.z - this.point00.z) + v * (this.point11.z - this.point01.z),\r\n      // v derivative ..\r\n      u0 * (this.point01.x - this.point00.x) + u * (this.point11.x - this.point10.x),\r\n      u0 * (this.point01.y - this.point00.y) + u * (this.point11.y - this.point10.y),\r\n      u0 * (this.point01.z - this.point00.z) + u * (this.point11.z - this.point10.z),\r\n      result,\r\n    );\r\n  }\r\n  /** If data[iB][pivotColumn] is larger in absolute value than data[iA][pivotColumn], then swap rows iA and iB. */\r\n  private static conditionalPivot(pivotColumn: number, data: Float64Array[], iA: number, iB: number) {\r\n    if (Math.abs(data[iB][pivotColumn]) > Math.abs(data[iA][pivotColumn])) {\r\n      const q = data[iA];\r\n      data[iA] = data[iB];\r\n      data[iB] = q;\r\n    }\r\n  }\r\n  /**\r\n   * Compute the points of intersection with a ray.\r\n   * @param ray ray in space\r\n   * @returns 1 or 2 points if there are intersections, undefined if no intersections\r\n   */\r\n  public intersectRay(ray: Ray3d): CurveAndSurfaceLocationDetail[] | undefined {\r\n    const vectorU = this.point10.minus(this.point00);\r\n    const vectorV = this.point01.minus(this.point00);\r\n    const vectorW = this.point11.minus(this.point10);\r\n    vectorW.subtractInPlace(vectorV);\r\n    // We seek t, u, v such that:\r\n    //    `ray.origin + t*ray.direction = point00 + u*vectorU + v*vectorV + u*v*vectorW`\r\n    // For typical direction as x, the scalar equation with coefficient order for arrays is:\r\n    //    `0 = -t*ray.direction.x + (point00.x - ray.origin.x) + u*vectorU.x + v*vectorV.x + u*v*vectorW.x`\r\n    // and this particular equation is invoked to compute t when u and v are known.\r\n    const coffs = [\r\n      new Float64Array([-ray.direction.x, this.point00.x - ray.origin.x, vectorU.x, vectorV.x, vectorW.x]),\r\n      new Float64Array([-ray.direction.y, this.point00.y - ray.origin.y, vectorU.y, vectorV.y, vectorW.y]),\r\n      new Float64Array([-ray.direction.z, this.point00.z - ray.origin.z, vectorU.z, vectorV.z, vectorW.z]),\r\n    ];\r\n    // swap rows so that the equation with largest ray.direction coefficient is first.\r\n    BilinearPatch.conditionalPivot(0, coffs, 0, 1);\r\n    BilinearPatch.conditionalPivot(0, coffs, 0, 2);\r\n    SmallSystem.eliminateFromPivot(coffs[0], 0, coffs[1], -1.0);\r\n    SmallSystem.eliminateFromPivot(coffs[0], 0, coffs[2], -1.0);\r\n    const uvArray = SmallSystem.solveBilinearPair(\r\n      coffs[1][1], coffs[1][2], coffs[1][3], coffs[1][4],\r\n      coffs[2][1], coffs[2][2], coffs[2][3], coffs[2][4],\r\n    );\r\n    if (uvArray) {\r\n      const result: CurveAndSurfaceLocationDetail[] = [];\r\n      for (const uv of uvArray) {\r\n        const t = -(coffs[0][1] + coffs[0][2] * uv.x + (coffs[0][3] + coffs[0][4] * uv.x) * uv.y) / coffs[0][0];\r\n        const point = ray.fractionToPoint(t);\r\n        result.push(new CurveAndSurfaceLocationDetail(\r\n          CurveLocationDetail.createRayFractionPoint(ray, t, point),\r\n          UVSurfaceLocationDetail.createSurfaceUVPoint(this, uv, point)),\r\n        );\r\n      }\r\n      return result;\r\n    }\r\n    return undefined;\r\n  }\r\n  /** Returns the larger of the u-direction edge lengths at v=0 and v=1. */\r\n  public maxUEdgeLength(): number {\r\n    return Geometry.maxXY(this.point00.distance(this.point10), this.point01.distance(this.point11));\r\n  }\r\n  /** Returns the larger of the v-direction edge lengths at u=0 and u=1. */\r\n  public maxVEdgeLength(): number {\r\n    return Geometry.maxXY(this.point00.distance(this.point01), this.point10.distance(this.point11));\r\n  }\r\n}\r\n"]}