wip

Author: seveibar

lib/solvers/HighDensityRepairSolver/HighDensityRepairSolver.ts

@@ -20,6 +20,107 @@ export interface HighDensityRepairSolverParams {
   connMap: ConnectivityMap
 }
 
+export const SINGLE_NODE_REPAIR_ADJACENT_OBSTACLE_MARGIN_MM = 0.1
+
+export const createNodeHdRoutesByNodeId = (
+  hdRoutes: HighDensityIntraNodeRoute[],
+): Map<string, HighDensityIntraNodeRoute[]> => {
+  const nodeHdRoutesByNodeId = new Map<string, HighDensityIntraNodeRoute[]>()
+
+  for (const hdRoute of hdRoutes) {
+    const nodeRoutes =
+      nodeHdRoutesByNodeId.get(hdRoute.capacityMeshNodeId) ?? []
+    nodeRoutes.push(hdRoute)
+    nodeHdRoutesByNodeId.set(hdRoute.capacityMeshNodeId, nodeRoutes)
+  }
+
+  return nodeHdRoutesByNodeId
+}
+
+const getObstacleBounds = (obstacle: Obstacle) => ({
+  minX: obstacle.center.x - obstacle.width / 2,
+  minY: obstacle.center.y - obstacle.height / 2,
+  maxX: obstacle.center.x + obstacle.width / 2,
+  maxY: obstacle.center.y + obstacle.height / 2,
+})
+
+const getRectDistance = (
+  a: { minX: number; minY: number; maxX: number; maxY: number },
+  b: { minX: number; minY: number; maxX: number; maxY: number },
+) => {
+  const dx = Math.max(a.minX - b.maxX, b.minX - a.maxX, 0)
+  const dy = Math.max(a.minY - b.maxY, b.minY - a.maxY, 0)
+  return Math.hypot(dx, dy)
+}
+
+export const getAdjacentObstaclesForNode = (
+  nodeWithPortPoints: NodeWithPortPoints,
+  obstacleIndex: ObstacleSpatialHashIndex,
+  adjacentObstacleMarginMm: number = SINGLE_NODE_REPAIR_ADJACENT_OBSTACLE_MARGIN_MM,
+): Obstacle[] => {
+  const bounds = getBoundsFromNodeWithPortPoints(nodeWithPortPoints)
+  const candidates = obstacleIndex.search({
+    minX: bounds.minX - adjacentObstacleMarginMm,
+    minY: bounds.minY - adjacentObstacleMarginMm,
+    maxX: bounds.maxX + adjacentObstacleMarginMm,
+    maxY: bounds.maxY + adjacentObstacleMarginMm,
+  })
+
+  return candidates.filter((obstacle) => {
+    const obstacleBounds = getObstacleBounds(obstacle)
+    return getRectDistance(bounds, obstacleBounds) <= adjacentObstacleMarginMm
+  })
+}
+
+export const createSingleNodeHighDensityRepairParams = ({
+  nodeWithPortPoints,
+  obstacleIndex,
+  nodeHdRoutesByNodeId,
+  connMap,
+  adjacentObstacleMarginMm = SINGLE_NODE_REPAIR_ADJACENT_OBSTACLE_MARGIN_MM,
+}: {
+  nodeWithPortPoints: NodeWithPortPoints
+  obstacleIndex: ObstacleSpatialHashIndex
+  nodeHdRoutesByNodeId: Map<string, HighDensityIntraNodeRoute[]>
+  connMap: ConnectivityMap
+  adjacentObstacleMarginMm?: number
+}): SingleNodeHighDensityRepairParams => {
+  return {
+    nodeWithPortPoints,
+    adjacentObstacles: getAdjacentObstaclesForNode(
+      nodeWithPortPoints,
+      obstacleIndex,
+      adjacentObstacleMarginMm,
+    ),
+    nodeHdRoutes:
+      nodeHdRoutesByNodeId.get(nodeWithPortPoints.capacityMeshNodeId) ?? [],
+    connMap,
+  }
+}
+
+export const createSingleNodeHighDensityRepairParamsList = ({
+  nodePortPoints,
+  obstacles,
+  hdRoutes,
+  connMap,
+  adjacentObstacleMarginMm = SINGLE_NODE_REPAIR_ADJACENT_OBSTACLE_MARGIN_MM,
+}: HighDensityRepairSolverParams & {
+  adjacentObstacleMarginMm?: number
+}): SingleNodeHighDensityRepairParams[] => {
+  const obstacleIndex = new ObstacleSpatialHashIndex("flatbush", obstacles)
+  const nodeHdRoutesByNodeId = createNodeHdRoutesByNodeId(hdRoutes)
+
+  return nodePortPoints.map((nodeWithPortPoints) =>
+    createSingleNodeHighDensityRepairParams({
+      nodeWithPortPoints,
+      obstacleIndex,
+      nodeHdRoutesByNodeId,
+      connMap,
+      adjacentObstacleMarginMm,
+    }),
+  )
+}
+
 export class HighDensityRepairSolver extends BaseSolver {
   override getSolverName(): string {
     return "HighDensityRepairSolver"
@@ -39,15 +140,8 @@ export class HighDensityRepairSolver extends BaseSolver {
       "flatbush",
       params.obstacles,
     )
-    this.nodeHdRoutesByNodeId = new Map()
+    this.nodeHdRoutesByNodeId = createNodeHdRoutesByNodeId(params.hdRoutes)
     this.MAX_ITERATIONS = Math.max(1000, this.unprocessedNodes.length * 4)
-
-    for (const hdRoute of params.hdRoutes) {
-      const nodeRoutes =
-        this.nodeHdRoutesByNodeId.get(hdRoute.capacityMeshNodeId) ?? []
-      nodeRoutes.push(hdRoute)
-      this.nodeHdRoutesByNodeId.set(hdRoute.capacityMeshNodeId, nodeRoutes)
-    }
   }
 
   getConstructorParams(): [HighDensityRepairSolverParams] {
@@ -57,15 +151,12 @@ export class HighDensityRepairSolver extends BaseSolver {
   private getSingleNodeParams(
     nodeWithPortPoints: NodeWithPortPoints,
   ): SingleNodeHighDensityRepairParams {
-    const bounds = getBoundsFromNodeWithPortPoints(nodeWithPortPoints)
-    return {
+    return createSingleNodeHighDensityRepairParams({
       nodeWithPortPoints,
-      adjacentObstacles: this.obstacleIndex.search(bounds),
-      nodeHdRoutes:
-        this.nodeHdRoutesByNodeId.get(nodeWithPortPoints.capacityMeshNodeId) ??
-        [],
+      obstacleIndex: this.obstacleIndex,
+      nodeHdRoutesByNodeId: this.nodeHdRoutesByNodeId,
       connMap: this.params.connMap,
-    }
+    })
   }
 
   _step() {