@math.gl/geometry 5.0.0-alpha.9 → 5.0.0-beta.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +97 -49
- package/README.md +16 -1
- package/THIRD-PARTY-NOTICES.md +18 -0
- package/dist/culling/constants.d.ts +3 -0
- package/dist/culling/constants.d.ts.map +1 -0
- package/dist/culling/constants.js +5 -0
- package/dist/culling/constants.js.map +1 -0
- package/dist/culling/index.cjs +2124 -0
- package/dist/culling/index.cjs.map +6 -0
- package/dist/culling/index.d.ts +31 -0
- package/dist/culling/index.d.ts.map +1 -0
- package/dist/culling/index.js +25 -0
- package/dist/culling/index.js.map +1 -0
- package/dist/culling/lib/algorithms/bounding-box-from-points.d.ts +15 -0
- package/dist/culling/lib/algorithms/bounding-box-from-points.d.ts.map +1 -0
- package/dist/culling/lib/algorithms/bounding-box-from-points.js +137 -0
- package/dist/culling/lib/algorithms/bounding-box-from-points.js.map +1 -0
- package/dist/culling/lib/algorithms/bounding-sphere-from-points.d.ts +14 -0
- package/dist/culling/lib/algorithms/bounding-sphere-from-points.d.ts.map +1 -0
- package/dist/culling/lib/algorithms/bounding-sphere-from-points.js +146 -0
- package/dist/culling/lib/algorithms/bounding-sphere-from-points.js.map +1 -0
- package/dist/culling/lib/algorithms/compute-eigen-decomposition.d.ts +37 -0
- package/dist/culling/lib/algorithms/compute-eigen-decomposition.d.ts.map +1 -0
- package/dist/culling/lib/algorithms/compute-eigen-decomposition.js +137 -0
- package/dist/culling/lib/algorithms/compute-eigen-decomposition.js.map +1 -0
- package/dist/culling/lib/algorithms/oriented-bounding-box-quaternion.d.ts +7 -0
- package/dist/culling/lib/algorithms/oriented-bounding-box-quaternion.d.ts.map +1 -0
- package/dist/culling/lib/algorithms/oriented-bounding-box-quaternion.js +26 -0
- package/dist/culling/lib/algorithms/oriented-bounding-box-quaternion.js.map +1 -0
- package/dist/culling/lib/bounding-volumes/axis-aligned-bounding-box.d.ts +56 -0
- package/dist/culling/lib/bounding-volumes/axis-aligned-bounding-box.d.ts.map +1 -0
- package/dist/culling/lib/bounding-volumes/axis-aligned-bounding-box.js +116 -0
- package/dist/culling/lib/bounding-volumes/axis-aligned-bounding-box.js.map +1 -0
- package/dist/culling/lib/bounding-volumes/bounding-sphere.d.ts +40 -0
- package/dist/culling/lib/bounding-volumes/bounding-sphere.d.ts.map +1 -0
- package/dist/culling/lib/bounding-volumes/bounding-sphere.js +123 -0
- package/dist/culling/lib/bounding-volumes/bounding-sphere.js.map +1 -0
- package/dist/culling/lib/bounding-volumes/bounding-volume.d.ts +30 -0
- package/dist/culling/lib/bounding-volumes/bounding-volume.d.ts.map +1 -0
- package/dist/culling/lib/bounding-volumes/bounding-volume.js +7 -0
- package/dist/culling/lib/bounding-volumes/bounding-volume.js.map +1 -0
- package/dist/culling/lib/bounding-volumes/oriented-bounding-box.d.ts +62 -0
- package/dist/culling/lib/bounding-volumes/oriented-bounding-box.d.ts.map +1 -0
- package/dist/culling/lib/bounding-volumes/oriented-bounding-box.js +230 -0
- package/dist/culling/lib/bounding-volumes/oriented-bounding-box.js.map +1 -0
- package/dist/culling/lib/culling-volume.d.ts +46 -0
- package/dist/culling/lib/culling-volume.d.ts.map +1 -0
- package/dist/culling/lib/culling-volume.js +126 -0
- package/dist/culling/lib/culling-volume.js.map +1 -0
- package/dist/culling/lib/perspective-frustum.d.ts +153 -0
- package/dist/culling/lib/perspective-frustum.d.ts.map +1 -0
- package/dist/culling/lib/perspective-frustum.js +191 -0
- package/dist/culling/lib/perspective-frustum.js.map +1 -0
- package/dist/culling/lib/perspective-off-center-frustum.d.ts +158 -0
- package/dist/culling/lib/perspective-off-center-frustum.d.ts.map +1 -0
- package/dist/culling/lib/perspective-off-center-frustum.js +276 -0
- package/dist/culling/lib/perspective-off-center-frustum.js.map +1 -0
- package/dist/culling/lib/plane.d.ts +35 -0
- package/dist/culling/lib/plane.d.ts.map +1 -0
- package/dist/culling/lib/plane.js +90 -0
- package/dist/culling/lib/plane.js.map +1 -0
- package/dist/culling/lib/ray.d.ts +13 -0
- package/dist/culling/lib/ray.d.ts.map +1 -0
- package/dist/culling/lib/ray.js +30 -0
- package/dist/culling/lib/ray.js.map +1 -0
- package/dist/culling/lib/shapes/box-shape.d.ts +19 -0
- package/dist/culling/lib/shapes/box-shape.d.ts.map +1 -0
- package/dist/culling/lib/shapes/box-shape.js +69 -0
- package/dist/culling/lib/shapes/box-shape.js.map +1 -0
- package/dist/culling/lib/shapes/capsule-shape.d.ts +23 -0
- package/dist/culling/lib/shapes/capsule-shape.d.ts.map +1 -0
- package/dist/culling/lib/shapes/capsule-shape.js +151 -0
- package/dist/culling/lib/shapes/capsule-shape.js.map +1 -0
- package/dist/culling/lib/shapes/cylinder-shape.d.ts +22 -0
- package/dist/culling/lib/shapes/cylinder-shape.d.ts.map +1 -0
- package/dist/culling/lib/shapes/cylinder-shape.js +99 -0
- package/dist/culling/lib/shapes/cylinder-shape.js.map +1 -0
- package/dist/culling/lib/shapes/implicit-shape.d.ts +56 -0
- package/dist/culling/lib/shapes/implicit-shape.d.ts.map +1 -0
- package/dist/culling/lib/shapes/implicit-shape.js +142 -0
- package/dist/culling/lib/shapes/implicit-shape.js.map +1 -0
- package/dist/culling/lib/shapes/plane-shape.d.ts +27 -0
- package/dist/culling/lib/shapes/plane-shape.d.ts.map +1 -0
- package/dist/culling/lib/shapes/plane-shape.js +71 -0
- package/dist/culling/lib/shapes/plane-shape.js.map +1 -0
- package/dist/culling/lib/shapes/sphere-shape.d.ts +18 -0
- package/dist/culling/lib/shapes/sphere-shape.d.ts.map +1 -0
- package/dist/culling/lib/shapes/sphere-shape.js +43 -0
- package/dist/culling/lib/shapes/sphere-shape.js.map +1 -0
- package/dist/culling/oriented-box-2d.d.ts +22 -0
- package/dist/culling/oriented-box-2d.d.ts.map +1 -0
- package/dist/culling/oriented-box-2d.js +86 -0
- package/dist/culling/oriented-box-2d.js.map +1 -0
- package/dist/culling/queries.d.ts +44 -0
- package/dist/culling/queries.d.ts.map +1 -0
- package/dist/culling/queries.js +259 -0
- package/dist/culling/queries.js.map +1 -0
- package/dist/curves/bezier-curves.d.ts +18 -0
- package/dist/curves/bezier-curves.d.ts.map +1 -0
- package/dist/curves/bezier-curves.js +54 -0
- package/dist/curves/bezier-curves.js.map +1 -0
- package/dist/curves/catmull-rom-curve.d.ts +15 -0
- package/dist/curves/catmull-rom-curve.d.ts.map +1 -0
- package/dist/curves/catmull-rom-curve.js +77 -0
- package/dist/curves/catmull-rom-curve.js.map +1 -0
- package/dist/curves/curve-arc-length.d.ts +17 -0
- package/dist/curves/curve-arc-length.d.ts.map +1 -0
- package/dist/curves/curve-arc-length.js +58 -0
- package/dist/curves/curve-arc-length.js.map +1 -0
- package/dist/curves/curve.d.ts +23 -0
- package/dist/curves/curve.d.ts.map +1 -0
- package/dist/curves/curve.js +77 -0
- package/dist/curves/curve.js.map +1 -0
- package/dist/curves/hermite-curve.d.ts +9 -0
- package/dist/curves/hermite-curve.d.ts.map +1 -0
- package/dist/curves/hermite-curve.js +24 -0
- package/dist/curves/hermite-curve.js.map +1 -0
- package/dist/curves/index.d.ts +8 -0
- package/dist/curves/index.d.ts.map +1 -0
- package/dist/curves/index.js +9 -0
- package/dist/curves/index.js.map +1 -0
- package/dist/geometries/box-geometry.js +1 -1
- package/dist/geometries/box-geometry.js.map +1 -1
- package/dist/geometries/capsule-geometry.js +1 -1
- package/dist/geometries/capsule-geometry.js.map +1 -1
- package/dist/geometries/cylinder-geometry.js +1 -1
- package/dist/geometries/cylinder-geometry.js.map +1 -1
- package/dist/geometries/geometry-helpers.js +1 -1
- package/dist/geometries/geometry-helpers.js.map +1 -1
- package/dist/geometries/ico-sphere-geometry.js +1 -1
- package/dist/geometries/ico-sphere-geometry.js.map +1 -1
- package/dist/geometries/plane-geometry.js +1 -1
- package/dist/geometries/plane-geometry.js.map +1 -1
- package/dist/geometries/primitive-mesh-builder.d.ts +24 -0
- package/dist/geometries/primitive-mesh-builder.d.ts.map +1 -0
- package/dist/geometries/primitive-mesh-builder.js +74 -0
- package/dist/geometries/primitive-mesh-builder.js.map +1 -0
- package/dist/geometries/prism-geometry.d.ts +13 -0
- package/dist/geometries/prism-geometry.d.ts.map +1 -0
- package/dist/geometries/prism-geometry.js +34 -0
- package/dist/geometries/prism-geometry.js.map +1 -0
- package/dist/geometries/ring-geometry.d.ts +15 -0
- package/dist/geometries/ring-geometry.d.ts.map +1 -0
- package/dist/geometries/ring-geometry.js +64 -0
- package/dist/geometries/ring-geometry.js.map +1 -0
- package/dist/geometries/sphere-geometry.js +1 -1
- package/dist/geometries/sphere-geometry.js.map +1 -1
- package/dist/geometries/surface-of-revolution.js +1 -1
- package/dist/geometries/surface-of-revolution.js.map +1 -1
- package/dist/geometries/truncated-cone-geometry.js +1 -1
- package/dist/geometries/truncated-cone-geometry.js.map +1 -1
- package/dist/index.cjs +6105 -16
- package/dist/index.cjs.map +3 -3
- package/dist/index.d.ts +26 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +15 -1
- package/dist/index.js.map +1 -1
- package/dist/lib/geometry-utils.js +1 -1
- package/dist/lib/geometry-utils.js.map +1 -1
- package/dist/lib/geometry.d.ts +1 -1
- package/dist/lib/geometry.d.ts.map +1 -1
- package/dist/lib/geometry.js +1 -1
- package/dist/lib/geometry.js.map +1 -1
- package/dist/lib/hinge-tree.d.ts +33 -0
- package/dist/lib/hinge-tree.d.ts.map +1 -0
- package/dist/lib/hinge-tree.js +144 -0
- package/dist/lib/hinge-tree.js.map +1 -0
- package/dist/parametric/lathe-geometry.d.ts +14 -0
- package/dist/parametric/lathe-geometry.d.ts.map +1 -0
- package/dist/parametric/lathe-geometry.js +48 -0
- package/dist/parametric/lathe-geometry.js.map +1 -0
- package/dist/parametric/parametric-geometry.d.ts +20 -0
- package/dist/parametric/parametric-geometry.d.ts.map +1 -0
- package/dist/parametric/parametric-geometry.js +88 -0
- package/dist/parametric/parametric-geometry.js.map +1 -0
- package/dist/parametric/torus-geometry.d.ts +19 -0
- package/dist/parametric/torus-geometry.d.ts.map +1 -0
- package/dist/parametric/torus-geometry.js +89 -0
- package/dist/parametric/torus-geometry.js.map +1 -0
- package/dist/parametric.d.ts +7 -0
- package/dist/parametric.d.ts.map +1 -0
- package/dist/parametric.js +7 -0
- package/dist/parametric.js.map +1 -0
- package/dist/polygon/clip-triangle-mesh.d.ts +41 -0
- package/dist/polygon/clip-triangle-mesh.d.ts.map +1 -0
- package/dist/polygon/clip-triangle-mesh.js +155 -0
- package/dist/polygon/clip-triangle-mesh.js.map +1 -0
- package/dist/polygon/cut-by-grid.d.ts +24 -0
- package/dist/polygon/cut-by-grid.d.ts.map +1 -0
- package/dist/polygon/cut-by-grid.js +221 -0
- package/dist/polygon/cut-by-grid.js.map +1 -0
- package/dist/polygon/cut-by-mercator-bounds.d.ts +17 -0
- package/dist/polygon/cut-by-mercator-bounds.d.ts.map +1 -0
- package/dist/polygon/cut-by-mercator-bounds.js +149 -0
- package/dist/polygon/cut-by-mercator-bounds.js.map +1 -0
- package/dist/polygon/earcut.d.ts +13 -0
- package/dist/polygon/earcut.d.ts.map +1 -0
- package/dist/polygon/earcut.js +693 -0
- package/dist/polygon/earcut.js.map +1 -0
- package/dist/polygon/index.d.ts +14 -0
- package/dist/polygon/index.d.ts.map +1 -0
- package/dist/polygon/index.js +13 -0
- package/dist/polygon/index.js.map +1 -0
- package/dist/polygon/lineclip.d.ts +31 -0
- package/dist/polygon/lineclip.d.ts.map +1 -0
- package/dist/polygon/lineclip.js +184 -0
- package/dist/polygon/lineclip.js.map +1 -0
- package/dist/polygon/polygon-utils.d.ts +103 -0
- package/dist/polygon/polygon-utils.d.ts.map +1 -0
- package/dist/polygon/polygon-utils.js +155 -0
- package/dist/polygon/polygon-utils.js.map +1 -0
- package/dist/polygon/polygon.d.ts +41 -0
- package/dist/polygon/polygon.d.ts.map +1 -0
- package/dist/polygon/polygon.js +76 -0
- package/dist/polygon/polygon.js.map +1 -0
- package/dist/polygon/subdivide-polyline.d.ts +56 -0
- package/dist/polygon/subdivide-polyline.d.ts.map +1 -0
- package/dist/polygon/subdivide-polyline.js +141 -0
- package/dist/polygon/subdivide-polyline.js.map +1 -0
- package/dist/polygon/subdivide-triangle-mesh.d.ts +78 -0
- package/dist/polygon/subdivide-triangle-mesh.d.ts.map +1 -0
- package/dist/polygon/subdivide-triangle-mesh.js +238 -0
- package/dist/polygon/subdivide-triangle-mesh.js.map +1 -0
- package/dist/polygon/utils.d.ts +5 -0
- package/dist/polygon/utils.d.ts.map +1 -0
- package/dist/polygon/utils.js +38 -0
- package/dist/polygon/utils.js.map +1 -0
- package/dist/spatial-index/box-index.d.ts +86 -0
- package/dist/spatial-index/box-index.d.ts.map +1 -0
- package/dist/spatial-index/box-index.js +335 -0
- package/dist/spatial-index/box-index.js.map +1 -0
- package/dist/spatial-index/index.d.ts +7 -0
- package/dist/spatial-index/index.d.ts.map +1 -0
- package/dist/spatial-index/index.js +6 -0
- package/dist/spatial-index/index.js.map +1 -0
- package/dist/spatial-index/triangle-bvh.d.ts +74 -0
- package/dist/spatial-index/triangle-bvh.d.ts.map +1 -0
- package/dist/spatial-index/triangle-bvh.js +221 -0
- package/dist/spatial-index/triangle-bvh.js.map +1 -0
- package/dist/utils/attribute-compression.d.ts +50 -0
- package/dist/utils/attribute-compression.d.ts.map +1 -0
- package/dist/utils/attribute-compression.js +186 -0
- package/dist/utils/attribute-compression.js.map +1 -0
- package/dist/utils/attribute-iterator.d.ts +8 -0
- package/dist/utils/attribute-iterator.d.ts.map +1 -0
- package/dist/utils/attribute-iterator.js +25 -0
- package/dist/utils/attribute-iterator.js.map +1 -0
- package/dist/utils/compose-attribute-provenance.d.ts +13 -0
- package/dist/utils/compose-attribute-provenance.d.ts.map +1 -0
- package/dist/utils/compose-attribute-provenance.js +63 -0
- package/dist/utils/compose-attribute-provenance.js.map +1 -0
- package/dist/utils/compute-vertex-normals.d.ts +4 -0
- package/dist/utils/compute-vertex-normals.d.ts.map +1 -0
- package/dist/utils/compute-vertex-normals.js +54 -0
- package/dist/utils/compute-vertex-normals.js.map +1 -0
- package/dist/utils/constants.d.ts +52 -0
- package/dist/utils/constants.d.ts.map +1 -0
- package/dist/utils/constants.js +39 -0
- package/dist/utils/constants.js.map +1 -0
- package/dist/utils/coordinates.d.ts +3 -0
- package/dist/utils/coordinates.d.ts.map +1 -0
- package/dist/utils/coordinates.js +8 -0
- package/dist/utils/coordinates.js.map +1 -0
- package/dist/utils/geometry.d.ts +20 -0
- package/dist/utils/geometry.d.ts.map +1 -0
- package/dist/utils/geometry.js +31 -0
- package/dist/utils/geometry.js.map +1 -0
- package/dist/utils/gl-type.d.ts +17 -0
- package/dist/utils/gl-type.d.ts.map +1 -0
- package/dist/utils/gl-type.js +69 -0
- package/dist/utils/gl-type.js.map +1 -0
- package/dist/utils/index.d.ts +18 -0
- package/dist/utils/index.d.ts.map +1 -0
- package/dist/utils/index.js +16 -0
- package/dist/utils/index.js.map +1 -0
- package/dist/utils/interpolate-packed-attributes.d.ts +43 -0
- package/dist/utils/interpolate-packed-attributes.d.ts.map +1 -0
- package/dist/utils/interpolate-packed-attributes.js +192 -0
- package/dist/utils/interpolate-packed-attributes.js.map +1 -0
- package/dist/utils/mesh-processing.d.ts +18 -0
- package/dist/utils/mesh-processing.d.ts.map +1 -0
- package/dist/utils/mesh-processing.js +300 -0
- package/dist/utils/mesh-processing.js.map +1 -0
- package/dist/utils/primitive-iterator.d.ts +21 -0
- package/dist/utils/primitive-iterator.d.ts.map +1 -0
- package/dist/utils/primitive-iterator.js +117 -0
- package/dist/utils/primitive-iterator.js.map +1 -0
- package/dist/utils/qualify-surface-transition.d.ts +21 -0
- package/dist/utils/qualify-surface-transition.d.ts.map +1 -0
- package/dist/utils/qualify-surface-transition.js +140 -0
- package/dist/utils/qualify-surface-transition.js.map +1 -0
- package/dist/utils/rgb565.d.ts +5 -0
- package/dist/utils/rgb565.d.ts.map +1 -0
- package/dist/utils/rgb565.js +24 -0
- package/dist/utils/rgb565.js.map +1 -0
- package/dist/utils/typed-array-utils.d.ts +3 -0
- package/dist/utils/typed-array-utils.d.ts.map +1 -0
- package/dist/utils/typed-array-utils.js +16 -0
- package/dist/utils/typed-array-utils.js.map +1 -0
- package/package.json +12 -4
- package/src/culling/constants.ts +6 -0
- package/src/culling/index.ts +55 -0
- package/src/culling/lib/algorithms/bounding-box-from-points.ts +174 -0
- package/src/culling/lib/algorithms/bounding-sphere-from-points.ts +175 -0
- package/src/culling/lib/algorithms/compute-eigen-decomposition.ts +171 -0
- package/src/culling/lib/algorithms/oriented-bounding-box-quaternion.ts +32 -0
- package/src/culling/lib/bounding-volumes/axis-aligned-bounding-box.ts +153 -0
- package/src/culling/lib/bounding-volumes/bounding-sphere.ts +154 -0
- package/src/culling/lib/bounding-volumes/bounding-volume.ts +38 -0
- package/src/culling/lib/bounding-volumes/oriented-bounding-box.ts +320 -0
- package/src/culling/lib/culling-volume.ts +163 -0
- package/src/culling/lib/perspective-frustum.ts +288 -0
- package/src/culling/lib/perspective-off-center-frustum.ts +381 -0
- package/src/culling/lib/plane.ts +118 -0
- package/src/culling/lib/ray.ts +33 -0
- package/src/culling/lib/shapes/box-shape.ts +78 -0
- package/src/culling/lib/shapes/capsule-shape.ts +232 -0
- package/src/culling/lib/shapes/cylinder-shape.ts +133 -0
- package/src/culling/lib/shapes/implicit-shape.ts +209 -0
- package/src/culling/lib/shapes/plane-shape.ts +78 -0
- package/src/culling/lib/shapes/sphere-shape.ts +60 -0
- package/src/culling/oriented-box-2d.ts +165 -0
- package/src/culling/queries.ts +332 -0
- package/src/curves/bezier-curves.ts +62 -0
- package/src/curves/catmull-rom-curve.ts +89 -0
- package/src/curves/curve-arc-length.ts +70 -0
- package/src/curves/curve.ts +96 -0
- package/src/curves/hermite-curve.ts +34 -0
- package/src/curves/index.ts +15 -0
- package/src/geometries/box-geometry.ts +1 -1
- package/src/geometries/capsule-geometry.ts +1 -1
- package/src/geometries/cylinder-geometry.ts +1 -1
- package/src/geometries/geometry-helpers.ts +1 -1
- package/src/geometries/ico-sphere-geometry.ts +1 -1
- package/src/geometries/plane-geometry.ts +1 -1
- package/src/geometries/primitive-mesh-builder.ts +84 -0
- package/src/geometries/prism-geometry.ts +57 -0
- package/src/geometries/ring-geometry.ts +102 -0
- package/src/geometries/sphere-geometry.ts +1 -1
- package/src/geometries/surface-of-revolution.ts +1 -1
- package/src/geometries/truncated-cone-geometry.ts +1 -1
- package/src/index.ts +179 -1
- package/src/lib/geometry-utils.ts +2 -2
- package/src/lib/geometry.ts +2 -2
- package/src/lib/hinge-tree.ts +170 -0
- package/src/parametric/lathe-geometry.ts +70 -0
- package/src/parametric/parametric-geometry.ts +118 -0
- package/src/parametric/torus-geometry.ts +118 -0
- package/src/parametric.ts +9 -0
- package/src/polygon/clip-triangle-mesh.ts +218 -0
- package/src/polygon/cut-by-grid.ts +313 -0
- package/src/polygon/cut-by-mercator-bounds.ts +204 -0
- package/src/polygon/earcut.ts +859 -0
- package/src/polygon/index.ts +42 -0
- package/src/polygon/lineclip.ts +218 -0
- package/src/polygon/polygon-utils.ts +273 -0
- package/src/polygon/polygon.ts +105 -0
- package/src/polygon/subdivide-polyline.ts +223 -0
- package/src/polygon/subdivide-triangle-mesh.ts +342 -0
- package/src/polygon/utils.ts +50 -0
- package/src/spatial-index/box-index.ts +452 -0
- package/src/spatial-index/index.ts +20 -0
- package/src/spatial-index/triangle-bvh.ts +345 -0
- package/src/utils/attribute-compression.ts +234 -0
- package/src/utils/attribute-iterator.ts +28 -0
- package/src/utils/compose-attribute-provenance.ts +74 -0
- package/src/utils/compute-vertex-normals.ts +63 -0
- package/src/utils/constants.ts +42 -0
- package/src/utils/coordinates.ts +8 -0
- package/src/utils/geometry.ts +49 -0
- package/src/utils/gl-type.ts +87 -0
- package/src/utils/index.ts +55 -0
- package/src/utils/interpolate-packed-attributes.ts +284 -0
- package/src/utils/mesh-processing.ts +377 -0
- package/src/utils/primitive-iterator.ts +145 -0
- package/src/utils/qualify-surface-transition.ts +169 -0
- package/src/utils/rgb565.ts +26 -0
- package/src/utils/typed-array-utils.ts +16 -0
|
@@ -0,0 +1,332 @@
|
|
|
1
|
+
// math.gl
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
|
|
4
|
+
|
|
5
|
+
/** Low-level Euclidean query kernels shared with spatial indexes. */
|
|
6
|
+
export type QueryPoint = Readonly<ArrayLike<number>>;
|
|
7
|
+
export type TriangleRayHit = {t: number; barycentric: [number, number, number]};
|
|
8
|
+
export type SegmentClosestPoints = {
|
|
9
|
+
distance: number;
|
|
10
|
+
pointA: [number, number, number];
|
|
11
|
+
pointB: [number, number, number];
|
|
12
|
+
fractionA: number;
|
|
13
|
+
fractionB: number;
|
|
14
|
+
};
|
|
15
|
+
export type SegmentTriangleClosestPoints = {
|
|
16
|
+
distance: number;
|
|
17
|
+
segmentPoint: [number, number, number];
|
|
18
|
+
trianglePoint: [number, number, number];
|
|
19
|
+
/** Parameter on the input segment, not a time of impact. */
|
|
20
|
+
segmentFraction: number;
|
|
21
|
+
};
|
|
22
|
+
|
|
23
|
+
export function validateQueryPoint(point: QueryPoint, dimension: number): void {
|
|
24
|
+
if (point.length !== dimension) throw new RangeError('Query dimension must match the index');
|
|
25
|
+
for (let i = 0; i < dimension; i++) {
|
|
26
|
+
if (!Number.isFinite(point[i])) throw new RangeError('Coordinates must be finite');
|
|
27
|
+
}
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
export function validateQueryDistance(distance: number): void {
|
|
31
|
+
if (Number.isNaN(distance) || distance < 0) throw new RangeError('Distance must be nonnegative');
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
/** Returns a unit direction; ray distances in indexes are always coordinate units. */
|
|
35
|
+
export function normalizeQueryDirection(direction: QueryPoint, dimension: number): number[] {
|
|
36
|
+
validateQueryPoint(direction, dimension);
|
|
37
|
+
const scale = Math.max(...Array.from(direction, Math.abs));
|
|
38
|
+
if (scale === 0) throw new RangeError('Ray direction must be nonzero');
|
|
39
|
+
const scaled = Array.from(direction, x => x / scale);
|
|
40
|
+
const length = Math.hypot(...scaled);
|
|
41
|
+
return scaled.map(x => x / length);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
/** Closed bounds; returns zero for an origin inside. t uses the supplied direction scale. */
|
|
45
|
+
export function intersectRayBounds(
|
|
46
|
+
origin: QueryPoint,
|
|
47
|
+
direction: QueryPoint,
|
|
48
|
+
minimum: QueryPoint,
|
|
49
|
+
maximum: QueryPoint,
|
|
50
|
+
maxT = Infinity
|
|
51
|
+
): number | null {
|
|
52
|
+
const dimension = origin.length;
|
|
53
|
+
if (dimension !== 2 && dimension !== 3) throw new RangeError('Bounds must be 2D or 3D');
|
|
54
|
+
validateQueryPoint(origin, dimension);
|
|
55
|
+
validateQueryPoint(direction, dimension);
|
|
56
|
+
validateQueryPoint(minimum, dimension);
|
|
57
|
+
validateQueryPoint(maximum, dimension);
|
|
58
|
+
validateQueryDistance(maxT);
|
|
59
|
+
let near = 0,
|
|
60
|
+
far = maxT,
|
|
61
|
+
nonzero = false;
|
|
62
|
+
for (let i = 0; i < dimension; i++) {
|
|
63
|
+
if (minimum[i] > maximum[i]) throw new RangeError('Bounds must be ordered');
|
|
64
|
+
nonzero ||= direction[i] !== 0;
|
|
65
|
+
}
|
|
66
|
+
if (!nonzero) throw new RangeError('Ray direction must be nonzero');
|
|
67
|
+
for (let i = 0; i < dimension; i++) {
|
|
68
|
+
if (direction[i] === 0) {
|
|
69
|
+
if (origin[i] < minimum[i] || origin[i] > maximum[i]) return null;
|
|
70
|
+
continue;
|
|
71
|
+
}
|
|
72
|
+
let a = (minimum[i] - origin[i]) / direction[i];
|
|
73
|
+
let b = (maximum[i] - origin[i]) / direction[i];
|
|
74
|
+
if (a > b) [a, b] = [b, a];
|
|
75
|
+
near = Math.max(near, a);
|
|
76
|
+
far = Math.min(far, b);
|
|
77
|
+
if (near > far) return null;
|
|
78
|
+
}
|
|
79
|
+
return Number.isFinite(near) ? near : null;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
/** Two-sided Möller–Trumbore test; degenerates and coplanar rays have no hit. */
|
|
83
|
+
export function intersectRayTriangle(
|
|
84
|
+
origin: QueryPoint,
|
|
85
|
+
direction: QueryPoint,
|
|
86
|
+
a: QueryPoint,
|
|
87
|
+
b: QueryPoint,
|
|
88
|
+
c: QueryPoint,
|
|
89
|
+
options: {backfaceCulling?: boolean; maxT?: number} = {}
|
|
90
|
+
): TriangleRayHit | null {
|
|
91
|
+
for (const point of [origin, direction, a, b, c]) validateQueryPoint(point, 3);
|
|
92
|
+
if (direction[0] === 0 && direction[1] === 0 && direction[2] === 0) {
|
|
93
|
+
throw new RangeError('Ray direction must be nonzero');
|
|
94
|
+
}
|
|
95
|
+
const maxT = options.maxT ?? Infinity;
|
|
96
|
+
validateQueryDistance(maxT);
|
|
97
|
+
const e1 = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
|
|
98
|
+
const e2 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
|
|
99
|
+
const p = cross(direction, e2);
|
|
100
|
+
const determinant = dot(e1, p);
|
|
101
|
+
if (determinant === 0 || (options.backfaceCulling && determinant < 0)) return null;
|
|
102
|
+
const offset = [origin[0] - a[0], origin[1] - a[1], origin[2] - a[2]];
|
|
103
|
+
const u = dot(offset, p) / determinant;
|
|
104
|
+
if (u < 0 || u > 1) return null;
|
|
105
|
+
const q = cross(offset, e1);
|
|
106
|
+
const v = dot(direction, q) / determinant;
|
|
107
|
+
if (v < 0 || u + v > 1) return null;
|
|
108
|
+
const t = dot(e2, q) / determinant;
|
|
109
|
+
if (!Number.isFinite(t) || t < 0 || t > maxT) return null;
|
|
110
|
+
return {t: Math.max(0, t), barycentric: [1 - u - v, u, v]};
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
/** Closest point on a filled triangle; degenerate triangles reduce to segments/points. */
|
|
114
|
+
export function getClosestPointOnTriangle(
|
|
115
|
+
point: QueryPoint,
|
|
116
|
+
a: QueryPoint,
|
|
117
|
+
b: QueryPoint,
|
|
118
|
+
c: QueryPoint
|
|
119
|
+
): [number, number, number] {
|
|
120
|
+
for (const value of [point, a, b, c]) validateQueryPoint(value, 3);
|
|
121
|
+
const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
|
|
122
|
+
const ac = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
|
|
123
|
+
const ap = [point[0] - a[0], point[1] - a[1], point[2] - a[2]];
|
|
124
|
+
const aa = dot(ab, ab),
|
|
125
|
+
bb = dot(ac, ac),
|
|
126
|
+
cc = dot(ab, ac);
|
|
127
|
+
const denominator = aa * bb - cc * cc;
|
|
128
|
+
if (denominator > 0 && Number.isFinite(denominator)) {
|
|
129
|
+
const u = (bb * dot(ap, ab) - cc * dot(ap, ac)) / denominator;
|
|
130
|
+
const v = (aa * dot(ap, ac) - cc * dot(ap, ab)) / denominator;
|
|
131
|
+
if (u >= 0 && v >= 0 && u + v <= 1) {
|
|
132
|
+
return [
|
|
133
|
+
a[0] + u * ab[0] + v * ac[0],
|
|
134
|
+
a[1] + u * ab[1] + v * ac[1],
|
|
135
|
+
a[2] + u * ab[2] + v * ac[2]
|
|
136
|
+
];
|
|
137
|
+
}
|
|
138
|
+
}
|
|
139
|
+
let best: [number, number, number] = [a[0], a[1], a[2]];
|
|
140
|
+
let distance = Infinity;
|
|
141
|
+
for (const [start, end] of [
|
|
142
|
+
[a, b],
|
|
143
|
+
[b, c],
|
|
144
|
+
[c, a]
|
|
145
|
+
]) {
|
|
146
|
+
const edge = [end[0] - start[0], end[1] - start[1], end[2] - start[2]];
|
|
147
|
+
const offset = [point[0] - start[0], point[1] - start[1], point[2] - start[2]];
|
|
148
|
+
const squared = dot(edge, edge);
|
|
149
|
+
const t = squared > 0 ? Math.max(0, Math.min(1, dot(offset, edge) / squared)) : 0;
|
|
150
|
+
const candidate: [number, number, number] = [
|
|
151
|
+
start[0] + t * edge[0],
|
|
152
|
+
start[1] + t * edge[1],
|
|
153
|
+
start[2] + t * edge[2]
|
|
154
|
+
];
|
|
155
|
+
const d = Math.hypot(point[0] - candidate[0], point[1] - candidate[1], point[2] - candidate[2]);
|
|
156
|
+
if (d < distance) {
|
|
157
|
+
distance = d;
|
|
158
|
+
best = candidate;
|
|
159
|
+
}
|
|
160
|
+
}
|
|
161
|
+
return best;
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
/** Closest pair on two closed segments; zero-length segments are points.
|
|
165
|
+
* Enumerates endpoint projections and the interior line-line stationary point.
|
|
166
|
+
* Equal computed distances prefer the lowest first-segment parameter, then the second.
|
|
167
|
+
*/
|
|
168
|
+
export function getClosestPointsOnSegments(
|
|
169
|
+
a0: QueryPoint,
|
|
170
|
+
a1: QueryPoint,
|
|
171
|
+
b0: QueryPoint,
|
|
172
|
+
b1: QueryPoint
|
|
173
|
+
): SegmentClosestPoints {
|
|
174
|
+
const frame = queryFrame([a0, a1, b0, b1]);
|
|
175
|
+
const pair = closestSegments(...(frame.points as [number[], number[], number[], number[]]));
|
|
176
|
+
const pointA = interpolatePoint(a0, a1, pair.fractionA);
|
|
177
|
+
const pointB = interpolatePoint(b0, b1, pair.fractionB);
|
|
178
|
+
return {
|
|
179
|
+
distance: finiteDistance(pointA, pointB),
|
|
180
|
+
pointA,
|
|
181
|
+
pointB,
|
|
182
|
+
fractionA: pair.fractionA,
|
|
183
|
+
fractionB: pair.fractionB
|
|
184
|
+
};
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
/** Closest pair on a closed segment and a filled triangle, including coplanar and degenerate cases.
|
|
188
|
+
* Face crossings, endpoint-face minima and all three segment-edge minima are considered.
|
|
189
|
+
* Equal computed distances prefer the lowest segment parameter; other ties use feature order.
|
|
190
|
+
*/
|
|
191
|
+
export function getClosestPointsSegmentTriangle(
|
|
192
|
+
start: QueryPoint,
|
|
193
|
+
end: QueryPoint,
|
|
194
|
+
a: QueryPoint,
|
|
195
|
+
b: QueryPoint,
|
|
196
|
+
c: QueryPoint
|
|
197
|
+
): SegmentTriangleClosestPoints {
|
|
198
|
+
const frame = queryFrame([start, end, a, b, c]);
|
|
199
|
+
const [s, e, va, vb, vc] = frame.points;
|
|
200
|
+
const direction = subtract(e, s);
|
|
201
|
+
if (direction.some(value => value !== 0)) {
|
|
202
|
+
const hit = intersectRayTriangle(s, direction, va, vb, vc, {maxT: 1});
|
|
203
|
+
if (hit) {
|
|
204
|
+
const point = interpolatePoint(start, end, hit.t);
|
|
205
|
+
return {distance: 0, segmentPoint: point, trianglePoint: [...point], segmentFraction: hit.t};
|
|
206
|
+
}
|
|
207
|
+
}
|
|
208
|
+
let best = {distance: Infinity, segmentFraction: 0, trianglePoint: va};
|
|
209
|
+
const consider = (point: QueryPoint, trianglePoint: number[], segmentFraction: number): void => {
|
|
210
|
+
const distance = Math.hypot(...subtract(point, trianglePoint));
|
|
211
|
+
if (
|
|
212
|
+
distance < best.distance ||
|
|
213
|
+
(distance === best.distance && segmentFraction < best.segmentFraction)
|
|
214
|
+
)
|
|
215
|
+
best = {distance, segmentFraction, trianglePoint};
|
|
216
|
+
};
|
|
217
|
+
consider(s, getClosestPointOnTriangle(s, va, vb, vc), 0);
|
|
218
|
+
consider(e, getClosestPointOnTriangle(e, va, vb, vc), 1);
|
|
219
|
+
for (const [v0, v1] of [
|
|
220
|
+
[va, vb],
|
|
221
|
+
[vb, vc],
|
|
222
|
+
[vc, va]
|
|
223
|
+
]) {
|
|
224
|
+
const pair = closestSegments(s, e, v0, v1);
|
|
225
|
+
consider(
|
|
226
|
+
interpolatePoint(s, e, pair.fractionA),
|
|
227
|
+
interpolatePoint(v0, v1, pair.fractionB),
|
|
228
|
+
pair.fractionA
|
|
229
|
+
);
|
|
230
|
+
}
|
|
231
|
+
// Restore and keep rounded coordinates inside the triangle's closed bounds.
|
|
232
|
+
const trianglePoint = best.trianglePoint.map((value, axis) =>
|
|
233
|
+
Math.max(
|
|
234
|
+
Math.min(a[axis], b[axis], c[axis]),
|
|
235
|
+
Math.min(Math.max(a[axis], b[axis], c[axis]), start[axis] + value * frame.scale)
|
|
236
|
+
)
|
|
237
|
+
) as [number, number, number];
|
|
238
|
+
if (!trianglePoint.every(Number.isFinite)) throw new RangeError('Closest-point result overflow');
|
|
239
|
+
const segmentPoint = interpolatePoint(start, end, best.segmentFraction);
|
|
240
|
+
return {
|
|
241
|
+
distance: finiteDistance(segmentPoint, trianglePoint),
|
|
242
|
+
segmentPoint,
|
|
243
|
+
trianglePoint,
|
|
244
|
+
segmentFraction: best.segmentFraction
|
|
245
|
+
};
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
/** Translate and uniformly scale before dot/cross products to avoid absolute-scale overflow. */
|
|
249
|
+
function queryFrame(input: QueryPoint[]): {points: number[][]; scale: number} {
|
|
250
|
+
input.forEach(point => validateQueryPoint(point, 3));
|
|
251
|
+
const offsets = input.map(point => subtract(point, input[0]));
|
|
252
|
+
let scale = 0;
|
|
253
|
+
for (const offset of offsets)
|
|
254
|
+
for (const value of offset) {
|
|
255
|
+
if (!Number.isFinite(value)) throw new RangeError('Closest-point coordinate span overflow');
|
|
256
|
+
scale = Math.max(scale, Math.abs(value));
|
|
257
|
+
}
|
|
258
|
+
scale ||= 1;
|
|
259
|
+
return {points: offsets.map(point => point.map(value => value / scale)), scale};
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
function closestSegments(
|
|
263
|
+
a0: QueryPoint,
|
|
264
|
+
a1: QueryPoint,
|
|
265
|
+
b0: QueryPoint,
|
|
266
|
+
b1: QueryPoint
|
|
267
|
+
): {distance: number; fractionA: number; fractionB: number} {
|
|
268
|
+
const da = subtract(a1, a0),
|
|
269
|
+
db = subtract(b1, b0);
|
|
270
|
+
const lengthA = Math.hypot(...da),
|
|
271
|
+
lengthB = Math.hypot(...db);
|
|
272
|
+
const ua = da.map(value => (lengthA ? value / lengthA : 0));
|
|
273
|
+
const ub = db.map(value => (lengthB ? value / lengthB : 0));
|
|
274
|
+
let best = {distance: Infinity, fractionA: 0, fractionB: 0};
|
|
275
|
+
const consider = (fractionA: number, fractionB: number): void => {
|
|
276
|
+
const distance = Math.hypot(
|
|
277
|
+
...subtract(interpolatePoint(a0, a1, fractionA), interpolatePoint(b0, b1, fractionB))
|
|
278
|
+
);
|
|
279
|
+
if (
|
|
280
|
+
distance < best.distance ||
|
|
281
|
+
(distance === best.distance &&
|
|
282
|
+
(fractionA < best.fractionA ||
|
|
283
|
+
(fractionA === best.fractionA && fractionB < best.fractionB)))
|
|
284
|
+
)
|
|
285
|
+
best = {distance, fractionA, fractionB};
|
|
286
|
+
};
|
|
287
|
+
for (const t of [0, 1]) {
|
|
288
|
+
consider(t, lengthB ? clampUnit(dot(subtract(t ? a1 : a0, b0), ub) / lengthB) : 0);
|
|
289
|
+
consider(lengthA ? clampUnit(dot(subtract(t ? b1 : b0, a0), ua) / lengthA) : 0, t);
|
|
290
|
+
}
|
|
291
|
+
const normal = cross(ua, ub);
|
|
292
|
+
const sine = Math.hypot(...normal);
|
|
293
|
+
if (sine > 0) {
|
|
294
|
+
const unit = normal.map(value => value / sine);
|
|
295
|
+
const offset = subtract(b0, a0);
|
|
296
|
+
const fractionA = dot(cross(offset, ub), unit) / sine / lengthA;
|
|
297
|
+
const fractionB = dot(cross(offset, ua), unit) / sine / lengthB;
|
|
298
|
+
if (fractionA >= 0 && fractionA <= 1 && fractionB >= 0 && fractionB <= 1)
|
|
299
|
+
consider(fractionA, fractionB);
|
|
300
|
+
}
|
|
301
|
+
return best;
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
function subtract(a: QueryPoint, b: QueryPoint): number[] {
|
|
305
|
+
return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
function interpolatePoint(a: QueryPoint, b: QueryPoint, t: number): [number, number, number] {
|
|
309
|
+
return [0, 1, 2].map(axis =>
|
|
310
|
+
Math.max(
|
|
311
|
+
Math.min(a[axis], b[axis]),
|
|
312
|
+
Math.min(Math.max(a[axis], b[axis]), (1 - t) * a[axis] + t * b[axis])
|
|
313
|
+
)
|
|
314
|
+
) as [number, number, number];
|
|
315
|
+
}
|
|
316
|
+
|
|
317
|
+
function clampUnit(value: number): number {
|
|
318
|
+
return Math.max(0, Math.min(1, value));
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
function finiteDistance(a: QueryPoint, b: QueryPoint): number {
|
|
322
|
+
const distance = Math.hypot(...subtract(a, b));
|
|
323
|
+
if (!Number.isFinite(distance)) throw new RangeError('Closest-point distance overflow');
|
|
324
|
+
return distance;
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
function dot(a: QueryPoint, b: QueryPoint): number {
|
|
328
|
+
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
|
329
|
+
}
|
|
330
|
+
function cross(a: QueryPoint, b: QueryPoint): number[] {
|
|
331
|
+
return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
|
|
332
|
+
}
|
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
// math.gl
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
|
|
4
|
+
|
|
5
|
+
import type {NumericArray} from '@math.gl/core';
|
|
6
|
+
import {Curve, copyPoints, type CurvePoint} from './curve';
|
|
7
|
+
|
|
8
|
+
abstract class BezierCurve extends Curve {
|
|
9
|
+
private readonly points: number[][];
|
|
10
|
+
|
|
11
|
+
protected constructor(points: readonly CurvePoint[]) {
|
|
12
|
+
const copied = copyPoints(points);
|
|
13
|
+
super(copied[0].length);
|
|
14
|
+
this.points = copied;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
protected evaluate(t: number, result: NumericArray, derivative: boolean): void {
|
|
18
|
+
const degree = this.points.length - 1;
|
|
19
|
+
// Scalar de Casteljau evaluation avoids temporary vectors and preserves endpoints.
|
|
20
|
+
for (let i = 0; i < this.dimension; i++) {
|
|
21
|
+
let a = this.points[0][i];
|
|
22
|
+
let b = this.points[1][i];
|
|
23
|
+
let c = degree >= 2 ? this.points[2][i] : 0;
|
|
24
|
+
const d = degree === 3 ? this.points[3][i] : 0;
|
|
25
|
+
let order = degree;
|
|
26
|
+
if (derivative) {
|
|
27
|
+
a = degree * (b - a);
|
|
28
|
+
b = degree * (c - b);
|
|
29
|
+
c = degree * (d - c);
|
|
30
|
+
order--;
|
|
31
|
+
}
|
|
32
|
+
if (order === 3) {
|
|
33
|
+
a = (1 - t) * a + t * b;
|
|
34
|
+
b = (1 - t) * b + t * c;
|
|
35
|
+
c = (1 - t) * c + t * d;
|
|
36
|
+
}
|
|
37
|
+
if (order >= 2) {
|
|
38
|
+
a = (1 - t) * a + t * b;
|
|
39
|
+
b = (1 - t) * b + t * c;
|
|
40
|
+
}
|
|
41
|
+
result[i] = order >= 1 ? (1 - t) * a + t * b : a;
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
export class LineCurve extends BezierCurve {
|
|
47
|
+
constructor(start: CurvePoint, end: CurvePoint) {
|
|
48
|
+
super([start, end]);
|
|
49
|
+
}
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
export class QuadraticBezierCurve extends BezierCurve {
|
|
53
|
+
constructor(start: CurvePoint, control: CurvePoint, end: CurvePoint) {
|
|
54
|
+
super([start, control, end]);
|
|
55
|
+
}
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
export class CubicBezierCurve extends BezierCurve {
|
|
59
|
+
constructor(start: CurvePoint, control1: CurvePoint, control2: CurvePoint, end: CurvePoint) {
|
|
60
|
+
super([start, control1, control2, end]);
|
|
61
|
+
}
|
|
62
|
+
}
|
|
@@ -0,0 +1,89 @@
|
|
|
1
|
+
// math.gl
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
|
|
4
|
+
|
|
5
|
+
import type {NumericArray} from '@math.gl/core';
|
|
6
|
+
import {Curve, copyPoints, type CurvePoint} from './curve';
|
|
7
|
+
import {HermiteCurve} from './hermite-curve';
|
|
8
|
+
|
|
9
|
+
export type CatmullRomCurveOptions = {
|
|
10
|
+
closed?: boolean;
|
|
11
|
+
parameterization?: 'centripetal' | 'chordal' | 'uniform';
|
|
12
|
+
/** Uniform splines only. Default 0.5; zero gives stationary knot tangents. */
|
|
13
|
+
tension?: number;
|
|
14
|
+
};
|
|
15
|
+
|
|
16
|
+
export class CatmullRomCurve extends Curve {
|
|
17
|
+
readonly closed: boolean;
|
|
18
|
+
private readonly segments: HermiteCurve[];
|
|
19
|
+
|
|
20
|
+
constructor(points: readonly CurvePoint[], options: CatmullRomCurveOptions = {}) {
|
|
21
|
+
const data = copyPoints(points);
|
|
22
|
+
super(data[0].length);
|
|
23
|
+
this.closed = options.closed ?? false;
|
|
24
|
+
if (data.length < (this.closed ? 3 : 2)) throw new RangeError('Not enough spline points');
|
|
25
|
+
const mode = options.parameterization ?? 'centripetal';
|
|
26
|
+
if (!['centripetal', 'chordal', 'uniform'].includes(mode)) {
|
|
27
|
+
throw new RangeError('Unknown Catmull-Rom parameterization');
|
|
28
|
+
}
|
|
29
|
+
const tension = options.tension ?? 0.5;
|
|
30
|
+
if (!Number.isFinite(tension) || tension < 0 || tension > 1) {
|
|
31
|
+
throw new RangeError('tension must be in [0, 1]');
|
|
32
|
+
}
|
|
33
|
+
if (options.tension !== undefined && mode !== 'uniform') {
|
|
34
|
+
throw new RangeError('tension is only supported for uniform splines');
|
|
35
|
+
}
|
|
36
|
+
const point = (index: number): number[] => {
|
|
37
|
+
if (this.closed) return data[(index + data.length) % data.length];
|
|
38
|
+
if (index < 0) return data[0].map((x, i) => 2 * x - data[1][i]);
|
|
39
|
+
if (index >= data.length) {
|
|
40
|
+
return data[data.length - 1].map((x, i) => 2 * x - data[data.length - 2][i]);
|
|
41
|
+
}
|
|
42
|
+
return data[index];
|
|
43
|
+
};
|
|
44
|
+
this.segments = [];
|
|
45
|
+
for (let s = 0; s < data.length - (this.closed ? 0 : 1); s++) {
|
|
46
|
+
const p0 = point(s - 1);
|
|
47
|
+
const p1 = point(s);
|
|
48
|
+
const p2 = point(s + 1);
|
|
49
|
+
const p3 = point(s + 2);
|
|
50
|
+
const interval = (a: number[], b: number[]): number => {
|
|
51
|
+
const distance = Math.hypot(...a.map((x, i) => b[i] - x));
|
|
52
|
+
return distance ** (mode === 'chordal' ? 1 : 0.5);
|
|
53
|
+
};
|
|
54
|
+
const d1 = interval(p1, p2);
|
|
55
|
+
if (mode !== 'uniform' && d1 === 0) {
|
|
56
|
+
// A repeated knot is a stationary segment, rather than a spurious loop.
|
|
57
|
+
const zero = new Array<number>(this.dimension).fill(0);
|
|
58
|
+
this.segments.push(new HermiteCurve(p1, p2, zero, zero));
|
|
59
|
+
continue;
|
|
60
|
+
}
|
|
61
|
+
// Reuse the current interval for coincident neighbors. This is scale invariant.
|
|
62
|
+
const d0 = interval(p0, p1) || d1;
|
|
63
|
+
const d2 = interval(p2, p3) || d1;
|
|
64
|
+
const m1 = p1.map((x, i) =>
|
|
65
|
+
mode === 'uniform'
|
|
66
|
+
? tension * (p2[i] - p0[i])
|
|
67
|
+
: d1 * ((x - p0[i]) / d0 - (p2[i] - p0[i]) / (d0 + d1) + (p2[i] - x) / d1)
|
|
68
|
+
);
|
|
69
|
+
const m2 = p2.map((x, i) =>
|
|
70
|
+
mode === 'uniform'
|
|
71
|
+
? tension * (p3[i] - p1[i])
|
|
72
|
+
: d1 * ((x - p1[i]) / d1 - (p3[i] - p1[i]) / (d1 + d2) + (p3[i] - x) / d2)
|
|
73
|
+
);
|
|
74
|
+
this.segments.push(new HermiteCurve(p1, p2, m1, m2));
|
|
75
|
+
}
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
protected evaluate(t: number, result: NumericArray, derivative: boolean): void {
|
|
79
|
+
const scaled = t * this.segments.length;
|
|
80
|
+
const index = Math.min(Math.floor(scaled), this.segments.length - 1);
|
|
81
|
+
const local = scaled - index;
|
|
82
|
+
if (derivative) {
|
|
83
|
+
this.segments[index].getDerivative(local, result);
|
|
84
|
+
for (let i = 0; i < this.dimension; i++) result[i] *= this.segments.length;
|
|
85
|
+
} else {
|
|
86
|
+
this.segments[index].getPoint(local, result);
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
}
|
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
// math.gl
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
|
|
4
|
+
|
|
5
|
+
import type {NumericArray} from '@math.gl/core';
|
|
6
|
+
import {Curve, validateDivisions, validateParameter} from './curve';
|
|
7
|
+
|
|
8
|
+
/** Reusable polyline approximation to a curve's cumulative arc length. */
|
|
9
|
+
export class CurveArcLength {
|
|
10
|
+
readonly curve: Curve;
|
|
11
|
+
readonly divisions: number;
|
|
12
|
+
readonly length: number;
|
|
13
|
+
private readonly cumulativeLengths: Float64Array;
|
|
14
|
+
|
|
15
|
+
constructor(curve: Curve, divisions = 1024) {
|
|
16
|
+
validateDivisions(divisions);
|
|
17
|
+
this.curve = curve;
|
|
18
|
+
this.divisions = divisions;
|
|
19
|
+
this.cumulativeLengths = new Float64Array(divisions + 1);
|
|
20
|
+
let previous = curve.getPoint(0);
|
|
21
|
+
let current = new Array<number>(curve.dimension);
|
|
22
|
+
let length = 0;
|
|
23
|
+
for (let i = 1; i <= divisions; i++) {
|
|
24
|
+
curve.getPoint(i / divisions, current);
|
|
25
|
+
length += Math.hypot(
|
|
26
|
+
current[0] - previous[0],
|
|
27
|
+
current[1] - previous[1],
|
|
28
|
+
curve.dimension === 3 ? current[2] - previous[2] : 0
|
|
29
|
+
);
|
|
30
|
+
if (!Number.isFinite(length)) throw new RangeError('Curve arc length must be finite');
|
|
31
|
+
this.cumulativeLengths[i] = length;
|
|
32
|
+
[previous, current] = [current, previous];
|
|
33
|
+
}
|
|
34
|
+
this.length = length;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
/** Map a fraction of total length to t, preserving endpoints and zero-length curves. */
|
|
38
|
+
getParameterAt(u: number): number {
|
|
39
|
+
validateParameter(u);
|
|
40
|
+
if (u === 0 || u === 1 || this.length === 0) return u;
|
|
41
|
+
const target = u * this.length;
|
|
42
|
+
let low = 0;
|
|
43
|
+
let high = this.divisions;
|
|
44
|
+
while (low + 1 < high) {
|
|
45
|
+
const middle = Math.floor((low + high) / 2);
|
|
46
|
+
if (this.cumulativeLengths[middle] <= target) low = middle;
|
|
47
|
+
else high = middle;
|
|
48
|
+
}
|
|
49
|
+
const span = this.cumulativeLengths[high] - this.cumulativeLengths[low];
|
|
50
|
+
return (low + (span > 0 ? (target - this.cumulativeLengths[low]) / span : 0)) / this.divisions;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
getPointAt(u: number): number[];
|
|
54
|
+
getPointAt<T extends NumericArray>(u: number, result: T): T;
|
|
55
|
+
getPointAt(u: number, result: NumericArray = new Array(this.curve.dimension)): NumericArray {
|
|
56
|
+
return this.curve.getPoint(this.getParameterAt(u), result);
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
/** Flat samples at approximately equal distances along the curve. */
|
|
60
|
+
getSpacedPoints(divisions = 64): Float64Array {
|
|
61
|
+
validateDivisions(divisions);
|
|
62
|
+
const points = new Float64Array((divisions + 1) * this.curve.dimension);
|
|
63
|
+
const point = new Array<number>(this.curve.dimension);
|
|
64
|
+
for (let i = 0; i <= divisions; i++) {
|
|
65
|
+
this.getPointAt(i / divisions, point);
|
|
66
|
+
points.set(point, i * this.curve.dimension);
|
|
67
|
+
}
|
|
68
|
+
return points;
|
|
69
|
+
}
|
|
70
|
+
}
|
|
@@ -0,0 +1,96 @@
|
|
|
1
|
+
// math.gl
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
|
|
4
|
+
|
|
5
|
+
import type {NumericArray} from '@math.gl/core';
|
|
6
|
+
|
|
7
|
+
export type CurvePoint = Readonly<ArrayLike<number>>;
|
|
8
|
+
|
|
9
|
+
/** Parameterized Euclidean curve, with t in [0, 1]. */
|
|
10
|
+
export abstract class Curve {
|
|
11
|
+
readonly dimension: number;
|
|
12
|
+
|
|
13
|
+
protected constructor(dimension: number) {
|
|
14
|
+
if (dimension !== 2 && dimension !== 3) {
|
|
15
|
+
throw new RangeError('Curve points must have two or three coordinates');
|
|
16
|
+
}
|
|
17
|
+
this.dimension = dimension;
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
getPoint(t: number): number[];
|
|
21
|
+
getPoint<T extends NumericArray>(t: number, result: T): T;
|
|
22
|
+
getPoint(t: number, result: NumericArray = new Array(this.dimension)): NumericArray {
|
|
23
|
+
validateParameter(t);
|
|
24
|
+
validateResult(result, this.dimension);
|
|
25
|
+
this.evaluate(t, result, false);
|
|
26
|
+
return result;
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
/** Derivative with respect to the normalized curve parameter t. */
|
|
30
|
+
getDerivative(t: number): number[];
|
|
31
|
+
getDerivative<T extends NumericArray>(t: number, result: T): T;
|
|
32
|
+
getDerivative(t: number, result: NumericArray = new Array(this.dimension)): NumericArray {
|
|
33
|
+
validateParameter(t);
|
|
34
|
+
validateResult(result, this.dimension);
|
|
35
|
+
this.evaluate(t, result, true);
|
|
36
|
+
return result;
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
/** Unit tangent; returns a zero vector at stationary points. */
|
|
40
|
+
getTangent(t: number): number[];
|
|
41
|
+
getTangent<T extends NumericArray>(t: number, result: T): T;
|
|
42
|
+
getTangent(t: number, result: NumericArray = new Array(this.dimension)): NumericArray {
|
|
43
|
+
this.getDerivative(t, result);
|
|
44
|
+
const length = Math.hypot(result[0], result[1], this.dimension === 3 ? result[2] : 0);
|
|
45
|
+
if (length > 0) {
|
|
46
|
+
for (let i = 0; i < this.dimension; i++) result[i] /= length;
|
|
47
|
+
}
|
|
48
|
+
return result;
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
/** Flat coordinates for divisions + 1 evenly spaced parameter samples. */
|
|
52
|
+
getPoints(divisions = 64): Float64Array {
|
|
53
|
+
validateDivisions(divisions);
|
|
54
|
+
const points = new Float64Array((divisions + 1) * this.dimension);
|
|
55
|
+
const point = new Array<number>(this.dimension);
|
|
56
|
+
for (let i = 0; i <= divisions; i++) {
|
|
57
|
+
this.getPoint(i / divisions, point);
|
|
58
|
+
points.set(point, i * this.dimension);
|
|
59
|
+
}
|
|
60
|
+
return points;
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
protected abstract evaluate(t: number, result: NumericArray, derivative: boolean): void;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
/** Copy caller-owned control data so curves and their length tables stay stable. */
|
|
67
|
+
export function copyPoints(points: readonly CurvePoint[]): number[][] {
|
|
68
|
+
if (!points.length) throw new RangeError('Invalid number of curve control points');
|
|
69
|
+
const dimension = points[0].length;
|
|
70
|
+
if (dimension !== 2 && dimension !== 3) {
|
|
71
|
+
throw new RangeError('Curve points must have two or three coordinates');
|
|
72
|
+
}
|
|
73
|
+
return points.map(point => {
|
|
74
|
+
if (point.length !== dimension) throw new RangeError('Control point dimensions must match');
|
|
75
|
+
return Array.from(point, value => {
|
|
76
|
+
if (!Number.isFinite(value)) throw new RangeError('Control coordinates must be finite');
|
|
77
|
+
return value;
|
|
78
|
+
});
|
|
79
|
+
});
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
export function validateParameter(t: number): void {
|
|
83
|
+
if (!Number.isFinite(t) || t < 0 || t > 1) {
|
|
84
|
+
throw new RangeError('Curve parameter must be finite and in [0, 1]');
|
|
85
|
+
}
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
export function validateDivisions(divisions: number): void {
|
|
89
|
+
if (!Number.isSafeInteger(divisions) || divisions < 1) {
|
|
90
|
+
throw new RangeError('divisions must be a positive safe integer');
|
|
91
|
+
}
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
function validateResult(result: NumericArray, dimension: number): void {
|
|
95
|
+
if (result.length < dimension) throw new RangeError('Result buffer is too short');
|
|
96
|
+
}
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
// math.gl
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
|
|
4
|
+
|
|
5
|
+
import type {NumericArray} from '@math.gl/core';
|
|
6
|
+
import {Curve, copyPoints, type CurvePoint} from './curve';
|
|
7
|
+
|
|
8
|
+
/** Cubic curve with endpoint derivatives (not unit tangent directions). */
|
|
9
|
+
export class HermiteCurve extends Curve {
|
|
10
|
+
private readonly data: number[][];
|
|
11
|
+
|
|
12
|
+
constructor(
|
|
13
|
+
start: CurvePoint,
|
|
14
|
+
end: CurvePoint,
|
|
15
|
+
startTangent: CurvePoint,
|
|
16
|
+
endTangent: CurvePoint
|
|
17
|
+
) {
|
|
18
|
+
const data = copyPoints([start, end, startTangent, endTangent]);
|
|
19
|
+
super(data[0].length);
|
|
20
|
+
this.data = data;
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
protected evaluate(t: number, result: NumericArray, derivative: boolean): void {
|
|
24
|
+
const t2 = t * t;
|
|
25
|
+
const h0 = derivative ? 6 * t2 - 6 * t : (1 + 2 * t) * (1 - t) ** 2;
|
|
26
|
+
const h1 = derivative ? -6 * t2 + 6 * t : t2 * (3 - 2 * t);
|
|
27
|
+
const h2 = derivative ? 3 * t2 - 4 * t + 1 : t * (1 - t) ** 2;
|
|
28
|
+
const h3 = derivative ? 3 * t2 - 2 * t : t2 * (t - 1);
|
|
29
|
+
for (let i = 0; i < this.dimension; i++) {
|
|
30
|
+
result[i] =
|
|
31
|
+
h0 * this.data[0][i] + h1 * this.data[1][i] + h2 * this.data[2][i] + h3 * this.data[3][i];
|
|
32
|
+
}
|
|
33
|
+
}
|
|
34
|
+
}
|