@itwin/core-geometry 4.4.0-dev.2 → 4.4.0-dev.21

package/lib/esm/topology/SignedDataSummary.js.map

@@ -1 +1 @@
-{"version":3,"file":"SignedDataSummary.js","sourceRoot":"","sources":["../../../src/topology/SignedDataSummary.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAE/F;;GAEG;AACH;;;;GAIG;AACH,MAAM,OAAO,iBAAiB;IAuB5B,+CAA+C;IAC/C,YAAmB,YAAqB;QACtC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;QAC1C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;QACzD,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,GAAG,GAAG,CAAC;QAC5D,IAAI,YAAY,EAAE;YAChB,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;YAC5B,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;YAC5B,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;SACzB;IACH,CAAC;IACD,8CAA8C;IACvC,YAAY,CAAC,IAAO,EAAE,IAAY;QACvC,IAAI,IAAI,GAAG,CAAC,EAAE;YACZ,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC;YACzB,IAAI,IAAI,CAAC,iBAAiB;gBACxB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpC,IAAI,IAAI,GAAG,IAAI,CAAC,oBAAoB,EAAE;gBACpC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;gBACjC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;aACjC;SACF;aAAM,IAAI,IAAI,GAAG,CAAC,EAAE;YACnB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC;YACzB,IAAI,IAAI,CAAC,iBAAiB;gBACxB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpC,IAAI,IAAI,GAAG,IAAI,CAAC,oBAAoB,EAAE;gBACpC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;gBACjC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;aACjC;SACF;aAAM;YACL,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,IAAI,CAAC,aAAa;gBACpB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACjC;IACH,CAAC;CACF","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 Topology\r\n */\r\n/**\r\n * Class to accumulate statistics about a stream of signed numbers with tag items.\r\n * * All sums, counts, extrema, and item values are initialized to zero in the constructor.\r\n * * Each call to `announceItem (item, value)` updates the various sums, counts, and extrema.\r\n */\r\nexport class SignedDataSummary<T> {\r\n  /** sum of all positive area items */\r\n  public positiveSum: number;\r\n  /** number of positive area items */\r\n  public numPositive: number;\r\n  /** sum of negative area items */\r\n  public negativeSum: number;\r\n  /** number of negative area items */\r\n  public numNegative: number;\r\n  /** number of zero area items */\r\n  public numZero: number;\r\n  /** the tag item item with the largest positive data */\r\n  public largestPositiveItem?: T;\r\n  /** the tag item item with the most negative data */\r\n  public largestNegativeItem?: T;\r\n  public largestPositiveValue: number;\r\n  public largestNegativeValue: number;\r\n  /** array of all negative area items */\r\n  public negativeItemArray?: T[];\r\n  /** array of zero area items */\r\n  public zeroItemArray?: T[];\r\n  /** array of positive area items */\r\n  public positiveItemArray?: T[];\r\n  /** setup with zero sums and optional arrays */\r\n  public constructor(createArrays: boolean) {\r\n    this.positiveSum = this.negativeSum = 0.0;\r\n    this.numPositive = this.numNegative = this.numZero = 0.0;\r\n    this.largestPositiveValue = this.largestNegativeValue = 0.0;\r\n    if (createArrays) {\r\n      this.negativeItemArray = [];\r\n      this.positiveItemArray = [];\r\n      this.zeroItemArray = [];\r\n    }\r\n  }\r\n  /** update with an item and its data value. */\r\n  public announceItem(item: T, data: number) {\r\n    if (data < 0) {\r\n      this.numNegative++;\r\n      this.negativeSum += data;\r\n      if (this.negativeItemArray)\r\n        this.negativeItemArray.push(item);\r\n      if (data < this.largestNegativeValue) {\r\n        this.largestNegativeValue = data;\r\n        this.largestNegativeItem = item;\r\n      }\r\n    } else if (data > 0) {\r\n      this.numPositive++;\r\n      this.positiveSum += data;\r\n      if (this.positiveItemArray)\r\n        this.positiveItemArray.push(item);\r\n      if (data > this.largestPositiveValue) {\r\n        this.largestPositiveValue = data;\r\n        this.largestPositiveItem = item;\r\n      }\r\n    } else {\r\n      this.numZero++;\r\n      if (this.zeroItemArray)\r\n        this.zeroItemArray.push(item);\r\n    }\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"SignedDataSummary.js","sourceRoot":"","sources":["../../../src/topology/SignedDataSummary.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAE/F;;GAEG;AACH;;;;GAIG;AACH,MAAM,OAAO,iBAAiB;IAuB5B,gDAAgD;IAChD,YAAmB,YAAqB;QACtC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;QAC1C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;QACzD,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,GAAG,GAAG,CAAC;QAC5D,IAAI,YAAY,EAAE;YAChB,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;YAC5B,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;YAC5B,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;SACzB;IACH,CAAC;IACD,8CAA8C;IACvC,YAAY,CAAC,IAAO,EAAE,IAAY;QACvC,IAAI,IAAI,GAAG,CAAC,EAAE;YACZ,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC;YACzB,IAAI,IAAI,CAAC,iBAAiB;gBACxB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpC,IAAI,IAAI,GAAG,IAAI,CAAC,oBAAoB,EAAE;gBACpC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;gBACjC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;aACjC;SACF;aAAM,IAAI,IAAI,GAAG,CAAC,EAAE;YACnB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC;YACzB,IAAI,IAAI,CAAC,iBAAiB;gBACxB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpC,IAAI,IAAI,GAAG,IAAI,CAAC,oBAAoB,EAAE;gBACpC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;gBACjC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;aACjC;SACF;aAAM;YACL,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,IAAI,CAAC,aAAa;gBACpB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACjC;IACH,CAAC;CACF","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 Topology\r\n */\r\n/**\r\n * Class to accumulate statistics about a stream of signed numbers with tag items.\r\n * * All sums, counts, extrema, and item values are initialized to zero in the constructor.\r\n * * Each call to `announceItem(item, value)` updates the various sums, counts, and extrema.\r\n */\r\nexport class SignedDataSummary<T> {\r\n  /** Sum of all positive area items. */\r\n  public positiveSum: number;\r\n  /** Number of positive area items. */\r\n  public numPositive: number;\r\n  /** Sum of negative area items. */\r\n  public negativeSum: number;\r\n  /** Number of negative area items. */\r\n  public numNegative: number;\r\n  /** Number of zero area items. */\r\n  public numZero: number;\r\n  /** The tag item item with the largest positive data. */\r\n  public largestPositiveItem?: T;\r\n  /** The tag item item with the most negative data. */\r\n  public largestNegativeItem?: T;\r\n  public largestPositiveValue: number;\r\n  public largestNegativeValue: number;\r\n  /** Array of all negative area items. */\r\n  public negativeItemArray?: T[];\r\n  /** Array of zero area items. */\r\n  public zeroItemArray?: T[];\r\n  /** Array of positive area items. */\r\n  public positiveItemArray?: T[];\r\n  /** Setup with zero sums and optional arrays. */\r\n  public constructor(createArrays: boolean) {\r\n    this.positiveSum = this.negativeSum = 0.0;\r\n    this.numPositive = this.numNegative = this.numZero = 0.0;\r\n    this.largestPositiveValue = this.largestNegativeValue = 0.0;\r\n    if (createArrays) {\r\n      this.negativeItemArray = [];\r\n      this.positiveItemArray = [];\r\n      this.zeroItemArray = [];\r\n    }\r\n  }\r\n  /** Update with an item and its data value. */\r\n  public announceItem(item: T, data: number) {\r\n    if (data < 0) {\r\n      this.numNegative++;\r\n      this.negativeSum += data;\r\n      if (this.negativeItemArray)\r\n        this.negativeItemArray.push(item);\r\n      if (data < this.largestNegativeValue) {\r\n        this.largestNegativeValue = data;\r\n        this.largestNegativeItem = item;\r\n      }\r\n    } else if (data > 0) {\r\n      this.numPositive++;\r\n      this.positiveSum += data;\r\n      if (this.positiveItemArray)\r\n        this.positiveItemArray.push(item);\r\n      if (data > this.largestPositiveValue) {\r\n        this.largestPositiveValue = data;\r\n        this.largestPositiveItem = item;\r\n      }\r\n    } else {\r\n      this.numZero++;\r\n      if (this.zeroItemArray)\r\n        this.zeroItemArray.push(item);\r\n    }\r\n  }\r\n}\r\n"]}

package/lib/esm/topology/XYParitySearchContext.d.ts

@@ -2,52 +2,58 @@
  * @module Topology
  */
 /**
- * * XYParitySearchContext is an internal class for callers that can feed points (without extracting to array structures)
+ * `XYParitySearchContext` is an internal class for callers that can feed points (without extracting to array structures)
  * * Most will be via static methods which handle a specific data source.
- *   * PolygonOps.classifyPointInPolygon (x,y,points: XAndY[])
- *   * HalfEdgeGraphSearch.pointInOrOnFaceXY (halfEdgeOnFace, x, y)
+ *   * PolygonOps.classifyPointInPolygon(x,y,points: XAndY[])
+ *   * HalfEdgeGraphSearch.pointInOrOnFaceXY(halfEdgeOnFace, x, y)
  * Use pattern:
- * * Caller must be able walk around polygon producing x,y coordinates (possibly transformed from actual polygon)
+ * * Caller must be able to walk around polygon producing x,y coordinates (possibly transformed from actual polygon).
  * * Caller announce edges to tryStartEdge until finding one acceptable to the search.
  * * Caller then passes additional points up to and including both x0,y0 and x1, y1 of the accepted start edge.
  * Call sequence is:
- *    `context = new XYParitySearchContext`
- *    `repeat {  acquire edge (x0,y0) (x1,y1)} until context.tryStartEdge (x0,y0,x1,y1);`
- *    `for each (x,y) beginning AFTER x1,y1 and ending with (x1,y1) context.advance (x,y)`
- *  `return context.classifyCounts ();`
+ *   * `context = new XYParitySearchContext`
+ *   * `repeat { acquire edge (x0,y0) (x1,y1) } until context.tryStartEdge(x0,y0,x1,y1);`
+ *   * `for each (x,y) beginning AFTER x1,y1 and ending with (x1,y1) context.advance (x,y)`
+ *   * `return context.classifyCounts();`
  */
 export declare class XYParitySearchContext {
     xTest: number;
     yTest: number;
+    /** local x-coordinate of the start of the previous (or earlier) edge */
     u0: number;
+    /** local y-coordinate of the start of the previous (or earlier) edge */
     v0: number;
+    /** local x-coordinate of the end of the previous edge (and start of current edge) */
     u1: number;
+    /** local y-coordinate of the end of the previous edge (and start of current edge) */
     v1: number;
     numLeftCrossing: number;
     numRightCrossing: number;
     numHit: number;
     /**
      * Create a new searcher for specified test point.
-     * @param xTest x coordinate of test point
-     * @param yTest y coordinate of test point
+     * @param xTest x coordinate of test point.
+     * @param yTest y coordinate of test point.
      */
     constructor(xTest: number, yTest: number);
-    /**
-     * test if x,y is a safe first coordinate to start the search.
-     * * safe start must have non-zero y so that final point test (return to x0,y0) does not need look back for exact crossing logic.
-     * @param x
-     * @param y
-     */
+    /** Test if parity processing can begin with this edge. */
     tryStartEdge(x0: number, y0: number, x1: number, y1: number): boolean;
-    /** Return true if parity accumulation proceeded normally.
-     * Return false if interrupted for exact hit.
+    /** Update local coordinates: the current edge becomes the previous edge. */
+    private updateUV01;
+    /**
+     * Process the current edge ending at (x2,y2).
+     * * Accumulate left/right parity of the test point wrt to the polygon. These counts track the number of polygon crossings
+     *   of the left and right horizontal rays emanating from the test point. After all edges are processed, if either count is
+     *   odd/even, the test point is inside/outside the polygon (see [[classifyCounts]]).
+     * * Check whether the test point lies on the edge.
+     * @returns whether caller should continue processing with the next edge. In particular, `false` if we have an exact hit.
      */
-    advance(x: number, y: number): boolean;
+    advance(x2: number, y2: number): boolean;
     /**
      * Return classification as ON, IN, or OUT according to hit and crossing counts.
-     * * Any nonzero hit count is ON
+     * * Any nonzero hit count is ON.
      * * Otherwise IN if left crossing count is odd.
-     * @return 0 if ON, 1 if IN, -1 if OUT
+     * @return 0 if ON, 1 if IN, -1 if OUT.
      */
     classifyCounts(): number | undefined;
 }

package/lib/esm/topology/XYParitySearchContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"XYParitySearchContext.d.ts","sourceRoot":"","sources":["../../../src/topology/XYParitySearchContext.ts"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH,qBAAa,qBAAqB;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACtB;;;;OAIG;gBACgB,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAO/C;;;;;OAKG;IACI,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IAU5E;;OAEG;IACI,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAqE7C;;;;;OAKG;IACI,cAAc,IAAI,MAAM,GAAG,SAAS;CAM5C"}
+{"version":3,"file":"XYParitySearchContext.d.ts","sourceRoot":"","sources":["../../../src/topology/XYParitySearchContext.ts"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH,qBAAa,qBAAqB;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACjE,EAAE,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACjE,EAAE,EAAE,MAAM,CAAC;IAClB,qFAAqF;IAC9E,EAAE,EAAE,MAAM,CAAC;IAClB,qFAAqF;IAC9E,EAAE,EAAE,MAAM,CAAC;IACX,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACtB;;;;OAIG;gBACgB,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAO/C,0DAA0D;IACnD,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IAU5E,4EAA4E;IAC5E,OAAO,CAAC,UAAU;IAOlB;;;;;;;OAOG;IACI,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IAgE/C;;;;;OAKG;IACI,cAAc,IAAI,MAAM,GAAG,SAAS;CAM5C"}

package/lib/esm/topology/XYParitySearchContext.js

@@ -6,127 +6,129 @@
  * @module Topology
  */
 /**
- * * XYParitySearchContext is an internal class for callers that can feed points (without extracting to array structures)
+ * `XYParitySearchContext` is an internal class for callers that can feed points (without extracting to array structures)
  * * Most will be via static methods which handle a specific data source.
- *   * PolygonOps.classifyPointInPolygon (x,y,points: XAndY[])
- *   * HalfEdgeGraphSearch.pointInOrOnFaceXY (halfEdgeOnFace, x, y)
+ *   * PolygonOps.classifyPointInPolygon(x,y,points: XAndY[])
+ *   * HalfEdgeGraphSearch.pointInOrOnFaceXY(halfEdgeOnFace, x, y)
  * Use pattern:
- * * Caller must be able walk around polygon producing x,y coordinates (possibly transformed from actual polygon)
+ * * Caller must be able to walk around polygon producing x,y coordinates (possibly transformed from actual polygon).
  * * Caller announce edges to tryStartEdge until finding one acceptable to the search.
  * * Caller then passes additional points up to and including both x0,y0 and x1, y1 of the accepted start edge.
  * Call sequence is:
- *    `context = new XYParitySearchContext`
- *    `repeat {  acquire edge (x0,y0) (x1,y1)} until context.tryStartEdge (x0,y0,x1,y1);`
- *    `for each (x,y) beginning AFTER x1,y1 and ending with (x1,y1) context.advance (x,y)`
- *  `return context.classifyCounts ();`
+ *   * `context = new XYParitySearchContext`
+ *   * `repeat { acquire edge (x0,y0) (x1,y1) } until context.tryStartEdge(x0,y0,x1,y1);`
+ *   * `for each (x,y) beginning AFTER x1,y1 and ending with (x1,y1) context.advance (x,y)`
+ *   * `return context.classifyCounts();`
  */
 export class XYParitySearchContext {
     /**
      * Create a new searcher for specified test point.
-     * @param xTest x coordinate of test point
-     * @param yTest y coordinate of test point
+     * @param xTest x coordinate of test point.
+     * @param yTest y coordinate of test point.
      */
     constructor(xTest, yTest) {
         this.xTest = xTest;
         this.yTest = yTest;
-        this.u0 = this.v0 = this.u1 = this.v1 = 0; // Not valid for search -- caller must satisfy tryStartEdge !!!
+        this.u0 = this.v0 = this.u1 = this.v1 = 0; // not valid for search; caller must satisfy tryStartEdge
         this.numLeftCrossing = this.numRightCrossing = 0;
         this.numHit = 0;
     }
-    /**
-     * test if x,y is a safe first coordinate to start the search.
-     * * safe start must have non-zero y so that final point test (return to x0,y0) does not need look back for exact crossing logic.
-     * @param x
-     * @param y
-     */
+    /** Test if parity processing can begin with this edge. */
     tryStartEdge(x0, y0, x1, y1) {
         if (y0 !== this.yTest) {
             this.u0 = x0 - this.xTest;
             this.v0 = y0 - this.yTest;
             this.u1 = x1 - this.xTest;
             this.v1 = y1 - this.yTest;
-            return true;
+            return true; // we won't need wraparound logic to process the final edge ending at (x0,y0)
         }
         return false;
     }
-    /** Return true if parity accumulation proceeded normally.
-     * Return false if interrupted for exact hit.
+    /** Update local coordinates: the current edge becomes the previous edge. */
+    updateUV01(u2, v2) {
+        this.u0 = this.u1;
+        this.v0 = this.v1;
+        this.u1 = u2;
+        this.v1 = v2;
+        return true;
+    }
+    /**
+     * Process the current edge ending at (x2,y2).
+     * * Accumulate left/right parity of the test point wrt to the polygon. These counts track the number of polygon crossings
+     *   of the left and right horizontal rays emanating from the test point. After all edges are processed, if either count is
+     *   odd/even, the test point is inside/outside the polygon (see [[classifyCounts]]).
+     * * Check whether the test point lies on the edge.
+     * @returns whether caller should continue processing with the next edge. In particular, `false` if we have an exact hit.
      */
-    advance(x, y) {
-        const u = x - this.xTest;
-        const v = y - this.yTest;
-        const p = v * this.v1;
+    advance(x2, y2) {
+        // In this method we use local u,v coordinates obtained by translating the test point to the origin.
+        // This simplifies our computations:
+        // * left (right) parity is incremented if the current edge crosses the u-axis at u<0 (u>0)
+        // * we have an exact hit if the current edge crosses the u-axis at u=0
+        const u2 = x2 - this.xTest;
+        const v2 = y2 - this.yTest;
+        const p = v2 * this.v1;
         if (p > 0) {
-            // The common case -- skittering along above or below the x axis . . .
-            this.u0 = this.u1;
-            this.v0 = this.v1;
-            this.u1 = u;
-            this.v1 = v;
-            return true;
+            // Current edge does not cross u-axis.
+            return this.updateUV01(u2, v2);
         }
         if (p < 0) {
-            // crossing within (u1,v1) to (u,v)
-            // both v values are nonzero and of opposite sign, so this division is safe . . .
-            const fraction = -this.v1 / (v - this.v1);
-            const uCross = this.u1 + fraction * (u - this.u1);
+            // Current edge crosses the u-axis at edge parameter 0 < lambda < 1 by the Intermediate Value Theorem.
+            // Solve for lambda in 0 = v1 + lambda (v2 - v1), then use it to compute the u-value of the crossing.
+            const lambda = -this.v1 / (v2 - this.v1);
+            const uCross = this.u1 + lambda * (u2 - this.u1);
             if (uCross === 0.0) {
-                this.numHit++;
+                this.numHit++; // Current edge crosses at the origin.
                 return false;
             }
             if (uCross > 0)
                 this.numRightCrossing++;
             else
                 this.numLeftCrossing++;
-            this.u0 = this.u1;
-            this.v0 = this.v1;
-            this.u1 = u;
-            this.v1 = v;
-            return true;
+            return this.updateUV01(u2, v2);
         }
-        // hard stuff -- one or more exact hits . . .
-        if (v === 0.0) {
+        // At this point, at least one endpoint of the current edge lies on the u-axis.
+        if (v2 === 0.0) {
             if (this.v1 === 0.0) {
-                // uh oh -- moving along x axis.  Does it pass through xTest:
-                if (u * this.u1 <= 0.0) {
-                    this.numHit++;
+                if (u2 * this.u1 <= 0.0) {
+                    this.numHit++; // Current edge lies on u-axis and contains the origin.
                     return false;
                 }
-                // quietly moving along the scan line, both xy and x1y1 to same side of test point ...
-                // u0 and u1 remain unchanged !!!
-                this.u1 = u;
-                this.v1 = v;
+                // Current edge lies on the u-axis to one side of the origin.
+                // This edge doesn't contribute to parity computations, so advance past it.
+                this.u1 = u2;
+                this.v1 = v2;
                 return true;
             }
-            // just moved onto the scan line ...
-            this.u0 = this.u1;
-            this.v0 = this.v1;
-            this.u1 = u;
-            this.v1 = v;
-            return true;
+            if (u2 === 0.0) {
+                this.numHit++; // Current edge ends at the origin.
+                return false;
+            }
+            // Current edge ends on the u-axis away from the origin.
+            return this.updateUV01(u2, v2);
         }
-        // fall out with v1 = 0
-        // both v0 and v are nonzero.
-        // any along-0 v values that have passed through are on the same side of xTest, so u1 determines crossing
-        const q = this.v0 * v;
-        if (this.u1 > 0) {
-            if (q < 0)
-                this.numRightCrossing++;
+        // At this point, the current edge starts at the u-axis.
+        if (this.u1 === 0.0) {
+            this.numHit++; // Current edge starts at the origin.
+            return false;
         }
-        else {
-            if (q < 0)
+        // At this point, the current edge starts on the u-axis away from the origin.
+        const q = this.v0 * v2;
+        if (q < 0) {
+            // The current edge and the previous edge lie on opposite sides of the u-axis, so we have a parity change.
+            if (this.u1 > 0)
+                this.numRightCrossing++;
+            else
                 this.numLeftCrossing++;
         }
-        this.u0 = this.u1;
-        this.v0 = this.v1;
-        this.u1 = u;
-        this.v1 = v;
-        return true;
+        // The current edge and the previous edge lie on the same sides of the u-axis, so no parity change.
+        return this.updateUV01(u2, v2);
     }
     /**
      * Return classification as ON, IN, or OUT according to hit and crossing counts.
-     * * Any nonzero hit count is ON
+     * * Any nonzero hit count is ON.
      * * Otherwise IN if left crossing count is odd.
-     * @return 0 if ON, 1 if IN, -1 if OUT
+     * @return 0 if ON, 1 if IN, -1 if OUT.
      */
     classifyCounts() {
         if (this.numHit > 0)

package/lib/esm/topology/XYParitySearchContext.js.map

@@ -1 +1 @@
-{"version":3,"file":"XYParitySearchContext.js","sourceRoot":"","sources":["../../../src/topology/XYParitySearchContext.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 Topology\r\n */\r\n\r\n/**\r\n * * XYParitySearchContext is an internal class for callers that can feed points (without extracting to array structures)\r\n * * Most will be via static methods which handle a specific data source.\r\n *   * PolygonOps.classifyPointInPolygon (x,y,points: XAndY[])\r\n *   * HalfEdgeGraphSearch.pointInOrOnFaceXY (halfEdgeOnFace, x, y)\r\n * Use pattern:\r\n * * Caller must be able walk around polygon producing x,y coordinates (possibly transformed from actual polygon)\r\n * * Caller announce edges to tryStartEdge until finding one acceptable to the search.\r\n * * Caller then passes additional points up to and including both x0,y0 and x1, y1 of the accepted start edge.\r\n * Call sequence is:\r\n *    `context = new XYParitySearchContext`\r\n *    `repeat {  acquire edge (x0,y0) (x1,y1)} until context.tryStartEdge (x0,y0,x1,y1);`\r\n *    `for each (x,y) beginning AFTER x1,y1 and ending with (x1,y1) context.advance (x,y)`\r\n *  `return context.classifyCounts ();`\r\n */\r\nexport class XYParitySearchContext {\r\n  public xTest: number;\r\n  public yTest: number;\r\n  public u0: number; // local coordinates of recent point with nonzero v.  Usually \"second last point\" but points can be skipped if y1 is zero\r\n  public v0: number;\r\n  public u1: number; // local coordinates of most recent point\r\n  public v1: number;\r\n  public numLeftCrossing: number;\r\n  public numRightCrossing: number;\r\n  public numHit: number;\r\n  /**\r\n   * Create a new searcher for specified test point.\r\n   * @param xTest x coordinate of test point\r\n   * @param yTest y coordinate of test point\r\n   */\r\n  public constructor(xTest: number, yTest: number) {\r\n    this.xTest = xTest;\r\n    this.yTest = yTest;\r\n    this.u0 = this.v0 = this.u1 = this.v1 = 0; // Not valid for search -- caller must satisfy tryStartEdge !!!\r\n    this.numLeftCrossing = this.numRightCrossing = 0;\r\n    this.numHit = 0;\r\n  }\r\n  /**\r\n   * test if x,y is a safe first coordinate to start the search.\r\n   * * safe start must have non-zero y so that final point test (return to x0,y0) does not need look back for exact crossing logic.\r\n   * @param x\r\n   * @param y\r\n   */\r\n  public tryStartEdge(x0: number, y0: number, x1: number, y1: number): boolean {\r\n    if (y0 !== this.yTest) {\r\n      this.u0 = x0 - this.xTest;\r\n      this.v0 = y0 - this.yTest;\r\n      this.u1 = x1 - this.xTest;\r\n      this.v1 = y1 - this.yTest;\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n  /** Return true if parity accumulation proceeded normally.\r\n   * Return false if interrupted for exact hit.\r\n   */\r\n  public advance(x: number, y: number): boolean {\r\n    const u = x - this.xTest;\r\n    const v = y - this.yTest;\r\n    const p = v * this.v1;\r\n    if (p > 0) {\r\n      // The common case -- skittering along above or below the x axis . . .\r\n      this.u0 = this.u1;\r\n      this.v0 = this.v1;\r\n      this.u1 = u;\r\n      this.v1 = v;\r\n      return true;\r\n    }\r\n    if (p < 0) {\r\n      // crossing within (u1,v1) to (u,v)\r\n      // both v values are nonzero and of opposite sign, so this division is safe . . .\r\n      const fraction = -this.v1 / (v - this.v1);\r\n      const uCross = this.u1 + fraction * (u - this.u1);\r\n      if (uCross === 0.0) {\r\n        this.numHit++;\r\n        return false;\r\n      }\r\n      if (uCross > 0)\r\n        this.numRightCrossing++;\r\n      else\r\n        this.numLeftCrossing++;\r\n      this.u0 = this.u1;\r\n      this.v0 = this.v1;\r\n      this.u1 = u;\r\n      this.v1 = v;\r\n      return true;\r\n    }\r\n    // hard stuff -- one or more exact hits . . .\r\n    if (v === 0.0) {\r\n      if (this.v1 === 0.0) {\r\n        // uh oh -- moving along x axis.  Does it pass through xTest:\r\n        if (u * this.u1 <= 0.0) {\r\n          this.numHit++;\r\n          return false;\r\n        }\r\n        // quietly moving along the scan line, both xy and x1y1 to same side of test point ...\r\n        // u0 and u1 remain unchanged !!!\r\n        this.u1 = u;\r\n        this.v1 = v;\r\n        return true;\r\n      }\r\n      // just moved onto the scan line ...\r\n      this.u0 = this.u1;\r\n      this.v0 = this.v1;\r\n      this.u1 = u;\r\n      this.v1 = v;\r\n      return true;\r\n    }\r\n    // fall out with v1 = 0\r\n    // both v0 and v are nonzero.\r\n    // any along-0 v values that have passed through are on the same side of xTest, so u1 determines crossing\r\n    const q = this.v0 * v;\r\n    if (this.u1 > 0) {\r\n      if (q < 0)\r\n        this.numRightCrossing++;\r\n    } else {\r\n      if (q < 0)\r\n        this.numLeftCrossing++;\r\n    }\r\n    this.u0 = this.u1;\r\n    this.v0 = this.v1;\r\n    this.u1 = u;\r\n    this.v1 = v;\r\n    return true;\r\n  }\r\n  /**\r\n   * Return classification as ON, IN, or OUT according to hit and crossing counts.\r\n   * * Any nonzero hit count is ON\r\n   * * Otherwise IN if left crossing count is odd.\r\n   * @return 0 if ON, 1 if IN, -1 if OUT\r\n   */\r\n  public classifyCounts(): number | undefined {\r\n    if (this.numHit > 0)\r\n      return 0;\r\n    const parity = this.numLeftCrossing & 0x01;\r\n    return (parity === 1) ? 1 : -1;\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"XYParitySearchContext.js","sourceRoot":"","sources":["../../../src/topology/XYParitySearchContext.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 Topology\r\n */\r\n\r\n/**\r\n * `XYParitySearchContext` is an internal class for callers that can feed points (without extracting to array structures)\r\n * * Most will be via static methods which handle a specific data source.\r\n *   * PolygonOps.classifyPointInPolygon(x,y,points: XAndY[])\r\n *   * HalfEdgeGraphSearch.pointInOrOnFaceXY(halfEdgeOnFace, x, y)\r\n * Use pattern:\r\n * * Caller must be able to walk around polygon producing x,y coordinates (possibly transformed from actual polygon).\r\n * * Caller announce edges to tryStartEdge until finding one acceptable to the search.\r\n * * Caller then passes additional points up to and including both x0,y0 and x1, y1 of the accepted start edge.\r\n * Call sequence is:\r\n *   * `context = new XYParitySearchContext`\r\n *   * `repeat { acquire edge (x0,y0) (x1,y1) } until context.tryStartEdge(x0,y0,x1,y1);`\r\n *   * `for each (x,y) beginning AFTER x1,y1 and ending with (x1,y1) context.advance (x,y)`\r\n *   * `return context.classifyCounts();`\r\n */\r\nexport class XYParitySearchContext {\r\n  public xTest: number;\r\n  public yTest: number;\r\n  /** local x-coordinate of the start of the previous (or earlier) edge */\r\n  public u0: number;\r\n  /** local y-coordinate of the start of the previous (or earlier) edge */\r\n  public v0: number;\r\n  /** local x-coordinate of the end of the previous edge (and start of current edge) */\r\n  public u1: number;\r\n  /** local y-coordinate of the end of the previous edge (and start of current edge) */\r\n  public v1: number;\r\n  public numLeftCrossing: number;\r\n  public numRightCrossing: number;\r\n  public numHit: number;\r\n  /**\r\n   * Create a new searcher for specified test point.\r\n   * @param xTest x coordinate of test point.\r\n   * @param yTest y coordinate of test point.\r\n   */\r\n  public constructor(xTest: number, yTest: number) {\r\n    this.xTest = xTest;\r\n    this.yTest = yTest;\r\n    this.u0 = this.v0 = this.u1 = this.v1 = 0; // not valid for search; caller must satisfy tryStartEdge\r\n    this.numLeftCrossing = this.numRightCrossing = 0;\r\n    this.numHit = 0;\r\n  }\r\n  /** Test if parity processing can begin with this edge. */\r\n  public tryStartEdge(x0: number, y0: number, x1: number, y1: number): boolean {\r\n    if (y0 !== this.yTest) {\r\n      this.u0 = x0 - this.xTest;\r\n      this.v0 = y0 - this.yTest;\r\n      this.u1 = x1 - this.xTest;\r\n      this.v1 = y1 - this.yTest;\r\n      return true;  // we won't need wraparound logic to process the final edge ending at (x0,y0)\r\n    }\r\n    return false;\r\n  }\r\n  /** Update local coordinates: the current edge becomes the previous edge. */\r\n  private updateUV01(u2: number, v2: number) {\r\n    this.u0 = this.u1;\r\n    this.v0 = this.v1;\r\n    this.u1 = u2;\r\n    this.v1 = v2;\r\n    return true;\r\n  }\r\n  /**\r\n   * Process the current edge ending at (x2,y2).\r\n   * * Accumulate left/right parity of the test point wrt to the polygon. These counts track the number of polygon crossings\r\n   *   of the left and right horizontal rays emanating from the test point. After all edges are processed, if either count is\r\n   *   odd/even, the test point is inside/outside the polygon (see [[classifyCounts]]).\r\n   * * Check whether the test point lies on the edge.\r\n   * @returns whether caller should continue processing with the next edge. In particular, `false` if we have an exact hit.\r\n   */\r\n  public advance(x2: number, y2: number): boolean {\r\n    // In this method we use local u,v coordinates obtained by translating the test point to the origin.\r\n    // This simplifies our computations:\r\n    // * left (right) parity is incremented if the current edge crosses the u-axis at u<0 (u>0)\r\n    // * we have an exact hit if the current edge crosses the u-axis at u=0\r\n    const u2 = x2 - this.xTest;\r\n    const v2 = y2 - this.yTest;\r\n    const p = v2 * this.v1;\r\n    if (p > 0) {\r\n      // Current edge does not cross u-axis.\r\n      return this.updateUV01(u2, v2);\r\n    }\r\n    if (p < 0) {\r\n      // Current edge crosses the u-axis at edge parameter 0 < lambda < 1 by the Intermediate Value Theorem.\r\n      // Solve for lambda in 0 = v1 + lambda (v2 - v1), then use it to compute the u-value of the crossing.\r\n      const lambda = -this.v1 / (v2 - this.v1);\r\n      const uCross = this.u1 + lambda * (u2 - this.u1);\r\n      if (uCross === 0.0) {\r\n        this.numHit++;  // Current edge crosses at the origin.\r\n        return false;\r\n      }\r\n      if (uCross > 0)\r\n        this.numRightCrossing++;\r\n      else\r\n        this.numLeftCrossing++;\r\n      return this.updateUV01(u2, v2);\r\n    }\r\n    // At this point, at least one endpoint of the current edge lies on the u-axis.\r\n    if (v2 === 0.0) {\r\n      if (this.v1 === 0.0) {\r\n        if (u2 * this.u1 <= 0.0) {\r\n          this.numHit++;  // Current edge lies on u-axis and contains the origin.\r\n          return false;\r\n        }\r\n        // Current edge lies on the u-axis to one side of the origin.\r\n        // This edge doesn't contribute to parity computations, so advance past it.\r\n        this.u1 = u2;\r\n        this.v1 = v2;\r\n        return true;\r\n      }\r\n      if (u2 === 0.0) {\r\n        this.numHit++;  // Current edge ends at the origin.\r\n        return false;\r\n      }\r\n      // Current edge ends on the u-axis away from the origin.\r\n      return this.updateUV01(u2, v2);\r\n    }\r\n    // At this point, the current edge starts at the u-axis.\r\n    if (this.u1 === 0.0) {\r\n      this.numHit++;  // Current edge starts at the origin.\r\n      return false;\r\n    }\r\n    // At this point, the current edge starts on the u-axis away from the origin.\r\n    const q = this.v0 * v2;\r\n    if (q < 0) {\r\n      // The current edge and the previous edge lie on opposite sides of the u-axis, so we have a parity change.\r\n      if (this.u1 > 0)\r\n        this.numRightCrossing++;\r\n      else\r\n        this.numLeftCrossing++;\r\n    }\r\n    // The current edge and the previous edge lie on the same sides of the u-axis, so no parity change.\r\n    return this.updateUV01(u2, v2);\r\n  }\r\n  /**\r\n   * Return classification as ON, IN, or OUT according to hit and crossing counts.\r\n   * * Any nonzero hit count is ON.\r\n   * * Otherwise IN if left crossing count is odd.\r\n   * @return 0 if ON, 1 if IN, -1 if OUT.\r\n   */\r\n  public classifyCounts(): number | undefined {\r\n    if (this.numHit > 0)\r\n      return 0;\r\n    const parity = this.numLeftCrossing & 0x01;\r\n    return (parity === 1) ? 1 : -1;\r\n  }\r\n}\r\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itwin/core-geometry",
-  "version": "4.4.0-dev.2",
+  "version": "4.4.0-dev.21",
   "description": "iTwin.js Core Geometry library",
   "main": "lib/cjs/core-geometry.js",
   "module": "lib/esm/core-geometry.js",
@@ -26,19 +26,19 @@
     "@itwin/eslint-plugin": "4.0.0-dev.44",
     "@types/chai": "4.3.1",
     "@types/flatbuffers": "~1.10.0",
-    "@types/mocha": "^8.2.2",
+    "@types/mocha": "^10.0.6",
     "chai": "^4.3.10",
     "debug": "^2.6.9",
     "eslint": "^8.44.0",
-    "mocha": "^10.0.0",
+    "mocha": "^10.2.0",
     "nyc": "^15.1.0",
     "rimraf": "^3.0.2",
     "typescript": "~5.0.2",
-    "@itwin/build-tools": "4.4.0-dev.2"
+    "@itwin/build-tools": "4.4.0-dev.21"
   },
   "dependencies": {
     "flatbuffers": "~1.12.0",
-    "@itwin/core-bentley": "4.4.0-dev.2"
+    "@itwin/core-bentley": "4.4.0-dev.21"
   },
   "nyc": {
     "extends": "./node_modules/@itwin/build-tools/.nycrc",