@eturnity/eturnity_3d 9.31.1 → 9.37.0-EXP-69.0

package/README.md

@@ -1,18 +1,19 @@
-# README #
+# README
 
-This README would normally document whatever steps are necessary to get your application up and running.
+This README would normally document whatever steps are necessary to get your
+application up and running.
 
-### Setup ###
-npm i
-npm run dev
-In order to preview, run
-nodejs server.js
-It will serve preview.html file
-### Build Image ###
+### Setup
 
-* docker build -t registry.digitalocean.com/eturnityhub/eturnity_3d_viewer:6.5.0-master-1 .
+npm i npm run dev In order to preview, run nodejs server.js It will serve
+preview.html file
 
-### Run Image on Localhost ###
+### Build Image
 
-* docker run -p 8080:8080 registry.digitalocean.com/eturnityhub/eturnity_3d_viewer:6.5.0-master-1
+- docker build -t
+  registry.digitalocean.com/eturnityhub/eturnity_3d_viewer:6.5.0-master-1 .
 
+### Run Image on Localhost
+
+- docker run -p 8080:8080
+  registry.digitalocean.com/eturnityhub/eturnity_3d_viewer:6.5.0-master-1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "9.31.1",
+  "version": "9.37.0-EXP-69.0",
   "files": [
     "dist",
     "src"
@@ -11,12 +11,13 @@
   "scripts": {
     "dev": "vite",
     "build": "vite build",
+    "test": "jest",
     "lint": "eslint --ext .js,.vue --ignore-path .gitignore --fix src`",
     "prettier": "prettier --write \"**/*.{js,vue}\"",
     "merge-remote-master": "node scripts/merge-remote-master.js"
   },
   "dependencies": {
-    "@eturnity/eturnity_maths": "9.31.0",
+    "@eturnity/eturnity_maths": "9.37.0-EXP-69.0",
     "@originjs/vite-plugin-commonjs": "1.0.3",
     "core-js": "3.30.2",
     "cors": "2.8.5",
@@ -35,14 +36,19 @@
     "vuex": "4.1.0"
   },
   "devDependencies": {
+    "@babel/core": "7.22.0",
+    "@babel/preset-env": "7.22.0",
     "@vitejs/plugin-vue": "2.0.1",
     "@vue/compiler-sfc": "3.3.4",
     "@vue/eslint-config-standard": "8.0.1",
+    "babel-jest": "29.7.0",
     "eslint": "8.0.1",
     "eslint-config-prettier": "8.8.0",
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-vue": "9.14.1",
     "html-webpack-plugin": "3.2.0",
+    "jest": "29.7.0",
+    "jest-environment-jsdom": "29.7.0",
     "prettier": "2.8.4",
     "prettier-plugin-vue": "1.1.6",
     "vite": "2.7.2",

package/src/helper/UpdateRoofModuleFieldRelations.js

@@ -120,6 +120,47 @@ export function updateModuleFieldFittingPanels(moduleField) {
   }
 }
 
+// Guarded variant of updateModuleFieldFittingPanels used by the new panel
+// placement engine: preserves the current visibility, tolerates fields without
+// panels/roof/margins, and skips the fitting_panel_area_m2 check.
+export function clipModuleFieldFittingPanels(moduleField) {
+  const prevVisible = moduleField?.fittingPanels?.visible
+  delete moduleField.fittingPanels
+  if (!moduleField?.panels?.length) return
+  if (!moduleField?.roof || !moduleField.data?.has_fitting_panels) return
+  const innerOutline = moduleField.roof.margins?.innerOutline
+  if (!innerOutline?.length) return
+
+  const outlines = getModuleFieldRoofIntersections(moduleField, innerOutline)
+  if (!outlines?.length) return
+  const holes = getModuleFieldHoleOutlines(moduleField)
+  const polygons = []
+
+  outlines.forEach((outline) => {
+    polygons.push({
+      outline,
+      // Clean up holes outside of the outline
+      holes: holes
+        .flatMap((hole) => intersectOutlines(hole, outline))
+        .filter(Boolean),
+    })
+  })
+  if (!polygons.length) return
+
+  const hasCustomTexture = !!moduleField.pvData?.texture_img_url
+  const defaultTextureIndex = moduleField.pvData?.module_texture_version_id || 0
+  const color = hasCustomTexture
+    ? moduleField.pvData?.backsheet_color
+    : defaultTextureColorMap[defaultTextureIndex]
+  const mappedColor = fittingPanelsColorMap[color || 'default']
+
+  moduleField.fittingPanels = {
+    polygons,
+    visible: prevVisible !== false,
+    color: mappedColor,
+  }
+}
+
 export function getRoofInnerMarginOutline({
   roof,
   moduleField,

package/src/helper/clipModuleFieldFittingPanels.spec.js

@@ -0,0 +1,81 @@
+import {
+  clipModuleFieldFittingPanels,
+  updateModuleFieldFittingPanels,
+} from './UpdateRoofModuleFieldRelations'
+
+function rect(x, y, width, height) {
+  return [
+    { x, y, z: 0 },
+    { x: x + width, y, z: 0 },
+    { x: x + width, y: y + height, z: 0 },
+    { x, y: y + height, z: 0 },
+  ]
+}
+
+function buildModuleField({ data = { has_fitting_panels: true } } = {}) {
+  const roof = {
+    id: 'roof-1',
+    normalVector: { x: 0, y: 0, z: 1 },
+    flatOutline: [{ x: 0, y: 0, z: 0 }],
+    margins: { innerOutline: rect(0, 0, 10000, 10000) },
+    holes: [],
+    moduleFields: [],
+  }
+  return {
+    id: 'mf-1',
+    layer: 'moduleField',
+    outline: rect(1000, 1000, 4000, 4000),
+    roof,
+    panels: [{ id: 'panel-1' }],
+    data,
+    pvData: {},
+    priority: 0,
+  }
+}
+
+describe('clipModuleFieldFittingPanels', () => {
+  test('builds fitting panels clipped to the roof inner outline', () => {
+    const moduleField = buildModuleField()
+    clipModuleFieldFittingPanels(moduleField)
+    expect(moduleField.fittingPanels).toBeDefined()
+    expect(moduleField.fittingPanels.polygons.length).toBeGreaterThan(0)
+    expect(moduleField.fittingPanels.visible).toBe(true)
+  })
+
+  test('preserves an explicitly hidden visibility across rebuilds', () => {
+    const moduleField = buildModuleField()
+    clipModuleFieldFittingPanels(moduleField)
+    moduleField.fittingPanels.visible = false
+    clipModuleFieldFittingPanels(moduleField)
+    expect(moduleField.fittingPanels.visible).toBe(false)
+  })
+
+  test('removes fitting panels for a field without panels', () => {
+    const moduleField = buildModuleField()
+    moduleField.fittingPanels = { polygons: [], visible: true }
+    moduleField.panels = []
+    clipModuleFieldFittingPanels(moduleField)
+    expect(moduleField.fittingPanels).toBeUndefined()
+  })
+
+  test('tolerates a field without roof or fitting-panel data', () => {
+    const noRoof = buildModuleField()
+    noRoof.roof = null
+    expect(() => clipModuleFieldFittingPanels(noRoof)).not.toThrow()
+    expect(noRoof.fittingPanels).toBeUndefined()
+
+    const noData = buildModuleField({ data: { has_fitting_panels: false } })
+    clipModuleFieldFittingPanels(noData)
+    expect(noData.fittingPanels).toBeUndefined()
+  })
+
+  test('does not require fitting_panel_area_m2, unlike the legacy builder', () => {
+    const clipped = buildModuleField()
+    clipModuleFieldFittingPanels(clipped)
+    expect(clipped.fittingPanels).toBeDefined()
+
+    const legacy = buildModuleField()
+    updateModuleFieldFittingPanels(legacy)
+    expect(legacy.fittingPanels).toBeUndefined()
+  })
+})

package/src/store/hydrateData.js

@@ -1,6 +1,9 @@
 //Synchronisation with BE:
 import {
-  Polygon,
+  Roof,
+  Obstacle,
+  ModuleField,
+  Panel,
   updateComputedGeometryPolygon,
   getObstacleMarginOutline,
   multiplyVector,
@@ -90,7 +93,7 @@ export async function hydratePolygons({
     const roof_outline = roofResp.roof_outline.map((p) => {
       return { x: p[0], y: p[1], z: p[2] }
     })
-    let roof = new Polygon(roof_outline, 'roof')
+    let roof = new Roof(roof_outline)
     roof.id = roofResp.roof_uuid
     roof.version = roofResp.version
     roof.name = roofResp.roof_name
@@ -116,7 +119,7 @@ export async function hydratePolygons({
     const obstacle_outline = obstacleResp.obstacle_outline.map((p) => {
       return { x: p[0], y: p[1], z: p[2] }
     })
-    let obstacle = new Polygon(obstacle_outline, 'obstacle')
+    let obstacle = new Obstacle(obstacle_outline)
     obstacle.id = obstacleResp.obstacle_uuid
     obstacle.version = obstacleResp.version
     obstacle.height = obstacleResp.obstacle_height_above_ground_mm
@@ -145,7 +148,7 @@ export async function hydratePolygons({
         return { x: p[0], y: p[1], z: p[2] }
       })
 
-    let moduleField = new Polygon(module_field_outline, 'moduleField')
+    let moduleField = new ModuleField(module_field_outline)
     moduleField.id = moduleFieldResp.module_field_uuid
     moduleField.version = moduleFieldResp.version
 
@@ -212,7 +215,7 @@ export async function hydratePolygons({
     })
 
     modules.forEach((module) => {
-      let panel = new Polygon(module.outline, '')
+      let panel = new Panel(module.outline)
       panel.id = module.module_uuid
       panel.gridIndex = module.gridIndex
       panel.row_index = module.row_index

package/src/store/hydratePolygons.spec.js

@@ -0,0 +1,111 @@
+import { hydratePolygons } from './hydrateData'
+import { Roof, Obstacle, ModuleField, Panel } from '@eturnity/eturnity_maths'
+
+const square = (size) => [
+  [0, 0, 0],
+  [size, 0, 0],
+  [size, size, 0],
+  [0, size, 0],
+]
+
+const moduleGrid = {
+  grid_origin: [0, 0, 0],
+  grid_row_vector: [1100, 0, 0],
+  grid_column_vector: [0, 1900, 0],
+  panel_height_vector: [0, 1800, 0],
+  panel_width_vector: [1000, 0, 0],
+  modules: [
+    {
+      module_uuid: 'module-active',
+      row_index: 0,
+      col_index: 0,
+      is_active: true,
+    },
+    {
+      module_uuid: 'module-inactive',
+      row_index: 0,
+      col_index: 1,
+      is_active: false,
+    },
+  ],
+}
+
+async function hydrateFixture() {
+  return hydratePolygons({
+    roofsResponse: [
+      {
+        roof_uuid: 'roof-1',
+        version: 3,
+        roof_outline: square(10000),
+        roof_margins_mm: [200, 200, 200, 200],
+        roof_slope_degrees: 0,
+        roof_orientation_degrees: 180,
+        roof_name: 'test roof',
+      },
+    ],
+    obstaclesResponse: [
+      {
+        obstacle_uuid: 'obstacle-1',
+        version: 1,
+        obstacle_outline: square(1000),
+        obstacle_margins_mm: [100, 100, 100, 100],
+        obstacle_height_above_ground_mm: 500,
+        obstacle_slope_is_parallel_to_roof: true,
+      },
+    ],
+    moduleFieldsResponse: [
+      {
+        module_field_uuid: 'mf-1',
+        version: 2,
+        module_field_outline: square(5000),
+        col_spacing_mm: 20,
+        row_spacing_mm: 20,
+        is_row_spacing_automatic: false,
+        offset_percent: 0,
+        panel_orientation: 'portrait',
+        panel_direction_degrees: 0,
+        module_grids: [moduleGrid],
+      },
+    ],
+  })
+}
+
+const byLayer = (polygons, layer) => polygons.filter((p) => p.layer == layer)
+
+describe('hydratePolygons builds typed polygon instances', () => {
+  it('hydrates roofs, obstacles and module fields to their subclasses', async () => {
+    const { polygons } = await hydrateFixture()
+    const [roof] = byLayer(polygons, 'roof')
+    const [obstacle] = byLayer(polygons, 'obstacle')
+    const [moduleField] = byLayer(polygons, 'moduleField')
+    expect(roof).toBeInstanceOf(Roof)
+    expect(obstacle).toBeInstanceOf(Obstacle)
+    expect(moduleField).toBeInstanceOf(ModuleField)
+  })
+
+  it('hydrates every grid module as a Panel, with activeness as the layer', async () => {
+    const { polygons } = await hydrateFixture()
+    const panels = byLayer(polygons, 'panel')
+    const userDeactivatedPanels = byLayer(polygons, 'user_deactivated_panel')
+    expect(panels).toHaveLength(1)
+    expect(panels[0]).toBeInstanceOf(Panel)
+    expect(panels[0].id).toBe('module-active')
+    expect(userDeactivatedPanels).toHaveLength(1)
+    expect(userDeactivatedPanels[0]).toBeInstanceOf(Panel)
+    expect(userDeactivatedPanels[0].id).toBe('module-inactive')
+  })
+
+  it('round-trips hydrated polygons through serializeForBEStorage', async () => {
+    const { polygons } = await hydrateFixture()
+    const [roof] = byLayer(polygons, 'roof')
+    const [obstacle] = byLayer(polygons, 'obstacle')
+    const roofPayload = roof.serializeForBEStorage()
+    expect(roofPayload.roof_uuid).toBe('roof-1')
+    expect(roofPayload.roof_outline).toEqual(square(10000))
+    expect(roofPayload.roof_margins_mm).toEqual([200, 200, 200, 200])
+    const obstaclePayload = obstacle.serializeForBEStorage()
+    expect(obstaclePayload.obstacle_uuid).toBe('obstacle-1')
+    expect(obstaclePayload.obstacle_height_above_ground_mm).toBe(500)
+    expect(obstaclePayload.obstacle_slope_is_parallel_to_roof).toBe(true)
+  })
+})