fix(2d shape factories): fix fromNestedPointsArray(#103)

* fix(fromNestedPointsArray) : polygon was not generated if only one points set is provided
* add simple test : polygon(nested points array, with single path)
* add contains() CAG validation: Check if all points from one CAG stay inside another CAG
* use contains() rather than hasPointInside() : More robust verification. Without that, two shapes that shares a side does not behave as intended.
1 - two shape that do not touch -> union
2 - one shape that stay inside another -> difference
3 - one shape that intersect with another -> union
4 - two shape that share one or multiple edges -> union
The last case did not happen as expected before this change.

Author: Sébastien Mischler (aka skarab)

src/api/primitives2d.test.js

@@ -313,7 +313,7 @@ test('polygon (params.points[][], params.paths[][] - two paths)', t => {
   t.truthy(comparePositonVertices(obs.sides, houseSides))
 })
 
-test('polygon (points[][] - with holes)', t => {
+test('polygon (nested points array, with holes)', t => {
   const obs = polygon([
     [ [0,0], [0,10], [10,10], [10,0] ],
     [ [2,2], [2,8], [8,8], [8,2] ],
@@ -337,10 +337,25 @@ test('polygon (points[][] - with holes)', t => {
     [ [8,8], [8,2] ],
     [ [2,8], [8,8] ],
     [ [2,2], [2,8] ],
-    [ [8,2], [2,2] ],
+    [ [8,2], [2,2] ]
   ]
 
   // we just use a sample of points for simplicity
   t.deepEqual(obs.sides.length, 16)
   t.truthy(comparePositonVertices(obs.sides, expSides))
 })
+
+test('polygon (nested points array, with single path)', t => {
+  const obs = polygon([ [ [0,0], [0,10], [10,10], [10,0] ] ])
+
+  const expSides = [
+    [ [10,0], [10,10] ],
+    [ [10,10], [0,10] ],
+    [ [0,10], [0,0] ],
+    [ [0,0], [10,0] ]
+  ]
+
+  // we just use a sample of points for simplicity
+  t.deepEqual(obs.sides.length, 4)
+  t.truthy(comparePositonVertices(obs.sides, expSides))
+})

src/core/CAGFactories.js

@@ -2,7 +2,7 @@ const Side = require('./math/Side')
 const Vector2D = require('./math/Vector2')
 const Vertex2 = require('./math/Vertex2')
 const {areaEPS} = require('./constants')
-const {isSelfIntersecting, hasPointInside} = require('./utils/cagValidation')
+const {isSelfIntersecting, contains} = require('./utils/cagValidation')
 const {union, difference} = require('../api/ops-booleans')
 
 /** Construct a CAG from a list of `Side` instances.
@@ -80,26 +80,26 @@ const fromPointsArray = function (points) {
 }
 
 const fromNestedPointsArray = function (points) {
+  if (points.length === 1) {
+    return fromPoints(points[0])
+  }
   // First pass: create a collection of CAG paths
   let paths = []
   points.forEach(path => {
     paths.push(fromPointsArray(path))
   })
   // Second pass: make a tree of paths
   let tree = {}
-  let point = null
-  // for each polygon extract parents and childs polygons
+    // for each polygon extract parents and childs polygons
   paths.forEach((p1, i) => {
-    // only check for first point in polygon
-    point = p1.sides[0].vertex0.pos
     // check for intersection
     paths.forEach((p2, y) => {
       if (p1 !== p2) {
         // create default node
         tree[i] || (tree[i] = { parents: [], isHole: false })
         tree[y] || (tree[y] = { parents: [], isHole: false })
-        // check if point stay in poylgon
-        if (hasPointInside(p2, point)) {
+        // check if polygon2 stay in poylgon1
+        if (contains(p2, p1)) {
           // push parent and child; odd parents number ==> hole
           tree[i].parents.push(y)
           tree[i].isHole = !! (tree[i].parents.length % 2)

src/core/utils/cagValidation.js

@@ -78,4 +78,23 @@ const hasPointInside = function (cag, p0) {
 hasPointInside.c1 = (p0, p1, p2) => (p1.y > p0.y) !== (p2.y > p0.y)
 hasPointInside.c2 = (p0, p1, p2) => (p0.x < (p2.x - p1.x) * (p0.y - p1.y) / (p2.y - p1.y) + p1.x)
 
-module.exports = {isCAGValid, isSelfIntersecting, hasPointInside}
+/** Check if all points from one CAG stay inside another CAG
+* @param {CAG} cag1 - CAG object
+* @param {Object} cag2 - CAG object
+* @returns {Boolean}
+*/
+const contains = function (cag1, cag2) {
+  for (let i = 0, il = cag2.sides.length; i < il; i++) {
+    if (!hasPointInside(cag1, cag2.sides[i].vertex0.pos)) {
+      return false
+    }
+  }
+  return true
+}
+
+module.exports = {
+  isCAGValid,
+  isSelfIntersecting,
+  hasPointInside,
+  contains
+}