@eturnity/eturnity_maths 7.48.2 → 7.51.1

package/package.json

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

package/src/SHPSolver.js

@@ -0,0 +1,342 @@
+import {
+  midPoint,
+  substractVector,
+  dotProduct,
+  vectorLength,
+  normalizeVector,
+  crossProduct,
+  getDegreeVectors,
+  areAlmostCollinear,
+  isSelfIntersecting,
+  isLastPointsInOutlineAtCloseAngle,
+} from './index'
+
+class ShortestHamiltonianPathSolver {
+  constructor() {
+    this.isVerbose = false
+    this.DISTANCE_TO_VIRTUAL_NODE = 1
+  }
+  solve(
+    user_nodes,
+    {
+      maxRecursion = 100000,
+      hasVirtualNode = true,
+      proximityMatrix = null,
+      preventIntersection = false,
+    } = {}
+  ) {
+    let sortedNodes = JSON.parse(JSON.stringify(user_nodes))
+    let hasSolution = false
+    let isOptimal = false
+    let indexOrder = Array(user_nodes.length)
+      .fill()
+      .map((_, i) => i)
+    let cost = Infinity
+    if (user_nodes.length <= 2) {
+      return { sortedNodes, indexOrder, hasSolution, isOptimal, cost }
+    }
+    // Helper function to calculate distance between two points
+    let nodes = JSON.parse(JSON.stringify(user_nodes))
+    let adj = this.computeDistanceMatrix(nodes)
+    if (hasVirtualNode) {
+      nodes = [{ x: -1, y: -1, z: -1 }, ...nodes]
+      adj = this.addVirtualNodeToDistanceMatrix(adj)
+    }
+
+    if (proximityMatrix) {
+      proximityMatrix = proximityMatrix.slice()
+      if (hasVirtualNode) {
+        for (let i = 0; i < proximityMatrix.length; i++) {
+          let row = proximityMatrix[i].slice()
+          row = [1, ...row]
+          proximityMatrix[i] = row.slice()
+        }
+        proximityMatrix.unshift(Array(proximityMatrix.length + 1).fill(1))
+      }
+      for (let i = 0; i < adj.length; i++) {
+        for (let k = 0; k < adj[0].length; k++) {
+          adj[i][k] *= proximityMatrix[i][k]
+        }
+      }
+    }
+    let final_res = Infinity
+    let final_path = []
+    const resultFromSolver = this.solveFromAdjacencyMatrix(adj, {
+      nodes,
+      hasVirtualNode,
+      maxRecursion,
+      proximityMatrix,
+      preventIntersection,
+    })
+    final_path = resultFromSolver.final_path
+    final_res = resultFromSolver.final_res
+    hasSolution = resultFromSolver.hasSolution
+    isOptimal = resultFromSolver.isOptimal
+    // Remove virtual node from path and reorder panels
+    if (hasSolution) {
+      let realPath = final_path
+      while (realPath[0] !== 0) {
+        realPath.unshift(realPath.pop())
+      }
+      if (hasVirtualNode) {
+        realPath = realPath.filter((i) => i > 0)
+        realPath = realPath.map((i) => i - 1)
+        final_res -= 2 * this.DISTANCE_TO_VIRTUAL_NODE
+      }
+      const sortedNodes = realPath.map((i) => user_nodes[i])
+
+      return {
+        sortedNodes,
+        hasSolution,
+        isOptimal,
+        indexOrder: realPath,
+        cost: final_res,
+      }
+    } else {
+      return {
+        hasSolution,
+        isOptimal,
+        sortedNodes: user_nodes,
+        indexOrder: Array(user_nodes.length)
+          .fill()
+          .map((_, i) => i),
+        cost: final_res,
+      }
+    }
+  }
+  solveFromAdjacencyMatrix(
+    adj,
+    {
+      nodes,
+      hasVirtualNode = true,
+      maxRecursion = 1000,
+      proximityMatrix = null,
+      preventIntersection = false,
+    } = {}
+  ) {
+    const N = adj.length
+    let hasSolution = false
+    let isOptimal = false
+    let final_path = Array(N).fill(-1)
+    let final_res = Infinity
+    //precompute final_res
+    if (hasVirtualNode) {
+      for (let i = 1; i < N - 1; i++) {
+        final_res += adj[i][(i + 1) % N]
+      }
+      final_res += adj[1][N - 1]
+    } else {
+      for (let i = 0; i < N; i++) {
+        final_res += adj[i][(i + 1) % N]
+      }
+    }
+    // Branch and bound implementation
+    let firstMin = Array(N).fill(Number.MAX_SAFE_INTEGER)
+    let secondMin = Array(N).fill(Number.MAX_SAFE_INTEGER)
+    let thirdMin = Array(N).fill(Number.MAX_SAFE_INTEGER)
+    for (let i = 0; i < N; i++) {
+      let first_min_i = Number.MAX_SAFE_INTEGER
+      let second_min_i = Number.MAX_SAFE_INTEGER
+      let third_min_i = Number.MAX_SAFE_INTEGER
+      for (let k = 0; k < N; k++) {
+        if (i === k && adj[i][k] === 0) {
+          continue
+        }
+        if (first_min_i >= adj[i][k]) {
+          third_min_i = second_min_i
+          second_min_i = first_min_i
+          first_min_i = adj[i][k]
+        } else if (second_min_i >= adj[i][k]) {
+          third_min_i = second_min_i
+          second_min_i = adj[i][k]
+        } else if (adj[i][k] < third_min_i) {
+          third_min_i = adj[i][k]
+        }
+      }
+      firstMin[i] = first_min_i
+      secondMin[i] = second_min_i
+      thirdMin[i] = third_min_i
+    }
+    let firstMax = adj.map((row) => {
+      return Math.max(...row)
+    })
+    if (hasVirtualNode) {
+      firstMin = secondMin
+      secondMin = thirdMin
+    }
+    const branchAndBound = () => {
+      // Initialize stack for DFS with starting state
+      let stack = []
+      let curr_path = Array(N).fill(-1)
+      curr_path[0] = 0 // Start from virtual node
+
+      // Calculate initial bound
+      let curr_bound = hasVirtualNode ? -this.DISTANCE_TO_VIRTUAL_NODE : 0
+      for (let i = 0; i < N; i++) {
+        curr_bound += (firstMin[i] + secondMin[i]) / 2
+      }
+      // Initial state: [bound, weight, level, path, visited]
+      stack.push([
+        curr_bound,
+        0,
+        1,
+        [...curr_path],
+        [true, ...Array(N - 1).fill(false)],
+      ])
+
+      let recursionCount = 0
+      while (stack.length > 0 && recursionCount < maxRecursion) {
+        recursionCount++
+        // Get next state from stack
+        let [curr_bound, curr_weight, level, curr_path, curr_visited] =
+          stack.pop()
+        // If we've visited all nodes, check if this path is better than current best
+        if (level === N) {
+          let curr_res = curr_weight + adj[curr_path[level - 1]][curr_path[0]]
+          if (curr_res <= final_res) {
+            if (
+              preventIntersection &&
+              this.isPathValid(curr_path, nodes, hasVirtualNode)
+            ) {
+              continue
+            }
+            hasSolution = true
+            final_res = curr_res
+            final_path = [...curr_path]
+          }
+          continue
+        }
+
+        // Try each possible next node
+        let level_candidates = []
+        for (let i = 0; i < N; i++) {
+          // Only consider unvisited nodes that are connected
+          if (proximityMatrix) {
+            if (proximityMatrix[curr_path[level - 1]][i] === 0) {
+              continue
+            }
+          }
+          if (adj[curr_path[level - 1]][i] !== 0 && !curr_visited[i]) {
+            let new_weight = curr_weight + adj[curr_path[level - 1]][i]
+            // Update bound using same logic as before
+            let new_bound = curr_bound
+            const firstLevelToUpdateBound = hasVirtualNode ? 2 : 1
+            const maxDistanceOfFirstLevel = hasVirtualNode
+              ? firstMax[curr_path[level - 1]]
+              : 0
+            if (level === firstLevelToUpdateBound) {
+              new_bound -= (firstMin[curr_path[level - 1]] + firstMin[i]) / 2
+              new_bound += adj[curr_path[level - 1]][i]
+              new_bound -= maxDistanceOfFirstLevel
+            } else if (level > firstLevelToUpdateBound) {
+              new_bound -= (secondMin[curr_path[level - 1]] + firstMin[i]) / 2
+              new_bound += adj[curr_path[level - 1]][i]
+            }
+            // Skip this branch if bound exceeds current best solution
+            if (new_bound > final_res) {
+              continue
+            }
+            // Create new state
+            let new_path = [...curr_path]
+            new_path[level] = i
+            let new_visited = [...curr_visited]
+            new_visited[i] = true
+            if (
+              preventIntersection &&
+              this.isPathValid(
+                new_path.slice(0, level + 1),
+                nodes,
+                hasVirtualNode
+              )
+            ) {
+              continue
+            }
+
+            level_candidates.push([
+              new_bound,
+              new_weight,
+              level + 1,
+              new_path,
+              new_visited,
+            ])
+          }
+        }
+
+        // Sort candidates by bound and push to stack in reverse order
+        // This ensures we explore the most promising paths first in DFS
+        level_candidates.sort((a, b) => b[0] - a[0]) // Reverse sort for stack
+        stack.push(...level_candidates)
+      }
+
+      isOptimal = true
+    }
+    // Find best path using branch and bound
+    branchAndBound()
+
+    return { final_path, final_res, hasSolution, isOptimal }
+  }
+  isPathValid(path, nodes, hasVirtualNode) {
+    const outline = path
+      .filter((i) => {
+        return hasVirtualNode ? i > 0 : i >= 0
+      })
+      .map((i) => nodes[i])
+    if (outline.length > 3) {
+      const hasNeedleAngle = isLastPointsInOutlineAtCloseAngle(outline)
+      const selfIntersecting = isSelfIntersecting(outline, false)
+      return selfIntersecting || hasNeedleAngle
+    } else {
+      return false
+    }
+  }
+  computePathCost(path, nodes, hasVirtualNode) {
+    const distance = (p1, p2) => {
+      const v = substractVector(p2, p1)
+      let distance = vectorLength(v)
+      return Math.round(distance)
+    }
+    const outline = path
+      .filter((i) => {
+        return hasVirtualNode ? i > 0 : i >= 0
+      })
+      .map((i) => nodes[i])
+    return outline.reduce((acc, cur, index) => {
+      const nextIndex = (index + 1) % outline.length
+      return acc + distance(cur, outline[nextIndex])
+    }, 0)
+  }
+  computeDistanceMatrix(nodes) {
+    const distance = (p1, p2) => {
+      const v = substractVector(p2, p1)
+      let distance = vectorLength(v)
+      return Math.round(distance)
+    }
+
+    const N = nodes.length
+    // Build adjacency matrix with virtual node
+    let adj = Array(N)
+      .fill()
+      .map(() => Array(N).fill(0))
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++) {
+        if (i !== j) {
+          adj[i][j] = distance(nodes[i], nodes[j])
+        }
+      }
+    }
+    return adj
+  }
+  addVirtualNodeToDistanceMatrix(adj) {
+    // Add new row at beginning
+    const N = adj.length
+    adj = [Array(N).fill(this.DISTANCE_TO_VIRTUAL_NODE), ...adj.slice()]
+    // Add new column at beginning of each row
+    for (let i = 0; i < N + 1; i++) {
+      adj[i] = [this.DISTANCE_TO_VIRTUAL_NODE, ...adj[i].slice()]
+    }
+    // Set diagonal to 0
+    adj[0][0] = 0
+    return adj.slice()
+  }
+}
+export const shortestHamiltonianPathSolver = new ShortestHamiltonianPathSolver()

package/src/geometry.js

@@ -15,7 +15,20 @@ import { Line } from './objects/Line'
 import concaveman from './lib/concaveman'
 import cdt2d from 'cdt2d'
 import { isSelfIntersecting } from './intersectionPolygon'
-
+export function get3DPolylineLength(outline) {
+  return outline.reduce((acc, cur, i) => {
+    return (
+      acc + get3DDistanceBetweenPoints(cur, outline[(i + 1) % outline.length])
+    )
+  }, 0)
+}
+export function getPolylineLength(outline) {
+  return outline.reduce((acc, cur, i) => {
+    return (
+      acc + getDistanceBetweenPoints(cur, outline[(i + 1) % outline.length])
+    )
+  }, 0)
+}
 export function getConcaveOutlines(selectedPanels, onePanelOutline) {
   let buckets = groupAdjacentObjects(selectedPanels)
   const outlines = []
@@ -848,19 +861,19 @@ export function groupAdjacentObjects(objects) {
       if (visited.indexOf(currentObjectIndex) == -1) {
         //if next queued index hasn't been visited, we mark it as visited and we collect all neighbourg to queue
         visited.push(currentObjectIndex)
-        let x = objects[currentObjectIndex].index[0]
-        let y = objects[currentObjectIndex].index[1]
+        let x = objects[currentObjectIndex].row_index
+        let y = objects[currentObjectIndex].col_index
         const left = objects.findIndex(
-          (o) => o.index[0] == x - 1 && o.index[1] == y
+          (o) => o.row_index == x - 1 && o.col_index == y
         )
         const right = objects.findIndex(
-          (o) => o.index[0] == x + 1 && o.index[1] == y
+          (o) => o.row_index == x + 1 && o.col_index == y
         )
         const top = objects.findIndex(
-          (o) => o.index[0] == x && o.index[1] == y - 1
+          (o) => o.row_index == x && o.col_index == y - 1
         )
         const bottom = objects.findIndex(
-          (o) => o.index[0] == x && o.index[1] == y + 1
+          (o) => o.row_index == x && o.col_index == y + 1
         )
         if (left != -1 && visited.indexOf(left) == -1) queue.push(left)
         if (right != -1 && visited.indexOf(right) == -1) queue.push(right)
@@ -887,19 +900,19 @@ export function areAdjacent(objects) {
     if (visited.indexOf(currentObjectIndex) == -1) {
       //if next queued index hasn't been visited, we mark it as visited and we collect all neighbourg to queue
       visited.push(currentObjectIndex)
-      let x = objects[currentObjectIndex].index[0]
-      let y = objects[currentObjectIndex].index[1]
+      let x = objects[currentObjectIndex].row_index
+      let y = objects[currentObjectIndex].col_index
       const left = objects.findIndex(
-        (o) => o.index[0] == x - 1 && o.index[1] == y
+        (o) => o.row_index == x - 1 && o.col_index == y
       )
       const right = objects.findIndex(
-        (o) => o.index[0] == x + 1 && o.index[1] == y
+        (o) => o.row_index == x + 1 && o.col_index == y
       )
       const top = objects.findIndex(
-        (o) => o.index[0] == x && o.index[1] == y - 1
+        (o) => o.row_index == x && o.col_index == y - 1
       )
       const bottom = objects.findIndex(
-        (o) => o.index[0] == x && o.index[1] == y + 1
+        (o) => o.row_index == x && o.col_index == y + 1
       )
       if (left != -1 && visited.indexOf(left) == -1) queue.push(left)
       if (right != -1 && visited.indexOf(right) == -1) queue.push(right)

package/src/index.js

@@ -10,3 +10,6 @@ export * from './splitMergePolygons'
 export * from './miscellaneous'
 export * from './stats'
 export * from './spherical'
+export * from './SHPSolver'
+export * from './panelFunctions'
+export * from './stringPatchMatching'

package/src/intersectionPolygon.js

@@ -2,6 +2,8 @@ import {
   getPointInsideOutline,
   isInsidePolygon,
   isSamePoint2D,
+  isInsideEdge2D,
+  getDegree,
 } from './geometry'
 import {
   getIntersections,
@@ -85,6 +87,15 @@ export function isSelfIntersecting(outline, isClosePolygon = true) {
   }
   return isSelfIntersecting
 }
+export function isLastPointsInOutlineAtCloseAngle(outline) {
+  const length = outline.length
+  const previousIndex = (length - 1) % length
+  const previousP = outline[previousIndex]
+  const nextIndex = 0
+  const nextP = outline[nextIndex]
+  const P = outline[length - 1]
+  return getDegree(previousP, P, nextP) == 0
+}
 
 export function logicOperationOnPolygons(
   outline1,

package/src/objects/Polygon.js

@@ -38,8 +38,7 @@ export class Polygon {
     this.angleOffset = 0
     if (this.layer == 'obstacle') {
       this.isParallel = true
-    }
-    if (this.layer == 'roof') {
+    } else if (this.layer == 'roof') {
       this.moduleFields = []
     }
   }
@@ -244,7 +243,8 @@ export class Polygon {
         this.panels.forEach((p) => {
           modules.push({
             id: p.id,
-            index: p.index,
+            row_index: p.row_index,
+            col_index: p.col_index,
             outline: p.outline,
             status: p.status || 'active',
             clipped: p.clipped || false,
@@ -255,7 +255,8 @@ export class Polygon {
         this.userDeactivatedPanels.forEach((p) => {
           modules.push({
             id: p.id,
-            index: p.index,
+            row_index: p.row_index,
+            col_index: p.col_index,
             outline: p.outline,
             status: p.status || 'user_deactivated',
             clipped: p.clipped || false,
@@ -275,10 +276,12 @@ export class Polygon {
       extraSerialization.needsOptimisation = this.needsOptimisation
       extraSerialization.priority = this.priority
     } else if (this.layer == 'panel') {
-      extraSerialization.index = this.index
+      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.index = this.index
+      extraSerialization.row_index = this.row_index
+      extraSerialization.col_index = this.col_index
       extraSerialization.moduleField = { id: this.moduleField.id }
     }
     return JSON.parse(
@@ -348,7 +351,8 @@ export class Polygon {
     } else if (['panel', 'user_deactivated_panel'].includes(this.layer)) {
       return {
         id: this.id,
-        index: this.index,
+        row_index: this.row_index,
+        col_index: this.col_index,
         outline: this.outline.map((v) => [v.x, v.y, v.z]),
         moduleField: {
           id: this.moduleField.id,

package/src/objects/hydrate.js

@@ -16,10 +16,12 @@ export function hydratePolygon(serializedPolygon) {
     polygon.panels = []
     polygon.userDeactivatedPanels = []
   } else if (layer == 'panel') {
-    polygon.index = serializedPolygon.index
+    polygon.row_index = serializedPolygon.row_index
+    polygon.col_index = serializedPolygon.col_index
     polygon.moduleField = serializedPolygon.moduleField
   } else if (layer == 'user_deactivated_panel') {
-    polygon.index = serializedPolygon.index
+    polygon.row_index = serializedPolygon.row_index
+    polygon.col_index = serializedPolygon.col_index
     polygon.moduleField = serializedPolygon.moduleField
   }
   return polygon

package/src/panelFunctions.js

@@ -0,0 +1,51 @@
+export function arePanelsAdjacent(panelA, panelB) {
+  const areSameModuleField = panelA.moduleField.id == panelB.moduleField.id
+  const areVerticalyAdjacent =
+    Math.abs(panelB.index[0] - panelA.index[0]) == 1 &&
+    panelB.index[1] == panelA.index[1]
+  const areHorizontallyAdjacent =
+    Math.abs(panelB.index[1] - panelA.index[1]) == 1 &&
+    panelB.index[0] == panelA.index[0]
+  return areSameModuleField && (areVerticalyAdjacent || areHorizontallyAdjacent)
+}
+export function arePanelsTouching(panelA, panelB) {
+  const areSameModuleField = panelA.moduleField.id == panelB.moduleField.id
+  const areTouching =
+    Math.abs(panelB.index[0] - panelA.index[0]) == 1 &&
+    Math.abs(panelB.index[1] - panelA.index[1]) == 1
+  return areSameModuleField && areTouching
+}
+
+export function dividePanelsIntoAdjacentPatches(panels) {
+  const patches = []
+  const visited = new Set()
+
+  for (let i = 0; i < panels.length; i++) {
+    if (!visited.has(panels[i])) {
+      const currentPatch = []
+      const queue = [panels[i]]
+      visited.add(panels[i])
+
+      while (queue.length > 0) {
+        const currentPanel = queue.shift()
+        currentPatch.push(currentPanel)
+
+        // Check adjacent panels
+        for (let j = 0; j < panels.length; j++) {
+          const otherPanel = panels[j]
+          if (
+            !visited.has(otherPanel) &&
+            arePanelsAdjacent(currentPanel, otherPanel)
+          ) {
+            queue.push(otherPanel)
+            visited.add(otherPanel)
+          }
+        }
+      }
+
+      patches.push(currentPatch)
+    }
+  }
+
+  return patches
+}