@itwin/core-geometry 3.5.0 → 3.6.0-dev.10

package/lib/esm/geometry3d/AngleSweep.js

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

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