@itwin/core-geometry 4.9.0-dev.12 → 4.9.0-dev.14

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

@@ -1 +1 @@
-{"version":3,"file":"HalfEdgeNodeXYZUV.js","sourceRoot":"","sources":["../../../src/topology/HalfEdgeNodeXYZUV.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAIxD;;GAEG;AACH;;;GAGG;AACH,MAAM,OAAO,SAAS;IAOpB,kBAAkB;IAClB,YAAoB,IAAc,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS;QACvF,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IACD;;;OAGG;IACI,GAAG,CAAC,IAAc,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS;QAC9E,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,uBAAuB;IAChB,OAAO,CAAC,KAAgB;QAC7B,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;QAClB,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;QAClB,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;QAClB,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;QAClB,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;QAClB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC;IAC1B,CAAC;IACD;;;;;;;OAOG;IACI,MAAM,CAAC,sBAAsB,CAAC,IAAc,EAAE,GAAU,EAAE,MAAkB;QACjF,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACjB,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACjB,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACjB,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;QAC5B,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;QAC5B,MAAM,CAAC,GAAG,QAAQ,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QAC5E,MAAM,CAAC,GAAG,QAAQ,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAC9E,IAAI,MAAM;YACR,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACzC,OAAO,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5C,CAAC;IACD,0DAA0D;IACnD,MAAM,CAAC,MAAM,CAClB,IAAc,EAAE,IAAY,CAAC,EAAE,IAAY,CAAC,EAAE,IAAY,CAAC,EAAE,IAAY,CAAC,EAAE,IAAY,CAAC;QAEzF,OAAO,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5C,CAAC;IACD,uBAAuB;IACvB,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,+BAA+B;IAC/B,IAAW,CAAC;QACV,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;IACD,+BAA+B;IAC/B,IAAW,CAAC;QACV,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;IACD,+BAA+B;IAC/B,IAAW,CAAC;QACV,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;IACD,+BAA+B;IAC/B,IAAW,CAAC;QACV,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;IACD,+BAA+B;IAC/B,IAAW,CAAC;QACV,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;IACD,oFAAoF;IAC7E,eAAe,CAAC,MAAgB;QACrC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAC3D,CAAC;IACD,iFAAiF;IAC1E,cAAc,CAAC,MAAgB;QACpC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAClD,CAAC;IACD,sDAAsD;IAC/C,SAAS,CAAC,MAAc,EAAE,GAAW;QAC1C,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC;QAC9B,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG;YACxB,OAAO,CAAC,CAAC;QACX,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7B,CAAC;IACD,sDAAsD;IAC/C,SAAS,CAAC,MAAc,EAAE,GAAW;QAC1C,MAAM,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;QAC/B,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG;YACxB,OAAO,CAAC,CAAC;QACX,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7B,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\nimport { Geometry } from \"../Geometry\";\r\nimport { Point2d } from \"../geometry3d/Point2dVector2d\";\r\nimport { Point3d } from \"../geometry3d/Point3dVector3d\";\r\nimport { Ray3d } from \"../geometry3d/Ray3d\";\r\nimport { HalfEdge } from \"./Graph\";\r\n\r\n/** @packageDocumentation\r\n * @module Topology\r\n */\r\n/**\r\n * Reference to a HalfEdge node with extra XYZ and UV data.\r\n * @internal\r\n */\r\nexport class NodeXYZUV {\r\n  private _node: HalfEdge;\r\n  private _x: number;\r\n  private _y: number;\r\n  private _z: number;\r\n  private _u: number;\r\n  private _v: number;\r\n  /** Constructor */\r\n  private constructor(node: HalfEdge, x: number, y: number, z: number, u: number, v: number) {\r\n    this._x = x;\r\n    this._y = y;\r\n    this._z = z;\r\n    this._u = u;\r\n    this._v = v;\r\n    this._node = node;\r\n  }\r\n  /**\r\n   * Set all content directly from args.\r\n   * @returns `this` reference\r\n   */\r\n  public set(node: HalfEdge, x: number, y: number, z: number, u: number, v: number): NodeXYZUV {\r\n    this._x = x;\r\n    this._y = y;\r\n    this._z = z;\r\n    this._u = u;\r\n    this._v = v;\r\n    this._node = node;\r\n    return this;\r\n  }\r\n  /** Set from `other` */\r\n  public setFrom(other: NodeXYZUV): void {\r\n    this._x = other.x;\r\n    this._y = other.y;\r\n    this._z = other.z;\r\n    this._u = other.u;\r\n    this._v = other.v;\r\n    this._node = other.node;\r\n  }\r\n  /**\r\n   * Create a `NodeXYZUV` with:\r\n   * * node from the given HalfEdge.\r\n   * * x,y,z as the coordinates of `node`.\r\n   * * u as the xy dot product of vectorA with `ray.direction`, where vectorA is the vector from ray origin to\r\n   * `node` coordinates.\r\n   * * v as the xy cross product of `ray.direction` with vectorA.\r\n   */\r\n  public static createNodeAndRayOrigin(node: HalfEdge, ray: Ray3d, result?: NodeXYZUV): NodeXYZUV {\r\n    const x = node.x;\r\n    const y = node.y;\r\n    const z = node.z;\r\n    const dx = x - ray.origin.x;\r\n    const dy = y - ray.origin.y;\r\n    const u = Geometry.dotProductXYXY(dx, dy, ray.direction.x, ray.direction.y);\r\n    const v = Geometry.crossProductXYXY(ray.direction.x, ray.direction.y, dx, dy);\r\n    if (result)\r\n      return result.set(node, x, y, z, u, v);\r\n    return new NodeXYZUV(node, x, y, z, u, v);\r\n  }\r\n  /** Create a `NodeXYZUV` with explicit `node`, xyz, uv. */\r\n  public static create(\r\n    node: HalfEdge, x: number = 0, y: number = 0, z: number = 0, u: number = 0, v: number = 0,\r\n  ): NodeXYZUV {\r\n    return new NodeXYZUV(node, x, y, z, u, v);\r\n  }\r\n  /** Access the node. */\r\n  public get node(): HalfEdge {\r\n    return this._node;\r\n  }\r\n  /** Access the x coordinate. */\r\n  public get x(): number {\r\n    return this._x;\r\n  }\r\n  /** Access the y coordinate. */\r\n  public get y(): number {\r\n    return this._y;\r\n  }\r\n  /** Access the z coordinate. */\r\n  public get z(): number {\r\n    return this._z;\r\n  }\r\n  /** Access the u coordinate. */\r\n  public get u(): number {\r\n    return this._u;\r\n  }\r\n  /** Access the v coordinate. */\r\n  public get v(): number {\r\n    return this._v;\r\n  }\r\n  /** Access the x,y,z coordinates as Point3d with optional caller-supplied result. */\r\n  public getXYZAsPoint3d(result?: Point3d): Point3d {\r\n    return Point3d.create(this._x, this._y, this._z, result);\r\n  }\r\n  /** Access the uv coordinates as Point2d with optional caller-supplied result. */\r\n  public getUVAsPoint2d(result?: Point2d): Point2d {\r\n    return Point2d.create(this._u, this._v, result);\r\n  }\r\n  /** Toleranced comparison function for u coordinate */\r\n  public classifyU(target: number, tol: number): number {\r\n    const delta = this.u - target;\r\n    if (Math.abs(delta) <= tol)\r\n      return 0;\r\n    return delta >= 0 ? 1 : -1;\r\n  }\r\n  /** Toleranced comparison function for v coordinate */\r\n  public classifyV(target: number, tol: number): number {\r\n    const delta = target - this._v;\r\n    if (Math.abs(delta) <= tol)\r\n      return 0;\r\n    return delta >= 0 ? 1 : -1;\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"HalfEdgeNodeXYZUV.js","sourceRoot":"","sources":["../../../src/topology/HalfEdgeNodeXYZUV.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\nimport { Geometry } from \"../Geometry\";\r\nimport { Point2d } from \"../geometry3d/Point2dVector2d\";\r\nimport { Point3d } from \"../geometry3d/Point3dVector3d\";\r\nimport { Ray3d } from \"../geometry3d/Ray3d\";\r\nimport { HalfEdge } from \"./Graph\";\r\n\r\n/** @packageDocumentation\r\n * @module Topology\r\n */\r\n/**\r\n * Reference to a HalfEdge node with extra XYZ and UV data.\r\n * @internal\r\n */\r\nexport class NodeXYZUV {\r\n  private _node: HalfEdge;\r\n  private _x: number;\r\n  private _y: number;\r\n  private _z: number;\r\n  private _u: number;\r\n  private _v: number;\r\n  /** Constructor */\r\n  private constructor(node: HalfEdge, x: number, y: number, z: number, u: number, v: number) {\r\n    this._x = x;\r\n    this._y = y;\r\n    this._z = z;\r\n    this._u = u;\r\n    this._v = v;\r\n    this._node = node;\r\n  }\r\n  /**\r\n   * Set all content directly from args.\r\n   * @returns `this` reference\r\n   */\r\n  public set(node: HalfEdge, x: number, y: number, z: number, u: number, v: number): NodeXYZUV {\r\n    this._x = x;\r\n    this._y = y;\r\n    this._z = z;\r\n    this._u = u;\r\n    this._v = v;\r\n    this._node = node;\r\n    return this;\r\n  }\r\n  /** Set from `other` */\r\n  public setFrom(other: NodeXYZUV): void {\r\n    this._x = other.x;\r\n    this._y = other.y;\r\n    this._z = other.z;\r\n    this._u = other.u;\r\n    this._v = other.v;\r\n    this._node = other.node;\r\n  }\r\n  /**\r\n   * Create a `NodeXYZUV` with:\r\n   * * node from the given HalfEdge.\r\n   * * x,y,z as the coordinates of `node`.\r\n   * * u as the xy dot product of vectorA with `ray.direction`, where vectorA is the vector from ray origin to\r\n   * `node` coordinates (z is ignored).\r\n   * * v as the xy cross product of `ray.direction` with vectorA.\r\n   */\r\n  public static createNodeAndRayOrigin(node: HalfEdge, ray: Ray3d, result?: NodeXYZUV): NodeXYZUV {\r\n    const x = node.x;\r\n    const y = node.y;\r\n    const z = node.z;\r\n    const dx = x - ray.origin.x;\r\n    const dy = y - ray.origin.y;\r\n    const u = Geometry.dotProductXYXY(dx, dy, ray.direction.x, ray.direction.y);\r\n    const v = Geometry.crossProductXYXY(ray.direction.x, ray.direction.y, dx, dy);\r\n    if (result)\r\n      return result.set(node, x, y, z, u, v);\r\n    return new NodeXYZUV(node, x, y, z, u, v);\r\n  }\r\n  /** Create a `NodeXYZUV` with explicit `node`, xyz, uv. */\r\n  public static create(\r\n    node: HalfEdge, x: number = 0, y: number = 0, z: number = 0, u: number = 0, v: number = 0,\r\n  ): NodeXYZUV {\r\n    return new NodeXYZUV(node, x, y, z, u, v);\r\n  }\r\n  /** Access the node. */\r\n  public get node(): HalfEdge {\r\n    return this._node;\r\n  }\r\n  /** Access the x coordinate. */\r\n  public get x(): number {\r\n    return this._x;\r\n  }\r\n  /** Access the y coordinate. */\r\n  public get y(): number {\r\n    return this._y;\r\n  }\r\n  /** Access the z coordinate. */\r\n  public get z(): number {\r\n    return this._z;\r\n  }\r\n  /** Access the u coordinate. */\r\n  public get u(): number {\r\n    return this._u;\r\n  }\r\n  /** Access the v coordinate. */\r\n  public get v(): number {\r\n    return this._v;\r\n  }\r\n  /** Access the x,y,z coordinates as Point3d with optional caller-supplied result. */\r\n  public getXYZAsPoint3d(result?: Point3d): Point3d {\r\n    return Point3d.create(this._x, this._y, this._z, result);\r\n  }\r\n  /** Access the uv coordinates as Point2d with optional caller-supplied result. */\r\n  public getUVAsPoint2d(result?: Point2d): Point2d {\r\n    return Point2d.create(this._u, this._v, result);\r\n  }\r\n  /** Toleranced comparison function for u coordinate */\r\n  public classifyU(target: number, tol: number): number {\r\n    const delta = this.u - target;\r\n    if (Math.abs(delta) <= tol)\r\n      return 0;\r\n    return delta >= 0 ? 1 : -1;\r\n  }\r\n  /** Toleranced comparison function for v coordinate */\r\n  public classifyV(target: number, tol: number): number {\r\n    const delta = target - this._v;\r\n    if (Math.abs(delta) <= tol)\r\n      return 0;\r\n    return delta >= 0 ? 1 : -1;\r\n  }\r\n}\r\n"]}

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

@@ -2,32 +2,74 @@ import { Point3d } from "../geometry3d/Point3dVector3d";
 import { Ray3d } from "../geometry3d/Ray3d";
 import { HalfEdge } from "./Graph";
 import { HalfEdgePositionDetail } from "./HalfEdgePositionDetail";
+/**
+ * Return code from [PointSearchContext.reAimAroundFace]
+ * @internal
+ */
 export declare enum RayClassification {
-    RC_NoHits = 0,
-    RC_TargetOnVertex = 1,
-    RC_TargetOnEdge = 2,
-    RC_Bracket = 3,
-    RC_TargetBefore = 4,
-    RC_TargetAfter = 5
+    NoHits = 0,
+    TargetOnVertex = 1,
+    TargetOnEdge = 2,
+    Bracket = 3,
+    TargetBefore = 4,
+    TargetAfter = 5
 }
+/**
+ * Context for searching for the location of an xy-point in a graph.
+ * * Assumptions: interior faces of the graph are convex, no edge has length less than `tol`.
+ * @internal
+ */
 export declare class PointSearchContext {
     private _tol;
     private constructor();
     static create(tol?: number): PointSearchContext;
     private panic;
+    /**
+     * Reposition `edgeHit` to an adjacent face or vertex, or another position on the edge, that is closer to the
+     * target point.
+     * @param edgeHit start position on a graph edge, updated and returned.
+     * @param ray the ray to the target point. Origin is assumed to lie on the edge.
+     * @param targetDistance distance along the ray to the target point.
+     * @return detail closer to the target point.
+     */
     reAimFromEdge(edgeHit: HalfEdgePositionDetail, ray: Ray3d, targetDistance: number): HalfEdgePositionDetail;
-    reAimFromVertex(searchBase: HalfEdgePositionDetail, ray: Ray3d, targetDistance: number): HalfEdgePositionDetail;
-    reAimAroundFace(faceNode: HalfEdge, ray: Ray3d, targetDistance: number, // !< distance to target point
-    lastBefore: HalfEdgePositionDetail, // CALLER CREATED -- reset as first hit on negative side of ray.
-    firstAfter: HalfEdgePositionDetail): RayClassification;
     /**
-     * Set (replace contents) ray with
-     * * `origin` at start
-     * * `direction` is unit vector from start towards target
-     * * `a` is distance from start to target.
+     * Reposition `vertexHit` to an adjacent face, edge, or vertex hit that is closer to the target point.
+     * @param vertexHit start position at a graph vertex, updated and returned.
+     * @param ray the ray to the target point, assumed to start exactly at the vertex.
+     * @param targetDistance distance along the ray to the target point.
+     * @return detail closer to the target point.
+     */
+    reAimFromVertex(vertexHit: HalfEdgePositionDetail, ray: Ray3d, targetDistance: number): HalfEdgePositionDetail;
+    /**
+     * Visit all edges around the face, updating `lastBefore` and `firstAfter` to ray-edge intersections that
+     * lie directly before and/or after the target point on the ray, if at all.
+     * @param faceNode starting node on a graph face.
+     * @param ray the ray to the target point.
+     * @param targetDistance distance along the ray to the target point.
+     * @param lastBefore the detail to reset as the last hit on the ray before the target point (CALLER CREATED).
+     * @param firstAfter the detail to reset as the first hit on the ray after the target point (CALLER CREATED).
+     * @returns summary of the updated details:
+     * * [[RayClassification.TargetOnVertex]] - target lies at a vertex of the face (details are identical).
+     * * [[RayClassification.TargetOnEdge]] - target lies on an edge of the face (details are identical).
+     * * [[RayClassification.TargetBefore]] - target lies before the face; the ray intersects the face beyond
+     * the target point.
+     * * [[RayClassification.TargetAfter]] - target lies after the face; the ray intersects the face before
+     * the target point.
+     * * [[RayClassification.Bracket]] - target lies between intersections of the ray and the face; if the face
+     * is convex, this means the target lies inside the face.
+     * * [[RayClassification.NoHits]] - the face does not intersect the ray.
+     */
+    reAimAroundFace(faceNode: HalfEdge, ray: Ray3d, targetDistance: number, lastBefore: HalfEdgePositionDetail, firstAfter: HalfEdgePositionDetail): RayClassification;
+    /**
+     * Initialize the input ray for topology search:
+     * * `origin` is at `start`
+     * * `direction` is the unit xy-vector from `start` towards `target`
+     * * `a` is the xy-distance from `start` to `target`
      * @param start existing position
      * @param target target xy coordinates
-     * @param ray ray to update
+     * @param ray updated in place
+     * @returns false if target is reached.
      */
     setSearchRay(start: HalfEdgePositionDetail, target: Point3d, ray: Ray3d): boolean;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"HalfEdgePointInGraphSearch.d.ts","sourceRoot":"","sources":["../../../src/topology/HalfEdgePointInGraphSearch.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,OAAO,EAAY,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,oBAAY,iBAAiB;IAC3B,SAAS,IAAA;IACT,iBAAiB,IAAA;IACjB,eAAe,IAAA;IACf,UAAU,IAAA;IACV,eAAe,IAAA;IACf,cAAc,IAAA;CACf;AAGD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO;WAGO,MAAM,CAAC,GAAG,GAAE,MAAqC;IAG/D,OAAO,CAAC,KAAK;IAKN,aAAa,CAClB,OAAO,EAAE,sBAAsB,EAC/B,GAAG,EAAE,KAAK,EACV,cAAc,EAAE,MAAM,GAAG,sBAAsB;IAgE1C,eAAe,CACpB,UAAU,EAAE,sBAAsB,EAClC,GAAG,EAAE,KAAK,EACV,cAAc,EAAE,MAAM,GAAG,sBAAsB;IAyD1C,eAAe,CACpB,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,KAAK,EACV,cAAc,EAAE,MAAM,EAAG,8BAA8B;IACvD,UAAU,EAAE,sBAAsB,EAAI,gEAAgE;IACtG,UAAU,EAAE,sBAAsB,GAAG,iBAAiB;IAoExD;;;;;;;;OAQG;IACI,YAAY,CAAC,KAAK,EAAE,sBAAsB,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,GAAG,OAAO;CASzF"}
+{"version":3,"file":"HalfEdgePointInGraphSearch.d.ts","sourceRoot":"","sources":["../../../src/topology/HalfEdgePointInGraphSearch.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,OAAO,EAAY,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAgB,MAAM,SAAS,CAAC;AAEjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAIlE;;;GAGG;AACH,oBAAY,iBAAiB;IAC3B,MAAM,IAAA;IACN,cAAc,IAAA;IACd,YAAY,IAAA;IACZ,OAAO,IAAA;IACP,YAAY,IAAA;IACZ,WAAW,IAAA;CACZ;AAED;;;;GAIG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO;WAGO,MAAM,CAAC,GAAG,GAAE,MAAqC;IAG/D,OAAO,CAAC,KAAK;IAab;;;;;;;OAOG;IACI,aAAa,CAClB,OAAO,EAAE,sBAAsB,EAAE,GAAG,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,GAClE,sBAAsB;IAsDzB;;;;;;OAMG;IACI,eAAe,CACpB,SAAS,EAAE,sBAAsB,EAAE,GAAG,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,GACpE,sBAAsB;IA0DzB;;;;;;;;;;;;;;;;;;OAkBG;IACI,eAAe,CACpB,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,KAAK,EACV,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,sBAAsB,EAClC,UAAU,EAAE,sBAAsB,GACjC,iBAAiB;IA0DpB;;;;;;;;;OASG;IACI,YAAY,CAAC,KAAK,EAAE,sBAAsB,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,GAAG,OAAO;CAWzF"}

package/lib/esm/topology/HalfEdgePointInGraphSearch.js

@@ -5,21 +5,31 @@
 /** @packageDocumentation
  * @module Topology
  */
+import { assert } from "@itwin/core-bentley";
 import { Geometry } from "../Geometry";
 import { Vector3d } from "../geometry3d/Point3dVector3d";
+import { HalfEdgeMask } from "./Graph";
 import { NodeXYZUV } from "./HalfEdgeNodeXYZUV";
 import { HalfEdgePositionDetail } from "./HalfEdgePositionDetail";
-/* eslint-disable @typescript-eslint/naming-convention */
+// cspell:word Chebyshev
+/**
+ * Return code from [PointSearchContext.reAimAroundFace]
+ * @internal
+ */
 export var RayClassification;
 (function (RayClassification) {
-    RayClassification[RayClassification["RC_NoHits"] = 0] = "RC_NoHits";
-    RayClassification[RayClassification["RC_TargetOnVertex"] = 1] = "RC_TargetOnVertex";
-    RayClassification[RayClassification["RC_TargetOnEdge"] = 2] = "RC_TargetOnEdge";
-    RayClassification[RayClassification["RC_Bracket"] = 3] = "RC_Bracket";
-    RayClassification[RayClassification["RC_TargetBefore"] = 4] = "RC_TargetBefore";
-    RayClassification[RayClassification["RC_TargetAfter"] = 5] = "RC_TargetAfter";
+    RayClassification[RayClassification["NoHits"] = 0] = "NoHits";
+    RayClassification[RayClassification["TargetOnVertex"] = 1] = "TargetOnVertex";
+    RayClassification[RayClassification["TargetOnEdge"] = 2] = "TargetOnEdge";
+    RayClassification[RayClassification["Bracket"] = 3] = "Bracket";
+    RayClassification[RayClassification["TargetBefore"] = 4] = "TargetBefore";
+    RayClassification[RayClassification["TargetAfter"] = 5] = "TargetAfter";
 })(RayClassification || (RayClassification = {}));
-/* eslint-enable @typescript-eslint/naming-convention */
+/**
+ * Context for searching for the location of an xy-point in a graph.
+ * * Assumptions: interior faces of the graph are convex, no edge has length less than `tol`.
+ * @internal
+ */
 export class PointSearchContext {
     constructor(tol) {
         this._tol = tol;
@@ -28,10 +38,26 @@ export class PointSearchContext {
         return new PointSearchContext(tol);
     }
     panic() {
+        // A note on "unexpectedly" found in comments in this file:
+        // Though this class assumes all edges of the graph have length at least tolerance, the tests below account for
+        // edges with smaller length. This is because we are using two different metrics: Euclidean for distinguishing
+        // points matching user expectation, and Chebyshev, aka "max component", for efficiently testing ray-sector
+        // inclusion in the reAimXXX methods. In particular, epsilon-balls in the former metric are smaller than in the
+        // latter. Thus an edge can be inserted into the graph with Euclidean length (barely) greater than epsilon, but
+        // the edge's parallel and perpendicular components with respect to a ray can have Euclidean length *less* than
+        // epsilon, yielding a Chebyshev edge length less than epsilon. This discrepancy requires careful analysis below,
+        // and if this method is invoked, it is probably because we've missed a case where a dot/cross product lies just
+        // beyond the tolerance.
         return HalfEdgePositionDetail.create();
     }
-    // From given edge start point
-    // The edgeHit is reused as the result.
+    /**
+     * Reposition `edgeHit` to an adjacent face or vertex, or another position on the edge, that is closer to the
+     * target point.
+     * @param edgeHit start position on a graph edge, updated and returned.
+     * @param ray the ray to the target point. Origin is assumed to lie on the edge.
+     * @param targetDistance distance along the ray to the target point.
+     * @return detail closer to the target point.
+     */
     reAimFromEdge(edgeHit, ray, targetDistance) {
         const nodeA = edgeHit.node;
         const dataA = NodeXYZUV.createNodeAndRayOrigin(nodeA, ray);
@@ -39,8 +65,7 @@ export class PointSearchContext {
         const sideA = -dataA.classifyV(0.0, this._tol);
         const sideB = -dataB.classifyV(0.0, this._tol);
         let result;
-        if (sideA * sideB < 0) {
-            // Simple crossing -- just aim into a face
+        if (sideA * sideB < 0) { // simple crossing; just aim into a face
             if (sideA > 0) {
                 result = edgeHit.resetAsFace(dataA.node);
             }
@@ -49,126 +74,150 @@ export class PointSearchContext {
             }
         }
         else if (sideA === 0 || sideB === 0) {
-            // The usual case is both 0 i.e. ray is clearly along the edge.
             const alongA = dataA.classifyU(targetDistance, this._tol);
             const alongB = dataB.classifyU(targetDistance, this._tol);
-            if (alongA === 0 && sideA === 0) {
+            if (sideA === 0 && alongA === 0) { // hit start vertex
                 result = edgeHit.resetAsVertex(dataA.node);
                 result.setITag(1);
             }
-            else if (alongB === 0 && sideB === 0) {
+            else if (sideB === 0 && alongB === 0) { // hit end vertex
                 result = edgeHit.resetAsVertex(dataB.node);
                 result.setITag(1);
             }
-            else if (alongA * alongB < 0) {
-                // target is within edge
-                // (.. This is written for the case where both sideA and sideB are zero.
-                //    If only one is zero, this computes a close edge point but the strong "on" conclusion might be wrong)
-                const edgeFraction = (targetDistance - dataA.u) / (dataB.u - dataA.u);
-                result = edgeHit.resetAtEdgeAndFraction(dataA.node, edgeFraction);
-                result.setITag(1);
-            }
-            else if (alongA < 0 && alongB < 0) {
-                // target is beyond the edge -- move towards it.
-                if (dataA.u > dataB.u)
-                    result = edgeHit.resetAsVertex(dataA.node);
-                else
-                    result = edgeHit.resetAsVertex(dataB.node);
-            }
-            else {
-                // This shouldn't happen -- maybe as if the initial edge point was not within the edge???
-                if (Math.abs(dataA.u) < this._tol
-                    && Math.abs(dataA.v) < this._tol) {
-                    result = edgeHit.resetAsVertex(dataA.node); // , dataA);
+            else if (sideA === 0 && sideB === 0) { // ray is clearly along the edge
+                if (alongA * alongB < 0) { // target is within edge
+                    const edgeFraction = (targetDistance - dataA.u) / (dataB.u - dataA.u);
+                    result = edgeHit.resetAtEdgeAndFraction(dataA.node, edgeFraction);
+                    result.setITag(1);
                 }
-                else if (Math.abs(dataB.u) < this._tol
-                    && Math.abs(dataB.v) < this._tol) {
-                    result = edgeHit.resetAsVertex(dataB.node);
+                else if (alongA < 0 && alongB < 0) { // target is beyond the edge; move towards it
+                    if (dataA.u > dataB.u)
+                        result = edgeHit.resetAsVertex(dataA.node);
+                    else
+                        result = edgeHit.resetAsVertex(dataB.node);
                 }
-                else {
+                else { // both vertices lie on the ray before or after the target; shouldn't happen for edgeHit between nodes
                     edgeHit.resetAsUnknown();
                     result = this.panic();
                 }
             }
+            else if (sideA === 0) { // ray near start vertex but NOT parallel to the edge
+                if (0 === dataA.classifyU(0.0, this._tol))
+                    result = edgeHit.resetAsVertex(dataA.node);
+                else
+                    result = edgeHit.resetAsFace(sideB > 0 ? dataB.node : dataA.node);
+            }
+            else { // ray near end vertex but NOT parallel to the edge
+                assert(sideB === 0);
+                if (0 === dataB.classifyU(0.0, this._tol))
+                    result = edgeHit.resetAsVertex(dataB.node);
+                else
+                    result = edgeHit.resetAsFace(sideA > 0 ? dataA.node : dataB.node);
+            }
         }
-        else {
-            // Both vertices are to same side of the line.   This can't happen for edge point between nodes.
+        else { // both vertices are to same side of the ray; shouldn't happen for edgeHit between nodes
             edgeHit.resetAsUnknown();
             result = this.panic();
         }
         return result;
     }
-    // From given edge start point, pick vertex or edge side for proceeding along ray.
-    // RAY IS ASSUMED TO START AT THE VERTEX PRECISELY !!!!
-    reAimFromVertex(searchBase, ray, targetDistance) {
-        const vertexNode = searchBase.node;
-        let result;
+    /**
+     * Reposition `vertexHit` to an adjacent face, edge, or vertex hit that is closer to the target point.
+     * @param vertexHit start position at a graph vertex, updated and returned.
+     * @param ray the ray to the target point, assumed to start exactly at the vertex.
+     * @param targetDistance distance along the ray to the target point.
+     * @return detail closer to the target point.
+     */
+    reAimFromVertex(vertexHit, ray, targetDistance) {
+        assert(ray.origin.isExactEqual(vertexHit));
+        const vertexNode = vertexHit.node;
         let outboundEdge = vertexNode;
+        // lambda to handle the case where the target definitively lies in the same direction as outboundEdge
+        const advancePositionAlongOutboundEdge = (rayParam) => {
+            if (Math.abs(rayParam - targetDistance) <= this._tol) { // direct hit at far end of outBoundEdge
+                vertexHit.resetAsVertex(outboundEdge.faceSuccessor).setITag(1);
+            }
+            else if (rayParam > targetDistance) { // direct hit within outBoundEdge
+                vertexHit.resetAtEdgeAndFraction(outboundEdge, targetDistance / rayParam);
+            }
+            else if (rayParam > this._tol) { // far end of outBoundEdge is closer to target
+                vertexHit.resetAsVertex(outboundEdge.faceSuccessor);
+            }
+            else {
+                return false;
+            }
+            return true;
+        };
         do {
-            // DPoint3d xyzBase;
-            // vu_getDPoint3d(& xyzBase, outboundEdge);
+            // examine the sector at the outboundEdge node; if ray lies in this sector, return updated detail
             const data0 = NodeXYZUV.createNodeAndRayOrigin(outboundEdge.faceSuccessor, ray);
             const data1 = NodeXYZUV.createNodeAndRayOrigin(outboundEdge.facePredecessor, ray);
+            // u0 is the length of projection of faceSuccessor to the ray and v0 is the length of projection of
+            // faceSuccessor to the ray perp line (90 degrees CCW). Similarly for u1 and v1 with facePredecessor.
             const u0 = data0.u;
-            // double u1 = data1.GetU ();
+            const u1 = data1.u;
             const v0 = data0.v;
             const v1 = data1.v;
-            if (Math.abs(v0) < this._tol) {
-                if (Math.abs(u0 - targetDistance) < this._tol) {
-                    // Direct hit at far end
-                    result = searchBase.resetAsVertex(data0.node);
-                    result.setITag(1);
-                    return result;
-                }
-                else if (u0 > targetDistance) {
-                    // Direct hig within edge
-                    const edgeFraction = targetDistance / u0;
-                    result = searchBase.resetAtEdgeAndFraction(outboundEdge, edgeFraction);
-                    return result;
-                }
-                else if (Math.abs(u0) <= this._tol) {
-                    // Unexpected direct hit on the base of the search, but call it a hit....
-                    result = searchBase.resetAsVertex(outboundEdge);
-                    result.setITag(1);
-                    return result;
-                }
-                else if (u0 > this._tol) {
-                    // Advance to vertex  ...
-                    // double edgeFraction = targetDistance / u0;
-                    result = searchBase.resetAsVertex(data0.node);
-                    return result;
-                }
-                else {
-                    // Search direction is exactly opposite this edge.
-                    // See if the other side of the sector is turned even beyond that ...
-                    if (v1 > this._tol) {
-                        result = searchBase.resetAsFace(outboundEdge, outboundEdge);
-                        return result;
-                    }
+            // examine dot and cross of ray with both edges defining this sector to see if ray lies between them
+            if (Math.abs(v0) <= this._tol) { // ray parallel to outBoundEdge
+                if (advancePositionAlongOutboundEdge(u0))
+                    return vertexHit;
+                if (Math.abs(u0) <= this._tol) { // edge is unexpectedly* small
+                    if (v0 <= 0 && v1 > this._tol && (u0 >= 0 || (u0 < 0 && u1 > this._tol)))
+                        return vertexHit.resetAsFace(outboundEdge, outboundEdge);
                 }
+                // The only remaining case is u0 < -this._tol: ray points opposite outBoundEdge.
+                // By our convexity assumption, the only way that ray lies in this sector is if the lookBack
+                // vector points in the same direction as ray, but this would be handled in the next sector.
             }
             else if (v0 < -this._tol) {
-                if (v1 > this._tol) {
-                    // The usual simple entry into an angle < 180
-                    result = searchBase.resetAsFace(outboundEdge, outboundEdge);
-                    return result;
+                if (v1 > this._tol) // ray definitely lies in this sector
+                    return vertexHit.resetAsFace(outboundEdge, outboundEdge);
+                if (v1 >= -this._tol) { // ray and lookBack vector are parallel
+                    // handle special cases not handled in the next sector
+                    if (Math.abs(u1) <= this._tol) { // lookBack vector is unexpectedly* small...
+                        if (v1 > 0 && (u1 >= 0 || (u0 > this._tol && u1 < 0))) // ...and ray is in this sector
+                            return vertexHit.resetAsFace(outboundEdge, outboundEdge);
+                    }
+                    else if (u0 > this._tol && u1 < 0) { // ray and lookBack point in opposite directions
+                        return vertexHit.resetAsVertex(outboundEdge.faceSuccessor); // far end is closer to target
+                    }
                 }
+                // The only remaining case is v1 < -this._tol: ray definitely lies outside this sector.
             }
-            // NEEDS WORK: angle >= 180 cases !!!!
+            // Proceed to the next sector around this vertex. We even examine the (concave) exterior sector at a boundary
+            // vertex in order to handle the case where the target lies in the direction of an exterior outboundEdge.
             outboundEdge = outboundEdge.vertexSuccessor;
         } while (outboundEdge !== vertexNode);
         return this.panic();
     }
-    // Visit all edges around face.
-    // reset lastBefore and firstAfter describing progress towards target distance on ray.
-    reAimAroundFace(faceNode, ray, targetDistance, // !< distance to target point
-    lastBefore, // CALLER CREATED -- reset as first hit on negative side of ray.
-    firstAfter) {
+    /**
+     * Visit all edges around the face, updating `lastBefore` and `firstAfter` to ray-edge intersections that
+     * lie directly before and/or after the target point on the ray, if at all.
+     * @param faceNode starting node on a graph face.
+     * @param ray the ray to the target point.
+     * @param targetDistance distance along the ray to the target point.
+     * @param lastBefore the detail to reset as the last hit on the ray before the target point (CALLER CREATED).
+     * @param firstAfter the detail to reset as the first hit on the ray after the target point (CALLER CREATED).
+     * @returns summary of the updated details:
+     * * [[RayClassification.TargetOnVertex]] - target lies at a vertex of the face (details are identical).
+     * * [[RayClassification.TargetOnEdge]] - target lies on an edge of the face (details are identical).
+     * * [[RayClassification.TargetBefore]] - target lies before the face; the ray intersects the face beyond
+     * the target point.
+     * * [[RayClassification.TargetAfter]] - target lies after the face; the ray intersects the face before
+     * the target point.
+     * * [[RayClassification.Bracket]] - target lies between intersections of the ray and the face; if the face
+     * is convex, this means the target lies inside the face.
+     * * [[RayClassification.NoHits]] - the face does not intersect the ray.
+     */
+    reAimAroundFace(faceNode, ray, targetDistance, lastBefore, firstAfter) {
+        assert(!faceNode.isMaskSet(HalfEdgeMask.EXTERIOR));
         lastBefore.resetAsUndefinedWithTag(-Number.MAX_VALUE);
         firstAfter.resetAsUndefinedWithTag(Number.MAX_VALUE);
         const data0 = NodeXYZUV.createNodeAndRayOrigin(faceNode, ray);
         let data1;
         let node0 = faceNode;
+        // find the intersection of the ray with each edge of the face to classify the ray hit
         do {
             const node1 = node0.faceSuccessor;
             data1 = NodeXYZUV.createNodeAndRayOrigin(node1, ray, data1);
@@ -176,78 +225,70 @@ export class PointSearchContext {
             const u1 = data1.u;
             const v0 = data0.v;
             const v1 = data1.v;
-            if (Math.abs(v1) < this._tol) {
-                // Vertex hit ...
+            if (Math.abs(v1) < this._tol) { // ray parallel to edge
                 const vertexHit = HalfEdgePositionDetail.createVertex(node1);
                 vertexHit.setDTag(u1);
                 if (Math.abs(u1 - targetDistance) < this._tol) {
                     firstAfter.setFrom(vertexHit);
                     lastBefore.setFrom(vertexHit);
-                    return RayClassification.RC_TargetOnVertex;
+                    return RayClassification.TargetOnVertex;
                 }
                 if (u1 > targetDistance && u1 < firstAfter.getDTag())
                     firstAfter.setFrom(vertexHit);
                 if (u1 < targetDistance && u1 > lastBefore.getDTag())
                     lastBefore.setFrom(vertexHit);
             }
-            else if (v0 * v1 < 0.0) {
-                // Edge Crossing ...
+            else if (v0 * v1 < 0.0) { // ray crosses edge
                 const edgeFraction = -v0 / (v1 - v0);
-                const uEdge = Geometry.interpolate(u0, edgeFraction, u1);
+                const rayFraction = Geometry.interpolate(u0, edgeFraction, u1);
                 const edgeHit = HalfEdgePositionDetail.createEdgeAtFraction(data0.node, edgeFraction);
-                edgeHit.setDTag(uEdge);
-                if (Math.abs(uEdge - targetDistance) <= this._tol) {
+                edgeHit.setDTag(rayFraction);
+                if (Math.abs(rayFraction - targetDistance) <= this._tol) {
                     firstAfter.setFrom(edgeHit);
                     lastBefore.setFrom(edgeHit);
-                    return RayClassification.RC_TargetOnEdge;
+                    return RayClassification.TargetOnEdge;
                 }
-                if (uEdge > targetDistance && uEdge < firstAfter.getDTag()) {
+                if (rayFraction > targetDistance && rayFraction < firstAfter.getDTag())
                     firstAfter.setFrom(edgeHit);
-                    firstAfter.setITag(v0 > 0.0 ? -1 : 1);
-                }
-                if (uEdge < targetDistance && uEdge > lastBefore.getDTag()) {
+                if (rayFraction < targetDistance && rayFraction > lastBefore.getDTag())
                     lastBefore.setFrom(edgeHit);
-                    lastBefore.setDTag(uEdge);
-                }
             }
             data0.setFrom(data1);
             node0 = node0.faceSuccessor;
         } while (node0 !== faceNode);
-        // Returned to start node !!!
-        const afterTag = firstAfter.getITag();
+        // returned to start node
         firstAfter.setITag(0);
         lastBefore.setITag(0);
         if (lastBefore.isUnclassified) {
             if (firstAfter.isUnclassified)
-                return RayClassification.RC_NoHits;
-            return RayClassification.RC_TargetBefore;
-        }
-        if (firstAfter.isUnclassified
-            || (firstAfter.isEdge && afterTag && afterTag < 0)) {
-            return RayClassification.RC_TargetAfter;
-        }
-        else {
-            return RayClassification.RC_Bracket;
+                return RayClassification.NoHits;
+            return RayClassification.TargetBefore;
         }
+        if (firstAfter.isUnclassified)
+            return RayClassification.TargetAfter;
+        else
+            return RayClassification.Bracket; // face is locally convex; target lies inside this face
     }
-    // Return false if target is reached !!!!
     /**
-     * Set (replace contents) ray with
-     * * `origin` at start
-     * * `direction` is unit vector from start towards target
-     * * `a` is distance from start to target.
+     * Initialize the input ray for topology search:
+     * * `origin` is at `start`
+     * * `direction` is the unit xy-vector from `start` towards `target`
+     * * `a` is the xy-distance from `start` to `target`
      * @param start existing position
      * @param target target xy coordinates
-     * @param ray ray to update
+     * @param ray updated in place
+     * @returns false if target is reached.
      */
     setSearchRay(start, target, ray) {
         ray.origin.setFromPoint3d(start);
         Vector3d.createStartEnd(ray.origin, target, ray.direction);
         ray.direction.z = 0.0;
-        const distanceToTarget = ray.direction.magnitudeXY();
-        ray.a = ray.direction.magnitude();
-        ray.direction.scaleInPlace(1 / ray.a);
-        return distanceToTarget >= this._tol;
+        const distanceToTargetXY = ray.direction.magnitudeXY();
+        if (distanceToTargetXY < this._tol)
+            return false; // no searching necessary, we are already at the target point
+        ray.a = distanceToTargetXY;
+        ray.direction.scaleInPlace(1 / distanceToTargetXY);
+        return true;
     }
 }
 //# sourceMappingURL=HalfEdgePointInGraphSearch.js.map