@eturnity/eturnity_maths 7.51.2 → 8.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "7.51.2",
+  "version": "8.4.1",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,

package/src/geometry.js

@@ -9,7 +9,7 @@ import {
   vectorLength,
   normalizeVector,
 } from './vector'
-import { inverse3x3matrix, multiplyMatrices } from './matrix'
+import { inverse3x3Matrix, multiplyMatrices } from './matrix'
 import { Point } from './objects/Point'
 import { Line } from './objects/Line'
 import concaveman from './lib/concaveman'
@@ -132,7 +132,7 @@ export function getDataAboutTwo3DLines(A, u, B, v) {
     [u.y, v.y, w.y],
     [u.z, v.z, w.z],
   ]
-  let mInv = inverse3x3matrix(m)
+  let mInv = inverse3x3Matrix(m)
   if (!mInv) {
     return null
   }

package/src/intersectionPolygon.js

@@ -2,6 +2,7 @@ import {
   getPointInsideOutline,
   isInsidePolygon,
   isSamePoint2D,
+  calcPolygonArea,
   isInsideEdge2D,
   getDegree,
 } from './geometry'
@@ -10,8 +11,37 @@ import {
   getNodeList,
   getEdgeList,
   getOutlineList,
+  getEdgeIntersections,
+  getEdgeListV2,
 } from './splitMergePolygons'
 
+export function isOutlineTouchingOutline(outline, outlineSelection) {
+  const isOutlinePointWithinSelection = outline.some((p) =>
+    isInsidePolygon(p, outlineSelection)
+  )
+  if (isOutlinePointWithinSelection) {
+    return true
+  }
+
+  const isEdgeInSelection = outline.some((p, index) => {
+    const nextIndex = (index + 1) % outline.length
+    const nextP = outline[nextIndex]
+    return outlineSelection.some((selectionPoint, selectionIndex) => {
+      const nextSelectionIndex = (selectionIndex + 1) % outlineSelection.length
+      const nextSelectionPoint = outlineSelection[nextSelectionIndex]
+      return doLineSegmentsIntersect(
+        p,
+        nextP,
+        selectionPoint,
+        nextSelectionPoint
+      )
+    })
+  })
+  if (isEdgeInSelection) {
+    return true
+  }
+  return false
+}
 export function isOutlineTouchingBoundingBox(outline, bbox) {
   const isOutlinePointWithinBbox = outline.some(
     (p) =>
@@ -87,6 +117,20 @@ export function isSelfIntersecting(outline, isClosePolygon = true) {
   }
   return isSelfIntersecting
 }
+function generateEdges2DFromOutlines(outlines) {
+  return outlines
+    .map((outline, outlineIndex) =>
+      outline.map((currentPoint, index) => {
+        const nextIndex = (index + 1) % outline.length
+        const nextPoint = outline[nextIndex]
+        return {
+          belongsTo: [{ polygonId: outlineIndex }],
+          outline: [currentPoint, nextPoint],
+        }
+      })
+    )
+    .flat()
+}
 export function isLastPointsInOutlineAtCloseAngle(outline) {
   const length = outline.length
   const previousIndex = (length - 1) % length
@@ -102,42 +146,13 @@ export function logicOperationOnPolygons(
   outline2,
   mode = 'intersect'
 ) {
-  const fig1 = outline1.map((p) => {
-    return { x: p.x, y: p.y, z: p.z }
-  })
-  fig1.push(fig1[0])
-  const fig2 = outline2.map((p) => {
-    return { x: p.x, y: p.y, z: p.z }
-  })
-  //nodeList:
-  let dirtyNodeList = []
-  fig1.forEach((p) => {
-    dirtyNodeList.push(p)
-  })
-  fig2.forEach((p) => {
-    dirtyNodeList.push(p)
-  })
-  //edgeList (just in term of indexes)
-  const edges = fig2.map((p, index) => {
-    return { outline: [p, fig2[(index + 1) % fig2.length]] }
-  })
-  let intersections = getIntersections({ outline: fig1 }, edges)
-
-  //2. gather all nodes+intersection in a list[[x,y],[x,y]]
-  const nodeList = getNodeList(intersections, edges, { outline: fig1 })
-  //3. generate all edges not cut, those cut and those from construction polyline
-
-  const edgeList = getEdgeList(
-    nodeList,
-    intersections,
-    edges,
-    { outline: fig1 },
-    1
-  )
-  //4. run planar-face-discovery to get all cycles and rebuild our polygons
+  const edges = generateEdges2DFromOutlines([outline1, outline2])
+  const intersections = getEdgeIntersections(edges)
+  const nodeList = getNodeList(intersections, edges)
+  const edgeList = getEdgeListV2(nodeList, intersections, edges)
   try {
     const outlineList = getOutlineList(nodeList, edgeList)
-    return filterPolygons(outlineList, fig1, fig2, mode)
+    return filterPolygons(outlineList, outline1, outline2, mode)
   } catch (err) {
     console.error('error with getOutlineList', nodeList, edgeList, err)
     return []
@@ -149,7 +164,7 @@ function filterPolygons(outlineList, fig1, fig2, mode) {
   const filtered = []
   let c1, c2
   let point
-  const bigPolygons = removeSmallPolygons(polygons, 0.0001)
+  const bigPolygons = removeSmallPolygons(polygons, 0.001)
   for (var i = 0; i < bigPolygons.length; i++) {
     point = getPointInsideOutline(
       bigPolygons[i],
@@ -570,7 +585,13 @@ function filterPolygonsOld(polygons, fig1, fig2, mode) {
 function removeSmallPolygons(polygons, minSize) {
   var big = []
   for (var i = 0; i < polygons.length; i++) {
-    if (polygonArea(polygons[i]) >= minSize) {
+    if (
+      calcPolygonArea(
+        polygons[i].map((p) => {
+          return { ...p, z: 0 }
+        })
+      ) >= minSize
+    ) {
       big.push(polygons[i])
     }
   }

package/src/matrix.js

@@ -1,15 +1,21 @@
-import { substractVector } from './vector'
-export function inverse2x2Matrix([a, b, c, d]) {
-  //inverse matrix |a,c|
-  //               |b,d|
-  const det = a * b - c * b
+import { substractVector, addVector, multiplyVector } from './vector'
+export function inverse2x2Matrix([[a, b], [c, d]]) {
+  //inverse matrix |a,b|
+  //               |c,d|
+  const det = a * d - c * b
   if (det == 0) {
     return null
   }
-  return [d / det, -b / det, -c / det, a / det]
+  return [
+    [d / det, -b / det],
+    [-c / det, a / det],
+  ]
 }
 
-export function inverse3x3matrix(m) {
+export function inverse3x3Matrix(m) {
+  //inverse matrix |a,b,c|
+  //               |d,e,f|
+  //               |g,h,i|
   let [[a, b, c], [d, e, f], [g, h, i]] = m
   let x = e * i - h * f
   let y = f * g - d * i
@@ -19,7 +25,7 @@ export function inverse3x3matrix(m) {
     ? [
         [x, c * h - b * i, b * f - c * e],
         [y, a * i - c * g, d * c - a * f],
-        [z, g * b - a * h, a * e - d * b]
+        [z, g * b - a * h, a * e - d * b],
       ].map((r) => r.map((v) => (v /= det)))
     : null
 }
@@ -55,11 +61,32 @@ export function multiplyMatrices(a, b) {
 export function rotateTransformation(point, angle, center = { x: 0, y: 0 }) {
   let rotationMatrix = [
     [Math.cos(angle), Math.sin(angle)],
-    [-Math.sin(angle), Math.cos(angle)]
+    [-Math.sin(angle), Math.cos(angle)],
   ]
   let k = multiplyMatrices(rotationMatrix, [
     [point.x - center.x],
-    [point.y - center.y]
+    [point.y - center.y],
   ])
   return { x: k[0][0] + center.x, y: k[1][0] + center.y }
 }
+
+export function getOutlineFromCornerPointsAndDirections(
+  downPoint,
+  point,
+  directions
+) {
+  let M = [
+    [directions[0].x, directions[1].x],
+    [directions[0].y, directions[1].y],
+  ]
+  let invM = inverse2x2Matrix(M)
+  const v = substractVector(point, downPoint)
+  const coefs = multiplyMatrices(invM, [[v.x], [v.y]])
+  const coords = [
+    downPoint,
+    addVector(downPoint, multiplyVector(coefs[0], directions[0])),
+    point,
+    addVector(downPoint, multiplyVector(coefs[1], directions[1])),
+  ]
+  return coords
+}

package/src/splitMergePolygons.js

@@ -17,13 +17,14 @@ import {
   calculateArea,
   getPointInsideOutline,
 } from './geometry'
-import { intersectOutlines } from './intersectionPolygon'
 import { groupBy } from 'lodash'
 import { Polygon } from './objects/Polygon'
-import { defaultBaseHeight, mmTolerance } from './config'
+import { defaultBaseHeight } from './config'
 import { generateEdges2D } from './objects/derivedState/nodesEdgesCreation'
 import { Point, updateComputedGeometryPolygon } from './objects'
 
+const FLOAT_PRECISION = 1e-6
+
 export function mergePolygons(polygonIdsToMerge, edges, layer, polygons) {
   const outsideEdge = edges.filter((e) => e.belongsTo.length == 1)
   const insideEdge = edges.filter((e) => e.belongsTo.length == 2)
@@ -43,7 +44,7 @@ export function mergePolygons(polygonIdsToMerge, edges, layer, polygons) {
   const nodeList = []
   for (let node of dirtyNodeList) {
     const nodeFound = nodeList.find((n) => {
-      return n && isAlmostSamePoint2D(n, node, mmTolerance)
+      return n && isAlmostSamePoint2D(n, node, FLOAT_PRECISION)
     })
     if (!nodeFound) {
       nodeList.push(node)
@@ -117,7 +118,7 @@ export function splitPolygonsV2(polygons) {
       let numberOfIntersectionPoints = 0
       outline.forEach((point) => {
         const result = intersections.filter((n) =>
-          isAlmostSamePoint2D(point, n.point, mmTolerance)
+          isAlmostSamePoint2D(point, n.point, FLOAT_PRECISION)
         )
         if (result.length) {
           numberOfIntersectionPoints++
@@ -190,7 +191,9 @@ export function splitPolygonsV2(polygons) {
             parentPolygons.sort(
               (a, b) => calculateArea(b.outline) - calculateArea(a.outline)
             )
-            if (Math.abs(edge.outline[0].z - edge.outline[1].z) < mmTolerance) {
+            if (
+              Math.abs(edge.outline[0].z - edge.outline[1].z) < FLOAT_PRECISION
+            ) {
               // edge is flat horizontally, create a flat polygon to project to
               const flatOutline = parentPolygons[0].outline.map((point) => {
                 return {
@@ -434,7 +437,7 @@ export function getNodeList(intersections, edges, constructionPolyline) {
   if (constructionPolyline) {
     constructionPolyline.outline.forEach((p) => {
       const node = nodeList.find((n) => {
-        return isAlmostSamePoint2D(p, n, mmTolerance)
+        return isAlmostSamePoint2D(p, n, FLOAT_PRECISION)
       })
       if (!node) {
         nodeList.push(p)
@@ -445,14 +448,14 @@ export function getNodeList(intersections, edges, constructionPolyline) {
       return isAlmostSamePoint2D(
         p,
         constructionPolyline.outline[0],
-        mmTolerance
+        FLOAT_PRECISION
       )
     })
     const polylineEnd = nodeList.find((p) =>
       isAlmostSamePoint2D(
         p,
         constructionPolyline.outline[polylineLength - 1],
-        mmTolerance
+        FLOAT_PRECISION
       )
     )
     constructionPolyline.outline.forEach((p, index) => {
@@ -466,11 +469,11 @@ export function getNodeList(intersections, edges, constructionPolyline) {
   }
 
   intersections.forEach((inter) => {
-    const edge = edges[inter.edgeIndex]
+    const edge = edges[inter.edge_index_1]
     if (edge) {
       inter.point.z =
         edge.outline[0].z +
-        inter.edgeParam * (edge.outline[1].z - edge.outline[0].z)
+        inter.edge_param_1 * (edge.outline[1].z - edge.outline[0].z)
     }
     nodeList.push(inter.point)
   })
@@ -479,7 +482,7 @@ export function getNodeList(intersections, edges, constructionPolyline) {
   for (let k = 0; k < nodeList.length; k++) {
     const node = nodeList[k]
     const newNode = nodeListClean.find((n) => {
-      return n && isAlmostSamePoint2D(n, node, mmTolerance)
+      return n && isAlmostSamePoint2D(n, node, FLOAT_PRECISION)
     })
     if (!newNode) {
       nodeListClean.push(node)
@@ -493,10 +496,10 @@ function getEdgeListSimple(nodeList, edges) {
   const edgeList = []
   for (let index in edges) {
     const node_0_index = nodeList.findIndex((n) =>
-      isAlmostSamePoint2D(edges[index].outline[0], n, mmTolerance)
+      isAlmostSamePoint2D(edges[index].outline[0], n, FLOAT_PRECISION)
     )
     const node_1_index = nodeList.findIndex((n) =>
-      isAlmostSamePoint2D(edges[index].outline[1], n, mmTolerance)
+      isAlmostSamePoint2D(edges[index].outline[1], n, FLOAT_PRECISION)
     )
     edgeList.push([node_0_index, node_1_index])
   }
@@ -562,10 +565,10 @@ export function getEdgeList(
   //get untouchEdge edge
   untouchedEdgeIndexes.forEach((index) => {
     const node_0_index = nodeList.findIndex((n) =>
-      isAlmostSamePoint2D(edges[index].outline[0], n, mmTolerance)
+      isAlmostSamePoint2D(edges[index].outline[0], n, FLOAT_PRECISION)
     )
     const node_1_index = nodeList.findIndex((n) =>
-      isAlmostSamePoint2D(edges[index].outline[1], n, mmTolerance)
+      isAlmostSamePoint2D(edges[index].outline[1], n, FLOAT_PRECISION)
     )
     edgeList.push([node_0_index, node_1_index])
   })
@@ -573,13 +576,17 @@ export function getEdgeList(
   untouchedPolylineIndexes.forEach((index) => {
     const length = constructionPolyline.outline.length
     const node_0_index = nodeList.findIndex((n) =>
-      isAlmostSamePoint2D(constructionPolyline.outline[index], n, mmTolerance)
+      isAlmostSamePoint2D(
+        constructionPolyline.outline[index],
+        n,
+        FLOAT_PRECISION
+      )
     )
     const node_1_index = nodeList.findIndex((n) =>
       isAlmostSamePoint2D(
         constructionPolyline.outline[(index + 1) % length],
         n,
-        mmTolerance
+        FLOAT_PRECISION
       )
     )
     edgeList.push([node_0_index, node_1_index])
@@ -591,36 +598,40 @@ export function getEdgeList(
       isAlmostSamePoint2D(
         edges[intersectionOnEdge[0].edgeIndex].outline[0],
         n,
-        mmTolerance
+        FLOAT_PRECISION
       )
     )
     const node_1_index_start = nodeList.findIndex((n) =>
-      isAlmostSamePoint2D(intersectionOnEdge[0].point, n, mmTolerance)
+      isAlmostSamePoint2D(intersectionOnEdge[0].point, n, FLOAT_PRECISION)
     )
     edgeList.push([node_0_index_start, node_1_index_start])
 
     for (let k = 0; k < length - 1; k++) {
       const node_0_index = nodeList.findIndex((n) =>
-        isAlmostSamePoint2D(intersectionOnEdge[k].point, n, mmTolerance)
+        isAlmostSamePoint2D(intersectionOnEdge[k].point, n, FLOAT_PRECISION)
       )
       const node_1_index = nodeList.findIndex((n) =>
         isAlmostSamePoint2D(
           intersectionOnEdge[(k + 1) % length].point,
           n,
-          mmTolerance
+          FLOAT_PRECISION
         )
       )
       edgeList.push([node_0_index, node_1_index])
     }
 
     const node_0_index_end = nodeList.findIndex((n) =>
-      isAlmostSamePoint2D(intersectionOnEdge[length - 1].point, n, mmTolerance)
+      isAlmostSamePoint2D(
+        intersectionOnEdge[length - 1].point,
+        n,
+        FLOAT_PRECISION
+      )
     )
     const node_1_index_end = nodeList.findIndex((n) =>
       isAlmostSamePoint2D(
         edges[intersectionOnEdge[0].edgeIndex].outline[1],
         n,
-        mmTolerance
+        FLOAT_PRECISION
       )
     )
     edgeList.push([node_0_index_end, node_1_index_end])
@@ -633,23 +644,23 @@ export function getEdgeList(
       isAlmostSamePoint2D(
         constructionPolyline.outline[intersectionOnPolyline[0].polylineIndex],
         n,
-        mmTolerance
+        FLOAT_PRECISION
       )
     )
     const node_1_index_start = nodeList.findIndex((n) =>
-      isAlmostSamePoint2D(intersectionOnPolyline[0].point, n, mmTolerance)
+      isAlmostSamePoint2D(intersectionOnPolyline[0].point, n, FLOAT_PRECISION)
     )
     edgeList.push([node_0_index_start, node_1_index_start])
 
     for (let k = 0; k < length - 1; k++) {
       const node_0_index = nodeList.findIndex((n) =>
-        isAlmostSamePoint2D(intersectionOnPolyline[k].point, n, mmTolerance)
+        isAlmostSamePoint2D(intersectionOnPolyline[k].point, n, FLOAT_PRECISION)
       )
       const node_1_index = nodeList.findIndex((n) =>
         isAlmostSamePoint2D(
           intersectionOnPolyline[(k + 1) % length].point,
           n,
-          mmTolerance
+          FLOAT_PRECISION
         )
       )
       edgeList.push([node_0_index, node_1_index])
@@ -659,7 +670,7 @@ export function getEdgeList(
       isAlmostSamePoint2D(
         intersectionOnPolyline[length - 1].point,
         n,
-        mmTolerance
+        FLOAT_PRECISION
       )
     )
     const node_1_index_end = nodeList.findIndex((n) =>
@@ -668,7 +679,7 @@ export function getEdgeList(
           (intersectionOnPolyline[0].polylineIndex + 1) % lengthPolyline
         ],
         n,
-        mmTolerance
+        FLOAT_PRECISION
       )
     )
     edgeList.push([node_0_index_end, node_1_index_end])
@@ -694,7 +705,7 @@ export function getEdgeList(
  * @param {Array<edge>} edges
  * @returns {Array<[index1, index2]>} Array of indices indicating which nodes create an edge
  */
-function getEdgeListV2(nodes, intersections, edges) {
+export function getEdgeListV2(nodes, intersections, edges) {
   const edgeList = []
   const groupedIntersections = {}
   intersections.forEach((intersection) => {
@@ -724,10 +735,10 @@ function getEdgeListV2(nodes, intersections, edges) {
       // untouched edge
       edgeList.push([
         nodes.findIndex((n) =>
-          isAlmostSamePoint2D(edge.outline[0], n, mmTolerance)
+          isAlmostSamePoint2D(edge.outline[0], n, FLOAT_PRECISION)
         ),
         nodes.findIndex((n) =>
-          isAlmostSamePoint2D(edge.outline[1], n, mmTolerance)
+          isAlmostSamePoint2D(edge.outline[1], n, FLOAT_PRECISION)
         ),
       ])
     } else {
@@ -741,10 +752,10 @@ function getEdgeListV2(nodes, intersections, edges) {
       for (let i = 0; i < tempNodes.length - 1; i++) {
         edgeList.push([
           nodes.findIndex((n) =>
-            isAlmostSamePoint2D(tempNodes[i], n, mmTolerance)
+            isAlmostSamePoint2D(tempNodes[i], n, FLOAT_PRECISION)
           ),
           nodes.findIndex((n) =>
-            isAlmostSamePoint2D(tempNodes[i + 1], n, mmTolerance)
+            isAlmostSamePoint2D(tempNodes[i + 1], n, FLOAT_PRECISION)
           ),
         ])
       }
@@ -805,6 +816,7 @@ export function getOutlineList(nodeList, edgeList, roofs = []) {
     let cycleArray = forestRecursion(cycleTree)
     cycles.push(...cycleArray)
   }
+
   let outlines = cycles
     .map(({ cycle, children }) => {
       cycle.pop()
@@ -849,8 +861,8 @@ function getIntersectionSegmentWithParams(A, B, C, D) {
   const denom_v = dotProduct(u, v_normal)
   const AB = vectorLength(u)
   const CD = vectorLength(v)
-  if (AB < mmTolerance && CD < mmTolerance) {
-    if (getDistanceBetweenPoints(A, C) < mmTolerance * 2) {
+  if (AB < FLOAT_PRECISION && CD < FLOAT_PRECISION) {
+    if (getDistanceBetweenPoints(A, C) < FLOAT_PRECISION * 2) {
       return [
         {
           point: A,
@@ -862,7 +874,7 @@ function getIntersectionSegmentWithParams(A, B, C, D) {
   } else if (AB == 0) {
     //let's check if CD go through A
     P = getPointOnLine(A, C, D)
-    if (getDistanceBetweenPoints(P, A) < mmTolerance) {
+    if (getDistanceBetweenPoints(P, A) < FLOAT_PRECISION) {
       j = vectorLength(substractVector(C, A)) / CD
       return [
         {
@@ -875,7 +887,7 @@ function getIntersectionSegmentWithParams(A, B, C, D) {
   } else if (CD == 0) {
     //let's check if AB go through C
     M = getPointOnLine(C, A, B)
-    if (getDistanceBetweenPoints(M, C) < mmTolerance) {
+    if (getDistanceBetweenPoints(M, C) < FLOAT_PRECISION) {
       h = vectorLength(substractVector(C, A)) / AB
       return [
         {
@@ -886,15 +898,15 @@ function getIntersectionSegmentWithParams(A, B, C, D) {
       ]
     }
   }
-  if (Math.abs(denom_u) / (AB * CD) < 0.01) {
+  if (Math.abs(denom_u) / (AB * CD) < FLOAT_PRECISION) {
     //u,v parallel
     //let's check if they are close
     //distance from A to CD
     P = getPointOnLine(A, C, D)
     M = getPointOnLine(B, C, D)
     if (
-      getDistanceBetweenPoints(A, P) < mmTolerance ||
-      getDistanceBetweenPoints(B, M) < mmTolerance
+      getDistanceBetweenPoints(A, P) < FLOAT_PRECISION ||
+      getDistanceBetweenPoints(B, M) < FLOAT_PRECISION
     ) {
       // AB and CD are colinear
       // let's find which point are in the middle

package/src/tests/intersectionPolygon/{logicOperationOnPolygons.spec.waitingList.js → logicOperationOnPolygons.spec.js}

@@ -6,6 +6,107 @@ import {
 
 //TEST CASE for new implementation of spliting algorithm
 describe('logicOperationOnPolygons function', () => {
+  test('returns intersecting polygon real case scenario', () => {
+    const out1 = [
+      {
+        x: 26665.34996686136,
+        y: 655753.6781718059,
+        z: 15000,
+      },
+      {
+        x: -55126.43646282707,
+        y: 640611.2872626077,
+        z: 15000,
+      },
+      {
+        x: -61494.57624074482,
+        y: 675008.8623742728,
+        z: 15000,
+      },
+      {
+        x: 20188.395676486834,
+        y: 690324.419608749,
+        z: 15000,
+      },
+    ]
+    const out2 = [
+      {
+        x: 26665.56077244963,
+        y: 655752.5529970465,
+        z: 15000,
+        hasWarning: false,
+      },
+      {
+        x: -55011.40036315337,
+        y: 640438.122784121,
+        z: 15000,
+        hasWarning: false,
+      },
+      {
+        x: -61493.45350740093,
+        y: 675009.0728867748,
+        z: 15000,
+        hasWarning: false,
+      },
+      {
+        x: 20188.395676486834,
+        y: 690324.419608749,
+        z: 15000,
+        hasWarning: false,
+      },
+    ]
+    expect(logicOperationOnPolygons(out1, out2).length).toEqual(1)
+  })
+  test('returns intersecting polygon simplified real case scenario', () => {
+    const A = {
+      x: 0,
+      y: 0,
+    }
+    const B = {
+      x: 1000,
+      y: 1000,
+    }
+    const C = {
+      x: 0,
+      y: 1000,
+    }
+    const out1 = [
+      A,
+      {
+        x: 1000,
+        y: 0,
+      },
+      B,
+      C,
+    ]
+    const out2 = [
+      A,
+      {
+        x: 1005,
+        y: 5,
+      },
+      B,
+      C,
+    ]
+    expect(logicOperationOnPolygons(out1, out2).length).toEqual(1)
+  })
+  test('returns child parent polygon', () => {
+    const O = { x: 0, y: 0, z: 0 }
+    const A = { x: 100, y: 0, z: 0 }
+    const B = { x: 100, y: 100, z: 0 }
+    const C = { x: 0, y: 100, z: 0 }
+    const D = { x: 96, y: 94, z: 0 }
+    const E = { x: 70, y: 50, z: 0 }
+    const F = { x: 70, y: 70, z: 0 }
+    const G = { x: 50, y: 70, z: 0 }
+
+    const out1 = [O, A, B, C]
+    const out2 = [O, D, B, C]
+    const res = [[O, D, B, C]]
+    expect(logicOperationOnPolygons(out1, out2)).toEqual(
+      expect.arrayContaining(res)
+    )
+  })
   test('returns intersecting polygon', () => {
     const O = { x: 0, y: 0, z: 0 }
     const A = { x: 10, y: 0, z: 0 }

package/src/tests/matrix/inverse2x2Matrix.spec.js

@@ -0,0 +1,17 @@
+import { inverse2x2Matrix, multiplyMatrices } from '../../index'
+
+describe('inverse2x2Matrix function', () => {
+  test('returns identity if MxinvM ', () => {
+    const M = [
+      [4, 3],
+      [7, 1],
+    ]
+    const invM = inverse2x2Matrix(M)
+    const id = multiplyMatrices(M, invM)
+    for (let i = 0; i < id.length; i++) {
+      for (let j = 0; j < id.length; j++) {
+        expect(id[i][j] - (i == j ? 1 : 0) < 0.001).toBe(true)
+      }
+    }
+  })
+})

package/src/tests/matrix/inverse3x3Matrix.spec.js

@@ -0,0 +1,18 @@
+import { inverse3x3Matrix, multiplyMatrices } from '../../index'
+
+describe('inverse3x3Matrix function', () => {
+  test('returns identity if MxinvM ', () => {
+    const M = [
+      [4, 3, 2],
+      [7, 1, 0],
+      [2, 1, 8],
+    ]
+    const invM = inverse3x3Matrix(M)
+    const id = multiplyMatrices(M, invM)
+    for (let i = 0; i < id.length; i++) {
+      for (let j = 0; j < id.length; j++) {
+        expect(id[i][j] - (i == j ? 1 : 0) < 0.001).toBe(true)
+      }
+    }
+  })
+})