@eturnity/eturnity_3d 0.0.4

package/src/helper/MapView.js

@@ -0,0 +1,253 @@
+import {Mesh, MeshBasicMaterial} from 'three';
+import {MapNode,LODRaycast,MapPlaneNode} from 'geo-three';
+/**
+ * Map viewer is used to read and display map tiles from a server.
+ *
+ * It was designed to work with a OpenMapTiles but can also be used with another map tiles.
+ *
+ * The map is drawn in plane map nodes using a quad tree that is subdivided as necessary to guaratee good map quality.
+ */
+export class MapView extends Mesh 
+{
+	/**
+	 * Planar map projection.
+	 */
+	PLANAR = 200;
+
+	
+	mapModes = new Map([
+		[MapView.PLANAR, MapPlaneNode]
+	]);
+
+	/**
+	 * LOD control object used to defined how tiles are loaded in and out of memory.
+	 */
+    lod = null;
+
+	/**
+	 * Map tile color layer provider.
+	 */
+	provider = null;
+
+	/**
+	 * Map height (terrain elevation) layer provider.
+	 * 
+	 * Only used for HEIGHT, HEIGHT_SHADER and MARTINI map modes.
+	 */
+	heightProvider = null;
+
+	/**
+	 * Define the type of map node in use, defined how the map is presented.
+	 *
+	 * Should only be set on creation.
+	 */
+	root = null;
+
+	/**
+	 * Indicate if the nodes should cache its children when it is simplified. Nodes that are no longer in use should be kept in memory.
+	 * 
+	 * Usefull for fast moving scenarios to prevent reparsing data in fast moving scenes.
+	 * 
+	 * Should only be used if the child generation process is time consuming. Should be kept off unless required.
+	 */
+	cacheTiles= false;
+
+	/**
+	 * Constructor for the map view objects.
+	 *
+	 * @param root - Map view node modes can be SPHERICAL, HEIGHT or PLANAR. PLANAR is used by default. Can also be a custom MapNode instance.
+	 * @param provider - Map color tile provider by default a OSM maps provider is used if none specified.
+	 * @param heightProvider - Map height tile provider, by default no height provider is used.
+	 */
+	constructor(root = MapView.PLANAR, provider = new OpenStreetMapsProvider(), heightProvider = null) 
+	{
+		super(undefined, new MeshBasicMaterial({transparent: true, opacity: 0.0}));
+		this.lod = new LODRaycast();
+		this.provider = provider;
+		this.heightProvider = heightProvider;
+		this.setRoot(root);
+		this.preSubdivide();
+	}
+
+	/**
+	 * Ajust node configuration depending on the camera distance.
+	 *
+	 * Called everytime automatically before render by the renderer.
+	 */
+	onBeforeRender=(renderer, scene, camera) => 
+	{
+		this.lod.updateLOD(this, camera, renderer, scene);
+	};
+
+	/**
+	 * Set the root of the map view.
+	 *
+	 * Is set by the constructor by default, can be changed in runtime.
+	 *
+	 * @param root - Map node to be used as root.
+	 */
+	setRoot(root)
+	{
+        console.log('root',root)
+
+		if (typeof root === 'number') 
+		{
+			const rootConstructor = MapPlaneNode//MapView.mapModes.get(root);
+            console.log('rootConstructor',rootConstructor)
+			// @ts-ignore
+			root = new rootConstructor(null, this);
+		}
+        console.log(root)
+
+		// Remove old root
+		if (!!this.root ) 
+		{
+			this.remove(this.root);
+			this.root = null;
+		}
+
+		// @ts-ignore
+		this.root = root;
+
+		// Initialize root node
+		if (!!this.root ) 
+		{
+			// @ts-ignore
+			this.geometry = this.root.constructor.baseGeometry;
+			// // @ts-ignore
+			this.scale.copy(this.root.constructor.baseScale);
+
+			 this.root.mapView = this;
+			 this.add(this.root);
+			 this.root.initialize();
+		}
+	}
+
+	/**
+	 * Pre-subdivide map tree to create nodes of levels not available in the provider.
+	 * 
+	 * Checks for the minimum zoom level in the providers attached to the map view.
+	 */
+	preSubdivide() 
+	{
+        console.log('preSbdivide')
+		const minZoom = this.provider.minZoom
+		const maxZoom = this.provider.maxZoom
+		function subdivide(node, depth) 
+		{
+			if (depth <= 0) 
+			{
+				return;
+			}
+
+
+			node.subdivide();
+
+			for (let i = 0; i < node.children.length; i++) 
+			{
+				if (node.children[i] instanceof MapNode) 
+				{
+					const child = node.children[i];
+					subdivide(child, depth - 1);
+				}
+			}
+		}
+
+		
+        console.log("minmax zoom",minZoom,maxZoom)
+		if (minZoom > 0) 
+		{  
+			subdivide(this.root, minZoom);
+		}
+	}
+
+	/**
+	 * Change the map provider of this map view.
+	 *
+	 * Will discard all the tiles already loaded using the old provider.
+	 */
+	 setProvider(provider)
+	{
+		if (provider !== this.provider) 
+		{
+			this.provider = provider;
+			this.clear();
+		}
+	}
+
+	/**
+	 * Change the map height provider of this map view.
+	 *
+	 * Will discard all the tiles already loaded using the old provider.
+	 */
+	 setHeightProvider(heightProvider)
+	{
+		if (heightProvider !== this.heightProvider) 
+		{
+			this.heightProvider = heightProvider;
+			this.clear();
+		}
+	}
+
+	/**
+	 * Clears all tiles from memory and reloads data. Used when changing the provider.
+	 *
+	 * Should be called manually if any changed to the provider are made without setting the provider.
+	 */
+	 clear()
+	{
+		this.traverse(function(children)
+		{
+			// @ts-ignore
+			if (children.childrenCache) 
+			{
+				// @ts-ignore
+				children.childrenCache = null;
+			}
+
+			// @ts-ignore
+			if (children.initialize) 
+			{
+				// @ts-ignore
+				children.initialize();
+			}
+		});
+
+		return this;
+	}
+
+	/**
+	 * Get the minimum zoom level available in the providers attached to the map view.
+	 * 
+	 * @returns Minimum zoom level available.
+	 */
+	 minZoom() 
+	{
+		return 15
+		return Math.max(this.provider.minZoom, -Infinity);
+	}
+
+	/**
+	 * Get the maximum zoom level available in the providers attached to the map view.
+	 * 
+	 * @returns Maximum zoom level available.
+	 */
+	 maxZoom() 
+	{
+		return 18
+		return Math.min(this.provider.maxZoom,  Infinity);
+	}
+
+	/**
+	 * Get map meta data from server if supported.
+	 */
+	 getMetaData()
+	{
+		this.provider.getMetaData();
+	}
+
+	 raycast(raycaster, intersects)
+	{
+		return false;
+	}
+}

package/src/helper/UpdateRoofModuleFieldRelations.js

@@ -0,0 +1,119 @@
+import {
+  isInsidePolygon,
+  verticalProjectionOnPlane,
+} from '@eturnity/eturnity_maths'
+//this function just update the "roof" and "moduleField(s)" properties of panels,moduleFields and roofs
+export function UpdateRoofModuleFieldRelations(state) {
+  const roofPolygons = state.polygons.filter((poly) => poly.layer == 'roof')
+  const moduleFieldPolygons = state.polygons.filter(
+    (poly) => poly.layer == 'moduleField'
+    )
+  const panelPolygons = state.polygons.filter((poly) =>
+    ['panel', 'user_deactivated_panel'].includes(poly.layer)
+  )
+  //let's remove all moduleFields from roofs
+  roofPolygons.forEach((roofPolygon) => {
+    //breaking circular reference for memory management
+    for (let k in roofPolygon.moduleFields) {
+      roofPolygon.moduleFields[k] = null
+    }
+    roofPolygon.moduleFields = []
+  })
+  moduleFieldPolygons.forEach((moduleFieldPolygon) => {
+    moduleFieldPolygon.roof = null
+  })
+  panelPolygons.forEach((panelPolygon) => {
+    panelPolygon.roof = null
+  })
+
+  for (let k in moduleFieldPolygons) {
+    const moduleField = moduleFieldPolygons[k]
+    //check if everypoint is in the same roof and if they are not too far from the flat surface.(at least above)
+    const roofPolygonCandidates = roofPolygons.filter((roof) =>
+      {
+        return moduleField.outline.every(p=>isInsidePolygon(p, roof.margins.innerOutline))
+      }
+    )
+    //roofs on roof can lead to multiple roof under a point. moduleField is in the smallest
+    let smallestRoof = null
+    for (let roof of roofPolygonCandidates) {
+      if (!smallestRoof || smallestRoof.area > roof.area) {
+        smallestRoof = roof
+      }
+    }
+    let roofPolygon = smallestRoof
+
+    if (!roofPolygon) {
+      //no roof found under first node of moduleField => moduleField will be deleted
+      continue
+    }
+    let moduleFieldBelongsToRoof = true
+    moduleField.outline.forEach((p) => {
+      const distanceToFlatRoof =
+        p.z -
+        verticalProjectionOnPlane(
+          p,
+          roofPolygon.normalVector,
+          roofPolygon.flatOutline[0]
+        ).z
+      if (
+        !isInsidePolygon(p, roofPolygon.margins.innerOutline) ||
+        distanceToFlatRoof < -1 ||
+        distanceToFlatRoof > 50
+      ) {
+        // one point from moduleField is not inside the roof or too far from it's flat surface => moduleField will be deleted
+        moduleFieldBelongsToRoof = false
+      }
+    })
+    if (moduleFieldBelongsToRoof) {
+      roofPolygon.moduleFields.push(moduleField)
+      moduleField.roof = roofPolygon
+      moduleField.panels.forEach((panel) => (panel.roof = roofPolygon))
+      panelPolygons.forEach((p) => {
+        if (p.moduleField.id == moduleField.id) {
+          p.roof = roofPolygon
+        }
+      })
+    }
+  }
+
+  let newPolygons = state.polygons.map((p) => {
+    if (
+      !['roof', 'moduleField', 'panel', 'user_deactivated_panel'].includes(
+        p.layer
+      )
+    )
+      return p
+    if (p.layer == 'roof') return roofPolygons.find((r) => r.id == p.id)
+    if (p.layer == 'moduleField')
+      return moduleFieldPolygons.find((mf) => mf.id == p.id)
+    if (['panel', 'user_deactivated_panel'].includes(p.layer))
+      return panelPolygons.find((panel) => panel.id == p.id)
+  })
+  state = { ...state, polygons: newPolygons }
+  state = removeModuleFieldAndPanelsOnNoOrMultipleRoofs(state)
+  return state
+}
+
+export function removeModuleFieldAndPanelsOnNoOrMultipleRoofs(state) {
+  const remainingPolygons = state.polygons.filter((polygon) =>
+    ['roof', 'obstacle'].includes(polygon.layer)
+  )
+  const remainingModuleFields = state.polygons.filter(
+    (polygon) => polygon.layer == 'moduleField' && !!polygon.roof
+  )
+  const remainingPanels = state.polygons.filter(
+    (polygon) => polygon.layer == 'panel' && !!polygon.roof
+  )
+  const remainingUserDeactivatedPanels = state.polygons.filter(
+    (polygon) => polygon.layer == 'user_deactivated_panel' && !!polygon.roof
+  )
+  
+  state.polygons = [
+    ...remainingPolygons,
+    ...remainingModuleFields,
+    ...remainingPanels,
+    ...remainingUserDeactivatedPanels
+  ]
+  return state
+}

package/src/helper/UpdateRoofObstacleRelations.js

@@ -0,0 +1,86 @@
+import {
+  verticalProjectionOnPlane,
+  calculateArea
+} from '@eturnity/eturnity_maths'
+import {
+  intersectOutlines
+} from '@eturnity/eturnity_maths'
+//this function just update the "roof" and "holes" properties of roofs and obstacles
+export function UpdateRoofObstacleRelations(state,updateVersionEnable=true) {
+  //let's remove all holes from roofs which are not obstacle then check for every obstacle and add them to roofs
+  const roofPolygons = state.polygons.filter((poly) => poly.layer == 'roof')
+  const initialRelation={}
+
+  roofPolygons.forEach((roofPolygon) => {
+    initialRelation[roofPolygon.id]=[]
+    //breaking circular reference for memory management
+    for (let k in roofPolygon.holes) {
+      initialRelation[roofPolygon.id].push(roofPolygon.holes.id)
+      roofPolygon.holes[k] = null
+    }
+    roofPolygon.holes = []
+  })
+  const holePolygons = state.polygons.filter((poly) =>
+    ['roof','obstacle'].includes(poly.layer)
+  )
+  
+  holePolygons.forEach((obstacle) => {
+    //breaking circular reference for memory management
+    for (let k in obstacle.roofs) {
+      obstacle.roofs[k] = null
+    }
+    obstacle.roofs = []
+    
+    let roofsWithObstacle=roofPolygons.filter(roof=>{
+      let intersection=intersectOutlines(obstacle.outline,roof.outline)[0]||[]
+      if(intersection.length==0)return false
+      if(obstacle.layer=='obstacle')return true
+
+      let deltaArea=calculateArea(roof.outline)-calculateArea(intersection)
+      if(deltaArea<100)return false
+      return true
+    })
+    
+    let heightReference = 0      
+      for (let roof of roofsWithObstacle) {
+        
+        heightReference = obstacle.outline.reduce((acc,cur)=>{
+          acc=Math.max(
+            acc,
+            verticalProjectionOnPlane(cur, roof.normalVector, roof.flatOutline[0])
+              .z
+          )
+          return acc
+        },0)
+        
+        if (!obstacle.roofs.map((r) => r.id).includes(roof.id) && obstacle.id!=roof.id) {
+          obstacle.roofs.push(roof)
+        }
+        if (!roof.holes.map((h) => h.id).includes(obstacle.id) && obstacle.id!=roof.id) {
+          roof.holes.push(obstacle)
+        }
+      }
+      obstacle.heightReference = heightReference
+    
+    
+  })
+
+  roofPolygons.forEach((roof)=>{
+    if(roof.holes.map(h=>h.id).sort().join()!=initialRelation[roof.id].sort().join()){
+      if(updateVersionEnable){
+        roof.version++
+      }
+    }
+  })
+
+  state = removeStandaloneObstacles(state)
+  
+  return state
+}
+
+export function removeStandaloneObstacles(state) {
+  state.polygons = state.polygons.filter(
+    (polygon) => polygon.layer != 'obstacle' || polygon.roofs.length > 0
+  )
+  return state
+}

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/customProvider.js

@@ -0,0 +1,57 @@
+import {
+  MapProvider,
+} from 'geo-three'
+import getLayers from '../utils/layers'
+export class CustomProvider extends MapProvider {
+  constructor(address, map_layer) {
+    super()
+	
+    const layer = getLayers().find((layer) => layer.key == map_layer)
+    this.layer = layer
+    // if (layer && layer.layerData && layer.layerData.options) {
+    //   this.minZoom = layer.layerData.options.minZoom || 9
+    //   this.maxZoom = layer.layerData.options.maxNativeZoom || 21
+    // } else {
+    //   this.minZoom = 9
+    //   this.maxZoom = 21
+    // }
+    this.defaultImage = document.createElement('img')
+    this.defaultImage.src=require('../assets/images/white_tile.png')
+    this.defaultImage.crossOrigin = 'Anonymous'
+    this.url = layer
+      ? layer.layerData._url
+      : 'https://a.tile.openstreetmap.org/{z}/{x}/{y}.png'
+    this.address = address
+  }
+
+  fetchTile(zoom, x, y) {
+    const minZoomLayer = this.layer.layerData.options.minZoom || 9
+    const maxZoomLayer = this.layer.layerData.options.maxNativeZoom || 20
+    return new Promise((resolve, reject) => {
+      
+      if (zoom < minZoomLayer) {
+		    resolve(this.defaultImage)
+      } else if(zoom > maxZoomLayer){
+
+      }
+      else {
+        var image = document.createElement('img')
+        image.onload = function () {
+          resolve(image)
+        }
+        image.onerror = function () {
+          resolve(this.defaultImage)
+        }
+        image.crossOrigin = 'Anonymous'
+        let imageSrc = this.url
+        imageSrc = imageSrc.replace('{x}', x)
+        imageSrc = imageSrc.replace('{y}', y)
+        imageSrc = imageSrc.replace('{z}', zoom)
+        imageSrc = imageSrc.replace('{s}', 'a')
+        imageSrc = imageSrc.replace('{format}', 'image/png')
+        imageSrc = imageSrc.replace('{tileMatrixSet}', 'PM')
+        image.src = imageSrc
+      }
+    })
+  }
+}