@eturnity/eturnity_maths 7.51.0 → 7.51.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "7.51.0",
+  "version": "7.51.2",
   "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 = []

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/panelFunctions.js

@@ -0,0 +1,51 @@
+export function arePanelsAdjacent(panelA, panelB) {
+  const areSameModuleField = panelA.moduleField.id == panelB.moduleField.id
+  const areVerticalyAdjacent =
+    Math.abs(panelB.row_index - panelA.row_index) == 1 &&
+    panelB.col_index == panelA.col_index
+  const areHorizontallyAdjacent =
+    Math.abs(panelB.col_index - panelA.col_index) == 1 &&
+    panelB.row_index == panelA.row_index
+  return areSameModuleField && (areVerticalyAdjacent || areHorizontallyAdjacent)
+}
+export function arePanelsTouching(panelA, panelB) {
+  const areSameModuleField = panelA.moduleField.id == panelB.moduleField.id
+  const areTouching =
+    Math.abs(panelB.row_index - panelA.row_index) == 1 &&
+    Math.abs(panelB.col_index - panelA.col_index) == 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
+}

package/src/stringPatchMatching.js

@@ -0,0 +1,140 @@
+export function solveStringPatchMatching(stringList, patchList) {
+  // Problem Setup
+  const n = patchList.length // Number of rows
+  const m = stringList.length // Number of columns
+  const R = patchList.slice() // Row sum constraints
+  const C = stringList.slice() // Column sum constraints
+
+  // Initialize matrix with zeros
+  const matrix = Array.from({ length: n }, () => Array(m).fill(0))
+
+  // Function to find combinations of columns to satisfy a row sum
+  //each row represent a patch, each column represent a string
+  //we try to find matches to complete one patch with one or multiple strings
+  function findCombinationMatchesForRow(rowSum, colSums) {
+    const matches = []
+    const colsData = colSums.map((colSum, index) => {
+      return { value: colSum, index }
+    })
+    function findCombinations(
+      currentColsData,
+      currentSum,
+      target,
+      availableColsData
+    ) {
+      const stack = [
+        {
+          currentColsData,
+          currentSum,
+          availableColsData,
+          index: 0,
+        },
+      ]
+
+      let iterations = 0
+      while (stack.length > 0 && iterations < 1000 && matches.length < 5) {
+        iterations++
+        const current = stack[stack.length - 1]
+
+        if (current.currentSum === target) {
+          matches.push(current.currentColsData.map((col) => col.index))
+          stack.pop()
+          continue
+        }
+
+        if (current.availableColsData.length === 0) {
+          stack.pop()
+          continue
+        }
+
+        // Filter once per stack frame
+        if (!current.filtered) {
+          current.availableColsData = current.availableColsData.filter(
+            (colData) => colData.value <= target - current.currentSum
+          )
+          current.filtered = true
+        }
+
+        if (current.index >= current.availableColsData.length) {
+          stack.pop()
+          continue
+        }
+
+        const selectedCol = current.availableColsData[current.index]
+        current.index++
+
+        const nextColsData = current.currentColsData.concat(selectedCol)
+        const nextSum = current.currentSum + selectedCol.value
+        const nextAvailableColsData = current.availableColsData.filter(
+          (colData) => colData.index > selectedCol.index
+        )
+
+        stack.push({
+          currentColsData: nextColsData,
+          currentSum: nextSum,
+          availableColsData: nextAvailableColsData,
+          index: 0,
+        })
+      }
+    }
+    findCombinations([], 0, rowSum, colsData)
+    return matches
+  }
+
+  // Function to assign values to matrix for matched rows and columns
+  function assignCombinationPerRowMatches(matches, rowSums, colSums) {
+    matches.forEach(({ row, cols }) => {
+      if (rowSums[row] && cols.every((col) => colSums[col])) {
+        cols.forEach((col) => {
+          matrix[row][col] = colSums[col]
+          colSums[col] = null // Mark column as completed
+        })
+        rowSums[row] = null // Mark row as completed
+      }
+    })
+  }
+  // Main greedy decomposition function
+  function greedyDecomposition(rowSums, colSums) {
+    // Step 1: Try to decompose rows (patch) using column (string) combinations
+    const matches = []
+    for (let i = 0; i < rowSums.length; i++) {
+      if (rowSums[i] !== null) {
+        const colCombinations = findCombinationMatchesForRow(
+          rowSums[i],
+          colSums
+        )
+        colCombinations.forEach((cols) => {
+          matches.push({
+            row: i,
+            cols,
+          })
+        })
+      }
+    }
+    //sort the matchs by biggest string first
+    matches.sort(
+      (a, b) =>
+        Math.max(...b.cols.map((col) => colSums[col])) -
+        Math.max(...a.cols.map((col) => colSums[col]))
+    )
+    //sort the matchs by patch in descending order
+    matches.sort((a, b) => rowSums[b.row] - rowSums[a.row])
+    assignCombinationPerRowMatches(matches, rowSums, colSums)
+  }
+
+  // Run the greedy decomposition algorithm
+  greedyDecomposition(R, C)
+
+  // Output the resulting matrix
+  return {
+    matrix,
+    R,
+    C,
+    rowsWithSolution: R.map((r, index) => (r == null ? index : null)).filter(
+      (r) => r !== null
+    ),
+    colsWithSolution: C.map((c, index) => (c == null ? index : null)).filter(
+      (c) => c !== null
+    ),
+  }
+}

package/src/tests/SHPSolver/SHPSolver.spec.js

@@ -0,0 +1,71 @@
+import {
+  shortestHamiltonianPathSolver,
+  vectorLength,
+  substractVector,
+} from '../../index'
+describe('ShortestHamiltonianPathSolver', () => {
+  let solver = shortestHamiltonianPathSolver
+  it('should return empty array for empty input', () => {
+    const result = solver.solve([])
+    expect(result.indexOrder).toEqual([])
+  })
+
+  it('should handle single node input', () => {
+    const nodes = [{ x: 1, y: 1, z: 1 }]
+    const result = solver.solve(nodes)
+    expect(result.sortedNodes).toEqual(nodes)
+    expect(result.indexOrder).toEqual([0])
+  })
+
+  it('should find optimal path for two nodes', () => {
+    const nodes = [
+      { x: 0, y: 0, z: 0 },
+      { x: 1, y: 1, z: 1 },
+    ]
+    const result = solver.solve(nodes)
+    expect(result.sortedNodes).toEqual(nodes)
+    expect(result.indexOrder).toEqual([0, 1])
+  })
+
+  it('should find optimal path for square', () => {
+    const input = [
+      { x: 0, y: 0, z: 0 },
+      { x: 100, y: 100, z: 0 },
+      { x: 0, y: 100, z: 0 },
+      { x: 100, y: 0, z: 0 },
+    ]
+    solver.isVerbose = true
+    const expectedIndexOrder = []
+    const result = solver.solve(input)
+    expect(result.cost).toBe(300)
+  })
+
+  it('should find optimal path for line', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 0, y: 100, z: 0 }
+    const C = { x: 0, y: 200, z: 0 }
+    const D = { x: 0, y: 300, z: 0 }
+    const E = { x: 0, y: 400, z: 0 }
+
+    let result = solver.solve([A, B, C, D, E])
+    expect(result.cost).toBe(400)
+    result = solver.solve([E, B, C, D, A])
+    expect(result.cost).toBe(400)
+    result = solver.solve([B, C, A, E, D])
+    expect(result.cost).toBe(400)
+    result = solver.solve([E, D, C, B, A])
+    expect(result.cost).toBe(400)
+    result = solver.solve([D, E, C, A, B])
+    expect(result.cost).toBe(400)
+  })
+
+  it('should handle nodes with same coordinates', () => {
+    const nodes = [
+      { x: 1, y: 1, z: 1 },
+      { x: 1, y: 1, z: 1 },
+    ]
+    const result = solver.solve(nodes)
+    expect(result.sortedNodes.length).toBe(2)
+    expect(result.indexOrder.length).toBe(2)
+  })
+})

package/src/tests/SHPSolver/SHPSolverDebugCase.spec.js

@@ -0,0 +1,26 @@
+import { shortestHamiltonianPathSolver } from '../../index'
+import { scenario_4 } from './scenarios'
+
+describe('ShortestHamiltonianPathSolver', () => {
+  let solver = shortestHamiltonianPathSolver
+  it('should be return shortestHamiltonianPath from real scenario 3', () => {
+    // const input = scenario_4.inputData.panels.map((p) => p.center)
+    // const N = scenario_4.inputData.panels.length
+    // const initialCost = solver.computePathCost(
+    //   Array(N)
+    //     .fill()
+    //     .map((_, i) => i),
+    //   input,
+    //   false
+    // )
+    // const result = solver.solve(input, {
+    //   hasVirtualNode: true,
+    //   proximityMatrix: null,
+    //   preventIntersection: true,
+    // })
+    // const sortedNodes = result.sortedNodes
+    // const areSelfIntersect = solver.isPathValid(result.indexOrder, input, false)
+    //console.log('result', initialCost, areSelfIntersect, result)
+    //expect(areSelfIntersect).toBe(false)
+  })
+})