@tscircuit/schematic-trace-solver 0.0.43 → 0.0.45

package/lib/solvers/TraceCleanupSolver/sub-solver/visualizeCandidates.ts

@@ -0,0 +1,33 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { Point } from "@tscircuit/math-utils"
+
+/**
+ * Visualizes a set of candidate paths and optional intersection points.
+ * It draws each candidate path as a line with a specified color and marks intersection points with green circles.
+ * This function is useful for debugging and understanding the rerouting process.
+ */
+export const visualizeCandidates = (
+  candidates: Point[][],
+  color = "gray",
+  intersectionPoints: Point[] = [],
+): GraphicsObject => {
+  const graphics: GraphicsObject = { lines: [], circles: [] }
+
+  for (const candidate of candidates) {
+    graphics.lines!.push({
+      points: candidate,
+      strokeColor: color,
+    })
+  }
+
+  // Draw intersection points
+  for (const point of intersectionPoints) {
+    graphics.circles!.push({
+      center: point,
+      radius: 0.01, // Larger radius for intersection points
+      fill: "green",
+    })
+  }
+
+  return graphics
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/visualizeCollision.ts

@@ -0,0 +1,20 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { CollisionInfo } from "./isPathColliding"
+
+/**
+ * Visualizes a collision point if collision information is provided and a collision occurred.
+ * It draws a red circle at the collision point to highlight the location of the collision.
+ */
+export const visualizeCollision = (
+  collisionInfo: CollisionInfo | null,
+): GraphicsObject => {
+  const collisionGraphics: GraphicsObject = { circles: [] }
+  if (collisionInfo?.isColliding && collisionInfo.collisionPoint) {
+    collisionGraphics.circles!.push({
+      center: collisionInfo.collisionPoint,
+      radius: 0.01,
+      fill: "red",
+    })
+  }
+  return collisionGraphics
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/visualizeIntersectionPoints.ts

@@ -0,0 +1,26 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { GraphicsObject } from "graphics-debug"
+
+/**
+ * Visualizes a set of intersection points by drawing circles at their locations.
+ * This function is used to highlight where different trace segments or obstacles intersect.
+ */
+export const visualizeIntersectionPoints = (
+  points: Point[],
+  color = "red",
+): GraphicsObject => {
+  const graphics: GraphicsObject = { circles: [] }
+
+  for (const point of points) {
+    graphics.circles!.push({
+      center: {
+        x: point.x,
+        y: point.y,
+      },
+      radius: 0.01,
+      fill: color,
+    })
+  }
+
+  return graphics
+}

package/lib/solvers/TraceCleanupSolver/sub-solver/visualizeLSapes.ts

@@ -0,0 +1,33 @@
+import type { LShape } from "./findAllLShapedTurns"
+import type { GraphicsObject } from "graphics-debug"
+
+/**
+ * Visualizes L-shaped turns by drawing a blue circle at the corner point (p2)
+ * and light blue lines connecting p1, p2, and p3.
+ * This function can visualize a single L-shape or an array of L-shapes.
+ */
+export const visualizeLSapes = (lShapes: LShape[] | LShape): GraphicsObject => {
+  const graphics: GraphicsObject = { circles: [], lines: [] }
+
+  const lShapesArray = Array.isArray(lShapes) ? lShapes : [lShapes]
+
+  for (const lShape of lShapesArray) {
+    // Draw the center point as a blue ball
+    graphics.circles!.push({
+      center: {
+        x: lShape.p2.x,
+        y: lShape.p2.y,
+      },
+      radius: 0.01,
+      fill: "blue",
+    })
+
+    // Draw the two lines in a light blue color
+    graphics.lines!.push({
+      points: [lShape.p1, lShape.p2, lShape.p3],
+      strokeColor: "lightblue",
+    })
+  }
+
+  return graphics
+}

package/lib/solvers/TraceCleanupSolver/turnMinimization.ts

@@ -4,75 +4,32 @@ import { countTurns } from "./countTurns"
 import { simplifyPath } from "./simplifyPath"
 import { tryConnectPoints } from "./tryConnectPoints"
 import { hasCollisionsWithLabels } from "./hasCollisionsWithLabels"
-
+import { recognizeStairStepPattern } from "./recognizeStairStepPattern"
+import { isSegmentAnEndpointSegment } from "./isSegmentAnEndpointSegment"
+
+/**
+ * Minimizes the number of turns in a given path while avoiding collisions with obstacles and labels.
+ * This function employs an iterative approach, attempting to simplify the path in several ways:
+ * 1. **Stair-step pattern recognition**: It first looks for and attempts to simplify stair-step patterns by connecting the start and end points of the pattern with a simpler path, if no collisions are introduced.
+ * 2. **Point removal and reconnection**: If no stair-step optimization is possible, it tries to remove intermediate points and reconnect the remaining segments with a simpler path, prioritizing solutions that reduce turns or path length.
+ * 3. **Collinear segment merging**: Finally, it attempts to merge collinear segments to further simplify the path.
+ * The process continues until no further improvements can be made without introducing collisions.
+ */
 export const minimizeTurns = ({
   path,
   obstacles,
   labelBounds,
+  originalPath,
 }: {
   path: Point[]
   obstacles: any[]
   labelBounds: any[]
+  originalPath: Point[]
 }): Point[] => {
   if (path.length <= 2) {
     return path
   }
 
-  const recognizeStairStepPattern = (
-    pathToCheck: Point[],
-    startIdx: number,
-  ): number => {
-    if (startIdx >= pathToCheck.length - 3) return -1
-
-    let endIdx = startIdx
-    let isStairStep = true
-
-    for (
-      let i = startIdx;
-      i < pathToCheck.length - 2 && i < startIdx + 10;
-      i++
-    ) {
-      if (i + 2 >= pathToCheck.length) break
-
-      const p1 = pathToCheck[i]
-      const p2 = pathToCheck[i + 1]
-      const p3 = pathToCheck[i + 2]
-
-      const seg1Vertical = p1.x === p2.x
-      const seg2Vertical = p2.x === p3.x
-
-      if (seg1Vertical === seg2Vertical) {
-        break
-      }
-
-      const seg1Direction = seg1Vertical
-        ? Math.sign(p2.y - p1.y)
-        : Math.sign(p2.x - p1.x)
-
-      if (i > startIdx) {
-        const prevP = pathToCheck[i - 1]
-        const prevSegVertical = prevP.x === p1.x
-        const prevDirection = prevSegVertical
-          ? Math.sign(p1.y - prevP.y)
-          : Math.sign(p1.x - prevP.x)
-
-        if (
-          (seg1Vertical &&
-            prevSegVertical &&
-            seg1Direction !== prevDirection) ||
-          (!seg1Vertical && !prevSegVertical && seg1Direction !== prevDirection)
-        ) {
-          isStairStep = false
-          break
-        }
-      }
-
-      endIdx = i + 2
-    }
-
-    return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1
-  }
-
   let optimizedPath = [...path]
   let currentTurns = countTurns(optimizedPath)
   let improved = true
@@ -85,6 +42,21 @@ export const minimizeTurns = ({
       const stairEndIdx = recognizeStairStepPattern(optimizedPath, startIdx)
 
       if (stairEndIdx > 0) {
+        if (
+          isSegmentAnEndpointSegment(
+            optimizedPath[startIdx],
+            optimizedPath[startIdx + 1],
+            originalPath,
+          ) ||
+          isSegmentAnEndpointSegment(
+            optimizedPath[stairEndIdx - 1],
+            optimizedPath[stairEndIdx],
+            originalPath,
+          )
+        ) {
+          continue
+        }
+
         const startPoint = optimizedPath[startIdx]
         const endPoint = optimizedPath[stairEndIdx]
 
@@ -129,6 +101,21 @@ export const minimizeTurns = ({
 
           if (endIdx >= optimizedPath.length) continue
 
+          if (
+            isSegmentAnEndpointSegment(
+              optimizedPath[startIdx],
+              optimizedPath[startIdx + 1],
+              originalPath,
+            ) ||
+            isSegmentAnEndpointSegment(
+              optimizedPath[endIdx - 1],
+              optimizedPath[endIdx],
+              originalPath,
+            )
+          ) {
+            continue
+          }
+
           const startPoint = optimizedPath[startIdx]
           const endPoint = optimizedPath[endIdx]
 
@@ -179,6 +166,13 @@ export const minimizeTurns = ({
         const p2 = optimizedPath[i + 1]
         const p3 = optimizedPath[i + 2]
 
+        if (
+          isSegmentAnEndpointSegment(p1, p2, originalPath) ||
+          isSegmentAnEndpointSegment(p2, p3, originalPath)
+        ) {
+          continue
+        }
+
         const allVertical = p1.x === p2.x && p2.x === p3.x
         const allHorizontal = p1.y === p2.y && p2.y === p3.y
 

package/lib/solvers/TraceCleanupSolver/visualizeTightRectangle.ts

@@ -0,0 +1,24 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { Rectangle } from "./sub-solver/generateRectangleCandidates"
+
+/**
+ * Visualizes a given rectangle by drawing it as a green-stroked rectangle.
+ * This function is useful for highlighting specific rectangular areas in a graphical representation.
+ */
+export const visualizeTightRectangle = (
+  rectangle: Rectangle,
+): GraphicsObject => {
+  const graphics: GraphicsObject = { rects: [] }
+
+  graphics.rects!.push({
+    center: {
+      x: rectangle.x + rectangle.width / 2,
+      y: rectangle.y + rectangle.height / 2,
+    },
+    width: rectangle.width,
+    height: rectangle.height,
+    stroke: "green",
+  })
+
+  return graphics
+}

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -42,6 +42,8 @@ export class TraceOverlapShiftSolver extends BaseSolver {
 
   correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath> = {}
 
+  cleanupPhase: "diagonals" | "done" | null = null
+
   constructor(params: {
     inputProblem: InputProblem
     inputTracePaths: Array<SolvedTracePath>
@@ -211,6 +213,62 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     return null
   }
 
+  private findNextDiagonalSegment() {
+    const EPS = 2e-3
+    for (const mspPairId in this.correctedTraceMap) {
+      const tracePath = this.correctedTraceMap[mspPairId]!.tracePath
+      for (let i = 0; i < tracePath.length - 1; i++) {
+        const p1 = tracePath[i]!
+        const p2 = tracePath[i + 1]!
+
+        const isHorizontal = Math.abs(p1.y - p2.y) < EPS
+        const isVertical = Math.abs(p1.x - p2.x) < EPS
+
+        if (!isHorizontal && !isVertical) {
+          return { mspPairId, tracePath, i, p1, p2 }
+        }
+      }
+    }
+    return null
+  }
+
+  private findAndFixNextDiagonalSegment(): boolean {
+    const diagonalInfo = this.findNextDiagonalSegment()
+
+    if (!diagonalInfo) {
+      return false // No diagonal segments found
+    }
+
+    const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo
+    const EPS = 2e-3
+
+    const p0 = i > 0 ? tracePath[i - 1] : null
+    const p3 = i + 2 < tracePath.length ? tracePath[i + 2] : null
+
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS : false
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS : false
+
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS : false
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS : false
+
+    const elbow1 = { x: p1.x, y: p2.y } // vertical from p1
+    const elbow2 = { x: p2.x, y: p1.y } // horizontal from p1
+
+    let score1 = 0
+    if (prevIsVertical) score1++
+    if (nextIsHorizontal) score1++
+
+    let score2 = 0
+    if (prevIsHorizontal) score2++
+    if (nextIsVertical) score2++
+
+    const elbowPoint = score1 < score2 ? elbow1 : elbow2
+
+    // Replace [p1, p2] with [p1, elbowPoint, p2]
+    tracePath.splice(i + 1, 0, elbowPoint)
+    return true // Fixed one diagonal, return true to re-evaluate in next step
+  }
+
   override _step() {
     if (this.activeSubSolver?.solved) {
       for (const [mspPairId, newTrace] of Object.entries(
@@ -231,6 +289,19 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     const overlapIssue = this.findNextOverlapIssue()
 
     if (overlapIssue === null) {
+      if (this.cleanupPhase === null) {
+        this.cleanupPhase = "diagonals"
+      }
+
+      if (this.cleanupPhase === "diagonals") {
+        const fixedDiagonal = this.findAndFixNextDiagonalSegment()
+        if (!fixedDiagonal) {
+          this.cleanupPhase = "done"
+          this.solved = true
+        }
+        return
+      }
+      // If cleanupPhase is "done", then the solver is truly solved.
       this.solved = true
       return
     }
@@ -249,6 +320,7 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     }
 
     const graphics = visualizeInputProblem(this.inputProblem)
+    graphics.circles = graphics.circles || []
 
     // Draw current corrected traces
     for (const trace of Object.values(this.correctedTraceMap)) {
@@ -258,6 +330,17 @@ export class TraceOverlapShiftSolver extends BaseSolver {
       })
     }
 
+    if (this.cleanupPhase === "diagonals") {
+      const diagonalInfo = this.findNextDiagonalSegment()
+      if (diagonalInfo) {
+        graphics.lines!.push({
+          points: [diagonalInfo.p1, diagonalInfo.p2],
+          strokeColor: "red",
+          strokeWidth: 0.05,
+        })
+      }
+    }
+
     return graphics
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/tests/examples/__snapshots__/example16.snap.svg

@@ -51,7 +51,7 @@ x-" data-x="1.6" data-y="1.7049999999999998" cx="353.6" cy="244.12000000000006"
     <circle data-type="point" data-label="" data-x="1.6" data-y="1.7049999999999998" cx="353.6" cy="244.12000000000006" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="1.3" data-y="1.0025" cx="320" cy="322.80000000000007" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="" data-x="1.3" data-y="0.09999999999999998" cx="320" cy="423.88000000000005" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="" data-x="0.9490000000000001" data-y="2.105" cx="280.68800000000005" cy="199.32000000000005" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
@@ -66,10 +66,10 @@ x-" data-x="1.6" data-y="1.7049999999999998" cx="353.6" cy="244.12000000000006"
     <polyline data-points="1.2000000000000002,0.30000000000000004 1.6,2.105" data-type="line" data-label="" points="308.80000000000007,401.48 353.6,199.32000000000005" fill="none" stroke="hsl(190, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
   </g>
   <g>
-    <polyline data-points="1.2000000000000002,0.09999999999999998 1.4000000000000001,0.09999999999999998 1.3,1.0025 1.3,1.5049999999999997 1.049,1.5049999999999997 1.049,1.905 1.6,1.9049999999999998" data-type="line" data-label="" points="308.80000000000007,423.88000000000005 331.20000000000005,423.88000000000005 320,322.80000000000007 320,266.5200000000001 291.88800000000003,266.5200000000001 291.88800000000003,221.72000000000003 353.6,221.72000000000006" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.2000000000000002,0.09999999999999998 1.3,0.09999999999999998 1.3,1.5049999999999997 1.049,1.5049999999999997 1.049,1.905 1.6,1.9049999999999998" data-type="line" data-label="" points="308.80000000000007,423.88000000000005 320,423.88000000000005 320,266.5200000000001 291.88800000000003,266.5200000000001 291.88800000000003,221.72000000000003 353.6,221.72000000000006" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="1.2000000000000002,0.30000000000000004 1.4000000000000001,0.30000000000000004 1.5000000000000002,1.2025000000000001 1.5000000000000002,1.4049999999999998 0.9490000000000001,1.4049999999999998 0.9490000000000001,2.105 1.6,2.105" data-type="line" data-label="" points="308.80000000000007,401.48 331.20000000000005,401.48 342.4000000000001,300.40000000000003 342.4000000000001,277.72 280.68800000000005,277.72 280.68800000000005,199.32000000000005 353.6,199.32000000000005" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="1.2000000000000002,0.30000000000000004 1.5000000000000002,0.30000000000000004 1.5000000000000002,1.4049999999999998 0.9490000000000001,1.4049999999999998 0.9490000000000001,2.105 1.6,2.105" data-type="line" data-label="" points="308.80000000000007,401.48 342.4000000000001,401.48 342.4000000000001,277.72 280.68800000000005,277.72 280.68800000000005,199.32000000000005 353.6,199.32000000000005" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
     <rect data-type="rect" data-label="schematic_component_0" data-x="0" data-y="0" x="40" y="379.08000000000004" width="268.80000000000007" height="112" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.008928571428571428" />
@@ -84,7 +84,7 @@ x-" data-x="1.6" data-y="1.7049999999999998" cx="353.6" cy="244.12000000000006"
     <rect data-type="rect" data-label="" data-x="1.374" data-y="1.7049999999999998" x="303.088" y="232.92000000000004" width="50.400000000000034" height="22.400000000000034" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008928571428571428" />
   </g>
   <g>
-    <rect data-type="rect" data-label="" data-x="1.075" data-y="1.0025" x="269.6" y="311.6" width="50.39999999999998" height="22.400000000000034" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008928571428571428" />
+    <rect data-type="rect" data-label="" data-x="1.5250000000000001" data-y="0.09999999999999998" x="320" y="412.68000000000006" width="50.40000000000009" height="22.399999999999977" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008928571428571428" />
   </g>
   <g>
     <rect data-type="rect" data-label="" data-x="0.9490000000000001" data-y="2.33" x="269.48800000000006" y="148.92000000000002" width="22.399999999999977" height="50.400000000000034" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.008928571428571428" />

package/tests/examples/__snapshots__/example29.snap.svg

@@ -534,7 +534,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <circle data-type="point" data-label="" data-x="3.5999999999999996" data-y="0.7000000000000015" cx="413.0516274346982" cy="82.94690496986073" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="-5.750000000000001" data-y="-10.1" cx="245.73764348961578" cy="276.2079773342341" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="" data-x="-5.750000000000001" data-y="-10" cx="245.73764348961578" cy="274.4185229604899" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="" data-x="-4" data-y="-11.775" cx="277.0530950301392" cy="306.1813380944494" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
@@ -543,7 +543,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <circle data-type="point" data-label="" data-x="3.5999999999999996" data-y="0.5000000000000013" cx="413.0516274346982" cy="86.52581371734914" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
   </g>
   <g>
-    <circle data-type="point" data-label="" data-x="-6.262500000000001" data-y="-12" cx="236.56668982417676" cy="310.2076104353738" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
+    <circle data-type="point" data-label="" data-x="-6.112500000000001" data-y="-12" cx="239.25087138479304" cy="310.2076104353738" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
   </g>
   <g>
     <circle data-type="point" data-label="" data-x="-4" data-y="-14.225" cx="277.0530950301392" cy="350.0229702511822" r="3" fill="hsl(80, 100%, 50%, 0.9)" />
@@ -849,7 +849,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <polyline data-points="-4.449999999999999,-10 -4,-10 -4,-10.45" data-type="line" data-label="" points="269.00055034829035,274.4185229604899 277.0530950301392,274.4185229604899 277.0530950301392,282.47106764233877" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="-5.550000000000001,-10 -5.750000000000001,-10.1 -7.075,-10.1 -7.075,-5 -8.4,-5" data-type="line" data-label="" points="249.31655223710416,274.4185229604899 245.73764348961578,276.2079773342341 222.02737303750516,276.2079773342341 222.02737303750516,184.94580427328003 198.31710258539454,184.94580427328003" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="-5.550000000000001,-10 -5.750000000000001,-10 -5.750000000000001,-9 -8.200000000000001,-9 -8.200000000000001,-5 -8.4,-5" data-type="line" data-label="" points="249.31655223710416,274.4185229604899 245.73764348961578,274.4185229604899 245.73764348961578,256.52397922304795 201.89601133288292,256.52397922304795 201.89601133288292,184.94580427328003 198.31710258539454,184.94580427328003" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
     <polyline data-points="-4,-11.55 -4,-12 -3,-12 -3,-12.45" data-type="line" data-label="" points="277.0530950301392,302.1550657535249 277.0530950301392,310.2076104353738 294.9476387675812,310.2076104353738 294.9476387675812,318.2601551172227" fill="none" stroke="purple" stroke-width="1" />
@@ -858,7 +858,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <polyline data-points="-4.449999999999999,-12 -4,-12 -4,-11.55" data-type="line" data-label="" points="269.00055034829035,310.2076104353738 277.0530950301392,310.2076104353738 277.0530950301392,302.1550657535249" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="-5.550000000000001,-12 -6.9750000000000005,-12 -6.9750000000000005,-9.2 -8.4,-9.2" data-type="line" data-label="" points="249.31655223710416,310.2076104353738 223.81682741124934,310.2076104353738 223.81682741124934,260.1028879705363 198.31710258539454,260.1028879705363" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="-5.550000000000001,-12 -6.675000000000001,-12 -6.675000000000001,-9.2 -8.4,-9.2" data-type="line" data-label="" points="249.31655223710416,310.2076104353738 229.18519053248195,310.2076104353738 229.18519053248195,260.1028879705363 198.31710258539454,260.1028879705363" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
     <polyline data-points="-4,-14.45 -4,-14 -3,-14 -3,-13.55" data-type="line" data-label="" points="277.0530950301392,354.0492425921067 277.0530950301392,345.9966979102578 294.9476387675812,345.9966979102578 294.9476387675812,337.94415322840894" fill="none" stroke="purple" stroke-width="1" />
@@ -876,7 +876,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <polyline data-points="-3,-16.45 -3,-16 -4,-16 -4,-15.55" data-type="line" data-label="" points="294.9476387675812,389.8383300669906 294.9476387675812,381.7857853851417 277.0530950301392,381.7857853851417 277.0530950301392,373.73324070329284" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
-    <polyline data-points="-5.550000000000001,-16 -6.875000000000001,-16 -6.875000000000001,-9.9 -8.200000000000001,-9.9 -8.4,-10" data-type="line" data-label="" points="249.31655223710416,381.7857853851417 225.60628178499354,381.7857853851417 225.60628178499354,272.6290685867457 201.89601133288292,272.6290685867457 198.31710258539454,274.4185229604899" fill="none" stroke="purple" stroke-width="1" />
+    <polyline data-points="-5.550000000000001,-16 -6.875000000000001,-16 -6.875000000000001,-10 -8.4,-10" data-type="line" data-label="" points="249.31655223710416,381.7857853851417 225.60628178499354,381.7857853851417 225.60628178499354,274.4185229604899 198.31710258539454,274.4185229604899" fill="none" stroke="purple" stroke-width="1" />
   </g>
   <g>
     <polyline data-points="-4,-18.45 -4,-18 -3,-18 -3,-17.55" data-type="line" data-label="" points="277.0530950301392,425.6274175418746 277.0530950301392,417.5748728600257 294.9476387675812,417.5748728600257 294.9476387675812,409.52232817817685" fill="none" stroke="purple" stroke-width="1" />
@@ -1056,7 +1056,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <rect data-type="rect" data-label="" data-x="3.3739999999999997" data-y="0.7000000000000015" x="404.9811882091119" y="81.15745059611653" width="8.052544681848872" height="3.5789087474883985" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
   </g>
   <g>
-    <rect data-type="rect" data-label="" data-x="-5.750000000000001" data-y="-9.875" x="243.94818911587157" y="268.15543265238523" width="3.5789087474883843" height="8.052544681848872" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
+    <rect data-type="rect" data-label="" data-x="-5.750000000000001" data-y="-10.225" x="243.94818911587157" y="274.4185229604899" width="3.5789087474883843" height="8.052544681848872" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
   </g>
   <g>
     <rect data-type="rect" data-label="" data-x="-3.775" data-y="-11.775" x="277.0530950301392" y="304.3918837207052" width="8.052544681848929" height="3.5789087474884127" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
@@ -1065,7 +1065,7 @@ x+" data-x="-8.4" data-y="-17" cx="198.31710258539454" cy="399.68032912258366" r
     <rect data-type="rect" data-label="" data-x="3.3739999999999997" data-y="0.5000000000000013" x="404.9811882091119" y="84.73635934360493" width="8.052544681848872" height="3.5789087474883985" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
   </g>
   <g>
-    <rect data-type="rect" data-label="" data-x="-6.262500000000001" data-y="-11.775" x="234.77723545043256" y="302.1550657535249" width="3.5789087474883843" height="8.052544681848872" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
+    <rect data-type="rect" data-label="" data-x="-6.112500000000001" data-y="-11.775" x="237.46141701104887" y="302.1550657535249" width="3.578908747488356" height="8.052544681848872" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />
   </g>
   <g>
     <rect data-type="rect" data-label="" data-x="-3.775" data-y="-14.225" x="277.0530950301392" y="348.23351587743804" width="8.052544681848929" height="3.578908747488356" fill="hsl(80, 100%, 50%, 0.35)" stroke="black" stroke-width="0.05588295598214286" />