@eturnity/eturnity_3d 7.24.1 → 7.24.2-EPDM-10923.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "7.24.1",
+  "version": "7.24.2-EPDM-10923.0",
   "files": [
     "dist",
     "src"
@@ -15,7 +15,7 @@
     "prettier": "prettier --write \"**/*.{js,vue}\""
   },
   "dependencies": {
-    "@eturnity/eturnity_maths": "7.24.1",
+    "@eturnity/eturnity_maths": "7.24.1-EPDM-10923.0",
     "@originjs/vite-plugin-commonjs": "1.0.3",
     "core-js": "2.6.12",
     "cors": "2.8.5",

package/src/store/three-d-module.js

@@ -3,7 +3,7 @@ import {
   generateNodes3D,
   generateEdges2D,
   generateEdges3D
-} from './nodesEdgesCreation'
+} from '@eturnity/eturnity_maths'
 import { hydrateData } from './hydrateData.js'
 
 const init_state = {

package/src/store/nodesEdgesCreation.js

@@ -1,286 +0,0 @@
-import { Point, Line } from '@eturnity/eturnity_maths'
-import { mmTolerance, mmTolerance3dNode } from '../config'
-import {
-  isAlmostSamePoint3D,
-  isAlmostSameSegment2D,
-  isAlmostSameSegment3D,
-  isAlmostSamePoint2D,
-  verticalProjectionOnPlane
-} from '@eturnity/eturnity_maths'
-
-export function generateNodes2D(polygons) {
-  let nodes2D = []
-  polygons
-    .filter((poly) =>
-      [
-        'roof',
-        'obstacle',
-        'tmpModuleField',
-        'moduleField',
-        'construction'
-      ].includes(poly.layer)
-    )
-    .forEach((polygon) => {
-      const outline = polygon.outline
-      outline.forEach((point, i) => {
-        //check if nodes2D already exist
-        let node2D = nodes2D.find(
-          (node) =>
-            isAlmostSamePoint2D(node, point, mmTolerance) &&
-            node.layer == polygon.layer
-        )
-        if (!node2D) {
-          node2D = new Point(point.x, point.y, point.z, polygon.layer)
-          node2D.belongsTo = []
-          node2D.id = 'node2D'
-          node2D.itemType = 'node2D'
-          node2D.layer = polygon.layer
-          node2D.masterHandle = {
-            id: node2D.id,
-            itemType: 'masterHandle',
-            open: null,
-            selected: null
-          }
-          nodes2D.push(node2D)
-        }
-        node2D.belongsTo.push({
-          polygonId: polygon.id,
-          index: i,
-          polygon
-        })
-        node2D.id += '_' + polygon.id + '_' + i
-      })
-    })
-
-  //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.polygon.outline[item.index].hasWarning
-      )
-      node2D.masterHandle.hasWarning = node2D.belongsTo.some(
-        (item) =>
-          item.index == null || item.polygon.outline[item.index].hasWarning
-      )
-      node2D.masterHandle.selected = node2D.belongsTo.every(
-        (item) =>
-          item.index == null || item.polygon.outline[item.index].selected
-      )
-      node2D.masterHandle.locked = node2D.belongsTo.every(
-        (item) => item.index == null || item.polygon.outline[item.index].locked
-      )
-    }
-  })
-  return nodes2D
-}
-
-export function generateNodes3D(polygons) {
-  let nodes3D = []
-  polygons
-    .filter((poly) =>
-      ['roof', 'obstacle', 'tmpModuleField', 'moduleField'].includes(poly.layer)
-    )
-    .forEach((polygon) => {
-      const outline = polygon.outline
-      outline.forEach((point, i) => {
-        //check if nodes2D already exist
-        let node3D = nodes3D.find((node) =>
-          isAlmostSamePoint3D(node, point, mmTolerance3dNode)
-        )
-        if (!node3D) {
-          node3D = new Point(point.x, point.y, point.z, polygon.layer)
-          node3D.belongsTo = []
-          node3D.id = 'node3D'
-          node3D.itemType = 'node3D'
-          node3D.layer = polygon.layer
-          node3D.masterHandle = {
-            id: node3D.id,
-            itemType: 'masterHandle',
-            open: null,
-            selected: null
-          }
-          nodes3D.push(node3D)
-        }
-        node3D.belongsTo.push({
-          polygonId: polygon.id,
-          index: i,
-          polygon
-        })
-        node3D.id += '_' + polygon.id + '_' + i
-      })
-    })
-  //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
-      )
-      node3D.masterHandle.selected = node3D.belongsTo.every(
-        (item) => item.polygon.outline[item.index].selected
-      )
-    }
-  })
-  return nodes3D
-}
-
-export function generateEdges2D(polygons, splitEdgesIds = []) {
-  let edges2D = []
-  polygons
-    .filter((poly) =>
-      ['roof', 'obstacle', 'moduleField', 'construction'].includes(poly.layer)
-    )
-    .forEach((polygon) => {
-      const outline = polygon.outline
-      outline.forEach((point, i) => {
-        const isLastPointOfPolygon = i == outline.length - 1
-        if (!polygon.isClosed && isLastPointOfPolygon) {
-          return
-        }
-        //check if edge2D already exist
-        const nextPoint = outline[(i + 1) % outline.length]
-        let edge2D = edges2D.find((edge) => {
-          return (
-            isAlmostSameSegment2D(
-              [point, nextPoint],
-              edge.outline,
-              mmTolerance
-            ) && edge.layer == polygon.layer
-          )
-        })
-        if (!edge2D) {
-          //create an edge at this position
-          edge2D = new Line(point, nextPoint, polygon.layer)
-          edge2D.id = 'edge2D'
-          edge2D.belongsTo = []
-          edge2D.layer = polygon.layer
-          edge2D.selected = false
-          edge2D.itemType = 'edge2D'
-          edges2D.push(edge2D)
-        }
-        //add BelongToPolygon
-        edge2D.belongsTo.push({
-          polygonId: polygon.id,
-          index: i,
-          polygon
-        })
-        if (polygon.roofs && polygon.roofs.length > 0) {
-          polygon.roofs.forEach((supportRoof) => {
-            edge2D.belongsTo.push({
-              polygonId: supportRoof.id,
-              index: null,
-              polygon: supportRoof
-            })
-          })
-        }
-        edge2D.id += '_' + polygon.id + '_' + i
-      })
-    })
-  edges2D.forEach((edge2D) => {
-    edge2D.isSplit = splitEdgesIds.includes(edge2D.id)
-    if (edge2D.belongsTo.length > 2) {
-      edge2D.belongsTo = edge2D.belongsTo.filter((i) => i.index !== null)
-    }
-  })
-  edges2D.forEach((edge2D) => {
-    const isNotSplit = edge2D.belongsTo.every((item, index, array) => {
-      if (index == 0) {
-        return true
-      }
-      const outline0 = array[0].polygon.outline
-      const outline1 = item.polygon.outline
-      let point0, point1, nextPoint0, nextPoint1
-      let pointNull = []
-      if (array[0].index !== null) {
-        point0 = outline0[array[0].index]
-        nextPoint0 = outline0[(array[0].index + 1) % outline0.length]
-      } else {
-        pointNull.push(0)
-        point0 = verticalProjectionOnPlane(
-          outline1[item.index],
-          array[0].polygon.normalVector,
-          array[0].polygon.flatOutline[0]
-        )
-        nextPoint0 = verticalProjectionOnPlane(
-          outline1[(item.index + 1) % outline1.length],
-          array[0].polygon.normalVector,
-          array[0].polygon.flatOutline[0]
-        )
-      }
-      if (item.index !== null) {
-        point1 = outline1[item.index]
-        nextPoint1 = outline1[(item.index + 1) % outline1.length]
-      } else {
-        pointNull.push(1)
-        point1 = verticalProjectionOnPlane(
-          outline0[array[0].index],
-          item.polygon.normalVector,
-          item.polygon.flatOutline[0]
-        )
-        nextPoint1 = verticalProjectionOnPlane(
-          outline0[(array[0].index + 1) % outline0.length],
-          item.polygon.normalVector,
-          item.polygon.flatOutline[0]
-        )
-      }
-      const isSameSeg = isAlmostSameSegment3D(
-        [point0, nextPoint0],
-        [point1, nextPoint1],
-        mmTolerance
-      )
-      return isSameSeg
-    })
-    if (!isNotSplit && edge2D.belongsTo.length == 2 && edge2D.layer == 'roof') {
-      edge2D.isSplit = true
-    }
-  })
-  return edges2D
-}
-
-export function generateEdges3D(polygons) {
-  let edges3D = []
-  polygons
-    .filter((poly) =>
-      ['roof', 'obstacle', 'moduleField', 'construction'].includes(poly.layer)
-    )
-    .forEach((polygon) => {
-      const outline = polygon.outline
-      outline.forEach((point, i) => {
-        const isLastPointOfPolygon = i == outline.length - 1
-        if (!polygon.isClosed && isLastPointOfPolygon) {
-          return
-        }
-        //check if edge2D already exist
-        const nextPoint = outline[(i + 1) % outline.length]
-        let edge3D = edges3D.find((edge) => {
-          return (
-            isAlmostSameSegment3D(
-              [point, nextPoint],
-              edge.outline,
-              mmTolerance
-            ) && edge.layer == polygon.layer
-          )
-        })
-        if (!edge3D) {
-          //create an edge at this position
-          edge3D = new Line(point, nextPoint, polygon.layer)
-          edge3D.id = 'edge3D'
-          edge3D.belongsTo = []
-          edge3D.layer = polygon.layer
-          edge3D.selected = false
-          edge3D.itemType = 'edge3D'
-          edges3D.push(edge3D)
-        }
-        //add BelongToPolygon
-        edge3D.belongsTo.push({
-          polygonId: polygon.id,
-          index: i,
-          polygon
-        })
-        edge3D.id += '_' + polygon.id + '_' + i
-      })
-    })
-  return edges3D
-}