@eturnity/eturnity_3d 6.34.0 → 6.34.1

package/src/store/hydrateData.js

@@ -6,9 +6,7 @@ import {
   getObstacleMarginOutline
 } from '@eturnity/eturnity_maths'
 import getLayers from '../utils/layers'
-import {
-  UpdateRoofObstacleRelations
-} from '../helper/UpdateRoofObstacleRelations'
+import { UpdateRoofObstacleRelations } from '../helper/UpdateRoofObstacleRelations'
 
 export async function hydrateData({ state, commit }, data) {
   let roofsResponse = data.roofs
@@ -17,18 +15,24 @@ export async function hydrateData({ state, commit }, data) {
   const layoutSettingResponse = data.layoutSettings
   const imageOverlayResponse = data.imageOverlay
   //removing empty roof,obstacle and modulefield generated by BE on variant creation
-  roofsResponse=roofsResponse.reduce((acc,cur)=>{
-    if(cur.roof_outline.length>0){acc.push(cur)}
+  roofsResponse = roofsResponse.reduce((acc, cur) => {
+    if (cur.roof_outline.length > 0) {
+      acc.push(cur)
+    }
     return acc
-  },[])
-  obstaclesResponse=obstaclesResponse.reduce((acc,cur)=>{
-    if(cur.obstacle_outline.length>0){acc.push(cur)}
+  }, [])
+  obstaclesResponse = obstaclesResponse.reduce((acc, cur) => {
+    if (cur.obstacle_outline.length > 0) {
+      acc.push(cur)
+    }
     return acc
-  },[])
-  moduleFieldsResponse=moduleFieldsResponse.reduce((acc,cur)=>{
-    if(cur.module_field_outline.length>0){acc.push(cur)}
+  }, [])
+  moduleFieldsResponse = moduleFieldsResponse.reduce((acc, cur) => {
+    if (cur.module_field_outline.length > 0) {
+      acc.push(cur)
+    }
     return acc
-  },[])
+  }, [])
 
   if (imageOverlayResponse && imageOverlayResponse.image_overlay_url) {
     let imageOverlay = {
@@ -38,22 +42,27 @@ export async function hydrateData({ state, commit }, data) {
     }
     commit('mutate_imageOverlay', imageOverlay)
   }
-  
+
   if (!!layoutSettingResponse) {
     const layoutSetting = layoutSettingResponse
-    const moduleTextureVersionId=layoutSetting.module_texture_version_id || 0
+    const moduleTextureVersionId = layoutSetting.module_texture_version_id || 0
     commit('mutate_layoutSettings', layoutSetting)
-    commit('mutate_moduleTextureVersionId',moduleTextureVersionId)
+    commit('mutate_moduleTextureVersionId', moduleTextureVersionId)
     commit('mutate_wallColor', layoutSetting.wall_color)
-    let layers=getLayers()
+    let layers = getLayers()
     let selectedLayer
-    if(layoutSetting.background_map_settings && layoutSetting.background_map_settings.layerKey){
-      selectedLayer=layers.find(layer=>layer.key==layoutSetting.background_map_settings.layerKey)
-    }else{
-      selectedLayer=layers.find(layer=>layer.key=="googleLayer")
+    if (
+      layoutSetting.background_map_settings &&
+      layoutSetting.background_map_settings.layerKey
+    ) {
+      selectedLayer = layers.find(
+        (layer) => layer.key == layoutSetting.background_map_settings.layerKey
+      )
+    } else {
+      selectedLayer = layers.find((layer) => layer.key == 'googleLayer')
     }
     commit('mutate_selectedMapLayer', selectedLayer)
-    
+
     //end of layoutSetting correction
     const newMapConfig = state.mapConfig
     newMapConfig.center = {
@@ -63,7 +72,7 @@ export async function hydrateData({ state, commit }, data) {
     newMapConfig.layer = layoutSetting.map_layer
     newMapConfig.zoom = layoutSetting.map_zoom
     commit('mutate_mapConfig', newMapConfig)
-  } 
+  }
 
   const roofs = []
   const obstacles = []
@@ -136,13 +145,15 @@ export async function hydrateData({ state, commit }, data) {
     pv_module_ids.push(moduleFieldResp.component_id_pv_module)
     mounting_system_ids.push(moduleFieldResp.component_id_mounting_system)
 
+    moduleField.data.number_of_panels_override =
+      moduleFieldResp.number_of_panels_override
+    moduleField.data.number_of_panels = moduleFieldResp.number_of_panels
+    moduleField.data.yearly_yield_manual_entry =
+      moduleFieldResp.yearly_yield_manual_entry
+    moduleField.data.yearly_yield_kwh_kwp = moduleFieldResp.yearly_yield_kwh_kwp
+    moduleField.data.yearly_yield_kwh_kwp_2 =
+      moduleFieldResp.yearly_yield_kwh_kwp_2
 
-    moduleField.data.number_of_panels_override=moduleFieldResp.number_of_panels_override
-    moduleField.data.number_of_panels=moduleFieldResp.number_of_panels
-    moduleField.data.yearly_yield_manual_entry=moduleFieldResp.yearly_yield_manual_entry
-    moduleField.data.yearly_yield_kwh_kwp=moduleFieldResp.yearly_yield_kwh_kwp
-    moduleField.data.yearly_yield_kwh_kwp_2=moduleFieldResp.yearly_yield_kwh_kwp_2
-    
     moduleField.data.modules = moduleFieldResp.modules
     moduleFieldResp.modules.forEach((m) => {
       const panel = new Polygon(
@@ -182,7 +193,7 @@ export async function hydrateData({ state, commit }, data) {
   //Get PV & Mounting system component Data (texture):
   pv_module_ids = [...new Set(pv_module_ids)]
   mounting_system_ids = [...new Set(mounting_system_ids)]
-  
+
   state.polygons = [
     ...roofs,
     ...obstacles,
@@ -192,4 +203,3 @@ export async function hydrateData({ state, commit }, data) {
   ]
   state = UpdateRoofObstacleRelations(state)
 }
-

package/src/store/nodesEdgesCreation.js

@@ -8,178 +8,195 @@ import {
 } 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)
+  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
           }
-          node2D.belongsTo.push({
-            polygonId: polygon.id,
-            index: i,
-            polygon
-          })
-          node2D.id+="_"+polygon.id+"_"+i
+          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.filter((item) => item.polygon.outline[item.index].open || item.polygon.outline[item.index].hasWarning)
-            .length > 0
-        node2D.masterHandle.hasWarning =
-        node2D.belongsTo.filter((item) => item.polygon.outline[item.index].hasWarning)
-          .length > 0
-        node2D.masterHandle.selected =
-          node2D.belongsTo.filter(
-            (item) => item.polygon.outline[item.index].selected
-          ).length == node2D.belongsTo.length
-      }
     })
-    return nodes2D
-  }
-  
+
+  //all nodes has been created. now lets update open/selected field
+  nodes2D.forEach((node2D) => {
+    if (node2D.masterHandle) {
+      node2D.masterHandle.open =
+        node2D.belongsTo.filter(
+          (item) =>
+            item.polygon.outline[item.index].open ||
+            item.polygon.outline[item.index].hasWarning
+        ).length > 0
+      node2D.masterHandle.hasWarning =
+        node2D.belongsTo.filter(
+          (item) => item.polygon.outline[item.index].hasWarning
+        ).length > 0
+      node2D.masterHandle.selected =
+        node2D.belongsTo.filter(
+          (item) => item.polygon.outline[item.index].selected
+        ).length == node2D.belongsTo.length
+    }
+  })
+  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) => isSamePoint3D(node, point))
-          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)
+  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) => isSamePoint3D(node, point))
+        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
           }
-          node3D.belongsTo.push({
-            polygonId: polygon.id,
-            index: i,
-            polygon
-          })
-          node3D.id+="_"+polygon.id+"_"+i
+          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.filter((item) => item.polygon.outline[item.index].open)
-            .length > 0
-        node3D.masterHandle.selected =
-          node3D.belongsTo.filter(
-            (item) => item.polygon.outline[item.index].selected
-          ).length > node3D.belongsTo.length
-      }
     })
-    return nodes3D
-  }
-  
+  //all nodes has been created. now lets update open/selected field
+  nodes3D.forEach((node3D) => {
+    if (node3D.masterHandle) {
+      node3D.masterHandle.open =
+        node3D.belongsTo.filter((item) => item.polygon.outline[item.index].open)
+          .length > 0
+      node3D.masterHandle.selected =
+        node3D.belongsTo.filter(
+          (item) => item.polygon.outline[item.index].selected
+        ).length > node3D.belongsTo.length
+    }
+  })
+  return nodes3D
+}
+
 export function generateEdges2D(polygons) {
-    let edges2D = []
-    polygons
-      .filter((poly) => ['roof', 'obstacle','moduleField','construction'].includes(poly.layer))
-      .forEach((polygon) => {
-        const outline = polygon.outline
-        outline.forEach((point, i) => {
-          if(!polygon.isClosed && i==outline.length-1){
-            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
-          })
-          edge2D.id+="_"+polygon.id+"_"+i
+  let edges2D = []
+  polygons
+    .filter((poly) =>
+      ['roof', 'obstacle', 'moduleField', 'construction'].includes(poly.layer)
+    )
+    .forEach((polygon) => {
+      const outline = polygon.outline
+      outline.forEach((point, i) => {
+        if (!polygon.isClosed && i == outline.length - 1) {
+          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
         })
+        edge2D.id += '_' + polygon.id + '_' + i
       })
-    return edges2D
-  }
-  
+    })
+  return edges2D
+}
+
 export function generateEdges3D(polygons) {
-    let edges3D = []
-    polygons
-      .filter((poly) => poly.layer == 'roof' || poly.layer == 'obstacle')
-      .forEach((polygon) => {
-        const outline = polygon.outline
-        outline.forEach((point, i) => {
-          //check if edge2D already exist
-          const nextPoint = outline[(i + 1) % outline.length]
-          let edge3D = edges3D.find((edge) => {
-            isSameSegment3D([point, nextPoint], edge.outline) &&
-              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
+  let edges3D = []
+  polygons
+    .filter((poly) => poly.layer == 'roof' || poly.layer == 'obstacle')
+    .forEach((polygon) => {
+      const outline = polygon.outline
+      outline.forEach((point, i) => {
+        //check if edge2D already exist
+        const nextPoint = outline[(i + 1) % outline.length]
+        let edge3D = edges3D.find((edge) => {
+          isSameSegment3D([point, nextPoint], edge.outline) &&
+            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
-  }
+    })
+  return edges3D
+}

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

@@ -19,7 +19,7 @@ const init_state = {
   cancelTokenGlobal: '',
   globalProjectProperties: [],
   buildingLocation: null,
-  imageOverlay:null,
+  imageOverlay: null,
   layoutSettings: {
     base64_image_url: null,
     layout_latitude: null,
@@ -29,22 +29,21 @@ const init_state = {
     camera_3d: {}
   },
   //useless state for viewer
-  pvDataMemo:[],
-  mountingDataMemo:[],
-  moduleTextureVersionId:0,
-  wallColor:'#454545',
-  panelOpacity:1,
-  selectedMapLayer:null,
+  pvDataMemo: [],
+  mountingDataMemo: [],
+  moduleTextureVersionId: 0,
+  wallColor: '#454545',
+  panelOpacity: 1,
+  selectedMapLayer: null,
   globalProjectProperties: [],
-  imageOverlay:null
+  imageOverlay: null
 }
 
 const state = init_state
 
 const getters = {
-  
   getSelectedTool() {
-    return ""
+    return ''
   },
   getRoofs(state) {
     return state.polygons.filter((p) => p.layer == 'roof')
@@ -89,7 +88,7 @@ const getters = {
   getBuildingLocation(state) {
     return state.buildingLocation
   },
-  getImageOverlay(state){
+  getImageOverlay(state) {
     return state.imageOverlay
   },
   getLayoutSettings(state) {
@@ -98,16 +97,31 @@ const getters = {
   getGeometryEvents() {
     return []
   },
-  getRoofsBounds(state,getters){
-    let bounds={xMin:Infinity,xMax:-Infinity,yMin:Infinity,yMax:-Infinity}
-    getters.getRoofs.forEach(polygon=>polygon.outline.forEach(p=>{
-      if(bounds.xMin>p.x){bounds.xMin=p.x}
-      if(bounds.xMax<p.x){bounds.xMax=p.x}
-      if(bounds.yMin>p.y){bounds.yMin=p.y}
-      if(bounds.yMax<p.y){bounds.yMax=p.y}
-    }))
+  getRoofsBounds(state, getters) {
+    let bounds = {
+      xMin: Infinity,
+      xMax: -Infinity,
+      yMin: Infinity,
+      yMax: -Infinity
+    }
+    getters.getRoofs.forEach((polygon) =>
+      polygon.outline.forEach((p) => {
+        if (bounds.xMin > p.x) {
+          bounds.xMin = p.x
+        }
+        if (bounds.xMax < p.x) {
+          bounds.xMax = p.x
+        }
+        if (bounds.yMin > p.y) {
+          bounds.yMin = p.y
+        }
+        if (bounds.yMax < p.y) {
+          bounds.yMax = p.y
+        }
+      })
+    )
     return bounds
-},
+  }
 }
 
 const mutations = {
@@ -138,15 +152,15 @@ const mutations = {
   mutate_buildingLocation(state, value) {
     state.buildingLocation = value
   },
-  mutate_moduleTextureVersionId(state,value){
-    state.moduleTextureVersionId=value
+  mutate_moduleTextureVersionId(state, value) {
+    state.moduleTextureVersionId = value
   },
-  mutate_wallColor(state,value){
-    state.wallColor=value
-  },
-  mutate_selectedMapLayer(state,value){
-    state.selectedMapLayer=value
+  mutate_wallColor(state, value) {
+    state.wallColor = value
   },
+  mutate_selectedMapLayer(state, value) {
+    state.selectedMapLayer = value
+  }
 }
 
 const actions = {

package/src/utils/cancellablePromise.js

@@ -0,0 +1,23 @@
+export function cancellablePromise(promise){
+    let status='pending'
+    let isCancel=false
+    const promiseObject=new Promise(function(res,rej){
+      promise
+        .then(data=>{
+          if(!isCancel){res(data);status='resolved'}else{
+            status='resolved but cancelled before'
+          }
+        })
+        .catch(data=>{
+          status='rejected'
+          if(!isCancel) rej(data)
+        })
+    })
+    promiseObject.getStatus=()=>{
+      return status  
+    }
+    promiseObject.cancel=()=>{
+      isCancel=true
+    }
+    return promiseObject
+  }

package/.eslintrc.json

@@ -1,18 +0,0 @@
-{
-    "env": {
-        "browser": true,
-        "es2021": true
-    },
-    "extends": "plugin:vue/vue3-essential",
-    "overrides": [
-    ],
-    "parserOptions": {
-        "ecmaVersion": "latest",
-        "sourceType": "module"
-    },
-    "plugins": [
-        "vue"
-    ],
-    "rules": {
-    }
-}