@eturnity/eturnity_maths 9.13.0 → 9.19.0-EPDM-19634.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "9.13.0",
+  "version": "9.19.0-EPDM-19634.0",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,
@@ -28,8 +28,8 @@
     "uuid": "9.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.21.4",
-    "@babel/preset-env": "7.21.4",
+    "@babel/core": "7.22.0",
+    "@babel/preset-env": "7.22.0",
     "babel-jest": "29.5.0",
     "husky": "^9.1.5",
     "@vue/eslint-config-standard": "8.0.1",

package/src/geometry.js

@@ -897,7 +897,9 @@ export function projectionOnPlaneFollowingVector(p, n, o, v) {
   const nv = dotProduct(n, v)
   if (nv == 0) {
     console.warn('projection plane and vector are coplanar')
-    throw new Error('Cannot project: normal vector and direction vector are perpendicular')
+    throw new Error(
+      'Cannot project: normal vector and direction vector are perpendicular'
+    )
   }
   const lambda = -opn / nv
   const projectedPoint = addVector(p, multiplyVector(lambda, v))
@@ -1086,8 +1088,8 @@ export function getMarginPoint(
       dotProduct(m, m) != 0
         ? addVector(B, m)
         : dotProduct(n, n) != 0
-        ? addVector(B, n)
-        : B
+          ? addVector(B, n)
+          : B
   } else {
     const mm = dotProduct(m, m)
     const nm = dotProduct(n, m)
@@ -1289,3 +1291,26 @@ export function getIndexesOfBiggestTriangleWithTwoFixedIndexes(
   }
   return maxTriangle
 }
+
+export function getRotatedRectBounds(width, height, angleDeg) {
+  const rad = (angleDeg * Math.PI) / 180
+  const c = Math.abs(Math.cos(rad))
+  const s = Math.abs(Math.sin(rad))
+  return {
+    width: width * c + height * s,
+    height: width * s + height * c,
+  }
+}
+export function getUnrotatedSizeFromAABB(aabbWidth, aabbHeight, angleDeg) {
+  const rad = (angleDeg * Math.PI) / 180
+  const c = Math.abs(Math.cos(rad))
+  const s = Math.abs(Math.sin(rad))
+  const det = c * c - s * s
+  if (Math.abs(det) < 1e-10) {
+    const side = Math.min(aabbWidth, aabbHeight) / Math.sqrt(2)
+    return { width: side, height: side }
+  }
+  const width = (aabbWidth * c - aabbHeight * s) / det
+  const height = (aabbHeight * c - aabbWidth * s) / det
+  return { width: Math.abs(width), height: Math.abs(height) }
+}

package/src/objects/Polygon.js

@@ -404,6 +404,7 @@ export class Polygon {
     } else if (this.layer == 'roof_plan_item') {
       extraSerialization.colorIndex = this.colorIndex
       extraSerialization.hasFillColor = this.hasFillColor
+      extraSerialization.isClosed = this.isClosed
     }
     return JSON.parse(
       JSON.stringify({ ...baseSerialization, ...extraSerialization })

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -78,7 +78,11 @@ export function updateComputedGeometryPolygon(polygon) {
     return polygon
   }
   let newOutline = [...polygon.outline]
+  const isOpenRoofPlanItem =
+    polygon.layer === 'roof_plan_item' && polygon.isClosed === false
+
   if (
+    !isOpenRoofPlanItem &&
     newOutline.length > 0 &&
     isAlmostSamePoint2D(newOutline[0], newOutline[newOutline.length - 1], 10)
   ) {
@@ -90,6 +94,15 @@ export function updateComputedGeometryPolygon(polygon) {
   }
   newOutline = calculateValidOutlineFromPolygon(newOutline)
 
+  if (isOpenRoofPlanItem) {
+    if (newOutline.length < 2) {
+      throw new Error('outline not valid')
+    }
+    if (newOutline.length < 3) {
+      return updateComputedGeometryOpenRoofPlanItemPolygon(polygon, newOutline)
+    }
+  }
+
   if (newOutline.length < 3) {
     throw new Error('outline not valid')
   }
@@ -124,6 +137,9 @@ export function updateComputedGeometryPolygon(polygon) {
   polygon.direction = direction
   polygon.area = calculateArea(polygon.flatOutline) / 1000000
   polygon.isClockwise = isClockWise(polygon.outline)
+  if (polygon.layer === 'roof_plan_item' && polygon.isClosed === false) {
+    polygon.isClockwise = false
+  }
   polygon = updateMarginOutlinePolygon(polygon)
   if (polygon.layer == 'moduleField') {
     let trimedOutline = []
@@ -150,6 +166,27 @@ export function updateComputedGeometryPolygon(polygon) {
   }
   return polygon
 }
+
+function updateComputedGeometryOpenRoofPlanItemPolygon(polygon, newOutline) {
+  polygon.outline = newOutline
+  const normalVector = { x: 0, y: 0, z: 1 }
+  const meanPoint = meanVector(newOutline)
+  polygon.flatOutline = newOutline.map((p) => ({
+    x: p.x,
+    y: p.y,
+    z: Math.max(0, Math.min(50000, p.z)),
+  }))
+  polygon.maximumGap = 0
+  polygon.isFlat = true
+  polygon.normalVector = normalVector
+  polygon.meanPoint = meanPoint
+  polygon.incline = inclineWithNormalVector(normalVector)
+  polygon.direction = directionWithNormalVector(normalVector)
+  polygon.area = 0
+  polygon.isClockwise = false
+  return updateMarginOutlinePolygon(polygon)
+}
+
 export function calculateValidOutlineFromPolygon(outline) {
   //check if two nodes are same
   outline = [...outline]

package/src/objects/hydrate.js

@@ -49,6 +49,9 @@ export function hydratePolygon(serializedPolygon) {
     polygon.shape = 'polygon'
     polygon.colorIndex = serializedPolygon.colorIndex
     polygon.hasFillColor = serializedPolygon.hasFillColor
+    if (serializedPolygon.isClosed === false) {
+      polygon.isClosed = false
+    }
   }
   updateComputedGeometryPolygon(polygon)
   return polygon

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

@@ -0,0 +1,98 @@
+import { getRotatedRectBounds, getUnrotatedSizeFromAABB } from '../../index'
+
+function expectSizeClose(actual, expected, digits = 8) {
+  expect(actual.width).toBeCloseTo(expected.width, digits)
+  expect(actual.height).toBeCloseTo(expected.height, digits)
+}
+
+describe('rectangle rotation helpers', () => {
+  describe('getRotatedRectBounds', () => {
+    test('returns same size at 0° (and equivalent angles)', () => {
+      expectSizeClose(getRotatedRectBounds(120, 45, 0), {
+        width: 120,
+        height: 45,
+      })
+      expectSizeClose(getRotatedRectBounds(120, 45, -180), {
+        width: 120,
+        height: 45,
+      })
+      expectSizeClose(getRotatedRectBounds(120, 45, 180), {
+        width: 120,
+        height: 45,
+      })
+      expectSizeClose(getRotatedRectBounds(120, 45, 360), {
+        width: 120,
+        height: 45,
+      })
+    })
+
+    test('swaps width/height at 90°', () => {
+      expectSizeClose(getRotatedRectBounds(120, 45, 90), {
+        width: 45,
+        height: 120,
+      })
+      expectSizeClose(getRotatedRectBounds(120, 45, -90), {
+        width: 45,
+        height: 120,
+      })
+    })
+
+    test('matches expected formula for an arbitrary angle', () => {
+      const width = 100
+      const height = 50
+      const angleDeg = 30
+      const rad = (angleDeg * Math.PI) / 180
+      const c = Math.abs(Math.cos(rad))
+      const s = Math.abs(Math.sin(rad))
+      expectSizeClose(getRotatedRectBounds(width, height, angleDeg), {
+        width: width * c + height * s,
+        height: width * s + height * c,
+      })
+    })
+    test('match for thin rectangle for an arbitrary angle', () => {
+      const width = 100
+      const height = 0.01
+      const angleDeg = 30
+
+      expectSizeClose(
+        getRotatedRectBounds(width, height, angleDeg),
+        {
+          width: (Math.sqrt(3) * 100) / 2,
+          height: 50,
+        },
+        1
+      )
+    })
+  })
+
+  describe('getUnrotatedSizeFromAABB', () => {
+    test('approximately inverts getRotatedRectBounds (non-degenerate angle)', () => {
+      const original = { width: 123.4, height: 56.7 }
+      const angleDeg = 27
+
+      const aabb = getRotatedRectBounds(
+        original.width,
+        original.height,
+        angleDeg
+      )
+      const unrotated = getUnrotatedSizeFromAABB(
+        aabb.width,
+        aabb.height,
+        angleDeg
+      )
+
+      expectSizeClose(unrotated, original, 6)
+    })
+
+    test('handles the 45° determinant edge-case by returning a square', () => {
+      const aabbWidth = 200
+      const aabbHeight = 150
+      const angleDeg = 45
+
+      const result = getUnrotatedSizeFromAABB(aabbWidth, aabbHeight, angleDeg)
+      const side = Math.min(aabbWidth, aabbHeight) / Math.sqrt(2)
+
+      expectSizeClose(result, { width: side, height: side }, 10)
+    })
+  })
+})