setup simplifiedpathsolver

Author: seveibar

examples/construct-45-degree-path/construct45degreepath1.fixture.tsx

@@ -15,63 +15,9 @@ const Construct45DegreePathFixture: React.FC = () => {
   // Path colors
   const pathColors = ["#FF5733", "#33FF57", "#3357FF", "#F033FF"]
 
-  // Calculate all possible paths with one straight segment and one 45-degree segment
+  // Update paths when points change
   useEffect(() => {
-    const calculatePaths = () => {
-      const result: Array<Array<Point>> = []
-      const dx = Math.abs(pointB.x - pointA.x)
-      const dy = Math.abs(pointB.y - pointA.y)
-      const signX = pointB.x > pointA.x ? 1 : -1
-      const signY = pointB.y > pointA.y ? 1 : -1
-
-      // Path 1: Horizontal then 45 degrees
-      const midPoint1: Point = {
-        x: pointB.x - signX * Math.abs(pointB.y - pointA.y),
-        y: pointA.y,
-      }
-      // Check if midpoint is within bounds
-      if (
-        (midPoint1.x - pointA.x) * signX >= 0 &&
-        (midPoint1.x - pointB.x) * signX <= 0
-      ) {
-        result.push([pointA, midPoint1, pointB])
-      }
-
-      // Path 2: Vertical then 45 degrees
-      const midPoint2: Point = {
-        x: pointA.x,
-        y: pointB.y - signY * Math.abs(pointB.x - pointA.x),
-      }
-      // Check if midpoint is within bounds
-      if (
-        (midPoint2.y - pointA.y) * signY >= 0 &&
-        (midPoint2.y - pointB.y) * signY <= 0
-      ) {
-        result.push([pointA, midPoint2, pointB])
-      }
-
-      // // Calculate 45-degree points
-      const minDist = Math.min(dx, dy)
-
-      // // Path 3: 45 degrees then horizontal
-      const midPoint3: Point = {
-        x: pointA.x + signX * minDist,
-        y: pointA.y + signY * minDist,
-      }
-      // Check if midpoint is within bounds
-      if (
-        (midPoint3.x - pointA.x) * signX >= 0 &&
-        (midPoint3.x - pointB.x) * signX <= 0 &&
-        (midPoint3.y - pointA.y) * signY >= 0 &&
-        (midPoint3.y - pointB.y) * signY <= 0
-      ) {
-        result.push([pointA, midPoint3, pointB])
-      }
-
-      return result
-    }
-
-    setPaths(calculatePaths())
+    setPaths(calculate45DegreePaths(pointA, pointB))
   }, [pointA, pointB])
 
   const handleDragMove = (e: any, point: "A" | "B") => {

lib/solvers/SimplifiedPathSolver/SingleSimplifiedPathSolver.ts

@@ -0,0 +1,45 @@
+import { HighDensityIntraNodeRoute } from "lib/types/high-density-types"
+import { BaseSolver } from "../BaseSolver"
+import { Obstacle } from "lib/types"
+import { calculate45DegreePaths } from "lib/utils/calculate45DegreePaths"
+
+interface Point {
+  x: number
+  y: number
+  z: number
+}
+
+export class SingleSimplifiedPathSolver extends BaseSolver {
+  newRoute: HighDensityIntraNodeRoute["route"]
+  newVias: HighDensityIntraNodeRoute["vias"]
+
+  headIndex = 0
+  tailIndex = 0
+
+  constructor(
+    public inputRoute: HighDensityIntraNodeRoute,
+    public otherHdRoutes: HighDensityIntraNodeRoute[],
+    public obstacles: Obstacle[],
+  ) {
+    super()
+    this.newRoute = []
+    this.newVias = []
+  }
+
+  isValidPath(pointsInRoute: Point[]): boolean {
+    // check that the segments don't intersect with any obstacles or other
+    // routes or vias
+    // TODO
+  }
+
+  _step() {
+    // Each iteration, we're going to increase the head and make sure that
+    // there's a compatible simplified path from the tail to the head
+    // If there isn't a compatible simplified path, we add a segment to the new
+    // route from [tail, tail + (head - tail) / 2] then start our next iteration
+    // at tail = tail + Math.ceil((head - tail) / 2)
+    // If there is a Z change between the tail and the head, we stop the
+    // simplification for that segment (add to newRoute and newVias, set tail to
+    // head)
+  }
+}

lib/utils/calculate45DegreePaths.ts

@@ -0,0 +1,61 @@
+interface Point {
+  x: number
+  y: number
+}
+
+export const calculate45DegreePaths = (
+  pointA: Point,
+  pointB: Point,
+): Array<Array<Point>> => {
+  const result: Array<Array<Point>> = []
+  const dx = Math.abs(pointB.x - pointA.x)
+  const dy = Math.abs(pointB.y - pointA.y)
+  const signX = pointB.x > pointA.x ? 1 : -1
+  const signY = pointB.y > pointA.y ? 1 : -1
+
+  // Path 1: Horizontal then 45 degrees
+  const midPoint1: Point = {
+    x: pointB.x - signX * Math.abs(pointB.y - pointA.y),
+    y: pointA.y,
+  }
+  // Check if midpoint is within bounds
+  if (
+    (midPoint1.x - pointA.x) * signX >= 0 &&
+    (midPoint1.x - pointB.x) * signX <= 0
+  ) {
+    result.push([pointA, midPoint1, pointB])
+  }
+
+  // Path 2: Vertical then 45 degrees
+  const midPoint2: Point = {
+    x: pointA.x,
+    y: pointB.y - signY * Math.abs(pointB.x - pointA.x),
+  }
+  // Check if midpoint is within bounds
+  if (
+    (midPoint2.y - pointA.y) * signY >= 0 &&
+    (midPoint2.y - pointB.y) * signY <= 0
+  ) {
+    result.push([pointA, midPoint2, pointB])
+  }
+
+  // // Calculate 45-degree points
+  const minDist = Math.min(dx, dy)
+
+  // // Path 3: 45 degrees then horizontal
+  const midPoint3: Point = {
+    x: pointA.x + signX * minDist,
+    y: pointA.y + signY * minDist,
+  }
+  // Check if midpoint is within bounds
+  if (
+    (midPoint3.x - pointA.x) * signX >= 0 &&
+    (midPoint3.x - pointB.x) * signX <= 0 &&
+    (midPoint3.y - pointA.y) * signY >= 0 &&
+    (midPoint3.y - pointB.y) * signY <= 0
+  ) {
+    result.push([pointA, midPoint3, pointB])
+  }
+
+  return result
+}