@eturnity/eturnity_maths 9.19.0 → 9.25.0-EPDM-19998.0

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "9.19.0",
+  "version": "9.25.0-EPDM-19998.0",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,
+  "scripts": {
+    "test": "jest",
+    "prepare": "husky",
+    "lint": "eslint --fix --debug --ext .js,.vue .",
+    "merge-remote-master": "node scripts/merge-master.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+ssh://git@bitbucket.org/eturnitydevs/eturnity_maths.git"
@@ -22,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",
@@ -34,13 +40,8 @@
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-vue": "9.14.1",
     "jest": "29.5.0",
-    "prettier": "^2.8.4",
-    "prettier-plugin-vue": "^1.1.6"
+    "prettier": "2.8.4",
+    "prettier-plugin-vue": "1.1.6"
   },
-  "description": "",
-  "scripts": {
-    "test": "jest",
-    "lint": "eslint --fix --debug --ext .js,.vue .",
-    "merge-remote-master": "node scripts/merge-master.js"
-  }
-}
+  "description": ""
+}

package/src/config.js

@@ -32,11 +32,6 @@ export const layerColors = {
     strokeColor: '#ffffff',
     strokeWidth: 1,
   },
-  user_deactivated_panel: {
-    fillColor: 'rgba(115, 115, 229, 0.1)',
-    strokeColor: 'white',
-    strokeWidth: 4,
-  },
   selectedPanel: {
     fillColor: '#0068DE80',
     strokeColor: theme.colors.blue,

package/src/geometry.js

@@ -887,6 +887,45 @@ export function verticalProjectionOnPlane(p, n, o) {
   const projectedPoint = { ...p, z: projectedHeight }
   return projectedPoint
 }
+
+// 2D convex hull (Andrew's monotone chain). Input/output: array of [x, y].
+// Returns the hull in counter-clockwise order; passes through collinear points
+// only at the endpoints. Used to grow a module-field outline so it encloses
+// newly added panels.
+export function convexHull2D(points) {
+  const pts = points
+    .map((p) => [p[0], p[1]])
+    .sort((a, b) => a[0] - b[0] || a[1] - b[1])
+  if (pts.length < 3) {
+    return pts
+  }
+  const cross = (o, a, b) =>
+    (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])
+  const lower = []
+  for (const p of pts) {
+    while (
+      lower.length >= 2 &&
+      cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0
+    ) {
+      lower.pop()
+    }
+    lower.push(p)
+  }
+  const upper = []
+  for (let i = pts.length - 1; i >= 0; i--) {
+    const p = pts[i]
+    while (
+      upper.length >= 2 &&
+      cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0
+    ) {
+      upper.pop()
+    }
+    upper.push(p)
+  }
+  lower.pop()
+  upper.pop()
+  return lower.concat(upper)
+}
 export function projectionOnPlaneFollowingVector(p, n, o, v) {
   // if p belongs to (n,o) plane return p
   const opn = dotProduct(substractVector(p, o), n)

package/src/objects/Polygon.js

@@ -50,6 +50,11 @@ export class Polygon {
       this.isParallel = true
     } else if (this.layer == 'roof') {
       this.moduleFields = []
+    } else if (['moduleField', 'tmpModuleField'].includes(this.layer)) {
+      // Transient validation state — never serialized / sent to BE.
+      this.warnings = []
+      this.hasWarnings = false
+      this.hasError = false
     }
   }
 
@@ -60,7 +65,6 @@ export class Polygon {
     })
     if (['tmpModuleField', 'moduleField'].includes(this.layer)) {
       polygon.panels = []
-      polygon.userDeactivatedPanels = []
       polygon.data?.moduleGrids?.forEach((grid) => {
         grid.project_variant_module_grid_3d_id = null
       })
@@ -394,10 +398,7 @@ export class Polygon {
       extraSerialization.needsOptimisation = this.needsOptimisation
       extraSerialization.priority = this.priority
     } else if (this.layer == 'panel') {
-      extraSerialization.row_index = this.row_index
-      extraSerialization.col_index = this.col_index
-      extraSerialization.moduleField = { id: this.moduleField.id }
-    } else if (this.layer == 'user_deactivated_panel') {
+      extraSerialization.gridIndex = this.gridIndex
       extraSerialization.row_index = this.row_index
       extraSerialization.col_index = this.col_index
       extraSerialization.moduleField = { id: this.moduleField.id }
@@ -442,9 +443,6 @@ export class Polygon {
       if (!this.panels) {
         this.panels = []
       }
-      if (!this.userDeactivatedPanels) {
-        this.userDeactivatedPanels = []
-      }
       return {
         module_field_uuid: this.id,
         roof_uuid: this.roof ? this.roof.id : null,
@@ -472,7 +470,7 @@ export class Polygon {
         yearly_yield_kwh_kwp: this.data.yearly_yield_kwh_kwp,
         yearly_yield_kwh_kwp_2: this.data.yearly_yield_kwh_kwp_2,
       }
-    } else if (['panel', 'user_deactivated_panel'].includes(this.layer)) {
+    } else if (this.layer == 'panel') {
       return {
         id: this.id,
         row_index: this.row_index,

package/src/objects/derivedState/updateComputedGeometryPolygon.js

@@ -67,7 +67,6 @@ export function updateOutlineFromInclineDirection(
 export function updateComputedGeometryPolygon(polygon) {
   if (
     ![
-      'user_deactivated_panel',
       'panel',
       'roof',
       'obstacle',

package/src/objects/hydrate.js

@@ -36,15 +36,10 @@ export function hydratePolygon(serializedPolygon) {
     polygon.pvData = serializedPolygon.pvData
     polygon.mountingData = serializedPolygon.mountingData
     polygon.panels = []
-    polygon.userDeactivatedPanels = []
   } else if (layer == 'panel') {
     polygon.row_index = serializedPolygon.row_index
     polygon.col_index = serializedPolygon.col_index
     polygon.moduleField = serializedPolygon.moduleField
-  } else if (layer == 'user_deactivated_panel') {
-    polygon.row_index = serializedPolygon.row_index
-    polygon.col_index = serializedPolygon.col_index
-    polygon.moduleField = serializedPolygon.moduleField
   } else if (layer == 'roof_plan_item') {
     polygon.shape = 'polygon'
     polygon.colorIndex = serializedPolygon.colorIndex

package/src/panelFunctions.js

@@ -1,3 +1,37 @@
+// Normalise a grid vector that may be stored as a [x,y,z] array (backend
+// format) or a {x,y,z} object.  Used internally by canonicalGridCoords.
+function _normalizeVec(v) {
+  if (Array.isArray(v)) return { x: v[0] ?? 0, y: v[1] ?? 0, z: v[2] ?? 0 }
+  return { x: v?.x ?? 0, y: v?.y ?? 0, z: v?.z ?? 0 }
+}
+
+/**
+ * Return the canonical (row, col) position of `module` in firstGrid's
+ * coordinate system.  Modules on firstGrid map 1-to-1; modules on other grids
+ * get their origin-offset projected onto firstGrid's row/column axes so that
+ * all panels of a multi-grid module field share one comparable coordinate space.
+ *
+ * Grid vectors may be stored as [x,y,z] arrays or {x,y,z} objects — both
+ * forms are normalised internally.
+ */
+export function canonicalGridCoords(module, grid, firstGrid) {
+  if (grid === firstGrid)
+    return { row: module.row_index, col: module.col_index }
+  const rowVec = _normalizeVec(firstGrid.grid_row_vector)
+  const colVec = _normalizeVec(firstGrid.grid_column_vector)
+  const rowLen2 = rowVec.x * rowVec.x + rowVec.y * rowVec.y + rowVec.z * rowVec.z
+  const colLen2 = colVec.x * colVec.x + colVec.y * colVec.y + colVec.z * colVec.z
+  const originA = _normalizeVec(grid.grid_origin)
+  const originB = _normalizeVec(firstGrid.grid_origin)
+  const dx = originA.x - originB.x
+  const dy = originA.y - originB.y
+  const dz = originA.z - originB.z
+  return {
+    row: (dx * rowVec.x + dy * rowVec.y + dz * rowVec.z) / rowLen2 + module.row_index,
+    col: (dx * colVec.x + dy * colVec.y + dz * colVec.z) / colLen2 + module.col_index,
+  }
+}
+
 export function arePanelsAdjacent(panelA, panelB) {
   const areSameModuleField = panelA.moduleField.id == panelB.moduleField.id
   const areVerticalyAdjacent =

package/src/plane.js

@@ -42,7 +42,7 @@ export function getPlaneFromPolygon(polygon) {
   const origin = pointProjectionOnPlane(
     { x: 0, y: 0, z: 0 },
     polygon.normalVector,
-    polygon.outline[0]
+    polygon.flatOutline?.[0] || polygon.outline[0]
   )
   const normalVector = polygon.normalVector
   const { edgeDirectionVector } = getLongestEdgeData(polygon.outline)
@@ -74,3 +74,17 @@ export function getPlaneFromPolygon(polygon) {
     upVector,
   })
 }
+
+export function isOnSamePlane(polygon0, polygon1) {
+  const plane0 = getPlaneFromPolygon(polygon0)
+  const plane1 = getPlaneFromPolygon(polygon1)
+  if (polygon0.outline.length < polygon1.outline.length) {
+    return (polygon0.flatOutline || polygon0.outline).every((p) =>
+      plane1.isPointOnPlane(p)
+    )
+  } else {
+    return (polygon1.flatOutline || polygon1.outline).every((p) =>
+      plane0.isPointOnPlane(p)
+    )
+  }
+}