@eturnity/eturnity_3d 0.0.4

package/src/store/nodesEdgesCreation.js

@@ -0,0 +1,216 @@
+import { Point, Line } from '@eturnity/eturnity_maths'
+import { mmTolerance } from '../config'
+import {
+  isSamePoint2D,
+  isSamePoint3D,
+  isSameSegment2D,
+  isAlmostSameSegment2D,
+  isSameSegment3D,
+  isAlmostSamePoint2D
+} from '@eturnity/eturnity_maths'
+
+export function generateNodes2D(polygons, constructionPolyline) {
+    let nodes2D = []
+    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 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.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
+          })
+        })
+      })
+    if (constructionPolyline) {
+      constructionPolyline.outline.forEach((point, i) => {
+        //check if nodes2D already exist
+        const node2D = new Point(
+          point.x,
+          point.y,
+          point.z,
+          constructionPolyline.layer
+        )
+        node2D.belongsTo = [
+          {
+            polygonId: constructionPolyline.id,
+            index: i,
+            polygon: constructionPolyline
+          }
+        ]
+        node2D.itemType = 'node2D'
+        node2D.layer = constructionPolyline.layer
+        nodes2D.push(node2D)
+      })
+    }
+    //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)
+            .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.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
+          })
+        })
+      })
+    //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, constructionPolyline) {
+    let edges2D = []
+    polygons
+      .filter((poly) => ['roof', 'obstacle'].includes(poly.layer))
+      .forEach((polygon) => {
+        const outline = polygon.outline
+        outline.forEach((point, i) => {
+          //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.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 (constructionPolyline) {
+      constructionPolyline.outline.forEach((point, i) => {
+        //check if nodes2D already exist
+        if (i != constructionPolyline.outline.length - 1) {
+          const nextPoint =
+            constructionPolyline.outline[
+              (i + 1) % constructionPolyline.outline.length
+            ]
+          const edge2D = new Line(point, nextPoint, constructionPolyline.layer)
+          edge2D.belongsTo = [
+            {
+              polygonId: constructionPolyline.id,
+              index: i,
+              polygon: constructionPolyline
+            }
+          ]
+          edge2D.layer = constructionPolyline.layer
+          edge2D.selected = false
+          edge2D.itemType = 'edge2D'
+          edges2D.push(edge2D)
+        }
+      })
+    }
+    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.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
+          })
+        })
+      })
+    return edges3D
+  }

package/src/store/store.js

@@ -0,0 +1,10 @@
+import Vue from 'vue'
+import Vuex from 'vuex'
+import threeDModule from './three-d-module'
+
+Vue.use(Vuex)
+export default new Vuex.Store({
+  modules: {
+    threeDModule
+  }
+})

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

@@ -0,0 +1,142 @@
+import {
+  generateNodes2D,
+  generateNodes3D,
+  generateEdges2D,
+  generateEdges3D
+} from './nodesEdgesCreation'
+import { hydrateData } from './hydrateData.js'
+
+const init_state = {
+  isLoading: false,
+
+  polygons: [],
+  nodes: [],
+  edges: [],
+
+  mapConfig: {},
+
+  //for Panels
+  cancelTokenGlobal: '',
+  globalProjectProperties: [],
+  buildingLocation: null,
+  layoutSettings: {
+    base64_image_url: null,
+    layout_latitude: null,
+    layout_longitude: null,
+    map_layer: 'swisstopoLayer_swissimage',
+    map_zoom: 19,
+    camera_3d: {}
+  },
+  //useless state for viewer
+  pvDataMemo:[],
+  mountingDataMemo:[],
+  module_texture_version_id:0,
+  selectedMapLayer:null,
+  globalProjectProperties: [],
+}
+
+const state = init_state
+
+const getters = {
+  
+  getSelectedTool() {
+    return ""
+  },
+  getRoofs(state) {
+    return state.polygons.filter((p) => p.layer == 'roof')
+  },
+  getObstacles(state) {
+    return state.polygons.filter((p) => p.layer == 'obstacle')
+  },
+  getModuleFields(state) {
+    return state.polygons.filter((p) => p.layer == 'moduleField')
+  },
+  getPanels(state) {
+    return state.polygons.filter((p) => p.layer == 'panel')
+  },
+  getUserDeactivatedPanels(state) {
+    return state.polygons.filter((p) => p.layer == 'user_deactivated_panel')
+  },
+  getNodes2D(state) {
+    return generateNodes2D(state.polygons, state.constructionPolyline)
+  },
+  getNodes3D(state) {
+    return generateNodes3D(state.polygons)
+  },
+  getEdges2D(state) {
+    return generateEdges2D(state.polygons, state.constructionPolyline)
+  },
+  getEdges3D(state) {
+    return generateEdges3D(state.polygons)
+  },
+
+  getPolygons(state) {
+    return state.polygons
+  },
+
+  getMapConfig(state) {
+    return state.mapConfig
+  },
+
+  getGlobalProjectProperties(state) {
+    return state.globalProjectProperties
+  },
+
+  getBuildingLocation(state) {
+    return state.buildingLocation
+  },
+
+  getLayoutSettings(state) {
+    return state.layoutSettings
+  },
+  getGeometryEvents() {
+    return []
+  }
+}
+
+const mutations = {
+  mutate_map(state, value) {
+    state.map = value
+  },
+  mutate_selectedLayer(state, value) {
+    state.selectedLayer = value
+  },
+  mutate_layoutSettings(state, value) {
+    state.layoutSettings = value
+  },
+  mutate_selectedZoom(state, value) {
+    state.selectedZoom = value
+  },
+
+  mutate_mapConfig(state, value) {
+    state.mapConfig = value
+  },
+
+  mutate_globalProjectProperties(state, value) {
+    state.globalProjectProperties = value
+  },
+
+  mutate_buildingLocation(state, value) {
+    state.buildingLocation = value
+  },
+  mutate_module_texture_version_id(state,value){
+    state.module_texture_version_id=value
+  },
+  mutate_module_texture_version_id(state,value){
+    state.module_texture_version_id=value
+  },
+  mutate_selectedMapLayer(state,value){
+    state.selectedMapLayer=value
+  },
+}
+
+const actions = {
+  hydrateData
+}
+
+export default {
+  state,
+  getters,
+  mutations,
+  actions
+}

package/src/style.css

@@ -0,0 +1,96 @@
+:root {
+  font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
+  font-size: 16px;
+  line-height: 24px;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  -webkit-text-size-adjust: 100%;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+.card {
+  padding: 2em;
+}
+
+#app {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+#app2 {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}