@eturnity/eturnity_3d 6.29.0-qa.0 → 6.29.0

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "6.29.0-qa.0",
+  "version": "6.29.0",
   "main": "dist/main.js",
   "scripts": {
     "dev": "vue-cli-service serve --skip-plugins @vue/cli-plugin-eslint",
     "build": "vue-cli-service build --skip-plugins @vue/cli-plugin-eslint"
   },
   "dependencies": {
-    "@eturnity/eturnity_maths": "6.28.0-EPDM-7663.0",
+    "@eturnity/eturnity_maths": "6.28.0",
     "axios": "^1.3.2",
-    "core-js": "^2.6.12",
     "cors": "^2.8.5",
+    "core-js": "^2.6.12",
     "earcut": "^2.2.4",
     "express": "^4.18.2",
     "geo-three": "^0.1.11",
@@ -19,12 +19,12 @@
     "leaflet.gridlayer.googlemutant": "^0.14.0",
     "svd-js": "^1.1.1",
     "three": "^0.149.0",
-    "three-projected-material": "2.2.1",
-    "tween": "0.9.0",
     "uuid": "^9.0.0",
     "vue": "^2.7.14",
     "vue-template-compiler": "^2.7.14",
-    "vuex": "^3.0.1"
+    "vuex": "^3.0.1",
+    "three-projected-material": "2.2.1",
+    "tween": "0.9.0"
   },
   "devDependencies": {
     "@babel/core": "^7.21.0",

package/src/components/ThreeCanvasViewer.vue

@@ -110,6 +110,8 @@ export default {
       let margin=0.2
       if (!polygon || view_mode == 'global') {
         let roofsBounds = this.roofsBounds
+        //let distance = 5 + objectRadius / Math.sin(((this.orthographicCamera.fov / 2) * Math.PI) / 180)
+        //console.log('distance:',distance)
         const position = [0, 0, 100]
         const target = [0, 0, 0]
         this.orthographicCamera.position.set(...position)
@@ -238,14 +240,6 @@ export default {
     },
     render() {
       this.renderer.clear()
-      if (this.orbitControl) {
-        this.orbitControl.target.set(
-          this.orbitControl.target.x,
-          this.orbitControl.target.y,
-          2
-        )
-        this.orbitControl.update()
-      }
       if (['top', 'global'].includes(this.view_mode)) {
         this.renderer.render(this.scene, this.orthographicCamera)
       } else {

package/src/config.js

@@ -75,7 +75,6 @@ export const defaultTextureUrls = [
   textureImageDomain+'textures/longiSolarLR4_60HPH_370M.png',
   textureImageDomain+'textures/longiSolarLR4_60HPH_350M.png',
 ]
-
 export const hitOption = {
   segments: true,
   stroke: true,

package/src/helper/DFS.js

@@ -0,0 +1,80 @@
+
+// Javascript program to print DFS
+// traversal from a given
+// graph
+ 
+// This class represents a
+// directed graph using adjacency
+// list representation
+export class Graph
+{
+     
+    // Constructor
+    //v=number of vertices
+    constructor()
+    {
+        this.visited=[]
+        this.dict= []
+        this.adj = []
+            
+    }
+     
+    // Function to add an edge into the graph
+    addEdge(uuid1, uuid2)
+    {
+        let v=this.dict.indexOf(uuid1)
+        let length
+        if(v==-1){
+          length=this.dict.length
+          this.dict[length]=uuid1
+          this.adj[length]=[]
+          v=length
+        }
+        let w=this.dict.indexOf(uuid2)
+        if(w==-1){
+          length=this.dict.length
+          this.dict[length]=uuid2
+          this.adj[length]=[]
+          w=length
+        }
+        // Add w to v's list.
+       if(!this.adj[v]){this.adj[v]=[]}
+       this.adj[v].push(w);
+       if(!this.adj[w]){this.adj[w]=[]}
+        this.adj[w].push(v);
+    }
+     
+    // A function used by DFS
+    DFSUtil(v, visited)
+    {
+         
+        // Mark the current node as visited and print it
+        visited[v] = true;
+        this.visited.push(v)
+  
+        // Recur for all the vertices adjacent to this
+        // vertex
+        for(let i in this.adj[v])
+        {
+            let n = this.adj[v][i]
+            if (!visited[n])
+                this.DFSUtil(n, visited);
+        }
+    }
+     
+    // The function to do DFS traversal.
+    // It uses recursive
+    // DFSUtil()
+    DFS(uuidStart){
+        let v=this.dict.indexOf(uuidStart)
+        // Mark all the vertices as
+        // not visited(set as
+        // false by default in java)
+        let visited = [];
+        // Call the recursive helper
+        // function to print DFS
+        // traversal
+        this.DFSUtil(v, visited);
+        return [...new Set(this.visited.map((i)=>{return this.dict[i]}))]
+    }
+}

package/src/helper/clearThreeObjects.js

@@ -0,0 +1,21 @@
+export default function clearThreeObject(obj) {
+  while (obj.children.length > 0) {
+    clearThreeObject(obj.children[0])
+    obj.remove(obj.children[0])
+  }
+  if (obj.geometry) obj.geometry.dispose()
+  if (obj.texture) obj.texture.dispose()
+
+  if (obj.material) {
+    //in case of map, bumpMap, normalMap, envMap ...
+    Object.keys(obj.material).forEach((prop) => {
+      if (!obj.material[prop]) return
+      if (
+        obj.material[prop] !== null &&
+        typeof obj.material[prop].dispose === 'function'
+      )
+        obj.material[prop].dispose()
+    })
+    obj.material.dispose()
+  }
+}

package/src/helper/{render/geometryHandler.js → geometryHandler.js}

@@ -1,5 +1,5 @@
 import * as THREE from 'three'
-import { defaultBaseHeight } from '../../config'
+import { defaultBaseHeight } from '../config'
 import earcut from 'earcut'
 import {
   verticalProjectionOnPlane,

package/src/helper/graphCreation.js

@@ -0,0 +1,43 @@
+import {Graph} from './DFS'
+import {
+    isSameSegment2D,
+  } from '@eturnity/eturnity_maths'
+export function generateGraph(polygons){
+    const edges2D=[]
+    const g=new Graph()
+    polygons
+      .filter((poly) => poly.layer=='roof')
+      .forEach((polygon,index) => {
+        g.dict.push(polygon.id)
+        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 (
+              isSameSegment2D([point, nextPoint], edge.outline)
+            )
+          })
+          if (!edge2D) {
+            //create an edge at this position
+            edge2D = {}
+            edge2D.outline=[point, nextPoint]
+            edge2D.belongsTo = []
+            edges2D.push(edge2D)
+          }
+          //add BelongToPolygon
+          edge2D.belongsTo.push({
+            polygonId: polygon.id,
+            index: i,
+            polygon
+          })
+        })
+      })
+    for(let k in edges2D){
+        let edge=edges2D[k]
+        if(edge.belongsTo.length==2){
+            g.addEdge(edge.belongsTo[0].polygonId,edge.belongsTo[1].polygonId)
+        }
+    }  
+    return g
+}