@eturnity/eturnity_maths 6.32.0 → 6.33.0-qa.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "6.32.0",
+  "version": "6.33.0-qa.0",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,

package/src/geo.js

@@ -2,8 +2,66 @@ import {
   earthRadius
 } from './config'
 
+  
+export function lon2tile(lon,zoom) { return (Math.floor((lon+180)/360*Math.pow(2,zoom))); }
+export function lat2tile(lat,zoom)  { return (Math.floor((1-Math.log(Math.tan(lat*Math.PI/180) + 1/Math.cos(lat*Math.PI/180))/Math.PI)/2 *Math.pow(2,zoom))); }
+export function tile2long(x,z) {
+    return (x/Math.pow(2,z)*360-180);
+   }
+export function tile2lat(y,z) {
+    var n=Math.PI-2*Math.PI*y/Math.pow(2,z);
+    return (180/Math.PI*Math.atan(0.5*(Math.exp(n)-Math.exp(-n))));
+   }
+export function latLngToTileXY(lat,lng,zoom){
+    const xTile = lon2tile(lng,zoom)
+    const yTile = lat2tile(lat,zoom)
+    return {
+      x:xTile,
+      y:yTile
+    }
+  }
+  
+  export function tileXYZToLatLng(x,y,zoom){
+        const longitude=tile2long(x,zoom)
+        const latitude=tile2lat(y,zoom)
+        return {lat: latitude,lng: longitude};
+    }
 
-export function distanceToDeltaLatLng(x, y, latitude) {
+  export function tileToCorners(x,y,zoom,lat,lng){
+    const tileAltitude=0
+    const tileLatLng=tileXYZToLatLng(x,y,zoom)
+    const deltaLat=tileLatLng.lat-lat
+    const deltaLng=tileLatLng.lng-lng
+    let { x:x_mm, y:y_mm }=deltaLatLngToDistance(deltaLat, deltaLng, lat)
+    let size=(earthRadius * 2000 * Math.PI / Math.pow(2.0, zoom))*Math.cos(lat*Math.PI/180)
+    let corner0={
+      x:x_mm,
+      y:y_mm,
+      z:tileAltitude
+    }
+    let corner1={
+      x:x_mm+size,
+      y:y_mm,
+      z:tileAltitude
+    }
+    let corner2={
+      x:x_mm+size,
+      y:y_mm-size,
+      z:tileAltitude
+    }
+    let corner3={
+      x:x_mm,
+      y:y_mm-size,
+      z:tileAltitude
+    }
+    return [
+      corner3,
+      corner0,
+      corner1,
+      corner2,
+    ]
+  }
+  export function distanceToDeltaLatLng(x, y, latitude) {
     //x,y,z in ENU coords
     let lat = (180 / Math.PI) * (y / 1000) / earthRadius
     let lng =((180 / Math.PI) * (x / 1000) / earthRadius)/(Math.cos(((latitude) * Math.PI) / 180))

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -21,7 +21,7 @@ export function updateComputedGeometryState(state) {
   })
   return state
 }
-export function updateOutlineFromInclineDirection(incline, direction, outline,initialAverageHeight) {
+export function updateOutlineFromInclineDirection(incline, direction, outline,initialAverageHeight,isRoofOnRoof = false) {
   const newNormalVector = {}
   newNormalVector.x =
     Math.sin((incline * Math.PI) / 180) * Math.sin((direction * Math.PI) / 180)
@@ -29,14 +29,21 @@ export function updateOutlineFromInclineDirection(incline, direction, outline,in
     Math.sin((incline * Math.PI) / 180) * Math.cos((direction * Math.PI) / 180)
   newNormalVector.z = Math.cos((incline * Math.PI) / 180)
   let meanPoint = meanVector(outline)
-  let minAltitude=Math.min(...outline.map(p=>p.z))
   meanPoint.z=initialAverageHeight
   let newOutline = outline.map((p) => {
     return verticalProjectionOnPlane(p, newNormalVector, meanPoint)
   })
   //if some points are with negative altitude, we offset the whole roof
-  const newMinAltitude = Math.min(...newOutline.map((p) => p.z))
-  let altitudeOffset=newMinAltitude-minAltitude
+  let altitudeOffset
+  let minAltitude=Math.min(...outline.map(p=>p.z))
+  let maxAltitude=Math.max(...outline.map(p=>p.z))
+  let newMinAltitude = Math.min(...newOutline.map((p) => p.z))
+  let newMaxAltitude = Math.max(...newOutline.map((p) => p.z))
+  if(isRoofOnRoof && maxAltitude!=0){
+    altitudeOffset=newMaxAltitude-maxAltitude
+  }else{
+    altitudeOffset=newMinAltitude-minAltitude
+  }
   newOutline.forEach((p) => (p.z -= altitudeOffset))
   
   //if some points are with altitude>50000, we limit those points