@immugio/three-math-extensions 0.2.32 → 0.2.34

package/CHANGELOG.md

@@ -7,7 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
-## [0.2.32](https://github.com/Immugio/three-math-extensions/compare/0.2.31...0.2.32)
+## [0.2.34](https://github.com/Immugio/three-math-extensions/compare/0.2.33...0.2.34)
+
+### Commits
+
+- Add containsPoint [`8e15aa2`](https://github.com/Immugio/three-math-extensions/commit/8e15aa275efa2b8c939bb3c85e456a269c360054)
+- Add isPolygonClockwise [`9fb7f1c`](https://github.com/Immugio/three-math-extensions/commit/9fb7f1c6f9f185ffacdf933158618588a12e4b33)
+- Add getPolygonArea [`f2f2c32`](https://github.com/Immugio/three-math-extensions/commit/f2f2c32ca19790972520c1d8827d76f20052a1fe)
+- Improve Polygon.containsPoint [`805822d`](https://github.com/Immugio/three-math-extensions/commit/805822df97009d4f4004227e642562760607bc9f)
+- Add Polygon.ensureOpen [`12d96bc`](https://github.com/Immugio/three-math-extensions/commit/12d96bcef0e06da62927b2fd336f821040a6c6c5)
+- Add ensurePolygonClockwise [`a8b1f03`](https://github.com/Immugio/three-math-extensions/commit/a8b1f03e85d86d56b341c2636e4e92eeb652af77)
+
+## [0.2.33](https://github.com/Immugio/three-math-extensions/compare/0.2.32...0.2.33) - 2024-10-21
+
+### Commits
+
+- Line2D.groupConnectedLines improve sort [`fa56c1e`](https://github.com/Immugio/three-math-extensions/commit/fa56c1e13b2b49f369034224985f31f069e3079f)
+
+## [0.2.32](https://github.com/Immugio/three-math-extensions/compare/0.2.31...0.2.32) - 2024-10-18
 
 ### Commits
 
@@ -274,29 +291,48 @@ Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
 - Add Vec2 documentation [`f625e66`](https://github.com/Immugio/three-math-extensions/commit/f625e66b60ee0d90c5c788a80989f64013d60265)
 
-## [0.0.11](https://github.com/Immugio/three-math-extensions/compare/0.0.6...0.0.11) - 2022-12-20
+## [0.0.11](https://github.com/Immugio/three-math-extensions/compare/0.0.10...0.0.11) - 2022-12-20
 
 ### Commits
 
+- Improve API, minor bug fix, improve test coverage [`881a5f0`](https://github.com/Immugio/three-math-extensions/commit/881a5f096823f0d5fd90faa76cd602f076291bc5)
 - Add Line2D.extendToOrTrimAtIntersection [`ab82a36`](https://github.com/Immugio/three-math-extensions/commit/ab82a36db52b9ae83cf8bfb848362d295140d073)
 - Added "isNear" to Vec2 & Vec3 as a shorthand for distanceTo <= maxDistance [`a27cff8`](https://github.com/Immugio/three-math-extensions/commit/a27cff8421472f625ed240439b9e6a7d2c430db8)
+- Add .npmignore [`f58329a`](https://github.com/Immugio/three-math-extensions/commit/f58329a86b96589bb574d6ebed37d4cc4474663a)
 - Add Vec2.moveTowards [`b46ba12`](https://github.com/Immugio/three-math-extensions/commit/b46ba1286f9924cd9bfecfb37200664202e964ba)
 - Add Line2D.extendToOrTrimAtIntersection [`b22aa12`](https://github.com/Immugio/three-math-extensions/commit/b22aa120b5eb02562cebc4573374ebb61e2dba14)
+- Correct change log version [`c6244bf`](https://github.com/Immugio/three-math-extensions/commit/c6244bf1488ad21bcc5589d1dff62c41d8182d48)
+
+## [0.0.10](https://github.com/Immugio/three-math-extensions/compare/0.0.9...0.0.10) - 2022-11-21
+
+### Commits
+
+- Release 0.0.4 - tag pattern 6 [`c1c5454`](https://github.com/Immugio/three-math-extensions/commit/c1c54541ed400e1ad49bf42fe8926cd5293efefd)
+
+## [0.0.9](https://github.com/Immugio/three-math-extensions/compare/0.0.8...0.0.9) - 2022-11-21
+
+### Commits
+
+- Release 0.0.4 - tag pattern 5 [`5245eed`](https://github.com/Immugio/three-math-extensions/commit/5245eed60195103e989c0fadf9bd642f39ef4589)
+
+## [0.0.8](https://github.com/Immugio/three-math-extensions/compare/0.0.7...0.0.8) - 2022-11-21
+
+### Commits
+
+- Release 0.0.4 - tag pattern 4 [`ab9ad4e`](https://github.com/Immugio/three-math-extensions/commit/ab9ad4e49477a991482ed6d4d3a3ca4687a70b44)
+
+## [0.0.7](https://github.com/Immugio/three-math-extensions/compare/0.0.6...0.0.7) - 2022-11-21
 
 ## [0.0.6](https://github.com/Immugio/three-math-extensions/compare/0.0.5...0.0.6) - 2022-11-24
 
-## 0.0.5 - 2023-09-01
+## [0.0.5](https://github.com/Immugio/three-math-extensions/compare/0.0.4...0.0.5) - 2023-09-01
 
 ### Commits
 
-- Automatic publish with change log [`a70c99d`](https://github.com/Immugio/three-math-extensions/commit/a70c99d0d42e60411ce01bcdb8dd4f3f489bb949)
-- Switch to npm [`ed47a17`](https://github.com/Immugio/three-math-extensions/commit/ed47a1787522db3bde5a2112bfd02480fe2edc54)
-- Initial commit [`3d1bf9e`](https://github.com/Immugio/three-math-extensions/commit/3d1bf9ef015570830007c9be99140c8c8d760d7f)
 - Generate documentation using TSDoc [`304c3a8`](https://github.com/Immugio/three-math-extensions/commit/304c3a84b5dcc49183db57083f550d134ae641b2)
 - Add eslint [`98e4912`](https://github.com/Immugio/three-math-extensions/commit/98e4912d637b42ba80e2f3267638b43296113019)
 - Update jest packages [`af23b4f`](https://github.com/Immugio/three-math-extensions/commit/af23b4f08154bba3407f05b773865215e7e1cba8)
 - Add Rectangle, update Polygon [`58ee875`](https://github.com/Immugio/three-math-extensions/commit/58ee87539af8f9ade186e5250cba9e01926da514)
-- Add Line2D [`9a1dd0f`](https://github.com/Immugio/three-math-extensions/commit/9a1dd0f58352b7b25828693c688aa4770e95c174)
 - Add isPointInPolygon [`a59eb4b`](https://github.com/Immugio/three-math-extensions/commit/a59eb4be026f17a3106070ae626a0588cd4f4411)
 - Improve Line2D.closestPointToPoint, add Vec2.signedAngle [`151f214`](https://github.com/Immugio/three-math-extensions/commit/151f21462e0358057ad8e9d75d5782563a1061f6)
 - Improve documentation [`d0fcb51`](https://github.com/Immugio/three-math-extensions/commit/d0fcb5132f127b4382ac5f7291575a061b8ec121)
@@ -310,7 +346,6 @@ Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 - Add Vec2.signedAngle [`863c8f2`](https://github.com/Immugio/three-math-extensions/commit/863c8f27f11288cbda535e21bb688206259269ed)
 - Add intersect method to Line3D [`6fe47de`](https://github.com/Immugio/three-math-extensions/commit/6fe47de7caaa1807b47a4363e551510c463757d7)
 - Add Line2D.extendToOrTrimAtIntersection [`ab82a36`](https://github.com/Immugio/three-math-extensions/commit/ab82a36db52b9ae83cf8bfb848362d295140d073)
-- Readme, npm info [`dda4a28`](https://github.com/Immugio/three-math-extensions/commit/dda4a282a71a00308dcae858ffe53d67d4185be8)
 - Add Vec2.fromPoints to accept multiple points [`a261402`](https://github.com/Immugio/three-math-extensions/commit/a2614027cf5fb8263189b48f7e0bb9a23a552c15)
 - Improve documentation for Vec2 and Vec3 [`6a2373d`](https://github.com/Immugio/three-math-extensions/commit/6a2373d8b6754a87720dcaea5d98336bfa7bc5b5)
 - Add Vec2.parallelTo [`989874d`](https://github.com/Immugio/three-math-extensions/commit/989874dcfe122d3ee84d8d56d79cb88e4e441736)
@@ -322,11 +357,8 @@ Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 - Add .npmignore [`f58329a`](https://github.com/Immugio/three-math-extensions/commit/f58329a86b96589bb574d6ebed37d4cc4474663a)
 - Polygon from bounding size [`eae6701`](https://github.com/Immugio/three-math-extensions/commit/eae67012f57f426f8b5259b765000447ce06d608)
 - Add Vec2 documentation [`f625e66`](https://github.com/Immugio/three-math-extensions/commit/f625e66b60ee0d90c5c788a80989f64013d60265)
-- Run tests in CI on commit [`e3f77ca`](https://github.com/Immugio/three-math-extensions/commit/e3f77ca76e25f4d99eef0130e5779b5e7c5aec6b)
 - Clean up documentation [`70c8d5e`](https://github.com/Immugio/three-math-extensions/commit/70c8d5efe8b7095d7a03af637df3af5d46615293)
-- Remove babel.config.js [`c9a1e16`](https://github.com/Immugio/three-math-extensions/commit/c9a1e1607cffec8a3d74adcca644320a79ca4c43)
 - Line2D and Line3D to return this instead of specific type [`761ef6a`](https://github.com/Immugio/three-math-extensions/commit/761ef6a9d8cc4e35120b666576794e521aa3b991)
-- Initial changelog [`6c98aa6`](https://github.com/Immugio/three-math-extensions/commit/6c98aa6ad631cf5e73d32dd76276f99b3ba5089f)
 - Line2D.in3DSpace added [`a6ce0ec`](https://github.com/Immugio/three-math-extensions/commit/a6ce0ecb67f5c7b2a75fcc283c28af626153a4af)
 - Line3D.connectsTo added [`6d2cfa0`](https://github.com/Immugio/three-math-extensions/commit/6d2cfa0f5335c665f325a694a32c57b574ec326d)
 - Line2D.hasIntersectionWithAngle to support optional tolerance [`b313bbe`](https://github.com/Immugio/three-math-extensions/commit/b313bbe118d435d53750deefd9a9e29ba6ec5c71)
@@ -335,21 +367,36 @@ Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 - Use Vec2 instead of Vector2 [`7e6a6ea`](https://github.com/Immugio/three-math-extensions/commit/7e6a6ea272f4441ef4bc78b3fdec23fc783fa1db)
 - Add release instructions into README.md [`03653b1`](https://github.com/Immugio/three-math-extensions/commit/03653b1ffa55be606d3f9cd588e28a6084462c2e)
 - Documentation improvements [`160db8b`](https://github.com/Immugio/three-math-extensions/commit/160db8ba6d6e5eb63a4e91ed9c40efd6fa70181a)
-- Release 0.0.4 [`bdac840`](https://github.com/Immugio/three-math-extensions/commit/bdac840f33261a3f39ef33bc05c80772169cfe87)
 - Update release instructions [`5b41a2e`](https://github.com/Immugio/three-math-extensions/commit/5b41a2ed7e15450dbb6088a7f7ed0031a013badc)
-- Add test badge [`37c62e8`](https://github.com/Immugio/three-math-extensions/commit/37c62e809bdcdfc63f7fe135469fd131f190f950)
 - Add Polygon to exports [`ed66775`](https://github.com/Immugio/three-math-extensions/commit/ed66775c33e961835b23843222b822cfd9c16b1d)
 - Vec2.fromPoint and Vec3.fromPoint should accept null [`4b871af`](https://github.com/Immugio/three-math-extensions/commit/4b871af297bdcbe8584f1e2b99d602247b77687c)
 - Documentation improvements [`2f3e676`](https://github.com/Immugio/three-math-extensions/commit/2f3e6768b3b0139b60688fc151a4084f15566f8d)
-- Edit publish script condition [`dc77d89`](https://github.com/Immugio/three-math-extensions/commit/dc77d8978d87daab8732d6429ad1b01ba0ca6f97)
-- CI to use node version 16 [`dc42650`](https://github.com/Immugio/three-math-extensions/commit/dc426508939de922cc0316b7652bbd09aeed4610)
-- Action rename [`26a1f01`](https://github.com/Immugio/three-math-extensions/commit/26a1f014827faab2c02d30ca8ed18dac8f9ff8af)
 - Documentation update [`d5c7a07`](https://github.com/Immugio/three-math-extensions/commit/d5c7a0765f6097f5d3a3be01967d4059f19682fb)
 - Fix peer dependency version [`00dd116`](https://github.com/Immugio/three-math-extensions/commit/00dd1169f578d5769207031fa625f29c96a38c31)
 - Add Line2D.extendToOrTrimAtIntersection [`b22aa12`](https://github.com/Immugio/three-math-extensions/commit/b22aa120b5eb02562cebc4573374ebb61e2dba14)
 - Correct change log version [`c6244bf`](https://github.com/Immugio/three-math-extensions/commit/c6244bf1488ad21bcc5589d1dff62c41d8182d48)
 - Release 0.0.4 - tag pattern 6 [`c1c5454`](https://github.com/Immugio/three-math-extensions/commit/c1c54541ed400e1ad49bf42fe8926cd5293efefd)
 - Release 0.0.4 - tag pattern 5 [`5245eed`](https://github.com/Immugio/three-math-extensions/commit/5245eed60195103e989c0fadf9bd642f39ef4589)
+- Excluded files from build [`ec70614`](https://github.com/Immugio/three-math-extensions/commit/ec70614bc7df7a98f854c7a6693365118e04faf7)
+- Revert npm ignore [`590b26a`](https://github.com/Immugio/three-math-extensions/commit/590b26a9e57fc41466b51e711f3f5c648e2d56ed)
+
+## 0.0.4 - 2022-11-21
+
+### Commits
+
+- Automatic publish with change log [`a70c99d`](https://github.com/Immugio/three-math-extensions/commit/a70c99d0d42e60411ce01bcdb8dd4f3f489bb949)
+- Switch to npm [`ed47a17`](https://github.com/Immugio/three-math-extensions/commit/ed47a1787522db3bde5a2112bfd02480fe2edc54)
+- Initial commit [`3d1bf9e`](https://github.com/Immugio/three-math-extensions/commit/3d1bf9ef015570830007c9be99140c8c8d760d7f)
+- Add Line2D [`9a1dd0f`](https://github.com/Immugio/three-math-extensions/commit/9a1dd0f58352b7b25828693c688aa4770e95c174)
+- Readme, npm info [`dda4a28`](https://github.com/Immugio/three-math-extensions/commit/dda4a282a71a00308dcae858ffe53d67d4185be8)
+- Run tests in CI on commit [`e3f77ca`](https://github.com/Immugio/three-math-extensions/commit/e3f77ca76e25f4d99eef0130e5779b5e7c5aec6b)
+- Remove babel.config.js [`c9a1e16`](https://github.com/Immugio/three-math-extensions/commit/c9a1e1607cffec8a3d74adcca644320a79ca4c43)
+- Initial changelog [`6c98aa6`](https://github.com/Immugio/three-math-extensions/commit/6c98aa6ad631cf5e73d32dd76276f99b3ba5089f)
+- Release 0.0.4 [`bdac840`](https://github.com/Immugio/three-math-extensions/commit/bdac840f33261a3f39ef33bc05c80772169cfe87)
+- Add test badge [`37c62e8`](https://github.com/Immugio/three-math-extensions/commit/37c62e809bdcdfc63f7fe135469fd131f190f950)
+- Edit publish script condition [`dc77d89`](https://github.com/Immugio/three-math-extensions/commit/dc77d8978d87daab8732d6429ad1b01ba0ca6f97)
+- CI to use node version 16 [`dc42650`](https://github.com/Immugio/three-math-extensions/commit/dc426508939de922cc0316b7652bbd09aeed4610)
+- Action rename [`26a1f01`](https://github.com/Immugio/three-math-extensions/commit/26a1f014827faab2c02d30ca8ed18dac8f9ff8af)
 - Release 0.0.4 - tag pattern 4 [`ab9ad4e`](https://github.com/Immugio/three-math-extensions/commit/ab9ad4e49477a991482ed6d4d3a3ca4687a70b44)
 - Release 0.0.4 - tag pattern 3 [`d7d4c8f`](https://github.com/Immugio/three-math-extensions/commit/d7d4c8f546e6550868ddd06a5213fdec6c68bcd2)
 - Release 0.0.4 - tag pattern 2 [`0dcf801`](https://github.com/Immugio/three-math-extensions/commit/0dcf80190bd67a3ca93d45131a403201ab39e00f)
@@ -357,6 +404,4 @@ Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 - Release 0.0.5 [`c80d6bd`](https://github.com/Immugio/three-math-extensions/commit/c80d6bd12c25ddad0f67610cdf5c804d5759f084)
 - Status badge update [`370843e`](https://github.com/Immugio/three-math-extensions/commit/370843ed0a28b024761555572b7d51ccbdb4b77d)
 - Run tests in CI on commit [`aee8c55`](https://github.com/Immugio/three-math-extensions/commit/aee8c556ae1cab9025dbe0984dd17278fe6275a1)
-- Excluded files from build [`ec70614`](https://github.com/Immugio/three-math-extensions/commit/ec70614bc7df7a98f854c7a6693365118e04faf7)
-- Revert npm ignore [`590b26a`](https://github.com/Immugio/three-math-extensions/commit/590b26a9e57fc41466b51e711f3f5c648e2d56ed)
 - Add Line2D to index [`a5fb6bd`](https://github.com/Immugio/three-math-extensions/commit/a5fb6bdeee5d9f07f325bfffc31ef96f0ce167d1)

package/cjs/Line2D.js

@@ -6,6 +6,7 @@ const Vec2_1 = require("./Vec2");
 const MathConstants_1 = require("./MathConstants");
 const Line3D_1 = require("./Line3D");
 const directions2d_1 = require("./directions2d");
+const sortLinesByConnections_1 = require("./sortLinesByConnections");
 const _startP = /*@__PURE__*/ new Vec2_1.Vec2();
 const _startEnd = /*@__PURE__*/ new Vec2_1.Vec2();
 class Line2D {
@@ -682,21 +683,9 @@ class Line2D {
             if (!visited.has(line)) {
                 const group = [];
                 dfs(line, group);
-                connectedLines.push(group);
+                connectedLines.push((0, sortLinesByConnections_1.sortLinesByConnections)(group, 1));
             }
         });
-        // Sort each group based on connection order
-        connectedLines.forEach(group => {
-            group.sort((a, b) => {
-                if (a.start.isNear(b.start, tolerance) || a.end.isNear(b.start, tolerance)) {
-                    return -1;
-                }
-                if (a.start.isNear(b.end, tolerance) || a.end.isNear(b.end, tolerance)) {
-                    return 1;
-                }
-                return 0;
-            });
-        });
         return connectedLines;
     }
     /**

package/cjs/Polygon.js

@@ -5,8 +5,11 @@ const Vec2_1 = require("./Vec2");
 const Rectangle_1 = require("./Rectangle");
 const BoundingBox_1 = require("./BoundingBox");
 const polygonPerimeter_1 = require("./polygonPerimeter");
-const isPointInPolygon_1 = require("./isPointInPolygon");
 const Line2D_1 = require("./Line2D");
+const isPolygonClockwise_1 = require("./isPolygonClockwise");
+const ensurePolygonClockwise_1 = require("./ensurePolygonClockwise");
+const containsPoint_1 = require("./containsPoint");
+const getPolygonArea_1 = require("./getPolygonArea");
 class Polygon {
     contour;
     holes;
@@ -61,6 +64,21 @@ class Polygon {
         }
         return this;
     }
+    ensureOpen() {
+        function ensure(points) {
+            if (points.length > 2 && points[0].equals(points.at(-1))) {
+                points.pop();
+            }
+        }
+        ensure(this.contour);
+        for (const hole of this.holes || []) {
+            ensure(hole);
+        }
+        return this;
+    }
+    get area() {
+        return (0, getPolygonArea_1.getPolygonArea)(this.contour);
+    }
     boundingBox() {
         let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
         for (const p of this.contour) {
@@ -93,8 +111,16 @@ class Polygon {
     perimeter() {
         return (0, polygonPerimeter_1.polygonPerimeter)(this.contour);
     }
-    containsPoint(point) {
-        return (0, isPointInPolygon_1.isPointInPolygon)(this.contour, point) && (this.holes || []).every(hole => !(0, isPointInPolygon_1.isPointInPolygon)(hole, point));
+    get isClockwise() {
+        return (0, isPolygonClockwise_1.isPolygonClockwise)(this.contour);
+    }
+    ensureClockwise() {
+        (0, ensurePolygonClockwise_1.ensurePolygonClockwise)(this.contour);
+        return this;
+    }
+    containsPoint(...points) {
+        return points.every(point => (0, containsPoint_1.containsPoint)(this.contour, point)) &&
+            (this.holes || []).every(hole => !points.some(point => (0, containsPoint_1.containsPoint)(hole, point)));
     }
     flipSingle(centerX, poly) {
         for (const point of poly) {

package/cjs/containsPoint.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsPoints = exports.containsPoint = void 0;
+/**
+ * Return if polygon contains @point or when the point is on the polygon boundary.
+ * Works consistently with points on the boundary.
+ * Works with simple polygons only.
+ * The code is copied from PolyK library.
+ * @returns {boolean} depth
+ * @param polygon
+ * @param point
+ */
+function containsPoint(polygon, point) {
+    const p = [];
+    for (let i = 0; i < polygon.length; i++) {
+        p.push(polygon[i].x);
+        p.push(polygon[i].y);
+    }
+    const px = point.x;
+    const py = point.y;
+    const n = p.length >> 1;
+    let ax;
+    let ay = p[2 * n - 3] - py;
+    let bx = p[2 * n - 2] - px;
+    let by = p[2 * n - 1] - py;
+    let lup;
+    // var lup = by > ay;
+    for (let i = 0; i < n; i++) {
+        ax = bx;
+        ay = by;
+        bx = p[2 * i] - px;
+        by = p[2 * i + 1] - py;
+        if (ay === by)
+            continue;
+        lup = by > ay;
+    }
+    let depth = 0;
+    for (let i = 0; i < n; i++) {
+        ax = bx;
+        ay = by;
+        bx = p[2 * i] - px;
+        by = p[2 * i + 1] - py;
+        if (ay < 0 && by < 0)
+            continue; // both "up" or both "down"
+        if (ay > 0 && by > 0)
+            continue; // both "up" or both "down"
+        if (ax < 0 && bx < 0)
+            continue; // both points on the left
+        if (ay === by && Math.min(ax, bx) <= 0)
+            return true;
+        if (ay === by)
+            continue;
+        const lx = ax + (bx - ax) * (-ay) / (by - ay);
+        if (lx === 0)
+            return true; // point on edge
+        if (lx > 0)
+            depth++;
+        if (ay === 0 && lup && by > ay)
+            depth--; // hit vertex, both up
+        if (ay === 0 && !lup && by < ay)
+            depth--; // hit vertex, both down(x < (p[j].x - p[i].x) * (y - p[i].y) / (p[j].y - p[i].y) + p[i].x)) {
+        lup = by > ay;
+    }
+    return (depth & 1) === 1;
+}
+exports.containsPoint = containsPoint;
+function containsPoints(polygon, points) {
+    return points.every(p => containsPoint(polygon, p));
+}
+exports.containsPoints = containsPoints;

package/cjs/ensurePolygonClockwise.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePolygonClockwise = void 0;
+const isPolygonClockwise_1 = require("./isPolygonClockwise");
+function ensurePolygonClockwise(poly) {
+    if (!(0, isPolygonClockwise_1.isPolygonClockwise)(poly)) {
+        return poly.reverse();
+    }
+    return poly;
+}
+exports.ensurePolygonClockwise = ensurePolygonClockwise;

package/cjs/getPolygonArea.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPolygonArea = void 0;
+/**
+ * Returns the area of polygon.
+ * @returns {number}
+ * @param polygon {Point2[]}
+ */
+function getPolygonArea(polygon) {
+    const p = [];
+    for (const point of polygon) {
+        p.push(point.x, point.y);
+    }
+    if (p.length < 6)
+        return 0;
+    const l = p.length - 2;
+    let sum = 0;
+    for (let i = 0; i < l; i += 2) {
+        sum += (p[i + 2] - p[i]) * (p[i + 1] + p[i + 3]);
+    }
+    sum += (p[0] - p[l]) * (p[l + 1] + p[1]);
+    return Math.abs(-sum * 0.5); // Handles -0
+}
+exports.getPolygonArea = getPolygonArea;

package/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extendOrTrimPolylinesAtIntersections = exports.offsetPolyline = exports.polygonPerimeter = exports.isContinuousClosedShape = exports.directions2d = exports.directions = exports.isPointInPolygon = exports.HalfPI = exports.TwoPI = exports.normalizeAngleRadians = exports.normalizeAngleDegrees = exports.Rectangle = exports.BoundingBox = exports.Polygon = exports.Size2 = exports.Line3D = exports.Line2D = exports.Vec3 = exports.Vec2 = void 0;
+exports.getPolygonArea = exports.containsPoint = exports.ensurePolygonClockwise = exports.isPolygonClockwise = exports.sortLinesByConnections = exports.extendOrTrimPolylinesAtIntersections = exports.offsetPolyline = exports.polygonPerimeter = exports.isContinuousClosedShape = exports.directions2d = exports.directions = exports.isPointInPolygon = exports.HalfPI = exports.TwoPI = exports.normalizeAngleRadians = exports.normalizeAngleDegrees = exports.Rectangle = exports.BoundingBox = exports.Polygon = exports.Size2 = exports.Line3D = exports.Line2D = exports.Vec3 = exports.Vec2 = void 0;
 var Vec2_1 = require("./Vec2");
 Object.defineProperty(exports, "Vec2", { enumerable: true, get: function () { return Vec2_1.Vec2; } });
 var Vec3_1 = require("./Vec3");
@@ -38,3 +38,13 @@ var offsetPolyline_1 = require("./offsetPolyline");
 Object.defineProperty(exports, "offsetPolyline", { enumerable: true, get: function () { return offsetPolyline_1.offsetPolyline; } });
 var extendOrTrimPolylinesAtIntersections_1 = require("./extendOrTrimPolylinesAtIntersections");
 Object.defineProperty(exports, "extendOrTrimPolylinesAtIntersections", { enumerable: true, get: function () { return extendOrTrimPolylinesAtIntersections_1.extendOrTrimPolylinesAtIntersections; } });
+var sortLinesByConnections_1 = require("./sortLinesByConnections");
+Object.defineProperty(exports, "sortLinesByConnections", { enumerable: true, get: function () { return sortLinesByConnections_1.sortLinesByConnections; } });
+var isPolygonClockwise_1 = require("./isPolygonClockwise");
+Object.defineProperty(exports, "isPolygonClockwise", { enumerable: true, get: function () { return isPolygonClockwise_1.isPolygonClockwise; } });
+var ensurePolygonClockwise_1 = require("./ensurePolygonClockwise");
+Object.defineProperty(exports, "ensurePolygonClockwise", { enumerable: true, get: function () { return ensurePolygonClockwise_1.ensurePolygonClockwise; } });
+var containsPoint_1 = require("./containsPoint");
+Object.defineProperty(exports, "containsPoint", { enumerable: true, get: function () { return containsPoint_1.containsPoint; } });
+var getPolygonArea_1 = require("./getPolygonArea");
+Object.defineProperty(exports, "getPolygonArea", { enumerable: true, get: function () { return getPolygonArea_1.getPolygonArea; } });

package/cjs/isPointInPolygon.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPointInPolygon = void 0;
+/**
+ * Check if a point is inside a polygon
+ * Warning: The function returns unreliable results for points on the polygon boundary.
+ * Obsolete, use containsPoint instead.
+ * @param p
+ * @param point
+ */
 function isPointInPolygon(p, point) {
     const x = point.x, y = point.y;
     let i, j, c = false;

package/cjs/isPolygonClockwise.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPolygonClockwise = void 0;
+/*
+* Determines if a polygon is clockwise or counter-clockwise.
+* X increases to the right, Y increases downwards.
+* Based on this answer https://stackoverflow.com/a/18472899/1837173 - the result is inverted, they assume the inverse y-axis
+*/
+function isPolygonClockwise(vertices) {
+    let sum = 0.0;
+    for (let i = 0; i < vertices.length; i++) {
+        const v1 = vertices[i];
+        const v2 = vertices[(i + 1) % vertices.length];
+        sum += (v2.x - v1.x) * (v2.y + v1.y);
+    }
+    return sum < 0.0;
+}
+exports.isPolygonClockwise = isPolygonClockwise;

package/cjs/sortLinesByConnections.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortLinesByConnections = void 0;
+/**
+ * Sort connected lines by their connections.
+ * When the polygon is open, the first line must be the line that has no connection at the start.
+ * When the polygon is open, the last line must be the line that has no connection at the end.
+ * If the lines form a closed polygon, any line can be the first line.
+ */
+function sortLinesByConnections(lines, tolerance = 0) {
+    const remainingLines = [...lines];
+    const startLineIndex = findStartLineIndex(remainingLines, tolerance);
+    const sortedLines = [remainingLines.splice(startLineIndex, 1)[0]];
+    while (remainingLines.length > 0) {
+        const lastLine = sortedLines[sortedLines.length - 1];
+        const nextLineIndex = remainingLines.findIndex(line => lastLine.end.isNear(line.start, tolerance));
+        if (nextLineIndex === -1) {
+            console.log("Lines do not form a connected path");
+            return [...sortedLines, ...remainingLines];
+        }
+        sortedLines.push(remainingLines.splice(nextLineIndex, 1)[0]);
+    }
+    return sortedLines;
+}
+exports.sortLinesByConnections = sortLinesByConnections;
+/**
+ * Find the index of the starting line.
+ * A starting line is defined as a line that has no other line connected to its start.
+ * If such a line does not exist, it means that the lines form a closed polygon, return 0.
+ * @param lines
+ * @param tolerance
+ */
+function findStartLineIndex(lines, tolerance) {
+    for (let i = 0; i < lines.length; i++) {
+        const startLine = lines[i];
+        const isStartLine = !lines.some(line => line.end.isNear(startLine.start, tolerance));
+        if (isStartLine) {
+            return i;
+        }
+    }
+    return 0;
+}

package/esm/Line2D.js

@@ -3,6 +3,7 @@ import { Vec2 } from "./Vec2";
 import { TwoPI } from "./MathConstants";
 import { Line3D } from "./Line3D";
 import { directions2d } from "./directions2d";
+import { sortLinesByConnections } from "./sortLinesByConnections";
 const _startP = /*@__PURE__*/ new Vec2();
 const _startEnd = /*@__PURE__*/ new Vec2();
 export class Line2D {
@@ -679,21 +680,9 @@ export class Line2D {
             if (!visited.has(line)) {
                 const group = [];
                 dfs(line, group);
-                connectedLines.push(group);
+                connectedLines.push(sortLinesByConnections(group, 1));
             }
         });
-        // Sort each group based on connection order
-        connectedLines.forEach(group => {
-            group.sort((a, b) => {
-                if (a.start.isNear(b.start, tolerance) || a.end.isNear(b.start, tolerance)) {
-                    return -1;
-                }
-                if (a.start.isNear(b.end, tolerance) || a.end.isNear(b.end, tolerance)) {
-                    return 1;
-                }
-                return 0;
-            });
-        });
         return connectedLines;
     }
     /**

package/esm/Polygon.js

@@ -2,8 +2,11 @@ import { Vec2 } from "./Vec2";
 import { Rectangle } from "./Rectangle";
 import { BoundingBox } from "./BoundingBox";
 import { polygonPerimeter } from "./polygonPerimeter";
-import { isPointInPolygon } from "./isPointInPolygon";
 import { Line2D } from "./Line2D";
+import { isPolygonClockwise } from "./isPolygonClockwise";
+import { ensurePolygonClockwise } from "./ensurePolygonClockwise";
+import { containsPoint } from "./containsPoint";
+import { getPolygonArea } from "./getPolygonArea";
 export class Polygon {
     contour;
     holes;
@@ -58,6 +61,21 @@ export class Polygon {
         }
         return this;
     }
+    ensureOpen() {
+        function ensure(points) {
+            if (points.length > 2 && points[0].equals(points.at(-1))) {
+                points.pop();
+            }
+        }
+        ensure(this.contour);
+        for (const hole of this.holes || []) {
+            ensure(hole);
+        }
+        return this;
+    }
+    get area() {
+        return getPolygonArea(this.contour);
+    }
     boundingBox() {
         let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
         for (const p of this.contour) {
@@ -90,8 +108,16 @@ export class Polygon {
     perimeter() {
         return polygonPerimeter(this.contour);
     }
-    containsPoint(point) {
-        return isPointInPolygon(this.contour, point) && (this.holes || []).every(hole => !isPointInPolygon(hole, point));
+    get isClockwise() {
+        return isPolygonClockwise(this.contour);
+    }
+    ensureClockwise() {
+        ensurePolygonClockwise(this.contour);
+        return this;
+    }
+    containsPoint(...points) {
+        return points.every(point => containsPoint(this.contour, point)) &&
+            (this.holes || []).every(hole => !points.some(point => containsPoint(hole, point)));
     }
     flipSingle(centerX, poly) {
         for (const point of poly) {

package/esm/containsPoint.js

@@ -0,0 +1,65 @@
+/**
+ * Return if polygon contains @point or when the point is on the polygon boundary.
+ * Works consistently with points on the boundary.
+ * Works with simple polygons only.
+ * The code is copied from PolyK library.
+ * @returns {boolean} depth
+ * @param polygon
+ * @param point
+ */
+export function containsPoint(polygon, point) {
+    const p = [];
+    for (let i = 0; i < polygon.length; i++) {
+        p.push(polygon[i].x);
+        p.push(polygon[i].y);
+    }
+    const px = point.x;
+    const py = point.y;
+    const n = p.length >> 1;
+    let ax;
+    let ay = p[2 * n - 3] - py;
+    let bx = p[2 * n - 2] - px;
+    let by = p[2 * n - 1] - py;
+    let lup;
+    // var lup = by > ay;
+    for (let i = 0; i < n; i++) {
+        ax = bx;
+        ay = by;
+        bx = p[2 * i] - px;
+        by = p[2 * i + 1] - py;
+        if (ay === by)
+            continue;
+        lup = by > ay;
+    }
+    let depth = 0;
+    for (let i = 0; i < n; i++) {
+        ax = bx;
+        ay = by;
+        bx = p[2 * i] - px;
+        by = p[2 * i + 1] - py;
+        if (ay < 0 && by < 0)
+            continue; // both "up" or both "down"
+        if (ay > 0 && by > 0)
+            continue; // both "up" or both "down"
+        if (ax < 0 && bx < 0)
+            continue; // both points on the left
+        if (ay === by && Math.min(ax, bx) <= 0)
+            return true;
+        if (ay === by)
+            continue;
+        const lx = ax + (bx - ax) * (-ay) / (by - ay);
+        if (lx === 0)
+            return true; // point on edge
+        if (lx > 0)
+            depth++;
+        if (ay === 0 && lup && by > ay)
+            depth--; // hit vertex, both up
+        if (ay === 0 && !lup && by < ay)
+            depth--; // hit vertex, both down(x < (p[j].x - p[i].x) * (y - p[i].y) / (p[j].y - p[i].y) + p[i].x)) {
+        lup = by > ay;
+    }
+    return (depth & 1) === 1;
+}
+export function containsPoints(polygon, points) {
+    return points.every(p => containsPoint(polygon, p));
+}

package/esm/ensurePolygonClockwise.js

@@ -0,0 +1,7 @@
+import { isPolygonClockwise } from "./isPolygonClockwise";
+export function ensurePolygonClockwise(poly) {
+    if (!isPolygonClockwise(poly)) {
+        return poly.reverse();
+    }
+    return poly;
+}

package/esm/getPolygonArea.js

@@ -0,0 +1,20 @@
+/**
+ * Returns the area of polygon.
+ * @returns {number}
+ * @param polygon {Point2[]}
+ */
+export function getPolygonArea(polygon) {
+    const p = [];
+    for (const point of polygon) {
+        p.push(point.x, point.y);
+    }
+    if (p.length < 6)
+        return 0;
+    const l = p.length - 2;
+    let sum = 0;
+    for (let i = 0; i < l; i += 2) {
+        sum += (p[i + 2] - p[i]) * (p[i + 1] + p[i + 3]);
+    }
+    sum += (p[0] - p[l]) * (p[l + 1] + p[1]);
+    return Math.abs(-sum * 0.5); // Handles -0
+}

package/esm/index.js

@@ -16,3 +16,8 @@ export { isContinuousClosedShape } from "./isContinuousClosedShape";
 export { polygonPerimeter } from "./polygonPerimeter";
 export { offsetPolyline } from "./offsetPolyline";
 export { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
+export { sortLinesByConnections } from "./sortLinesByConnections";
+export { isPolygonClockwise } from "./isPolygonClockwise";
+export { ensurePolygonClockwise } from "./ensurePolygonClockwise";
+export { containsPoint } from "./containsPoint";
+export { getPolygonArea } from "./getPolygonArea";

package/esm/isPointInPolygon.js

@@ -1,3 +1,10 @@
+/**
+ * Check if a point is inside a polygon
+ * Warning: The function returns unreliable results for points on the polygon boundary.
+ * Obsolete, use containsPoint instead.
+ * @param p
+ * @param point
+ */
 export function isPointInPolygon(p, point) {
     const x = point.x, y = point.y;
     let i, j, c = false;

package/esm/isPolygonClockwise.js

@@ -0,0 +1,14 @@
+/*
+* Determines if a polygon is clockwise or counter-clockwise.
+* X increases to the right, Y increases downwards.
+* Based on this answer https://stackoverflow.com/a/18472899/1837173 - the result is inverted, they assume the inverse y-axis
+*/
+export function isPolygonClockwise(vertices) {
+    let sum = 0.0;
+    for (let i = 0; i < vertices.length; i++) {
+        const v1 = vertices[i];
+        const v2 = vertices[(i + 1) % vertices.length];
+        sum += (v2.x - v1.x) * (v2.y + v1.y);
+    }
+    return sum < 0.0;
+}

package/esm/sortLinesByConnections.js

@@ -0,0 +1,38 @@
+/**
+ * Sort connected lines by their connections.
+ * When the polygon is open, the first line must be the line that has no connection at the start.
+ * When the polygon is open, the last line must be the line that has no connection at the end.
+ * If the lines form a closed polygon, any line can be the first line.
+ */
+export function sortLinesByConnections(lines, tolerance = 0) {
+    const remainingLines = [...lines];
+    const startLineIndex = findStartLineIndex(remainingLines, tolerance);
+    const sortedLines = [remainingLines.splice(startLineIndex, 1)[0]];
+    while (remainingLines.length > 0) {
+        const lastLine = sortedLines[sortedLines.length - 1];
+        const nextLineIndex = remainingLines.findIndex(line => lastLine.end.isNear(line.start, tolerance));
+        if (nextLineIndex === -1) {
+            console.log("Lines do not form a connected path");
+            return [...sortedLines, ...remainingLines];
+        }
+        sortedLines.push(remainingLines.splice(nextLineIndex, 1)[0]);
+    }
+    return sortedLines;
+}
+/**
+ * Find the index of the starting line.
+ * A starting line is defined as a line that has no other line connected to its start.
+ * If such a line does not exist, it means that the lines form a closed polygon, return 0.
+ * @param lines
+ * @param tolerance
+ */
+function findStartLineIndex(lines, tolerance) {
+    for (let i = 0; i < lines.length; i++) {
+        const startLine = lines[i];
+        const isStartLine = !lines.some(line => line.end.isNear(startLine.start, tolerance));
+        if (isStartLine) {
+            return i;
+        }
+    }
+    return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@immugio/three-math-extensions",
-  "version": "0.2.32",
+  "version": "0.2.34",
   "description": "Set of utilities for 2d and 3d line math built on top of three.js",
   "author": "Jan Mikeska <janmikeska@gmail.com>",
   "license": "ISC",

package/src/Line2D.ts

@@ -4,6 +4,7 @@ import { Vec2 } from "./Vec2";
 import { TwoPI } from "./MathConstants";
 import { Line3D } from "./Line3D";
 import { directions2d } from "./directions2d";
+import { sortLinesByConnections } from "./sortLinesByConnections";
 
 const _startP = /*@__PURE__*/ new Vec2();
 const _startEnd = /*@__PURE__*/ new Vec2();
@@ -803,23 +804,10 @@ export class Line2D {
             if (!visited.has(line)) {
                 const group: Line2D[] = [];
                 dfs(line, group);
-                connectedLines.push(group);
+                connectedLines.push(sortLinesByConnections(group, 1));
             }
         });
 
-        // Sort each group based on connection order
-        connectedLines.forEach(group => {
-            group.sort((a, b) => {
-                if (a.start.isNear(b.start, tolerance) || a.end.isNear(b.start, tolerance)) {
-                    return -1;
-                }
-                if (a.start.isNear(b.end, tolerance) || a.end.isNear(b.end, tolerance)) {
-                    return 1;
-                }
-                return 0;
-            });
-        });
-
         return connectedLines;
     }
 

package/src/Polygon.ts

@@ -3,8 +3,11 @@ import { Vec2 } from "./Vec2";
 import { Rectangle } from "./Rectangle";
 import { BoundingBox } from "./BoundingBox";
 import { polygonPerimeter } from "./polygonPerimeter";
-import { isPointInPolygon } from "./isPointInPolygon";
 import { Line2D } from "./Line2D";
+import { isPolygonClockwise } from "./isPolygonClockwise";
+import { ensurePolygonClockwise } from "./ensurePolygonClockwise";
+import { containsPoint } from "./containsPoint";
+import { getPolygonArea } from "./getPolygonArea";
 
 export class Polygon {
 
@@ -73,6 +76,26 @@ export class Polygon {
         return this;
     }
 
+    public ensureOpen(): this {
+        function ensure(points: Vec2[]): void {
+            if (points.length > 2 && points[0].equals(points.at(-1))) {
+                points.pop();
+            }
+        }
+
+        ensure(this.contour);
+
+        for (const hole of this.holes || []) {
+            ensure(hole);
+        }
+
+        return this;
+    }
+
+    public get area(): number {
+        return getPolygonArea(this.contour);
+    }
+
     public boundingBox(): BoundingBox {
         let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
 
@@ -107,8 +130,18 @@ export class Polygon {
         return polygonPerimeter(this.contour);
     }
 
-    public containsPoint(point: Vec2): boolean {
-        return isPointInPolygon(this.contour, point) && (this.holes || []).every(hole => !isPointInPolygon(hole, point));
+    public get isClockwise(): boolean {
+        return isPolygonClockwise(this.contour);
+    }
+
+    public ensureClockwise(): this {
+        ensurePolygonClockwise(this.contour);
+        return this;
+    }
+
+    public containsPoint(...points: Vec2[]): boolean {
+        return points.every(point => containsPoint(this.contour, point)) &&
+            (this.holes || []).every(hole => !points.some(point => containsPoint(hole, point)));
     }
 
     private flipSingle(centerX: number, poly: Vec2[]): void {

package/src/containsPoint.ts

@@ -0,0 +1,66 @@
+import { Point2 } from "./Point2";
+
+/**
+ * Return if polygon contains @point or when the point is on the polygon boundary.
+ * Works consistently with points on the boundary.
+ * Works with simple polygons only.
+ * The code is copied from PolyK library.
+ * @returns {boolean} depth
+ * @param polygon
+ * @param point
+ */
+export function containsPoint(polygon: Point2[], point: Point2): boolean {
+    const p: number[] = [];
+    for (let i = 0; i < polygon.length; i++) {
+        p.push(polygon[i].x);
+        p.push(polygon[i].y);
+    }
+
+    const px = point.x;
+    const py = point.y;
+    const n = p.length >> 1;
+
+    let ax: number;
+
+    let ay = p[2 * n - 3] - py;
+    let bx = p[2 * n - 2] - px;
+    let by = p[2 * n - 1] - py;
+    let lup: boolean;
+
+    // var lup = by > ay;
+    for (let i = 0; i < n; i++) {
+        ax = bx;
+        ay = by;
+        bx = p[2 * i] - px;
+        by = p[2 * i + 1] - py;
+        if (ay === by) continue;
+        lup = by > ay;
+    }
+
+    let depth = 0;
+    for (let i = 0; i < n; i++) {
+        ax = bx;
+        ay = by;
+        bx = p[2 * i] - px;
+        by = p[2 * i + 1] - py;
+        if (ay < 0 && by < 0) continue;  // both "up" or both "down"
+        if (ay > 0 && by > 0) continue;  // both "up" or both "down"
+        if (ax < 0 && bx < 0) continue;   // both points on the left
+
+        if (ay === by && Math.min(ax, bx) <= 0) return true;
+        if (ay === by) continue;
+
+        const lx = ax + (bx - ax) * (-ay) / (by - ay);
+        if (lx === 0) return true;      // point on edge
+        if (lx > 0) depth++;
+        if (ay === 0 && lup && by > ay) depth--;  // hit vertex, both up
+        if (ay === 0 && !lup && by < ay) depth--; // hit vertex, both down(x < (p[j].x - p[i].x) * (y - p[i].y) / (p[j].y - p[i].y) + p[i].x)) {
+        lup = by > ay;
+    }
+
+    return (depth & 1) === 1;
+}
+
+export function containsPoints(polygon: Point2[], points: Point2[]): boolean {
+    return points.every(p => containsPoint(polygon, p));
+}

package/src/ensurePolygonClockwise.ts

@@ -0,0 +1,10 @@
+import { Point2 } from "./Point2";
+import { isPolygonClockwise } from "./isPolygonClockwise";
+
+export function ensurePolygonClockwise<T extends Point2>(poly: T[]): T[] {
+    if (!isPolygonClockwise(poly)) {
+        return poly.reverse();
+    }
+
+    return poly;
+}

package/src/getPolygonArea.ts

@@ -0,0 +1,22 @@
+import { Point2 } from "./Point2";
+
+/**
+ * Returns the area of polygon.
+ * @returns {number}
+ * @param polygon {Point2[]}
+ */
+export function getPolygonArea(polygon: Point2[]): number {
+    const p: number[] = [];
+    for (const point of polygon) {
+        p.push(point.x, point.y);
+    }
+
+    if (p.length < 6) return 0;
+    const l = p.length - 2;
+    let sum = 0;
+    for (let i = 0; i < l; i += 2) {
+        sum += (p[i + 2] - p[i]) * (p[i + 1] + p[i + 3]);
+    }
+    sum += (p[0] - p[l]) * (p[l + 1] + p[1]);
+    return Math.abs(-sum * 0.5); // Handles -0
+}

package/src/index.ts

@@ -17,4 +17,9 @@ export { directions2d } from "./directions2d";
 export { isContinuousClosedShape } from "./isContinuousClosedShape";
 export { polygonPerimeter } from "./polygonPerimeter";
 export { offsetPolyline } from "./offsetPolyline";
-export { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
+export { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
+export { sortLinesByConnections } from "./sortLinesByConnections";
+export { isPolygonClockwise } from "./isPolygonClockwise";
+export { ensurePolygonClockwise } from "./ensurePolygonClockwise";
+export { containsPoint } from "./containsPoint";
+export { getPolygonArea } from "./getPolygonArea";

package/src/isPointInPolygon.ts

@@ -1,13 +1,18 @@
 import { Point2 } from "./Point2";
 
+/**
+ * Check if a point is inside a polygon
+ * Warning: The function returns unreliable results for points on the polygon boundary.
+ * Obsolete, use containsPoint instead.
+ * @param p
+ * @param point
+ */
 export function isPointInPolygon(p: Point2[], point: Point2): boolean {
-
     const x = point.x, y = point.y;
 
     let i: number, j: number, c = false;
 
     for (i = 0, j = p.length - 1; i < p.length; j = i++) {
-
         if ((((p[i].y <= y) && (y < p[j].y)) ||
                 ((p[j].y <= y) && (y < p[i].y))) &&
             (x < (p[j].x - p[i].x) * (y - p[i].y) / (p[j].y - p[i].y) + p[i].x)) {

package/src/isPolygonClockwise.ts

@@ -0,0 +1,16 @@
+import { Point2 } from "./Point2";
+
+/*
+* Determines if a polygon is clockwise or counter-clockwise.
+* X increases to the right, Y increases downwards.
+* Based on this answer https://stackoverflow.com/a/18472899/1837173 - the result is inverted, they assume the inverse y-axis
+*/
+export function isPolygonClockwise(vertices: Point2[]): boolean {
+    let sum = 0.0;
+    for (let i = 0; i < vertices.length; i++) {
+        const v1 = vertices[i];
+        const v2 = vertices[(i + 1) % vertices.length];
+        sum += (v2.x - v1.x) * (v2.y + v1.y);
+    }
+    return sum < 0.0;
+}

package/src/sortLinesByConnections.ts

@@ -0,0 +1,46 @@
+import { Line2D } from "./Line2D";
+
+/**
+ * Sort connected lines by their connections.
+ * When the polygon is open, the first line must be the line that has no connection at the start.
+ * When the polygon is open, the last line must be the line that has no connection at the end.
+ * If the lines form a closed polygon, any line can be the first line.
+ */
+export function sortLinesByConnections(lines: Line2D[], tolerance: number = 0): Line2D[] {
+    const remainingLines = [...lines];
+    const startLineIndex = findStartLineIndex(remainingLines, tolerance);
+
+    const sortedLines: Line2D[] = [remainingLines.splice(startLineIndex, 1)[0]];
+
+    while (remainingLines.length > 0) {
+        const lastLine = sortedLines[sortedLines.length - 1];
+        const nextLineIndex = remainingLines.findIndex(line => lastLine.end.isNear(line.start, tolerance));
+
+        if (nextLineIndex === -1) {
+            console.log("Lines do not form a connected path");
+            return [...sortedLines, ...remainingLines];
+        }
+
+        sortedLines.push(remainingLines.splice(nextLineIndex, 1)[0]);
+    }
+
+    return sortedLines;
+}
+
+/**
+ * Find the index of the starting line.
+ * A starting line is defined as a line that has no other line connected to its start.
+ * If such a line does not exist, it means that the lines form a closed polygon, return 0.
+ * @param lines
+ * @param tolerance
+ */
+function findStartLineIndex(lines: Line2D[], tolerance: number): number {
+    for (let i = 0; i < lines.length; i++) {
+        const startLine = lines[i];
+        const isStartLine = !lines.some(line => line.end.isNear(startLine.start, tolerance));
+        if (isStartLine) {
+            return i;
+        }
+    }
+    return 0;
+}

package/types/Polygon.d.ts

@@ -12,11 +12,15 @@ export declare class Polygon {
     centerOnOrigin(): this;
     center(): Vec2;
     ensureLastPoint(): this;
+    ensureOpen(): this;
+    get area(): number;
     boundingBox(): BoundingBox;
     toBoundingPolygon(): Polygon;
     flip(): this;
     perimeter(): number;
-    containsPoint(point: Vec2): boolean;
+    get isClockwise(): boolean;
+    ensureClockwise(): this;
+    containsPoint(...points: Vec2[]): boolean;
     private flipSingle;
     translate(translate: Vec2): this;
     /**

package/types/containsPoint.d.ts

@@ -0,0 +1,12 @@
+import { Point2 } from "./Point2";
+/**
+ * Return if polygon contains @point or when the point is on the polygon boundary.
+ * Works consistently with points on the boundary.
+ * Works with simple polygons only.
+ * The code is copied from PolyK library.
+ * @returns {boolean} depth
+ * @param polygon
+ * @param point
+ */
+export declare function containsPoint(polygon: Point2[], point: Point2): boolean;
+export declare function containsPoints(polygon: Point2[], points: Point2[]): boolean;

package/types/ensurePolygonClockwise.d.ts

@@ -0,0 +1,2 @@
+import { Point2 } from "./Point2";
+export declare function ensurePolygonClockwise<T extends Point2>(poly: T[]): T[];

package/types/getPolygonArea.d.ts

@@ -0,0 +1,7 @@
+import { Point2 } from "./Point2";
+/**
+ * Returns the area of polygon.
+ * @returns {number}
+ * @param polygon {Point2[]}
+ */
+export declare function getPolygonArea(polygon: Point2[]): number;

package/types/index.d.ts

@@ -18,3 +18,8 @@ export { isContinuousClosedShape } from "./isContinuousClosedShape";
 export { polygonPerimeter } from "./polygonPerimeter";
 export { offsetPolyline } from "./offsetPolyline";
 export { extendOrTrimPolylinesAtIntersections } from "./extendOrTrimPolylinesAtIntersections";
+export { sortLinesByConnections } from "./sortLinesByConnections";
+export { isPolygonClockwise } from "./isPolygonClockwise";
+export { ensurePolygonClockwise } from "./ensurePolygonClockwise";
+export { containsPoint } from "./containsPoint";
+export { getPolygonArea } from "./getPolygonArea";

package/types/isPointInPolygon.d.ts

@@ -1,2 +1,9 @@
 import { Point2 } from "./Point2";
+/**
+ * Check if a point is inside a polygon
+ * Warning: The function returns unreliable results for points on the polygon boundary.
+ * Obsolete, use containsPoint instead.
+ * @param p
+ * @param point
+ */
 export declare function isPointInPolygon(p: Point2[], point: Point2): boolean;

package/types/isPolygonClockwise.d.ts

@@ -0,0 +1,2 @@
+import { Point2 } from "./Point2";
+export declare function isPolygonClockwise(vertices: Point2[]): boolean;

package/types/sortLinesByConnections.d.ts

@@ -0,0 +1,8 @@
+import { Line2D } from "./Line2D";
+/**
+ * Sort connected lines by their connections.
+ * When the polygon is open, the first line must be the line that has no connection at the start.
+ * When the polygon is open, the last line must be the line that has no connection at the end.
+ * If the lines form a closed polygon, any line can be the first line.
+ */
+export declare function sortLinesByConnections(lines: Line2D[], tolerance?: number): Line2D[];