kicad-sch-api 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

kicad_sch_api/core/simple_manhattan.py

@@ -0,0 +1,228 @@
+"""
+Simple Manhattan routing with basic obstacle avoidance.
+
+This module provides a simple, working implementation of Manhattan routing
+that can be integrated with the existing auto_route_pins API.
+"""
+
+import logging
+from typing import List, Optional, Tuple
+
+from .component_bounds import BoundingBox, get_component_bounding_box
+from .types import Point, SchematicSymbol
+
+logger = logging.getLogger(__name__)
+
+
+def simple_manhattan_route(start: Point, end: Point) -> List[Point]:
+    """
+    Create a simple L-shaped Manhattan route between two points.
+
+    Args:
+        start: Starting point
+        end: Ending point
+
+    Returns:
+        List of waypoints for L-shaped route
+    """
+    # Simple L-route: horizontal first, then vertical
+    if abs(start.x - end.x) > 0.1:  # Need horizontal segment
+        if abs(start.y - end.y) > 0.1:  # Need vertical segment too
+            # L-shaped route: start -> corner -> end
+            corner = Point(end.x, start.y)
+            return [start, corner, end]
+        else:
+            # Pure horizontal
+            return [start, end]
+    else:
+        # Pure vertical or same point
+        return [start, end]
+
+
+def check_horizontal_line_collision(start: Point, end: Point, bbox: BoundingBox) -> bool:
+    """Check if a horizontal line collides with a bounding box."""
+    line_y = start.y
+    line_min_x = min(start.x, end.x)
+    line_max_x = max(start.x, end.x)
+
+    # Check Y range collision
+    if not (bbox.min_y <= line_y <= bbox.max_y):
+        return False
+
+    # Check X range collision
+    if line_max_x < bbox.min_x or line_min_x > bbox.max_x:
+        return False
+
+    return True
+
+
+def simple_obstacle_avoidance_route(
+    start: Point, end: Point, obstacles: List[BoundingBox], clearance: float = 2.54
+) -> List[Point]:
+    """
+    Route around obstacles with simple above/below strategy.
+
+    Args:
+        start: Starting point
+        end: Ending point
+        obstacles: List of obstacle bounding boxes
+        clearance: Clearance distance from obstacles
+
+    Returns:
+        List of waypoints avoiding obstacles
+    """
+    # Try direct L-shaped route first
+    direct_route = simple_manhattan_route(start, end)
+
+    # Check if any segment collides with obstacles
+    collision_detected = False
+    for i in range(len(direct_route) - 1):
+        seg_start = direct_route[i]
+        seg_end = direct_route[i + 1]
+
+        for obstacle in obstacles:
+            if check_horizontal_line_collision(seg_start, seg_end, obstacle):
+                collision_detected = True
+                logger.debug(
+                    f"Collision detected between {seg_start} -> {seg_end} and obstacle {obstacle}"
+                )
+                break
+        if collision_detected:
+            break
+
+    if not collision_detected:
+        logger.debug("Direct route is clear")
+        return direct_route
+
+    # Find obstacles that block the path
+    blocking_obstacles = []
+    for obstacle in obstacles:
+        # Check if obstacle is roughly between start and end points
+        if min(start.x, end.x) < obstacle.max_x and max(start.x, end.x) > obstacle.min_x:
+            blocking_obstacles.append(obstacle)
+
+    if not blocking_obstacles:
+        logger.debug("No blocking obstacles found, using direct route")
+        return direct_route
+
+    # Find the combined bounding area of all blocking obstacles
+    combined_min_y = min(obs.min_y for obs in blocking_obstacles)
+    combined_max_y = max(obs.max_y for obs in blocking_obstacles)
+
+    # Calculate routing options
+    above_y = combined_max_y + clearance
+    below_y = combined_min_y - clearance
+
+    # Route above obstacles
+    route_above = [
+        start,
+        Point(start.x, above_y),  # Go up
+        Point(end.x, above_y),  # Go across above obstacles
+        end,  # Go down to destination
+    ]
+
+    # Route below obstacles
+    route_below = [
+        start,
+        Point(start.x, below_y),  # Go down
+        Point(end.x, below_y),  # Go across below obstacles
+        end,  # Go up to destination
+    ]
+
+    # Calculate Manhattan distances
+    def manhattan_distance(route):
+        total = 0
+        for i in range(len(route) - 1):
+            total += abs(route[i + 1].x - route[i].x) + abs(route[i + 1].y - route[i].y)
+        return total
+
+    above_distance = manhattan_distance(route_above)
+    below_distance = manhattan_distance(route_below)
+
+    # Choose shorter route
+    if above_distance <= below_distance:
+        chosen_route = route_above
+        choice = "above"
+    else:
+        chosen_route = route_below
+        choice = "below"
+
+    logger.debug(
+        f"Obstacle avoidance: routing {choice} obstacles (distance: {min(above_distance, below_distance):.1f}mm)"
+    )
+    return chosen_route
+
+
+def auto_route_with_manhattan(
+    schematic,
+    start_component: SchematicSymbol,
+    start_pin: str,
+    end_component: SchematicSymbol,
+    end_pin: str,
+    avoid_components: Optional[List[SchematicSymbol]] = None,
+    clearance: float = 2.54,
+) -> Optional[str]:
+    """
+    Auto route between pins using Manhattan routing with obstacle avoidance.
+
+    Args:
+        schematic: The schematic object
+        start_component: Starting component
+        start_pin: Starting pin number
+        end_component: Ending component
+        end_pin: Ending pin number
+        avoid_components: Components to avoid (if None, avoid all components)
+        clearance: Clearance distance from obstacles
+
+    Returns:
+        Wire UUID if successful, None if failed
+    """
+    # Get pin positions
+    from .pin_utils import get_component_pin_position
+
+    start_pos = get_component_pin_position(start_component, start_pin)
+    end_pos = get_component_pin_position(end_component, end_pin)
+
+    if not start_pos or not end_pos:
+        logger.warning("Could not determine pin positions")
+        return None
+
+    logger.debug(
+        f"Manhattan routing: {start_component.reference} pin {start_pin} -> {end_component.reference} pin {end_pin}"
+    )
+    logger.debug(f"  From: {start_pos}")
+    logger.debug(f"  To: {end_pos}")
+
+    # Get obstacle bounding boxes
+    obstacles = []
+    if avoid_components is None:
+        # Avoid all components in schematic except start and end
+        avoid_components = [
+            comp
+            for comp in schematic.components
+            if comp.reference != start_component.reference
+            and comp.reference != end_component.reference
+        ]
+
+    for component in avoid_components:
+        bbox = get_component_bounding_box(component, include_properties=False)
+        obstacles.append(bbox)
+        logger.debug(f"  Obstacle: {component.reference} at {bbox}")
+
+    # Calculate route
+    route = simple_obstacle_avoidance_route(start_pos, end_pos, obstacles, clearance)
+
+    logger.debug(f"  Route: {len(route)} waypoints")
+    for i, point in enumerate(route):
+        logger.debug(f"    {i}: {point}")
+
+    # Add wires to schematic
+    wire_uuids = []
+    for i in range(len(route) - 1):
+        wire_uuid = schematic.add_wire(route[i], route[i + 1])
+        wire_uuids.append(wire_uuid)
+
+    logger.debug(f"Added {len(wire_uuids)} wire segments")
+
+    # Return first wire UUID (for compatibility)
+    return wire_uuids[0] if wire_uuids else None

kicad_sch_api/core/types.py

@@ -190,7 +190,7 @@ class Wire:
         self.wire_type = (
             WireType(self.wire_type) if isinstance(self.wire_type, str) else self.wire_type
         )
-        
+
         # Ensure we have at least 2 points
         if len(self.points) < 2:
             raise ValueError("Wire must have at least 2 points")
@@ -259,7 +259,7 @@ class LabelType(Enum):
 
 class HierarchicalLabelShape(Enum):
     """Hierarchical label shapes/directions."""
-    
+
     INPUT = "input"
     OUTPUT = "output"
     BIDIRECTIONAL = "bidirectional"
@@ -287,7 +287,7 @@ class Label:
         self.label_type = (
             LabelType(self.label_type) if isinstance(self.label_type, str) else self.label_type
         )
-        
+
         if self.shape:
             self.shape = (
                 HierarchicalLabelShape(self.shape) if isinstance(self.shape, str) else self.shape
@@ -320,7 +320,12 @@ class TextBox:
     text: str
     rotation: float = 0.0
     font_size: float = 1.27
-    margins: Tuple[float, float, float, float] = (0.9525, 0.9525, 0.9525, 0.9525)  # top, right, bottom, left
+    margins: Tuple[float, float, float, float] = (
+        0.9525,
+        0.9525,
+        0.9525,
+        0.9525,
+    )  # top, right, bottom, left
     stroke_width: float = 0.0
     stroke_type: str = "solid"
     fill_type: str = "none"

kicad_sch_api/core/wire_routing.py

@@ -0,0 +1,380 @@
+"""
+Simple wire routing and connectivity detection for KiCAD schematics.
+
+Provides basic wire routing between component pins and pin connectivity detection.
+All positioning follows KiCAD's 1.27mm grid alignment rules.
+"""
+
+from typing import List, Optional, Tuple, Union
+
+from .types import Point
+
+
+def snap_to_kicad_grid(
+    position: Union[Point, Tuple[float, float]], grid_size: float = 1.27
+) -> Point:
+    """
+    Snap position to KiCAD's standard 1.27mm grid.
+
+    KiCAD uses a 1.27mm (0.05 inch) grid for precise electrical connections.
+    ALL components, wires, and labels must be exactly on grid points.
+
+    Args:
+        position: Point or (x, y) tuple to snap
+        grid_size: Grid size in mm (default 1.27mm)
+
+    Returns:
+        Point snapped to grid
+    """
+    if isinstance(position, Point):
+        x, y = position.x, position.y
+    else:
+        x, y = position
+
+    # Round to nearest grid point
+    snapped_x = round(x / grid_size) * grid_size
+    snapped_y = round(y / grid_size) * grid_size
+
+    return Point(snapped_x, snapped_y)
+
+
+def calculate_component_position_for_grid_pins(
+    pin_offsets: List[Tuple[float, float]], target_pin_grid_pos: Point, target_pin_index: int = 0
+) -> Point:
+    """
+    Calculate component position so that pins land exactly on grid points.
+
+    Args:
+        pin_offsets: List of (x_offset, y_offset) tuples for each pin relative to component center
+        target_pin_grid_pos: Desired grid position for the target pin
+        target_pin_index: Index of pin to align to grid (default: pin 0)
+
+    Returns:
+        Component center position that places target pin on grid
+    """
+    target_offset_x, target_offset_y = pin_offsets[target_pin_index]
+
+    # Component center = target pin position - pin offset
+    comp_center_x = target_pin_grid_pos.x - target_offset_x
+    comp_center_y = target_pin_grid_pos.y - target_offset_y
+
+    return Point(comp_center_x, comp_center_y)
+
+
+def get_resistor_grid_position(target_pin1_grid: Point) -> Point:
+    """
+    Get component position for Device:R resistor so pin 1 is at target grid position.
+
+    Device:R resistor pin offsets: Pin 1 = (0, +3.81), Pin 2 = (0, -3.81)
+
+    Args:
+        target_pin1_grid: Desired grid position for pin 1
+
+    Returns:
+        Component center position
+    """
+    # Device:R pin offsets (standard KiCAD library values)
+    pin_offsets = [(0.0, 3.81), (0.0, -3.81)]  # Pin 1 and Pin 2 offsets
+    return calculate_component_position_for_grid_pins(pin_offsets, target_pin1_grid, 0)
+
+
+def route_pins_direct(pin1_position: Point, pin2_position: Point) -> Point:
+    """
+    Simple direct routing between two pins.
+    Just draws a straight wire - ok to go through other components.
+
+    Args:
+        pin1_position: Position of first pin
+        pin2_position: Position of second pin
+
+    Returns:
+        End point (pin2_position) for wire creation
+    """
+    return pin2_position
+
+
+def are_pins_connected(
+    schematic, comp1_ref: str, pin1_num: str, comp2_ref: str, pin2_num: str
+) -> bool:
+    """
+    Detect if two component pins are connected via wires or labels (local or hierarchical).
+
+    Checks for electrical connectivity through:
+    1. Direct wire connections
+    2. Indirect wire network connections
+    3. Local labels on connected nets
+    4. Hierarchical labels for inter-sheet connections
+
+    Args:
+        schematic: The schematic object to analyze
+        comp1_ref: Reference of first component (e.g., 'R1')
+        pin1_num: Pin number on first component (e.g., '1')
+        comp2_ref: Reference of second component (e.g., 'R2')
+        pin2_num: Pin number on second component (e.g., '2')
+
+    Returns:
+        True if pins are electrically connected, False otherwise
+    """
+    # Get pin positions
+    pin1_pos = schematic.get_component_pin_position(comp1_ref, pin1_num)
+    pin2_pos = schematic.get_component_pin_position(comp2_ref, pin2_num)
+
+    if not pin1_pos or not pin2_pos:
+        return False
+
+    # 1. Check for direct wire connection between the pins
+    for wire in schematic.wires:
+        wire_start = wire.points[0]
+        wire_end = wire.points[-1]  # Last point for multi-segment wires
+
+        # Check if wire directly connects the two pins
+        if (
+            wire_start.x == pin1_pos.x
+            and wire_start.y == pin1_pos.y
+            and wire_end.x == pin2_pos.x
+            and wire_end.y == pin2_pos.y
+        ) or (
+            wire_start.x == pin2_pos.x
+            and wire_start.y == pin2_pos.y
+            and wire_end.x == pin1_pos.x
+            and wire_end.y == pin1_pos.y
+        ):
+            return True
+
+    # 2. Check for indirect connection through wire network
+    visited_wires = set()
+    if _pins_connected_via_wire_network(schematic, pin1_pos, pin2_pos, visited_wires):
+        return True
+
+    # 3. Check for connection via local labels
+    if _pins_connected_via_labels(schematic, pin1_pos, pin2_pos):
+        return True
+
+    # 4. Check for connection via hierarchical labels
+    if _pins_connected_via_hierarchical_labels(schematic, pin1_pos, pin2_pos):
+        return True
+
+    return False
+
+
+def _pins_connected_via_wire_network(
+    schematic, pin1_pos: Point, pin2_pos: Point, visited_wires: set
+) -> bool:
+    """
+    Check if pins are connected through wire network tracing.
+
+    Args:
+        schematic: The schematic object
+        pin1_pos: First pin position
+        pin2_pos: Second pin position
+        visited_wires: Set to track visited wires
+
+    Returns:
+        True if pins connected via wire network
+    """
+    # Find all wires connected to pin1
+    pin1_wires = []
+    for wire in schematic.wires:
+        for point in wire.points:
+            if point.x == pin1_pos.x and point.y == pin1_pos.y:
+                pin1_wires.append(wire)
+                break
+
+    # For each wire connected to pin1, trace the network to see if it reaches pin2
+    visited_wire_uuids = set()  # Use UUIDs instead of Wire objects
+    for start_wire in pin1_wires:
+        if _trace_wire_network(schematic, start_wire, pin2_pos, visited_wire_uuids):
+            return True
+
+    return False
+
+
+def _pins_connected_via_labels(schematic, pin1_pos: Point, pin2_pos: Point) -> bool:
+    """
+    Check if pins are connected via local labels (net names).
+
+    Two pins are connected if they're on nets with the same label name.
+
+    Args:
+        schematic: The schematic object
+        pin1_pos: First pin position
+        pin2_pos: Second pin position
+
+    Returns:
+        True if pins connected via same local label
+    """
+    # Get labels connected to pin1's net
+    pin1_labels = _get_net_labels_at_position(schematic, pin1_pos)
+    if not pin1_labels:
+        return False
+
+    # Get labels connected to pin2's net
+    pin2_labels = _get_net_labels_at_position(schematic, pin2_pos)
+    if not pin2_labels:
+        return False
+
+    # Check if any label names match (case-insensitive)
+    pin1_names = {label.text.upper() for label in pin1_labels}
+    pin2_names = {label.text.upper() for label in pin2_labels}
+
+    return bool(pin1_names.intersection(pin2_names))
+
+
+def _pins_connected_via_hierarchical_labels(schematic, pin1_pos: Point, pin2_pos: Point) -> bool:
+    """
+    Check if pins are connected via hierarchical labels.
+
+    Hierarchical labels create connections between different sheets in a hierarchy.
+
+    Args:
+        schematic: The schematic object
+        pin1_pos: First pin position
+        pin2_pos: Second pin position
+
+    Returns:
+        True if pins connected via hierarchical labels
+    """
+    # Get hierarchical labels connected to pin1's net
+    pin1_hier_labels = _get_hierarchical_labels_at_position(schematic, pin1_pos)
+    if not pin1_hier_labels:
+        return False
+
+    # Get hierarchical labels connected to pin2's net
+    pin2_hier_labels = _get_hierarchical_labels_at_position(schematic, pin2_pos)
+    if not pin2_hier_labels:
+        return False
+
+    # Check if any hierarchical label names match (case-insensitive)
+    pin1_names = {label.text.upper() for label in pin1_hier_labels}
+    pin2_names = {label.text.upper() for label in pin2_hier_labels}
+
+    return bool(pin1_names.intersection(pin2_names))
+
+
+def _get_net_labels_at_position(schematic, position: Point) -> List:
+    """
+    Get all local labels connected to the wire network at the given position.
+
+    Uses coordinate proximity matching like kicad-skip (0.6mm tolerance).
+
+    Args:
+        schematic: The schematic object
+        position: Pin position to check
+
+    Returns:
+        List of labels connected to this position's net
+    """
+    connected_labels = []
+    tolerance = 0.0  # Zero tolerance - KiCAD requires exact coordinate matching
+
+    # Find all wires connected to this position
+    connected_wires = []
+    for wire in schematic.wires:
+        for point in wire.points:
+            if point.x == position.x and point.y == position.y:
+                connected_wires.append(wire)
+                break
+
+    # Find labels near any connected wire points
+    labels_data = schematic._data.get("labels", [])
+    for label_dict in labels_data:
+        label_pos_dict = label_dict.get("position", {})
+        label_pos = Point(label_pos_dict.get("x", 0), label_pos_dict.get("y", 0))
+
+        # Check if label is near any connected wire
+        for wire in connected_wires:
+            for wire_point in wire.points:
+                if label_pos.x == wire_point.x and label_pos.y == wire_point.y:
+                    # Create a simple object with text attribute
+                    class SimpleLabel:
+                        def __init__(self, text):
+                            self.text = text
+
+                    connected_labels.append(SimpleLabel(label_dict.get("text", "")))
+                    break
+
+    return connected_labels
+
+
+def _get_hierarchical_labels_at_position(schematic, position: Point) -> List:
+    """
+    Get all hierarchical labels connected to the wire network at the given position.
+
+    Args:
+        schematic: The schematic object
+        position: Pin position to check
+
+    Returns:
+        List of hierarchical labels connected to this position's net
+    """
+    connected_labels = []
+    tolerance = 0.0  # Zero tolerance - KiCAD requires exact coordinate matching
+
+    # Find all wires connected to this position
+    connected_wires = []
+    for wire in schematic.wires:
+        for point in wire.points:
+            if point.x == position.x and point.y == position.y:
+                connected_wires.append(wire)
+                break
+
+    # Find hierarchical labels near any connected wire points
+    hier_labels_data = schematic._data.get("hierarchical_labels", [])
+    for label_dict in hier_labels_data:
+        label_pos_dict = label_dict.get("position", {})
+        label_pos = Point(label_pos_dict.get("x", 0), label_pos_dict.get("y", 0))
+
+        # Check if hierarchical label is near any connected wire
+        for wire in connected_wires:
+            for wire_point in wire.points:
+                if label_pos.x == wire_point.x and label_pos.y == wire_point.y:
+                    # Create a simple object with text attribute
+                    class SimpleLabel:
+                        def __init__(self, text):
+                            self.text = text
+
+                    connected_labels.append(SimpleLabel(label_dict.get("text", "")))
+                    break
+
+    return connected_labels
+
+
+def _trace_wire_network(
+    schematic, current_wire, target_position: Point, visited_uuids: set
+) -> bool:
+    """
+    Recursively trace wire network to find if it reaches target position.
+
+    Args:
+        schematic: The schematic object
+        current_wire: Current wire being traced
+        target_position: Target pin position we're looking for
+        visited_uuids: Set of already visited wire UUIDs to prevent infinite loops
+
+    Returns:
+        True if network reaches target position
+    """
+    wire_uuid = current_wire.uuid
+    if wire_uuid in visited_uuids:
+        return False
+
+    visited_uuids.add(wire_uuid)
+
+    # Check if current wire reaches target
+    for point in current_wire.points:
+        if point.x == target_position.x and point.y == target_position.y:
+            return True
+
+    # Find other wires connected to this wire's endpoints and trace them
+    for wire_point in current_wire.points:
+        for other_wire in schematic.wires:
+            if other_wire.uuid == wire_uuid or other_wire.uuid in visited_uuids:
+                continue
+
+            # Check if other wire shares an endpoint with current wire
+            for other_point in other_wire.points:
+                if wire_point.x == other_point.x and wire_point.y == other_point.y:
+                    if _trace_wire_network(schematic, other_wire, target_position, visited_uuids):
+                        return True
+
+    return False