@eturnity/eturnity_maths 9.7.0 → 9.10.0

package/src/objects/Polygon.js

@@ -1,11 +1,20 @@
-import { translate2D, getDegree } from '../geometry'
+import {
+  translate2D,
+  getDegree,
+  isOnBorderOfPolygon,
+  getDistanceBetweenPoints,
+  get3DDistanceBetweenPoints,
+} from '../geometry'
 import {
   substractVector,
   normalizeVector,
   multiplyVector,
   addVector,
+  areAlmostCollinear,
 } from '../vector'
-
+import { Line } from './Line'
+import { getPlaneFromPolygon } from '../plane'
+import { defaultPlane } from './Plane'
 import { v4 as uuidv4 } from 'uuid'
 import { updateComputedGeometryPolygon } from './derivedState/updateComputedGeometryPolygon'
 import { rotateTransformation } from '../matrix'
@@ -211,6 +220,122 @@ export class Polygon {
   resetOffset() {
     this.positionOffset = { x: 0, y: 0, z: 0 }
   }
+  isPointOnBorder(point, tolerance = 0.0001) {
+    return isOnBorderOfPolygon(point, this.outline)
+  }
+  isLineIntersecting(line) {
+    return this.outline.some((p, index) => {
+      const nextP = this.outline[(index + 1) % this.outline.length]
+      const edge = new Line(p, nextP, null)
+      return edge.isTouchingLine(line)
+    })
+  }
+  isCircleIntersecting(circle) {
+    const isPolygonStrictlyInsideCircle = this.outline.every((p, index) => {
+      return getDistanceBetweenPoints(p, circle.center) < circle.radius
+    })
+    const isPolygonStrictlyOutsideCircle = this.outline.every((p, index) => {
+      const nextP = this.outline[(index + 1) % this.outline.length]
+      const edge = new Line(p, nextP)
+      return edge.getDistanceToPoint(circle.center) > circle.radius
+    })
+    return !isPolygonStrictlyOutsideCircle && !isPolygonStrictlyInsideCircle
+  }
+  isPolygonIntersecting(polygon) {
+    return this.outline.some((p, index) => {
+      const nextP = this.outline[(index + 1) % this.outline.length]
+      const edge = new Line(p, nextP)
+      return edge.isTouchingLine(polygon)
+    })
+  }
+  getDistanceToPoint(point) {
+    return this.outline
+      .map((p, index) => {
+        const nextP = this.outline[(index + 1) % this.outline.length]
+        const edge = new Line(p, nextP)
+        return edge.getDistanceToPoint(point)
+      })
+      .reduce((minDistance, distance) => {
+        return distance ? Math.min(minDistance, distance) : minDistance
+      }, Infinity)
+  }
+  getEdgesParallelToLine(line) {
+    return this.outline
+      .map((p, index) => {
+        const nextP = this.outline[(index + 1) % this.outline.length]
+        const edge = new Line(p, nextP)
+        const edgeDirection = edge.getDirectionVector()
+        const lineDirection = line.getDirectionVector()
+        if (areAlmostCollinear(edgeDirection, lineDirection, 0.1)) {
+          //projection of one to the other is not empty
+          const projectionA = line.getProjectedPointFromTop(
+            edge.outline[0],
+            false
+          )
+          const projectionB = edge.getProjectedPointFromTop(
+            line.outline[0],
+            false
+          )
+          const projectionC = edge.getProjectedPointFromTop(
+            line.outline[1],
+            false
+          )
+          const projectionD = line.getProjectedPointFromTop(
+            edge.outline[1],
+            false
+          )
+          const isProjectionOnLineA = line.includesPoint(projectionA)
+          const isProjectionOnLineB = edge.includesPoint(projectionB)
+          const isProjectionOnLineC = edge.includesPoint(projectionC)
+          const isProjectionOnLineD = line.includesPoint(projectionD)
+
+          if (
+            isProjectionOnLineA ||
+            isProjectionOnLineB ||
+            isProjectionOnLineC ||
+            isProjectionOnLineD
+          ) {
+            return edge
+          }
+        }
+      })
+      .filter((edge) => edge)
+  }
+  getProjectedPoints(point, isInfinite = false) {
+    return this.outline.map((p, index) => {
+      const nextP = this.outline[(index + 1) % this.outline.length]
+      const edge = new Line(p, nextP)
+      return edge.getProjectedPointFromTop(point, isInfinite)
+    })
+  }
+  getPlaneProjectionWithPointVector(point, vector) {
+    const line = new Line(point, addVector(point, vector), '', true)
+    const plane = getPlaneFromPolygon(this)
+    const intersections = plane.getIntersections(line)
+    return intersections
+  }
+  getProjectedPointFromPlane(point, isInfinite = false, plane = defaultPlane) {
+    const closestEdge = this.getClosestPolygonEdgeFromPlane(point, plane)
+    return closestEdge.getProjectedPointFromPlane(point, isInfinite, plane)
+  }
+  getProjectedPointsFromPlane(point, isInfinite = false, plane = defaultPlane) {
+    return this.outline.map((p, index) => {
+      const nextP = this.outline[(index + 1) % this.outline.length]
+      const edge = new Line(p, nextP)
+      return edge.getProjectedPointFromPlane(point, isInfinite, plane)
+    })
+  }
+  getClosestPolygonEdgeFromPlane(point, plane = defaultPlane) {
+    const polygonEdgeData = this.outline.map((p, index) => {
+      const nextP = this.outline[(index + 1) % this.outline.length]
+      const edge = new Line(p, nextP)
+      const projectedPoint = edge.getProjectedPointFromPlane(point, true, plane)
+      const distanceToPoint = get3DDistanceBetweenPoints(projectedPoint, point)
+      return { distanceToPoint, projectedPoint, edge }
+    })
+    polygonEdgeData.sort((a, b) => a.distanceToPoint - b.distanceToPoint)
+    return polygonEdgeData[0].edge
+  }
   serialize() {
     const baseSerialization = {
       id: this.id,
@@ -274,6 +399,9 @@ export class Polygon {
       extraSerialization.row_index = this.row_index
       extraSerialization.col_index = this.col_index
       extraSerialization.moduleField = { id: this.moduleField.id }
+    } else if (this.layer == 'roof_plan_item') {
+      extraSerialization.colorIndex = this.colorIndex
+      extraSerialization.hasFillColor = this.hasFillColor
     }
     return JSON.parse(
       JSON.stringify({ ...baseSerialization, ...extraSerialization })

package/src/objects/derivedState/nodesEdgesCreation.js

@@ -6,10 +6,10 @@ import {
   isAlmostSameSegment2D,
   isAlmostSameSegment3D,
   isAlmostSamePoint2D,
-  verticalProjectionOnPlane
+  verticalProjectionOnPlane,
 } from '../../geometry'
 
-export function generateNodes2D(polygons) {
+export function generateNodes2D(polygons, circles) {
   let nodes2D = []
   polygons
     .filter((poly) =>
@@ -18,7 +18,8 @@ export function generateNodes2D(polygons) {
         'obstacle',
         'tmpModuleField',
         'moduleField',
-        'construction'
+        'construction',
+        'roof_plan_item',
       ].includes(poly.layer)
     )
     .forEach((polygon) => {
@@ -36,46 +37,79 @@ export function generateNodes2D(polygons) {
           node2D.id = 'node2D'
           node2D.itemType = 'node2D'
           node2D.layer = polygon.layer
+          node2D.colorIndex = polygon.colorIndex
           node2D.masterHandle = {
             id: node2D.id,
             itemType: 'masterHandle',
             open: null,
-            selected: null
+            selected: null,
           }
           nodes2D.push(node2D)
         }
         node2D.belongsTo.push({
-          polygonId: polygon.id,
+          itemId: polygon.id,
           index: i,
-          polygon
+          item: polygon,
         })
         node2D.id += '_' + polygon.id + '_' + i
       })
     })
-
+  circles.forEach((circle) => {
+    const point = circle.center
+    let node2D = nodes2D.find(
+      (node) =>
+        isAlmostSamePoint2D(node, point, mmTolerance) &&
+        node.layer == circle.layer
+    )
+    if (!node2D) {
+      node2D = new Point(point.x, point.y, point.z, circle.layer)
+      node2D.belongsTo = []
+      node2D.id = 'node2D'
+      node2D.itemType = 'node2D'
+      node2D.layer = circle.layer
+      node2D.colorIndex = circle.colorIndex
+      nodes2D.push(node2D)
+    }
+    node2D.belongsTo.push({
+      itemId: circle.id,
+      item: circle,
+    })
+    node2D.id += '_' + circle.id
+  })
   //all nodes has been created. now lets update open/selected field
   nodes2D.forEach((node2D) => {
     if (node2D.masterHandle) {
       node2D.masterHandle.open = node2D.belongsTo.some(
-        (item) => item.index == null || item.polygon.outline[item.index].open
+        (item) =>
+          item.index == null ||
+          (item.item.type === 'polygon' && item.item.outline[item.index].open)
       )
       node2D.masterHandle.selected = node2D.belongsTo.every(
         (item) =>
-          item.index == null || item.polygon.outline[item.index].selected
+          item.index == null ||
+          (item.item.type === 'polygon' && item.item.outline[item.index].selected)
       )
       node2D.masterHandle.locked = node2D.belongsTo.every(
-        (item) => item.index == null || item.polygon.outline[item.index].locked
+        (item) =>
+          item.index == null ||
+          (item.item.type === 'polygon' && item.item.outline[item.index].locked)
       )
     }
   })
   return nodes2D
 }
 
-export function generateNodes3D(polygons) {
+export function generateNodes3D(polygons, circles) {
   let nodes3D = []
   polygons
     .filter((poly) =>
-      ['roof', 'obstacle', 'tmpModuleField', 'moduleField'].includes(poly.layer)
+      [
+        'roof',
+        'obstacle',
+        'tmpModuleField',
+        'moduleField',
+        'roof_plan_item',
+      ].includes(poly.layer)
     )
     .forEach((polygon) => {
       const outline = polygon.outline
@@ -90,30 +124,55 @@ export function generateNodes3D(polygons) {
           node3D.id = 'node3D'
           node3D.itemType = 'node3D'
           node3D.layer = polygon.layer
+          node3D.colorIndex = polygon.colorIndex
           node3D.masterHandle = {
             id: node3D.id,
             itemType: 'masterHandle',
             open: null,
-            selected: null
+            selected: null,
           }
           nodes3D.push(node3D)
         }
         node3D.belongsTo.push({
-          polygonId: polygon.id,
+          itemId: polygon.id,
           index: i,
-          polygon
+          item: polygon,
         })
         node3D.id += '_' + polygon.id + '_' + i
       })
     })
+  circles.forEach((circle) => {
+    const point = circle.center
+    let node3D = nodes3D.find(
+      (node) =>
+        isAlmostSamePoint3D(node, point, mmTolerance) &&
+        node.layer == circle.layer
+    )
+    if (!node3D) {
+      node3D = new Point(point.x, point.y, point.z, circle.layer)
+      node3D.belongsTo = []
+      node3D.id = 'node3D'
+      node3D.itemType = 'node3D'
+      node3D.layer = circle.layer
+      node3D.colorIndex = circle.colorIndex
+      nodes3D.push(node3D)
+    }
+    node3D.belongsTo.push({
+      itemId: circle.id,
+      item: circle,
+    })
+    node3D.id += '_' + circle.id
+  })
   //all nodes has been created. now lets update open/selected field
   nodes3D.forEach((node3D) => {
     if (node3D.masterHandle) {
       node3D.masterHandle.open = node3D.belongsTo.some(
-        (item) => item.polygon.outline[item.index].open
+        (item) =>
+          item.item.type === 'polygon' && item.item.outline[item.index].open
       )
       node3D.masterHandle.selected = node3D.belongsTo.every(
-        (item) => item.polygon.outline[item.index].selected
+        (item) =>
+          item.item.type === 'polygon' && item.item.outline[item.index].selected
       )
     }
   })
@@ -124,7 +183,13 @@ export function generateEdges2D(polygons, splitEdgesIds = []) {
   let edges2D = []
   polygons
     .filter((poly) =>
-      ['roof', 'obstacle', 'moduleField', 'construction'].includes(poly.layer)
+      [
+        'roof',
+        'obstacle',
+        'moduleField',
+        'construction',
+        'roof_plan_item',
+      ].includes(poly.layer)
     )
     .forEach((polygon) => {
       const outline = polygon.outline
@@ -152,20 +217,21 @@ export function generateEdges2D(polygons, splitEdgesIds = []) {
           edge2D.layer = polygon.layer
           edge2D.selected = false
           edge2D.itemType = 'edge2D'
+          edge2D.colorIndex = polygon.colorIndex
           edges2D.push(edge2D)
         }
         //add BelongToPolygon
         edge2D.belongsTo.push({
-          polygonId: polygon.id,
+          itemId: polygon.id,
           index: i,
-          polygon
+          item: polygon,
         })
         if (polygon.roofs && polygon.roofs.length > 0) {
           polygon.roofs.forEach((supportRoof) => {
             edge2D.belongsTo.push({
-              polygonId: supportRoof.id,
+              itemId: supportRoof.id,
               index: null,
-              polygon: supportRoof
+              item: supportRoof,
             })
           })
         }
@@ -183,8 +249,12 @@ export function generateEdges2D(polygons, splitEdgesIds = []) {
       if (index == 0) {
         return true
       }
-      const outline0 = array[0].polygon.outline
-      const outline1 = item.polygon.outline
+      // Only process polygon items (circles don't have outlines)
+      if (array[0].item.type !== 'polygon' || item.item.type !== 'polygon') {
+        return true
+      }
+      const outline0 = array[0].item.outline
+      const outline1 = item.item.outline
       let point0, point1, nextPoint0, nextPoint1
       let pointNull = []
       if (array[0].index !== null) {
@@ -194,13 +264,13 @@ export function generateEdges2D(polygons, splitEdgesIds = []) {
         pointNull.push(0)
         point0 = verticalProjectionOnPlane(
           outline1[item.index],
-          array[0].polygon.normalVector,
-          array[0].polygon.flatOutline[0]
+          array[0].item.normalVector,
+          array[0].item.flatOutline[0]
         )
         nextPoint0 = verticalProjectionOnPlane(
           outline1[(item.index + 1) % outline1.length],
-          array[0].polygon.normalVector,
-          array[0].polygon.flatOutline[0]
+          array[0].item.normalVector,
+          array[0].item.flatOutline[0]
         )
       }
       if (item.index !== null) {
@@ -210,13 +280,13 @@ export function generateEdges2D(polygons, splitEdgesIds = []) {
         pointNull.push(1)
         point1 = verticalProjectionOnPlane(
           outline0[array[0].index],
-          item.polygon.normalVector,
-          item.polygon.flatOutline[0]
+          item.item.normalVector,
+          item.item.flatOutline[0]
         )
         nextPoint1 = verticalProjectionOnPlane(
           outline0[(array[0].index + 1) % outline0.length],
-          item.polygon.normalVector,
-          item.polygon.flatOutline[0]
+          item.item.normalVector,
+          item.item.flatOutline[0]
         )
       }
       const isSameSeg = isAlmostSameSegment3D(
@@ -237,7 +307,13 @@ export function generateEdges3D(polygons) {
   let edges3D = []
   polygons
     .filter((poly) =>
-      ['roof', 'obstacle', 'moduleField', 'construction'].includes(poly.layer)
+      [
+        'roof',
+        'obstacle',
+        'moduleField',
+        'construction',
+        'roof_plan_item',
+      ].includes(poly.layer)
     )
     .forEach((polygon) => {
       const outline = polygon.outline
@@ -264,14 +340,15 @@ export function generateEdges3D(polygons) {
           edge3D.belongsTo = []
           edge3D.layer = polygon.layer
           edge3D.selected = false
+          edge3D.colorIndex = polygon.colorIndex
           edge3D.itemType = 'edge3D'
           edges3D.push(edge3D)
         }
         //add BelongToPolygon
         edge3D.belongsTo.push({
-          polygonId: polygon.id,
+          itemId: polygon.id,
           index: i,
-          polygon
+          item: polygon,
         })
         edge3D.id += '_' + polygon.id + '_' + i
       })

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -72,6 +72,7 @@ export function updateComputedGeometryPolygon(polygon) {
       'roof',
       'obstacle',
       'moduleField',
+      'roof_plan_item'
     ].includes(polygon.layer)
   ) {
     return polygon

package/src/objects/graph/graphCreation.js

@@ -24,15 +24,15 @@ export function generateGraph(polygons, { includingRoofOnRoofs = true } = {}) {
 				}
 				//add BelongToPolygon
 				edge2D.belongsTo.push({
-					polygonId: polygon.id,
+					itemId: polygon.id,
 					index: i,
-					polygon
+					item: polygon
 				})
 				if (includingRoofOnRoofs && polygon.roofs && polygon.roofs.length == 1) {
 					edge2D.belongsTo.push({
-						polygonId: polygon.roofs[0].id,
+						itemId: polygon.roofs[0].id,
 						index: null,
-						polygon: polygon.roofs[0]
+						item: polygon.roofs[0]
 					})
 				}
 			})
@@ -40,7 +40,7 @@ export function generateGraph(polygons, { includingRoofOnRoofs = true } = {}) {
 	for (let k in edges2D) {
 		let edge = edges2D[k]
 		if (edge.belongsTo.length == 2) {
-			g.addEdge(edge.belongsTo[0].polygonId, edge.belongsTo[1].polygonId)
+			g.addEdge(edge.belongsTo[0].itemId, edge.belongsTo[1].itemId)
 		}
 	}
 	return g