clean up

CAD/.gitignore

@@ -0,0 +1 @@
+*.FCBak

Flow_Controller.kicad_sch

@@ -4824,7 +4824,7 @@
 				)
 			)
 		)
-		(property "Footprint" "Connector_JST:JST_XH_B3B-XH-A_1x03_P2.50mm_Vertical"
+		(property "Footprint" "Connector_JST:JST_XH_S3B-XH-A_1x03_P2.50mm_Horizontal"
 			(at 44.45 49.53 0)
 			(effects
 				(font

Readme.md

@@ -6,6 +6,10 @@ A fail-safe water flow monitoring module designed to protect CNC spindles and la
 
 ![Front](images/Flow_Controller_front.png)
 ![Back](images/Flow_Controller_back.png)
+![Panel](images/Flow_Controller_Panel.png)
+
+![Case](CAD/Case.png)
+![Case_exploded](CAD/Case_exploded.png)
 
 ![ZJ-S401](images/Sensor_ZJ-S401.png)
 
@@ -31,7 +35,9 @@ A fail-safe water flow monitoring module designed to protect CNC spindles and la
 * **Output:** 3-pin CNC interface (+24V, GND, ALARM_CNC). Connects directly to standard CNC active-low sinking inputs.
 
 ## Panel Design and GCode
-The [scripts](scripts) folder contains a guide to panelize the board (`Flow_Controller_Panel.kicad_pcb`) and howto generate gcode.
+The [../kicad2panel](../kicad2panel) folder contains a guide to panelize the board.
+The [../kicad2msla](../kicad2msla) folder contains a guide to use the MSLA for UV exposure.
+The [../kicad2gcode](../kicad2gcode) folder contains a guide to generate G-code to use CNC for drilling and cutting (optionally also for the isolation trace routing).
 
 ## Microcontroller Pin Mapping (Per Schematic)
 | Pin | Schematic Net | Function | MCU Port (SOP8) |

scripts/.gitignore

@@ -1,4 +0,0 @@
-__pycache__/
-panel/
-gerbers/
-gcode/

scripts/Readme.md

@@ -1,77 +0,0 @@
-![Panel](../images/Flow_Controller_Panel.png)
-
-# Install kikit
-Install `kikit`:
-```bash
-pipx install --system-site-packages kikit
-```
-
-# KiKit Fixture Processor
-Processing script for KiKit panelizes PCBs and draws a fixture sketch and positions the whole panel for easy CNC processing.
-
-The script:
-
-- Draws fixture reference geometry
-- Centres the finished panel inside a predefined fixture frame
-- Adds mechanical alignment pin holes
-- Moves the finished panel to the origin `(0, 0)`
-
-The resulting output is intended for repeatable CNC manufacturing workflows
-where drilling, routing, and UV exposure all share the same physical fixture
-and alignment holes.
-
-Check the kikit panelization [examples](https://yaqwsx.github.io/KiKit/latest/panelization/examples/).
-
----
-
-# Usage
-
-```bash
-# Panelize the PCB using the preset defined in `myPreset.json`.
-kikit panelize \
-    -p myPreset.json \
-    ../Flow_Controller.kicad_pcb \
-    panel/Flow_Controller_Panel.kicad_pcb
-```
-
-The new `panel/Flow_Controller_Panel.kicad_pcb` file will contain the panelized PCB with the following feature specified in `myPreset.json`. E.g.: Grid of 1 x 2 with space 2.1 mm, new mounting holes and fiducials.
-
-```json
-    "layout": {
-        "type": "grid",
-        "rows": 1,
-        "cols": 2,
-        "hspace": "2.1mm",
-        "vspace": "2.1mm"
-    }
-```
-See all values in [default.json](https://raw.githubusercontent.com/yaqwsx/KiKit/refs/heads/master/kikit/resources/panelizePresets/default.json)
-## Exporting gcode files from KiCad
-
-Adapt milling and drilling parameters in `millproject`. Look up [pcb2gcode/wiki](https://github.com/pcb2gcode/pcb2gcode/wiki) for help.
-```bash
-nano millproject
-```
-*Make sure to set `mirror-axis` in the `millproject` to half of your board width!!!*
-
-Run the export by providing the `.kicad_pcb` file as a first argument:
-
-```bash
-./export.sh panel/Flow_Controller_Panel.kicad_pcb
-```
-The script will first generate gerber files in the `gerbers` directory and then generate gcode files in the `gcode` directory.
-
-Launch the `gSender` program.
-*   Load the `gcode/drill.ngc` file for drilling holes.
-*   Load the `gcode/outline.ngc` file for milling the board outlines.
-*   Load the `gcode/back.ngc` file if you want to mill the isolation traces.
-*   Load the `gcode/front.ngc` file if you want to mill the isolation traces.
-
-## Milling tip: Increase the thermal spoke and trace width
-When routing for milling, use the widest traces possible. 1mm, 2mm and wider, the machine doesn't care, but later you won't be soldering leads to small fragile strips of copper. You can use copper pours for routing too.
-
-Set up the entire back side as one big GND pour. Then, increase the thermal spoke width to be larger than 1mm. This avoids small features and gives more room for error if a larger drill is used for the holes.
-
-![Thermal spoke width](../images/spoke_width.png)
-
-

scripts/cleanup.py

@@ -1,96 +0,0 @@
-import pcbnew
-from shapely.geometry import MultiPolygon, Polygon
-
-# ---------------------------------------------------------------------------
-# KiKit postprocess hook – cleanup.py
-#
-# 1. Copy all Edge.Cuts content (substrate rings) to Eco1_User as segments,
-#    EXCEPT the outermost panel rectangle.
-# ---------------------------------------------------------------------------
-
-TOLERANCE_NM = 1_000   # 1 µm
-
-
-def _mm(nm_val):
-    return f"{pcbnew.ToMM(int(nm_val)):.4f} mm"
-
-
-def _collect_rings(geom):
-    """Return all rings as list of (shapely_ring, coord_list)."""
-    rings = []
-    if isinstance(geom, Polygon):
-        rings.append((geom.exterior, list(geom.exterior.coords)))
-        for interior in geom.interiors:
-            rings.append((interior, list(interior.coords)))
-    elif isinstance(geom, MultiPolygon):
-        for poly in geom.geoms:
-            rings.extend(_collect_rings(poly))
-    return rings
-
-
-def _is_outer_frame(ring_geom, x0, y0, x1, y1, tol=TOLERANCE_NM):
-    """True if the ring's bounding box equals the panel bounding box."""
-    b = ring_geom.bounds
-    return (abs(b[0] - x0) <= tol and abs(b[1] - y0) <= tol and
-            abs(b[2] - x1) <= tol and abs(b[3] - y1) <= tol)
-
-
-def _shapely_to_segments(board, coords, layer, width_mm=0.05):
-    pts = list(coords)
-    if not pts:
-        return 0
-    if pts[0] != pts[-1]:
-        pts.append(pts[0])
-    count = 0
-    for i in range(len(pts) - 1):
-        seg = pcbnew.PCB_SHAPE(board)
-        seg.SetShape(pcbnew.SHAPE_T_SEGMENT)
-        seg.SetLayer(layer)
-        seg.SetWidth(pcbnew.FromMM(width_mm))
-        seg.SetStart(pcbnew.VECTOR2I(int(pts[i][0]),   int(pts[i][1])))
-        seg.SetEnd  (pcbnew.VECTOR2I(int(pts[i+1][0]), int(pts[i+1][1])))
-        board.Add(seg)
-        count += 1
-    return count
-
-
-def kikitPostprocess(panel, arg):
-    print("=" * 60)
-    print("[cleanup] START")
-
-    board     = panel.board
-    substrate = panel.boardSubstrate
-
-    # outer panel bbox
-    b = substrate.bounds()
-    x0, y0, x1, y1 = int(b[0]), int(b[1]), int(b[2]), int(b[3])
-    print(f"[cleanup] Panel bbox: ({_mm(x0)},{_mm(y0)})–({_mm(x1)},{_mm(y1)})")
-
-    # get substrate geometry
-    geom = None
-    for attr in ("substrates", "substrate", "_substrate", "geometry"):
-        if hasattr(substrate, attr):
-            geom = getattr(substrate, attr)
-            break
-    if geom is None:
-        print("[cleanup] ERROR: cannot access substrate geometry")
-        return
-
-    rings = _collect_rings(geom)
-    print(f"[cleanup] Total rings in substrate: {len(rings)}")
-
-    total = 0
-    for i, (ring_geom, coords) in enumerate(rings):
-        rb = ring_geom.bounds
-        if _is_outer_frame(ring_geom, x0, y0, x1, y1):
-            print(f"[cleanup]   ring[{i}] pts={len(coords)-1} → OUTER FRAME, skipped")
-            continue
-        n = _shapely_to_segments(board, coords, pcbnew.Eco1_User)
-        total += n
-        print(f"[cleanup]   ring[{i}] pts={len(coords)-1}"
-              f"  bbox=({_mm(rb[0])},{_mm(rb[1])})–({_mm(rb[2])},{_mm(rb[3])})"
-              f" → {n} segments on Eco1_User")
-
-    print(f"[cleanup] Total Eco1_User segments added: {total}")
-    print("[cleanup] END")
-    print("=" * 60)

scripts/export.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-GERBERS_DIR="gerbers"
-
-usage() {
-    echo "Usage: $0 <kicad_pcb_file>"
-    exit 1
-}
-
-PCB_FILE="$1"
-
-mkdir -p "$GERBERS_DIR"
-
-# Export drill, front and back layers as gerber files.
-echo "Exporting gerbers..."
-kicad-cli pcb export drill -o "$GERBERS_DIR" "$PCB_FILE"
-kicad-cli pcb export gerbers -o "$GERBERS_DIR" -l Front "$PCB_FILE"
-kicad-cli pcb export gerbers -o "$GERBERS_DIR" -l Back "$PCB_FILE"
-kicad-cli pcb export gerbers -o "$GERBERS_DIR" -l Edge.Cuts "$PCB_FILE"
-
-# Export outlines of the penelized board i.e. use the layer 'User.Eco1'.
-echo "Exporting panelized outlines from layer 'User.Eco1'..."
-python3 export_panel_outlines_gerber.py \
-    --layers User.Eco1 \
-    --output "$GERBERS_DIR" \
-    "$PCB_FILE"
-
-# Input layers/filenames and all milling/drilling parameters are taken from the config file: 'millproject'.
-echo "Exporting Gcode..."
-docker run --rm -i -t \
-    -u "$(id -u):$(id -g)" \
-    -v "$(pwd):/data" \
-    ptodorov/pcb2gcode

scripts/export_panel_outlines_gerber.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import os
-import pcbnew
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Export a single PCB layer to a Gerber file using pcbnew."
-    )
-    parser.add_argument("input", help="Input .kicad_pcb file")
-    parser.add_argument("--output", "-o", required=True, help="Output directory")
-    parser.add_argument("--layers", "-l", required=True,
-                        help="Layer name to export (e.g. User.Eco1)")
-    args = parser.parse_args()
-
-    board = pcbnew.LoadBoard(args.input)
-
-    # Resolve layer name to ID
-    layer_id = board.GetLayerID(args.layers)
-    if layer_id == -1:
-        parser.error(f"Unknown layer: {args.layers!r}. "
-                     f"Run with a known layer name (e.g. User.Eco1, Edge.Cuts).")
-
-    # Resolve output directory to absolute path so pcbnew doesn't make it
-    # relative to the board file location
-    output_dir = os.path.abspath(args.output)
-    os.makedirs(output_dir, exist_ok=True)
-
-    prefix = args.layers.replace(".", "-")
-
-    pc = pcbnew.PLOT_CONTROLLER(board)
-    po = pc.GetPlotOptions()
-    po.SetOutputDirectory(output_dir)
-    po.SetPlotFrameRef(False)
-
-    pc.SetLayer(layer_id)
-    pc.OpenPlotfile(prefix, pcbnew.PLOT_FORMAT_GERBER, args.layers)
-    print(f"Plotting layer {args.layers!r} (id={layer_id}) to {pc.GetPlotFileName()}")
-    pc.PlotLayer()
-    pc.ClosePlot()
-    print("Done.")
-
-if __name__ == "__main__":
-    main()

scripts/macro/SlotCenterlines.FCMacro

@@ -1,376 +0,0 @@
-"""
-=============================================================================
-MACRO: CNC Slot Skeletonizer (Centerlines Only)
-=============================================================================
-DESCRIPTION:
-This macro is specifically designed for CAM/CNC routing where the router bit 
-diameter matches the slot width. It reads a DXF-style slot sketch, calculates
-the mathematical centerlines, and produces a sketch containing ONLY the 
-toolpaths (centerlines).
-
-WHAT IT DOES:
-1. Safely duplicates the selected sketch.
-2. Mathematically calculates true Arcs from faceted DXF micro-segments.
-3. Calculates intersections for Straight, L-shape, and T-shape junctions. 
-4. Merges collinear centerline segments.
-5. ADVANCED CAM OPTIMIZATION: Groups connected lines into continuous chains so
-   the tool doesn't lift unnecessarily. Starts the job at the origin (0,0) and
-   takes the shortest rapid paths between cut groups.
-6. WIPES THE SKETCH COMPLETELY CLEAN of all original geometry.
-7. Draws ONLY the pure skeleton centerlines.
-=============================================================================
-"""
-
-import FreeCAD as App
-import FreeCADGui as Gui
-import Part
-import math
-
-try:
-    from PySide6.QtWidgets import QMessageBox
-except ImportError:
-    try:
-        from PySide2.QtWidgets import QMessageBox
-    except ImportError:
-        from PySide.QtGui import QMessageBox
-
-# =================================================================
-# CONFIGURATION
-MAX_SEGMENT_LENGTH = 0.5  
-# =================================================================
-
-def get_circumcenter(p1, p2, p3):
-    temp = p2.x**2 + p2.y**2
-    bc = (p1.x**2 + p1.y**2 - temp) / 2.0
-    cd = (temp - p3.x**2 - p3.y**2) / 2.0
-    det = (p1.x - p2.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p2.y)
-    
-    if abs(det) < 1e-6: return None, None 
-    
-    cx = (bc * (p2.y - p3.y) - cd * (p1.y - p2.y)) / det
-    cy = ((p1.x - p2.x) * cd - (p2.x - p3.x) * bc) / det
-    center = App.Vector(cx, cy, 0)
-    radius = (p1 - center).Length 
-    return center, radius
-
-def prepare_working_sketch():
-    doc = App.ActiveDocument
-    if not doc: return None
-        
-    target = None
-    edit_view = Gui.ActiveDocument.getInEdit()
-    if edit_view and edit_view.Object.isDerivedFrom("Sketcher::SketchObject"):
-        target = edit_view.Object
-        Gui.ActiveDocument.resetEdit() 
-        
-    if not target:
-        sel = Gui.Selection.getSelection()
-        if sel and sel[0].isDerivedFrom("Sketcher::SketchObject"):
-            target = sel[0]
-            
-    if not target: return None
-
-    new_sketch = doc.copyObject(target, False)
-    new_sketch.Label = target.Label + "_Toolpath"
-    
-    if hasattr(target, "ViewObject") and target.ViewObject:
-        target.ViewObject.Visibility = False
-    if hasattr(new_sketch, "ViewObject") and new_sketch.ViewObject:
-        new_sketch.ViewObject.Visibility = True
-        
-    doc.recompute()
-    return new_sketch
-
-def merge_collinear_lines(lines):
-    merged = True
-    while merged:
-        merged = False
-        for i in range(len(lines)):
-            for j in range(i + 1, len(lines)):
-                l1 = lines[i]
-                l2 = lines[j]
-                
-                shared_pt, other1, other2 = None, None, None
-                tol = 1e-3
-                
-                if (l1[0] - l2[0]).Length < tol: shared_pt, other1, other2 = l1[0], l1[1], l2[1]
-                elif (l1[0] - l2[1]).Length < tol: shared_pt, other1, other2 = l1[0], l1[1], l2[0]
-                elif (l1[1] - l2[0]).Length < tol: shared_pt, other1, other2 = l1[1], l1[0], l2[1]
-                elif (l1[1] - l2[1]).Length < tol: shared_pt, other1, other2 = l1[1], l1[0], l2[0]
-                
-                if shared_pt:
-                    v1 = (other1 - shared_pt)
-                    v2 = (other2 - shared_pt)
-                    if v1.Length > tol and v2.Length > tol:
-                        v1.normalize()
-                        v2.normalize()
-                        if abs(v1.dot(v2) + 1.0) < 1e-4: 
-                            lines.pop(j)
-                            lines.pop(i)
-                            lines.append((other1, other2))
-                            merged = True
-                            break
-            if merged: break
-    return lines
-
-def optimize_toolpath_order(lines):
-    if not lines: return []
-    
-    # Phase 1: Build continuous chains (Polylines)
-    unvisited = lines.copy()
-    chains = []
-    tol = 1e-3
-    
-    while unvisited:
-        current_chain = [unvisited.pop(0)]
-        growing = True
-        
-        while growing:
-            growing = False
-            chain_start = current_chain[0][0]
-            chain_end = current_chain[-1][1]
-            
-            for i, line in enumerate(unvisited):
-                l_start, l_end = line[0], line[1]
-                
-                if (l_start - chain_end).Length < tol:
-                    current_chain.append(unvisited.pop(i))
-                    growing = True; break
-                elif (l_end - chain_end).Length < tol:
-                    current_chain.append((l_end, l_start)) # Flip
-                    unvisited.pop(i)
-                    growing = True; break
-                elif (l_end - chain_start).Length < tol:
-                    current_chain.insert(0, unvisited.pop(i))
-                    growing = True; break
-                elif (l_start - chain_start).Length < tol:
-                    current_chain.insert(0, (l_end, l_start)) # Flip
-                    unvisited.pop(i)
-                    growing = True; break
-                    
-        chains.append(current_chain)
-        
-    # Phase 2: Traveling Salesperson between chains
-    unvisited_chains = chains.copy()
-    optimized_lines = []
-    
-    # Start with the chain closest to global Origin (0,0,0)
-    start_idx = 0
-    best_origin_dist = float('inf')
-    for i, chain in enumerate(unvisited_chains):
-        d1 = chain[0][0].Length
-        d2 = chain[-1][1].Length
-        if min(d1, d2) < best_origin_dist:
-            best_origin_dist = min(d1, d2)
-            start_idx = i
-            
-    current_chain = unvisited_chains.pop(start_idx)
-    # Ensure it starts at the point closer to origin
-    if current_chain[-1][1].Length < current_chain[0][0].Length:
-        current_chain.reverse()
-        current_chain = [(l[1], l[0]) for l in current_chain]
-        
-    optimized_lines.extend(current_chain)
-    current_pos = current_chain[-1][1] # Position after cutting first chain
-    
-    while unvisited_chains:
-        best_dist = float('inf')
-        best_idx = -1
-        reverse_chain = False
-        
-        for i, chain in enumerate(unvisited_chains):
-            c_start = chain[0][0]
-            c_end = chain[-1][1]
-            
-            dist_to_start = (c_start - current_pos).Length
-            dist_to_end = (c_end - current_pos).Length
-            
-            if dist_to_start < best_dist:
-                best_dist = dist_to_start
-                best_idx = i
-                reverse_chain = False
-            
-            if dist_to_end < best_dist:
-                best_dist = dist_to_end
-                best_idx = i
-                reverse_chain = True
-                
-        next_chain = unvisited_chains.pop(best_idx)
-        
-        if reverse_chain:
-            next_chain.reverse()
-            next_chain = [(l[1], l[0]) for l in next_chain]
-            
-        optimized_lines.extend(next_chain)
-        current_pos = next_chain[-1][1]
-        
-    return optimized_lines
-
-def show_message(title, message):
-    msg = QMessageBox()
-    msg.setIcon(QMessageBox.Information)
-    msg.setWindowTitle(title)
-    msg.setText(message)
-    try:
-        msg.exec() 
-    except AttributeError:
-        msg.exec_()
-
-def process_sketch():
-    sketch = prepare_working_sketch()
-    if not sketch:
-        App.Console.PrintError("Could not find a sketch. Select one in the tree view and run.\n")
-        return
-
-    geo = sketch.Geometry
-    
-    # --- STEP 1: IDENTIFY MICRO-SEGMENTS TO INFER ARC DATA ---
-    graph = {}
-    pt_dict = {}
-    def get_pt_key(pt): return (round(pt.x, 3), round(pt.y, 3))
-    
-    for i, g in enumerate(geo):
-        if isinstance(g, Part.LineSegment) and not sketch.GeometryFacadeList[i].Construction:
-            if (g.EndPoint - g.StartPoint).Length < MAX_SEGMENT_LENGTH:
-                k1 = get_pt_key(g.StartPoint)
-                k2 = get_pt_key(g.EndPoint)
-                
-                if k1 not in graph: graph[k1] = []
-                if k2 not in graph: graph[k2] = []
-                
-                graph[k1].append((k2, i))
-                graph[k2].append((k1, i))
-                
-                pt_dict[k1] = g.StartPoint
-                pt_dict[k2] = g.EndPoint
-
-    paths = []
-    visited_edges = set()
-    
-    for node, edges in graph.items():
-        if len(edges) == 1: 
-            first_edge = edges[0][1]
-            if first_edge in visited_edges: continue
-                
-            path_nodes = [node]
-            curr = node; prev = None
-            
-            while True:
-                neighbors = graph[curr]
-                next_node = None; next_idx = None
-                for n, idx in neighbors:
-                    if n != prev:
-                        next_node = n; next_idx = idx
-                        break
-                if next_node is None: break 
-                path_nodes.append(next_node)
-                visited_edges.add(next_idx)
-                if len(graph[next_node]) > 2: break 
-                prev = curr; curr = next_node
-                
-            if len(path_nodes) >= 3:
-                paths.append(path_nodes)
-
-    # --- STEP 2: CALCULATE TRUE ARC CENTERS & DIRECTIONS ---
-    arc_data = [] 
-    
-    for path_nodes in paths:
-        p1 = pt_dict[path_nodes[0]] 
-        p2 = pt_dict[path_nodes[len(path_nodes)//2]] 
-        p3 = pt_dict[path_nodes[-1]] 
-        
-        center, radius = get_circumcenter(p1, p2, p3)
-        if center:
-            v1 = p1 - center
-            v3 = p3 - center
-            if v1.Length > 1e-4 and v3.Length > 1e-4:
-                dot = max(-1.0, min(1.0, v1.dot(v3) / (v1.Length * v3.Length)))
-                angle = math.acos(dot)
-                if angle > 2.0:
-                    chord = p3 - p1
-                    perp = App.Vector(-chord.y, chord.x, 0)
-                    if perp.Length > 1e-6:
-                        perp.normalize()
-                        if perp.dot(center - p2) < 0: perp = -perp
-                        arc_data.append((center, perp))
-
-    # Existing native Arcs
-    for i, g in enumerate(geo):
-        if isinstance(g, Part.ArcOfCircle) and not sketch.GeometryFacadeList[i].Construction:
-            p1 = g.StartPoint
-            p3 = g.EndPoint
-            center = g.Center
-            v1 = p1 - center
-            v3 = p3 - center
-            if v1.Length > 1e-4 and v3.Length > 1e-4:
-                dot = max(-1.0, min(1.0, v1.dot(v3) / (v1.Length * v3.Length)))
-                angle = math.acos(dot)
-                if angle > 2.0:
-                    chord = p3 - p1
-                    perp = App.Vector(-chord.y, chord.x, 0)
-                    if perp.Length > 1e-6:
-                        perp.normalize()
-                        mid_u = (g.FirstParameter + g.LastParameter) / 2.0
-                        p2 = g.value(mid_u)
-                        if perp.dot(center - p2) < 0: perp = -perp
-                        arc_data.append((center, perp))
-
-    # --- STEP 3: WIPE THE SKETCH CLEAN ---
-    for i in range(sketch.ConstraintCount - 1, -1, -1):
-        sketch.delConstraint(i)
-    for i in range(sketch.GeometryCount - 1, -1, -1):
-        sketch.delGeometry(i)
-
-    # --- STEP 4: CALCULATE TOOLPATHS ---
-    raw_lines = []
-
-    for i, (c1, dir1) in enumerate(arc_data):
-        min_t = float('inf')
-        best_stop = None
-        
-        for j, (c2, dir2) in enumerate(arc_data):
-            if i == j: continue
-            cross = dir1.x * dir2.y - dir1.y * dir2.x
-            
-            if abs(cross) < 1e-4:
-                vec = c2 - c1
-                dist_cross = vec.x * dir1.y - vec.y * dir1.x
-                if abs(dist_cross) < 1e-2: 
-                    t1 = vec.dot(dir1)
-                    t2 = (-vec).dot(dir2)
-                    if t1 > 1e-2 and t2 > 1e-2: 
-                        if t1 < min_t:
-                            min_t = t1
-                            best_stop = c2
-            else:
-                dx = c2.x - c1.x
-                dy = c2.y - c1.y
-                t1 = (dx * dir2.y - dy * dir2.x) / cross
-                t2 = (dx * dir1.y - dy * dir1.x) / cross
-                if t1 > 1e-2 and t2 > -1e-2: 
-                    if t1 < min_t:
-                        min_t = t1
-                        best_stop = c1 + dir1 * t1
-                        
-        if best_stop is not None:
-            if (c1 - best_stop).Length > 1e-3:
-                pts = sorted([(round(c1.x, 3), round(c1.y, 3)), (round(best_stop.x, 3), round(best_stop.y, 3))])
-                pA = App.Vector(pts[0][0], pts[0][1], 0)
-                pB = App.Vector(pts[1][0], pts[1][1], 0)
-                if not any((l[0]-pA).Length < 1e-3 and (l[1]-pB).Length < 1e-3 for l in raw_lines):
-                    raw_lines.append((pA, pB))
-
-    # --- STEP 5: MERGE AND OPTIMIZE PATHS FOR CNC ---
-    merged_lines = merge_collinear_lines(raw_lines)
-    optimized_lines = optimize_toolpath_order(merged_lines)
-
-    # Draw the final optimized lines sequentially
-    for pA, pB in optimized_lines:
-        sketch.addGeometry(Part.LineSegment(pA, pB), False)
-
-    App.ActiveDocument.recompute()
-    App.Console.PrintMessage(f"Skeletonizer successful: Created '{sketch.Label}'.\n")
-    show_message("CAM Toolpath Complete", f"Successfully generated continuous, optimized CNC toolpaths in:\n\n{sketch.Label}")
-
-# Run it
-process_sketch()

scripts/millproject

@@ -1,55 +0,0 @@
-front=gerbers/Flow_Controller_Panel-Front.gtl
-back=gerbers/Flow_Controller_Panel-Back.gbl
-drill=gerbers/Flow_Controller_Panel.drl
-# Use the 'User-Eco1' layer instead as it contains panelized board's slot outlines only.
-outline=gerbers/Flow_Controller_Panel-User-Eco1.gbr
-# Do not use the 'Edge_Cuts' layer as it contains also the panel outline.
-#outline=gerbers/Flow_Controller_Panel-Edge_Cuts.gm1
-
-# Generic
-metric=true         # use metric units for parameters
-metricoutput=true   # use metric units for output
-nog64=true          # do not set an explicit g64
-#nom6=true           # do not emit m6
-zsafe=2             # The height in mm at which the bit can move freely without obstruction
-zchange=2           # Tool changing height in mm
-output-dir=gcode
-
-# Place a 5x7cm board in the lower right quadrant of the coordinate system
-# This will allow you to probe the fixed jaw of the vise for (0,0) on the CNC.
-
-# For two-sided boards, the PCB needs to be flipped along the axis x=VALUE
-mirror-axis=80      # set this to half of your board width
-
-# Drilling
-zdrill=-2.2         # drilling depth
-drill-feed=200      # Vertical mm/min feed
-drill-speed=24000   # Spindle RPM
-#onedrill=true       # Use a single drill for all holes
-nog81=true          # replace G81 with G0+G1 (no G81 in GRBL)
-drill-side=back
-
-# Milling
-zwork=-0.1          # V-bit plunge depth
-#mill-diameters=0.11 # 60 deg V-bit dia at -0.1 plunge depth
-#mill-diameters=0.08 # 45 deg V-bit dia at -0.1 plunge depth
-mill-diameters=0.05 # 30 deg V-bit dia at -0.1 plunge depth
-mill-speed=24000    # Spindle RPM
-mill-feed=600       # Horizontal feedrate in mm/min
-mill-vertfeed=100   # Plunge rate in mm/min
-voronoi=true        # cuts the milling time significantly, but check with this on and off if everything looks ok
-preserve-thermal-reliefs = true # has effect only if voronoi=true
-
-# Cutting
-zcut=-4
-cutter-diameter=2.1
-cut-feed=400
-cut-vertfeed=50
-cut-infeed=4
-cut-speed=24000
-cut-side=back
-
-# Tabs
-#bridgesnum=4        # Total 4 tabs
-#bridges=0.5	    # Tab width 0.5 mm
-#zbridges=0	    # bridges height (default to zsafe)

scripts/myPreset.json

@@ -1,112 +0,0 @@
-{
-    "layout": {
-        "type": "grid",
-        "rows": 1,
-        "cols": 2,
-        "hspace": "2.1mm",
-        "vspace": "2.1mm"
-    },
-    "tabs": {
-        "type": "fixed",
-        "hcount": 1,
-        "vcount": 1,
-        "hwidth": "3mm",
-        "vwidth": "3mm"
-    },
-    "cuts": {
-        "type": "mousebites",
-        "offset": "0.2mm",
-        "prolong": "0.7mm",
-        "drill": "0.5mm",
-        "spacing": "0.8mm"
-    },
-    "framing": {
-        "type": "tightframe",
-        "copperFill": true,
-        "slotwidth": "2.1mm",
-        "mintotalheight": "100mm",
-        "mintotalwidth": "160mm",
-        "maxtotalheight": "100mm",
-        "maxtotalwidth": "160mm"
-    },
-    "tooling": {
-        "type": "plugin",
-        "code": "tooling_plugin.py.CustomTooling",
-        "arg": ""
-    },
-    "fiducials": {
-        "type": "4fid",
-        "hoffset": "6mm",
-        "voffset": "9.2mm",
-        "coppersize": "2mm",
-        "opening": "1mm",
-        "paste": true,
-        "code": "none",
-        "arg": ""
-    },
-    "text": {
-        "type": "simple",
-        "text": "Front",
-        "anchor": "mt",
-        "hoffset": "0mm",
-        "voffset": "15mm",
-        "orientation": "0deg",
-        "width": "3.5mm",
-        "height": "3.5mm",
-        "hjustify": "center",
-        "vjustify": "center",
-        "thickness": "0.3mm",
-        "layer": "F.SilkS"
-    },
-    "text2": {
-        "type": "simple",
-        "text": "Back",
-        "anchor": "mt",
-        "hoffset": "0mm",
-        "voffset": "15mm",
-        "orientation": "0deg",
-        "width": "3.5mm",
-        "height": "3.5mm",
-        "hjustify": "center",
-        "vjustify": "center",
-        "thickness": "0.3mm",
-        "layer": "B.SilkS"
-    },
-     "copperfill": {
-        "type": "solid",
-        "clearance": "0.5mm",
-        "edgeclearance": "0.5mm",
-        "layers": "B.Cu"        
-    },
-    "post": {
-        "type": "auto",
-        "copperfill": false,
-        "reconstructarcs": false,
-        "millradius": "1mm",
-        "millradiusouter": "0mm",
-        "script": "cleanup.py", 
-        "scriptarg": "",
-        "origin": "tl",
-        "refillzones": false,
-        "dimensions": true,
-        "edgewidth": "0.1mm"
-    },
-    "page": {
-        "type": "inherit",
-        "anchor": "tl",
-        "posx": "0mm",
-        "posy": "0mm",
-        "width": "1000mm",
-        "height": "1000mm"
-    },
-    "debug": {
-        "type": "none",
-        "drawPartitionLines": false,
-        "drawBackboneLines": false,
-        "drawboxes": false,
-        "trace": false,
-        "deterministic": false,
-        "drawtabfail": false,
-        "drawTabFillet": false
-    }
-}

scripts/tooling_plugin.py

@@ -1,131 +0,0 @@
-from kikit.plugin import ToolingPlugin
-import pcbnew
-
-class CustomTooling(ToolingPlugin):
-    def buildTooling(self, panel):
-        board = panel.board
-
-        # panelBBox() -> (xmin, ymin, xmax, ymax) 
-        xmin, ymin, xmax, ymax = panel.panelBBox()
-
-        min_x = pcbnew.ToMM(xmin)
-        min_y = pcbnew.ToMM(ymin)
-        max_x = pcbnew.ToMM(xmax)
-        max_y = pcbnew.ToMM(ymax)
-
-        margin_x_mm = 10
-        margin_y_mm = 2.5
-
-        center_x = (min_x + max_x) / 2
-        center_y = (min_y + max_y) / 2
-
-        holes = [
-            (min_x + margin_x_mm, min_y + margin_y_mm),         # top left
-            (center_x, min_y + margin_y_mm),                    # top center
-            (max_x - margin_x_mm, min_y + margin_y_mm),         # top right
-
-            (min_x + margin_x_mm, max_y - margin_y_mm),      # bottom left
-            (center_x, max_y - margin_y_mm),                 # bottom center
-            (max_x - margin_x_mm, max_y - margin_y_mm),      # bottom right
-        ]
-
-        hole_d = pcbnew.FromMM(3.172)
-
-        for x_mm, y_mm in holes:
-            fp = pcbnew.FOOTPRINT(board)
-            fp.SetReference("")
-
-            pos = pcbnew.VECTOR2I(
-                pcbnew.FromMM(x_mm),
-                pcbnew.FromMM(y_mm)
-            )
-
-            fp.SetPosition(pos)
-
-            pad = pcbnew.PAD(fp)
-            pad.SetShape(pcbnew.PAD_SHAPE_CIRCLE)
-            pad.SetAttribute(pcbnew.PAD_ATTRIB_NPTH)
-
-            pad.SetSize(pcbnew.VECTOR2I(hole_d, hole_d))
-            pad.SetDrillSize(pcbnew.VECTOR2I(hole_d, hole_d))
-            pad.SetPosition(pos)
-
-            fp.Add(pad)
-            board.Add(fp)
-        
-        # =========================
-        # SCREEN RECTANGLE
-        # =========================
-
-        screen_w = 153.4
-        screen_h = 87.0
-
-        # Panel center
-        center_x = (min_x + max_x) / 2
-        center_y = (min_y + max_y) / 2
-
-        # Screen rectangle corners
-        screen_x0 = center_x - (screen_w / 2)
-        screen_y0 = center_y - (screen_h / 2)
-
-        screen_x1 = center_x + (screen_w / 2)
-        screen_y1 = center_y + (screen_h / 2)
-
-        screen = pcbnew.PCB_SHAPE(board)
-        screen.SetShape(pcbnew.SHAPE_T_RECT)
-        screen.SetLayer(pcbnew.Dwgs_User)
-
-        screen.SetStart(
-            pcbnew.VECTOR2I(
-                pcbnew.FromMM(screen_x0),
-                pcbnew.FromMM(screen_y0)
-            )
-        )
-
-        screen.SetEnd(
-            pcbnew.VECTOR2I(
-                pcbnew.FromMM(screen_x1),
-                pcbnew.FromMM(screen_y1)
-            )
-        )
-
-        screen.SetWidth(pcbnew.FromMM(0.2))
-
-        board.Add(screen)
-
-        # =========================
-        # FIXTURE RECTANGLE
-        # =========================
-
-        fixture_w = 200.0
-        fixture_h = 130.0
-
-        # Fixture rectangle corners
-        fixture_x0 = center_x - (fixture_w / 2)
-        fixture_y0 = center_y - (fixture_h / 2)
-
-        fixture_x1 = center_x + (fixture_w / 2)
-        fixture_y1 = center_y + (fixture_h / 2)
-
-        fixture = pcbnew.PCB_SHAPE(board)
-        fixture.SetShape(pcbnew.SHAPE_T_RECT)
-        fixture.SetLayer(pcbnew.Dwgs_User)
-
-        fixture.SetStart(
-            pcbnew.VECTOR2I(
-                pcbnew.FromMM(fixture_x0),
-                pcbnew.FromMM(fixture_y0)
-            )
-        )
-
-        fixture.SetEnd(
-            pcbnew.VECTOR2I(
-                pcbnew.FromMM(fixture_x1),
-                pcbnew.FromMM(fixture_y1)
-            )
-        )
-
-        fixture.SetWidth(pcbnew.FromMM(0.2))
-
-        board.Add(fixture)
-