@eturnity/eturnity_maths 7.42.1 → 7.42.2-qa-25.0

package/package.json

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

package/src/geometry.js

@@ -77,6 +77,10 @@ export function getSnapedValue(value, snaps, tolerance) {
   )
   return closeSnapsItem.value
 }
+export function getAngleInDegFrom2DENUVector(v) {
+  const angle = Math.atan2(v.y, -v.x)
+  return ((angle * 180) / Math.PI + 90 + 360) % 360
+}
 export function getAngleInDegFromCanvasVector(v) {
   const angle = Math.atan2(v.y, v.x)
   return ((angle * 180) / Math.PI + 90 + 360) % 360

package/src/index.js

@@ -9,3 +9,4 @@ export * from './objects'
 export * from './splitMergePolygons'
 export * from './miscellaneous'
 export * from './stats'
+export * from './spherical'

package/src/objects/Polygon.js

@@ -170,20 +170,22 @@ export class Polygon {
     this.outline = this.outline.map((point) => {
       return translate2D(point, vectorInMm)
     })
-    if (this.layer == 'moduleField' && this.data && this.data.modules) {
-      this.data.modules.forEach((module) => {
-        module.outline.forEach((p) => {
-          p[0] += vectorInMm.x
-          p[1] += vectorInMm.y
-        })
+
+    if (this.layer == 'moduleField') {
+      this.trimedOutline = this.trimedOutline.map((point) => {
+        return addVector(point, vectorInMm)
       })
+    } else {
+      updateComputedGeometryPolygon(this)
     }
-    updateComputedGeometryPolygon(this)
   }
   translateOffset(newPositionOffset, center = { x: 0, y: 0 }) {
     const shift = substractVector(newPositionOffset, this.positionOffset)
     this.translate(shift)
   }
+  resetOffset() {
+    this.positionOffset = { x: 0, y: 0, z: 0 }
+  }
   serialize() {
     const baseSerialization = {
       id: this.id,

package/src/spherical.js

@@ -0,0 +1,54 @@
+import { get3DDistanceBetweenPoints, midPoint } from './geometry'
+import {
+  normalizeVector,
+  substractVector,
+  addVector,
+  multiplyVector,
+} from './vector'
+
+export function fromSphericalCoordinatesToENU(radius, altitude, azimuth) {
+  return {
+    x: -radius * Math.cos(altitude) * Math.sin(azimuth),
+    y: -radius * Math.cos(altitude) * Math.cos(azimuth),
+    z: radius * Math.sin(altitude),
+  }
+}
+export function getBoundingSphere(cloudPoint) {
+  let radius = 0
+  let center = { x: 0, y: 0, z: 0 }
+  if (cloudPoint.length == 0) {
+    return { radius, center }
+  }
+  const P0 = cloudPoint[0]
+  let vMin = { x: P0.x, y: P0.y, z: P0.z }
+  let vMax = { x: P0.x, y: P0.y, z: P0.z }
+  for (let i = 1; i < cloudPoint.length; i++) {
+    let P = cloudPoint[i]
+    vMin.x = Math.min(P.x, vMin.x)
+    vMin.y = Math.min(P.y, vMin.y)
+    vMin.z = Math.min(P.z, vMin.z)
+    vMax.x = Math.min(P.x, vMax.x)
+    vMax.y = Math.min(P.y, vMax.y)
+    vMax.z = Math.min(P.z, vMax.z)
+  }
+  center = midPoint(vMin, vMax)
+  radius = get3DDistanceBetweenPoints(vMin, vMax) / 2
+  for (let i = 0; i < cloudPoint.length; i++) {
+    let P = cloudPoint[i]
+    let distanceToCenter = get3DDistanceBetweenPoints(P, center)
+    if (distanceToCenter > radius) {
+      let difference = distanceToCenter - radius
+      radius = (radius + distanceToCenter) / 2
+      center = addVector(
+        center,
+        multiplyVector(
+          difference / 2,
+          normalizeVector(substractVector(P, center))
+        )
+      )
+
+      radius = distanceToCenter
+    }
+  }
+  return { radius, center }
+}

package/src/tests/geometry/getNormalVectortoEdgeTowardPolygon.spec.js

@@ -1,75 +1,86 @@
-import { getNormalVectortoEdgeTowardPolygon} from '../../index'
+import { getNormalVectortoEdgeTowardPolygon } from '../../index'
 
 function toBeCloseToVector(received, expected, tolerance = 0.01) {
-    
-        
-        
-            const recPoint = received
-            const expPoint = expected
+  const recPoint = received
+  const expPoint = expected
 
-            if (
-            Math.abs(recPoint.x - expPoint.x) > tolerance ||
-            Math.abs(recPoint.y - expPoint.y) > tolerance ||
-            Math.abs(recPoint.z - expPoint.z) > tolerance
-            ) {
-            return {
-                message: () =>
-                `Expected points at index ${i} to be close, but found ${JSON.stringify(recPoint)} and ${JSON.stringify(expPoint)}`,
-                pass: false,
-            };
-            }
-        
+  if (
+    Math.abs(recPoint.x - expPoint.x) > tolerance ||
+    Math.abs(recPoint.y - expPoint.y) > tolerance ||
+    Math.abs(recPoint.z - expPoint.z) > tolerance
+  ) {
+    return {
+      message: () =>
+        `Expected points to be close, but found ${JSON.stringify(
+          recPoint
+        )} and ${JSON.stringify(expPoint)}`,
+      pass: false,
+    }
+  }
 
-        return {
-            message: () => `Points are close within the given tolerance`,
-            pass: true,
-        };
-    
+  return {
+    message: () => `Points are close within the given tolerance`,
+    pass: true,
+  }
 }
 expect.extend({ toBeCloseToVector })
 
-const A = {x:0,y:0,z:0}
-const B = {x:10,y:0,z:0}
-const C = {x:10,y:10,z:0}
-const D = {x:0,y:10,z:0}
-const E = {x:5,y:5,z:0}
-const F = {x:2,y:0,z:0}
-const G = {x:3,y:-10,z:0}
-const H = {x:4,y:0,z:0}
+const A = { x: 0, y: 0, z: 0 }
+const B = { x: 10, y: 0, z: 0 }
+const C = { x: 10, y: 10, z: 0 }
+const D = { x: 0, y: 10, z: 0 }
+const E = { x: 5, y: 5, z: 0 }
+const F = { x: 2, y: 0, z: 0 }
+const G = { x: 3, y: -10, z: 0 }
+const H = { x: 4, y: 0, z: 0 }
 describe('getNormalVectortoEdgeTowardPolygon function', () => {
   test('anti-clockwise outline ABCD', () => {
-    const outline = [A,B,C,D]
-    const expectedNormalVector={x:0,y:1,z:0}
-    expect(getNormalVectortoEdgeTowardPolygon(0,outline)).toBeCloseToVector(expectedNormalVector)
+    const outline = [A, B, C, D]
+    const expectedNormalVector = { x: 0, y: 1, z: 0 }
+    expect(getNormalVectortoEdgeTowardPolygon(0, outline)).toBeCloseToVector(
+      expectedNormalVector
+    )
   })
   test('clockwise outline', () => {
-    const outline = [A,D,C,B]
-    const expectedNormalVector={x:1,y:0,z:0}
-    expect(getNormalVectortoEdgeTowardPolygon(0,outline)).toBeCloseToVector(expectedNormalVector)
+    const outline = [A, D, C, B]
+    const expectedNormalVector = { x: 1, y: 0, z: 0 }
+    expect(getNormalVectortoEdgeTowardPolygon(0, outline)).toBeCloseToVector(
+      expectedNormalVector
+    )
   })
   test('anti clockwise concave outline', () => {
-    const outline = [A,E,D,C,B]
-    const expectedNormalVector={x:0,y:-1,z:0}
-    expect(getNormalVectortoEdgeTowardPolygon(2,outline)).toBeCloseToVector(expectedNormalVector)
+    const outline = [A, E, D, C, B]
+    const expectedNormalVector = { x: 0, y: -1, z: 0 }
+    expect(getNormalVectortoEdgeTowardPolygon(2, outline)).toBeCloseToVector(
+      expectedNormalVector
+    )
   })
   test('clockwise concave outline', () => {
-    const outline = [A,E,B,C,D]
-    const expectedNormalVector={x:-1,y:0,z:0}
-    expect(getNormalVectortoEdgeTowardPolygon(2,outline)).toBeCloseToVector(expectedNormalVector)
+    const outline = [A, E, B, C, D]
+    const expectedNormalVector = { x: -1, y: 0, z: 0 }
+    expect(getNormalVectortoEdgeTowardPolygon(2, outline)).toBeCloseToVector(
+      expectedNormalVector
+    )
   })
   test('anti-clockwise concave outline', () => {
-    const outline = [A,E,B,C,D]
-    const expectedNormalVector={x:-1,y:0,z:0}
-    expect(getNormalVectortoEdgeTowardPolygon(2,outline)).toBeCloseToVector(expectedNormalVector)
+    const outline = [A, E, B, C, D]
+    const expectedNormalVector = { x: -1, y: 0, z: 0 }
+    expect(getNormalVectortoEdgeTowardPolygon(2, outline)).toBeCloseToVector(
+      expectedNormalVector
+    )
   })
   test('clockwise concave outline', () => {
-    const outline = [A,E,B,C,D]
-    const expectedNormalVector={x:1,y:0,z:0}
-    expect(getNormalVectortoEdgeTowardPolygon(4,outline)).toBeCloseToVector(expectedNormalVector)
+    const outline = [A, E, B, C, D]
+    const expectedNormalVector = { x: 1, y: 0, z: 0 }
+    expect(getNormalVectortoEdgeTowardPolygon(4, outline)).toBeCloseToVector(
+      expectedNormalVector
+    )
   })
   test('anti-clockwise concave on first outline', () => {
-    const outline = [A,F,G,B,C,D]
-    const expectedNormalVector={x:0,y:1,z:0}
-    expect(getNormalVectortoEdgeTowardPolygon(0,outline)).toBeCloseToVector(expectedNormalVector)
+    const outline = [A, F, G, B, C, D]
+    const expectedNormalVector = { x: 0, y: 1, z: 0 }
+    expect(getNormalVectortoEdgeTowardPolygon(0, outline)).toBeCloseToVector(
+      expectedNormalVector
+    )
   })
-});
+})

package/src/tests/spherical/fromSphericalCoordinatesToENU.spec.js

@@ -0,0 +1,62 @@
+import { fromSphericalCoordinatesToENU } from '../../index'
+function toBeCloseToVector(received, expected, tolerance = 0.01) {
+  const recPoint = received
+  const expPoint = expected
+
+  if (
+    Math.abs(recPoint.x - expPoint.x) > tolerance ||
+    Math.abs(recPoint.y - expPoint.y) > tolerance ||
+    Math.abs(recPoint.z - expPoint.z) > tolerance
+  ) {
+    return {
+      message: () =>
+        `Expected points to be close, but found ${JSON.stringify(
+          recPoint
+        )} and ${JSON.stringify(expPoint)}`,
+      pass: false,
+    }
+  }
+
+  return {
+    message: () => `Points are close within the given tolerance`,
+    pass: true,
+  }
+}
+expect.extend({ toBeCloseToVector })
+describe('fromSphericalCoordinatesToENU function', () => {
+  test('rising on east', () => {
+    let radius = 100
+    let altitude = 0
+    let azimuth = (-90 * Math.PI) / 180
+
+    expect(
+      fromSphericalCoordinatesToENU(radius, altitude, azimuth)
+    ).toBeCloseToVector({ x: 100, y: 0, z: 0 })
+  })
+  test('setting on west', () => {
+    let radius = 100
+    let altitude = 0
+    let azimuth = (90 * Math.PI) / 180
+
+    expect(
+      fromSphericalCoordinatesToENU(radius, altitude, azimuth)
+    ).toBeCloseToVector({ x: -100, y: 0, z: 0 })
+  })
+  test('high noon', () => {
+    let radius = 100
+    let altitude = (90 * Math.PI) / 180
+    let azimuth = 0
+    expect(
+      fromSphericalCoordinatesToENU(radius, altitude, azimuth)
+    ).toBeCloseToVector({ x: 0, y: 0, z: 100 })
+  })
+  test('winter noon', () => {
+    let radius = 100
+    let altitude = (45 * Math.PI) / 180
+    let azimuth = 0
+
+    expect(
+      fromSphericalCoordinatesToENU(radius, altitude, azimuth)
+    ).toBeCloseToVector({ x: 0, y: -70.71, z: 70.71 })
+  })
+})