Electrical

def place_dual_rails(
    c: KCell,
    p1: Port,
    p2: Port,
    pts: Sequence[kdb.Point],
    route_width: int | None = None,
    layer_info: kdb.LayerInfo | None = None,
    separation_rails: int | None = None,
    **kwargs: Any,
) -> ManhattanRoute:
    """Placer function for a single wire.

    Args:
        c: KCell to place the route in.
        p1: Start port.
        p2: End port.
        pts: Route backbone.
        route_width: Overwrite automatic detection of wire width.
            Total width of all rails.
        layer_info: Place on a specific layer. Otherwise, use
            `p1.layer_info`.
        separation_rails: Separation between the two rails.
        kwargs: Compatibility for type checkers. Throws an error if not empty.
    """
    if kwargs:
        raise ValueError(
            f"Additional kwargs aren't supported in route_dual_rails {kwargs=}"
        )
    if layer_info is None:
        layer_info = p1.layer_info
    if route_width is None:
        route_width = p1.width
    if separation_rails is None:
        raise ValueError("Must specify a separation between the two rails.")
    if separation_rails >= route_width:
        raise ValueError(f"{separation_rails=} must be smaller than the {route_width}")

    region = kdb.Region(kdb.Path(pts, route_width)) - kdb.Region(
        kdb.Path(pts, separation_rails)
    )

    shapes = [
        c.shapes(c.layer(layer_info)).insert(region[0]).polygon,
        c.shapes(c.layer(layer_info)).insert(region[1]).polygon,
    ]

    return ManhattanRoute(
        backbone=list(pts),
        start_port=p1,
        end_port=p2,
        taper_length=0,
        bend90_radius=0,
        polygons={layer_info: shapes},
        instances=[],
    )

def place_rf_rails(
    c: KCell,
    p1: Port,
    p2: Port,
    pts: Sequence[kdb.Point],
    route_width: int | None = None,
    *,
    center_trans: kdb.Trans | None = None,
    layer_info: kdb.LayerInfo | None = None,
    enclosure: LayerEnclosure | None = None,
    center_radius: dbu = 0,
    bend_factory: BendFactory | None = None,
    wire_factory: WireFactory | None = None,
    port_type: str = "electrical",
    allow_small_routes: bool = False,
    allow_width_mismatch: bool | None = None,
    allow_layer_mismatch: bool | None = None,
    allow_type_mismatch: bool | None = None,
    purpose: str | None = "routing",
    **kwargs: Any,
) -> ManhattanRoute:
    """Placer function for a single wire.

    Args:
        c: KCell to place the route in.
        p1: Start port.
        p2: End port.
        pts: Route backbone.
        route_width: Overwrite automatic detection of wire width.
            Total width of all rails.
        layer_info: Place on a specific layer. Otherwise, use
            `p1.layer_info`.
        enclosure: Apply an enclosure to the rail.
        center_radius: The radius at the center of the rails.
        bend_factory: The function to call to create the rail bends.
        wire_factory: The function to call to create the straights of the rails.
        port_type: Which port_type to filter the bend for.
        allow_small_routes: Proceed with placing even if there is not enough space.
        allow_width_mismatch: Allow to place even if port widths do not match.
        allow_layer_mismatch: Allow to place even if port layers do not match.
        allow_type_mismatch: Allow to place even if port port_type do not match.
        purpose: Which `Instance.purpose` to assign to the created instances of the
            placer.
        kwargs: Compatibility for type checkers. Throws an error if not empty.
    """
    if kwargs:
        raise ValueError(
            f"Additional kwargs aren't supported in route_dual_rails {kwargs=}"
        )

    if center_trans is None:
        raise ValueError("For placing rf rails, center_radius must be defined")
    if wire_factory is None:
        raise ValueError("for placing rf rails a wire factory must be supplied")
    if bend_factory is None:
        raise ValueError("for placing rf rails a bend factory must be supplied")

    if len(kwargs) > 0:
        raise ValueError(
            f"Additional args and kwargs are not allowed for route_smart.{kwargs=}"
        )
    if allow_width_mismatch is None:
        allow_width_mismatch = config.allow_width_mismatch
    if allow_layer_mismatch is None:
        allow_layer_mismatch = config.allow_layer_mismatch
    if allow_type_mismatch is None:
        allow_type_mismatch = config.allow_type_mismatch
    if wire_factory is None:
        raise ValueError(
            "place_rf_rails needs to have a wire_factory set. Please pass a "
            "wire_factory which takes kwargs 'width: int' and 'length: int'."
        )
    cross_section = p1.kcl.get_icross_section(
        SymmetricalCrossSection(
            width=p1.width,
            enclosure=enclosure or LayerEnclosure(sections=[], main_layer=layer_info),
        )
    )
    route_start_port = p1.copy()
    route_start_port.name = "route_start"
    route_start_port.trans.angle = (route_start_port.angle + 2) % 4
    route_end_port = p2.copy()
    route_end_port.name = "route_end"
    route_end_port.trans.angle = (route_end_port.angle + 2) % 4

    old_pt = pts[0]
    old_bend_port = p1

    offset = (center_trans.inverted() * p1.trans).disp.y
    inner_radius = center_radius - abs(offset)
    if inner_radius < 0:
        raise ValueError(
            "Radius for inner turns is below 0. Please increase center radius to get"
            " a radius >= 0."
        )
    outer_radius = center_radius + abs(offset)

    bend90_inner = bend_factory(cross_section=cross_section, radius=inner_radius)
    bend90_outer = bend_factory(cross_section=cross_section, radius=outer_radius)

    bend90_inner_ports = [p for p in bend90_inner.ports if p.port_type == port_type]
    bend90_outer_ports = [p for p in bend90_outer.ports if p.port_type == port_type]

    # test for outer same port names
    bend_outer_ports = [p for p in bend90_outer.ports if p.port_type == port_type]
    for p_in, p_out in zip(bend90_inner_ports, bend_outer_ports, strict=True):
        if not p_in.name == p_out.name:
            raise ValueError(
                "The bend port names and order must be consistent for different radii"
            )
        if not p_in.angle == p_out.angle:
            raise ValueError(
                "The bend port angles must be consistent for different radii"
            )

    if len(bend90_inner_ports) != NUM_PORTS_FOR_ROUTING:
        raise AttributeError(
            f"{bend90_inner.name} should have 2 ports but has "
            f"{len(bend90_inner_ports)} ports"
            f"with {port_type=}"
        )
    if (
        abs((bend90_inner_ports[0].trans.angle - bend90_inner_ports[1].trans.angle) % 4)
        != 1
    ):
        raise AttributeError(
            f"{bend90_inner.name} bend ports should be 90° apart from each other"
        )

    if (
        bend90_inner_ports[1].trans.angle - bend90_inner_ports[0].trans.angle
    ) % 4 == ANGLE_270:
        b90p1_inner = bend90_inner_ports[1]
        b90p2_inner = bend90_inner_ports[0]
    else:
        b90p1_inner = bend90_inner_ports[0]
        b90p2_inner = bend90_inner_ports[1]
    assert b90p1_inner.name is not None, logger.error(
        "bend90 needs named ports, {}", b90p1_inner
    )
    assert b90p2_inner.name is not None, logger.error(
        "bend90 needs named ports, {}", b90p2_inner
    )
    b90c_inner = kdb.Trans(
        b90p1_inner.trans.rot,
        b90p1_inner.trans.is_mirror(),
        b90p1_inner.trans.disp.x
        if b90p1_inner.trans.angle % 2
        else b90p2_inner.trans.disp.x,
        b90p2_inner.trans.disp.y
        if b90p1_inner.trans.angle % 2
        else b90p1_inner.trans.disp.y,
    )
    if (
        bend90_outer_ports[1].trans.angle - bend90_outer_ports[0].trans.angle
    ) % 4 == ANGLE_270:
        b90p1_outer = bend90_outer_ports[1]
        b90p2_outer = bend90_outer_ports[0]
    else:
        b90p1_outer = bend90_outer_ports[0]
        b90p2_outer = bend90_outer_ports[1]
    b90c_outer = kdb.Trans(
        b90p1_outer.trans.rot,
        b90p1_outer.trans.is_mirror(),
        b90p1_outer.trans.disp.x
        if b90p1_outer.trans.angle % 2
        else b90p2_outer.trans.disp.x,
        b90p2_outer.trans.disp.y
        if b90p1_outer.trans.angle % 2
        else b90p1_outer.trans.disp.y,
    )
    b90r_inner = round(
        max(
            (b90p1_inner.trans.disp - b90c_inner.disp).length(),
            (b90p2_inner.trans.disp - b90c_inner.disp).length(),
        )
    )
    b90r_outer = round(
        max(
            (b90p1_outer.trans.disp - b90c_outer.disp).length(),
            (b90p2_outer.trans.disp - b90c_outer.disp).length(),
        )
    )
    route = ManhattanRoute(
        backbone=list(pts).copy(),
        start_port=route_start_port,
        end_port=route_end_port,
        instances=[],
        bend90_radius=center_radius,
        taper_length=0,
    )

    if not pts or len(pts) < MIN_POINTS_FOR_PLACEMENT:
        # Nothing to be placed
        return route

    if len(pts) == MIN_POINTS_FOR_PLACEMENT:
        length = int((pts[1] - pts[0]).length())
        wg = c << wire_factory(
            cross_section=cross_section, length=int((pts[1] - pts[0]).length())
        )
        wg.purpose = purpose
        wg_p1, wg_p2 = (v for v in wg.ports if v.port_type == port_type)
        wg.connect(
            wg_p1,
            p1,
            allow_width_mismatch=route_width is not None or allow_width_mismatch,
            allow_layer_mismatch=allow_layer_mismatch,
            allow_type_mismatch=allow_type_mismatch,
        )
        route.instances.append(wg)
        route.start_port = Port(base=wg_p1.base.transformed())
        route.start_port.name = "route_start"
        route.length_straights += int(length)
        return route
    for i in range(1, len(pts) - 1):
        pt = pts[i]
        new_pt = pts[i + 1]

        if (pt.distance(old_pt) < b90r_inner) and not allow_small_routes:
            raise ValueError(
                f"distance between points {old_pt!s} and {pt!s} is too small to"
                f" safely place bends {pt.to_s()=}, {old_pt.to_s()=},"
                f" {pt.distance(old_pt)=} < {b90r_inner=}"
            )
        if (
            pt.distance(old_pt) < b90r_inner + b90r_outer
            and i not in {1, len(pts) - 1}
            and not allow_small_routes
        ):
            raise ValueError(
                f"distance between points {old_pt!s} and {pt!s} is too small to"
                f" safely place bends {pt=!s}, {old_pt=!s},"
                f" {pt.distance(old_pt)=} < {b90r_inner + b90r_outer=}"
            )

        vec = pt - old_pt
        vec_n = new_pt - pt
        old_angle = vec_angle(vec)
        angle = vec_angle(vec_n)

        sign = int(np.sign(offset)) or 1

        d_angle = (sign * (angle - old_angle)) % 4
        if d_angle == 1:
            bend90 = c << bend_factory(cross_section=cross_section, radius=inner_radius)
            b90c = b90c_inner
        elif d_angle == 3:
            bend90 = c << bend_factory(cross_section=cross_section, radius=outer_radius)
            b90c = b90c_outer
        else:
            raise ValueError(
                "Points are not clean. Make sure to clean the points before supplying "
                "them to the multi rail placer"
            )

        bend90.purpose = purpose
        route.n_bend90 += 1
        mirror = (vec_angle(vec_n) - vec_angle(vec)) % 4 != ANGLE_270
        if (vec.y != 0) and (vec.x != 0):
            raise ValueError(
                f"The vector between manhattan points is not manhattan {old_pt}, {pt}"
            )
        ang = (vec_angle(vec) + 2) % 4
        if ang is None:
            raise ValueError(
                f"The vector between manhattan points is not manhattan {old_pt}, {pt}"
            )
        bend90.transform(kdb.Trans(ang, mirror, pt.x, pt.y) * b90c.inverted())
        length = int(
            (
                bend90.ports[b90p1_inner.name].trans.disp - old_bend_port.trans.disp
            ).length()
        )
        if length > 0:
            wg = c << wire_factory(cross_section=cross_section, length=length)
            wg.purpose = purpose
            wg_p1, wg_p2 = (v for v in wg.ports if v.port_type == port_type)
            wg.connect(
                wg_p1,
                bend90,
                b90p1_inner.name,
                allow_width_mismatch=allow_width_mismatch,
                allow_layer_mismatch=allow_layer_mismatch,
                allow_type_mismatch=allow_type_mismatch,
            )
            route.instances.append(wg)
            route.length_straights += int(length)
        route.instances.append(bend90)
        old_pt = pt
        old_bend_port = bend90.ports[b90p2_inner.name]
    length = int((bend90.ports[b90p2_inner.name].trans.disp - p2.trans.disp).length())
    if length > 0:
        wg = c << wire_factory(cross_section=cross_section, length=length)
        wg.purpose = purpose
        wg_p1, wg_p2 = (v for v in wg.ports if v.port_type == port_type)
        wg.connect(
            wg_p1.name,
            bend90,
            b90p2_inner.name,
            allow_width_mismatch=allow_width_mismatch,
            allow_layer_mismatch=allow_layer_mismatch,
            allow_type_mismatch=allow_type_mismatch,
        )
        route.instances.append(wg)
        route.end_port = wg.ports[wg_p2.name].copy()
        route.end_port.name = "route_end"
        route.length_straights += int(length)

    else:
        route.end_port = old_bend_port.copy()
        route.end_port.name = "route_end"
    return route

def place_single_wire(
    c: KCell,
    p1: Port,
    p2: Port,
    pts: Sequence[kdb.Point],
    route_width: int | None = None,
    layer_info: kdb.LayerInfo | None = None,
    **kwargs: Any,
) -> ManhattanRoute:
    """Placer function for a single wire.

    Args:
        c: KCell to place the route in.
        p1: Start port.
        p2: End port.
        pts: Route backbone.
        route_width: Overwrite automatic detection of wire width.
        layer_info: Place on a specific layer. Otherwise, use
            `p1.layer_info`.
        kwargs: Compatibility for type checkers. Throws an error if not empty.
    """
    if layer_info is None:
        layer_info = p1.layer_info
    if route_width is None:
        route_width = p1.width
    if kwargs:
        raise ValueError(
            f"Additional kwargs aren't supported in route_single_wire {kwargs=}"
        )

    shape = (
        c.shapes(c.layer(layer_info))
        .insert(kdb.Path(pts, width=route_width).polygon())
        .polygon
    )

    length = 0.0
    pt1 = pts[0]
    for pt2 in pts[1:]:
        length += (pt2 - pt1).length()

    return ManhattanRoute(
        backbone=list(pts),
        start_port=p1,
        end_port=p2,
        taper_length=0,
        bend90_radius=0,
        polygons={layer_info: [shape]},
        instances=[],
        length_straights=round(length),
        length_function=get_length_from_backbone,
    )

def route_bundle(
    c: KCell | DKCell,
    start_ports: Sequence[Port] | Sequence[DPort],
    end_ports: Sequence[Port] | Sequence[DPort],
    separation: dbu | um,
    place_layer: kdb.LayerInfo | None = None,
    route_width: dbu | um | list[dbu] | list[um] | None = None,
    bboxes: Sequence[kdb.Box] | Sequence[kdb.DBox] | None = None,
    bbox_routing: Literal["minimal", "full"] = "minimal",
    sort_ports: bool = False,
    collision_check_layers: Sequence[kdb.LayerInfo] | None = None,
    on_collision: Literal["error", "show_error"] | None = "show_error",
    on_placer_error: Literal["error", "show_error"] | None = "show_error",
    waypoints: kdb.Trans
    | list[kdb.Point]
    | kdb.DTrans
    | list[kdb.DPoint]
    | None = None,
    starts: dbu
    | list[dbu]
    | um
    | list[um]
    | list[Step]
    | list[list[Step]]
    | None = None,
    ends: dbu | list[dbu] | um | list[um] | list[Step] | list[list[Step]] | None = None,
    start_angles: list[int] | float | list[float] | None = None,
    end_angles: list[int] | float | list[float] | None = None,
    purpose: str | None = "routing",
    constraints: Sequence[Constraint] | None = None,
    route_debug: RouteDebug | None = None,
) -> list[ManhattanRoute]:
    r"""Connect multiple input ports to output ports.

    This function takes a list of input ports and assume they are all oriented in the
    same direction (could be any of W, S, E, N). The target ports have the opposite
    orientation, i.e. if input ports are oriented to north, and target ports should
    be oriented to south. The function will produce a routing to connect input ports
    to output ports without any crossings.

    Waypoints will create a front which will create ports in a 1D array. If waypoints
    are a transformation it will be like a point with a direction. If multiple points
    are passed, the direction will be invfered.
    For orientation of 0 degrees it will create the following front for 4 ports:

    ```
          │
          │
          │
          p1 ->
          │
          │
          │


          │
          │
          │
          p2 ->
          │
          │
          │
      ___\waypoint
         /
          │
          │
          │
          p3 ->
          │
          │
          │


          │
          │
          │
          p4 ->
          │
          │
          │
    ```

    Args:
        c: KCell to place the routes in.
        start_ports: List of start ports.
        end_ports: List of end ports.
        separation: Minimum space between wires. [dbu]
        starts: Minimal straight segment after `start_ports`.
        ends: Minimal straight segment before `end_ports`.
        place_layer: Override automatic detection of layers with specific layer.
        route_width: Width of the route. If None, the width of the ports is used.
        bboxes: List of boxes to consider. Currently only boxes overlapping ports will
            be considered.
        bbox_routing: "minimal": only route to the bbox so that it can be safely routed
            around, but start or end bends might encroach on the bounding boxes when
            leaving them.
        sort_ports: Automatically sort ports.
        collision_check_layers: Layers to check for actual errors if manhattan routes
            detect potential collisions.
        on_collision: Define what to do on routing collision. Default behaviour is to
            open send the layout of c to klive and open an error lyrdb with the
            collisions. "error" will simply raise an error. None will ignore any error.
        on_placer_error: If a placing of the components fails, use the strategy above to
            handle the error. show_error will visualize it in klayout with the intended
            route along the already placed parts of c. Error will just throw an error.
            None will ignore the error.
        waypoints: Bundle the ports and route them with minimal separation through
            the waypoints. The waypoints can either be a list of at least two points
            or a single transformation. If it's a transformation, the points will be
            routed through it as if it were a tunnel with length 0.
        start_angles: Overwrite the port orientation of all start_ports together
            (single value) or each one (list of values which is as long as start_ports).
        end_angles: Overwrite the port orientation of all start_ports together
            (single value) or each one (list of values which is as long as end_ports).
            If no waypoints are set, the target angles of all ends muts be the same
            (after the steps).
        purpose: Purpose of the routes. (Unused)
    """
    if ends is None:
        ends = []
    if starts is None:
        starts = []
    if bboxes is None:
        bboxes = []

    start_ports_ = [p.base.model_copy() for p in start_ports]
    end_ports_ = [p.base.model_copy() for p in end_ports]

    if isinstance(c, KCell):
        try:
            return route_bundle_generic(
                c=c,
                start_ports=start_ports_,
                end_ports=end_ports_,
                starts=cast("dbu | list[dbu] | list[Step] | list[list[Step]]", starts),
                ends=cast("dbu | list[dbu] | list[Step] | list[list[Step]]", ends),
                routing_function=route_smart,
                routing_kwargs={
                    "separation": separation,
                    "sort_ports": sort_ports,
                    "bbox_routing": bbox_routing,
                    "bboxes": list(bboxes),
                    "bend90_radius": 0,
                    "waypoints": waypoints,
                },
                placer_function=place_single_wire,
                placer_kwargs={
                    "route_width": route_width,
                },
                on_collision=on_collision,
                on_placer_error=on_placer_error,
                collision_check_layers=collision_check_layers,
                start_angles=cast("int | list[int] | None", start_angles),
                end_angles=cast("int | list[int]", end_angles),
                route_width=cast("int", route_width),
                constraints=constraints,
                route_debug=route_debug,
            )
        except ValueError as e:
            if str(e).startswith("Found non-manhattan waypoints."):
                waypoints = cast("list[kdb.Point]", waypoints)
                wp_old = waypoints[0]
                non_manhattan_wps: list[tuple[kdb.Point, kdb.Point, kdb.Vector]] = []
                for wp in waypoints[1:]:
                    v = wp - wp_old
                    if not _is_manhattan(v):
                        non_manhattan_wps.append((wp_old, wp, v))
                    wp_old = wp
                error_msg = (
                    "Found non-manhattan waypoints. route_smart only supports manhattan"
                    " (orthogonal to the axes) routing.\n Non-manhattan waypoints "
                    "(x,y)[dbu]:\n"
                )
                for error_wp in non_manhattan_wps:
                    error_msg += (
                        f"Start point: {error_wp[0]} End point: {error_wp[1]} "
                        f"Resulting vector (end - start): {error_wp[2]}\n"
                    )
                if on_placer_error == "show_error":
                    c_: KCell | DKCell = c.dup()
                    c_.name = c.kcl.future_cell_name or c.name
                    db = rdb.ReportDatabase("Routing Waypoint Errors")
                    err_cat = db.create_category("Waypoint Error")
                    wp_cat = db.create_category("Waypoints")
                    cell = db.create_cell(c_.name)
                    wp_len = len(waypoints)

                    width = (
                        cast("int | None", route_width)
                        or Port(base=start_ports_[0]).width
                    )

                    for i, wp in enumerate(waypoints):
                        it = db.create_item(cell=cell, category=wp_cat)
                        it.add_value(f"Waypoint {i + 1}/{wp_len}")
                        it.add_value(
                            kdb.DText(
                                f"Waypoint {i + 1}/{wp_len}",
                                kdb.Trans(wp.to_v()).to_dtype(c.kcl.dbu),
                            )
                        )
                        it.add_value(
                            kdb.Box(width).moved(wp.to_v()).to_dtype(c.kcl.dbu)
                        )
                    for error_wp in non_manhattan_wps:
                        it = db.create_item(cell=cell, category=err_cat)
                        it.add_value(
                            kdb.Path([error_wp[0], error_wp[1]], width)
                            .to_dtype(c.kcl.dbu)
                            .polygon()
                        )
                    c_.show(lyrdb=db)
                raise ValueError(error_msg) from e

    if route_width is not None:
        if isinstance(route_width, list):
            route_width = [c.kcl.to_dbu(width) for width in route_width]
        else:
            route_width = c.kcl.to_dbu(route_width)
    angles: dict[int | float, int] = {0: 0, 90: 1, 180: 2, 270: 30}
    if start_angles is not None:
        if isinstance(start_angles, list):
            start_angles = [angles[angle] for angle in start_angles]
        else:
            start_angles = angles[start_angles]
    if end_angles is not None:
        if isinstance(end_angles, list):
            end_angles = [angles[angle] for angle in end_angles]
        else:
            end_angles = angles[end_angles]

    if isinstance(starts, int | float):
        starts = c.kcl.to_dbu(starts)
    elif isinstance(starts, list):
        if isinstance(starts[0], int | float):
            starts = [c.kcl.to_dbu(cast("int|float", start)) for start in starts]
        starts = cast("int | list[int] | list[Step] | list[list[Step]]", starts)
    if isinstance(ends, int | float):
        ends = c.kcl.to_dbu(ends)
    elif isinstance(ends, list):
        if isinstance(ends[0], int | float):
            ends = [c.kcl.to_dbu(cast("int|float", end)) for end in ends]
        ends = cast("int | list[int] | list[Step] | list[list[Step]]", ends)
    if waypoints is not None:
        if isinstance(waypoints, list):
            waypoints = [
                p.to_itype(c.kcl.dbu) for p in cast("list[kdb.DPoint]", waypoints)
            ]
        else:
            waypoints = cast("kdb.DCplxTrans", waypoints).s_trans().to_itype(c.kcl.dbu)
    try:
        return route_bundle_generic(
            c=c.kcl[c.cell_index()],
            start_ports=start_ports_,
            end_ports=end_ports_,
            starts=starts,
            ends=ends,
            routing_function=route_smart,
            routing_kwargs={
                "separation": c.kcl.to_dbu(separation),
                "sort_ports": sort_ports,
                "bbox_routing": bbox_routing,
                "bboxes": [
                    bb.to_itype(c.kcl.dbu) for bb in cast("list[kdb.DBox]", bboxes)
                ],
                "bend90_radius": 0,
                "waypoints": waypoints,
            },
            placer_function=place_single_wire,
            placer_kwargs={
                "route_width": route_width,
                "layer_info": place_layer,
            },
            on_collision=on_collision,
            on_placer_error=on_placer_error,
            collision_check_layers=collision_check_layers,
            start_angles=start_angles,
            end_angles=end_angles,
            route_width=route_width,
            constraints=constraints,
            route_debug=route_debug,
        )
    except ValueError as e:
        if str(e).startswith("Found non-manhattan waypoints."):
            waypoints = cast("list[kdb.DPoint]", waypoints)
            wp_old_d = waypoints[0]
            non_manhattan_wps_d: list[tuple[kdb.DPoint, kdb.DPoint, kdb.DVector]] = []
            for wp_d in waypoints[1:]:
                v_d = wp_d - wp_old_d
                if not _is_manhattan(v_d):
                    non_manhattan_wps_d.append((wp_old_d, wp_d, v_d))
                wp_old_d = wp_d
            error_msg = (
                "Found non-manhattan waypoints. route_smart only supports manhattan"
                " (orthogonal to the axes) routing.\n Non-manhattan waypoints "
                "(x,y)[dbu]:\n"
            )
            for error_wp_d in non_manhattan_wps_d:
                error_msg += (
                    f"Start point: {error_wp_d[0]} End point: {error_wp_d[1]} "
                    f"Resulting vector (end - start): {error_wp_d[2]}\n"
                )
            if on_placer_error == "show_error":
                c_ = c.dup()
                c_.name = c.kcl.future_cell_name or c.name
                db = rdb.ReportDatabase("Routing Waypoint Errors")
                err_cat = db.create_category("Waypoint Error")
                wp_cat = db.create_category("Waypoints")
                cell = db.create_cell(c_.name)
                wp_len = len(waypoints)

                width_d = (
                    cast("float | None", route_width)
                    or DPort(base=start_ports_[0]).width
                )

                for i, wp_d in enumerate(waypoints):
                    it = db.create_item(cell=cell, category=wp_cat)
                    it.add_value(f"Waypoint {i + 1}/{wp_len}")
                    it.add_value(
                        kdb.DText(f"Waypoint {i + 1}/{wp_len}", kdb.DTrans(wp_d.to_v()))
                    )
                    it.add_value(kdb.DBox(width_d).moved(wp_d.to_v()))
                for error_wp_d in non_manhattan_wps_d:
                    it = db.create_item(cell=cell, category=err_cat)
                    it.add_value(
                        kdb.DPath([error_wp_d[0], error_wp_d[1]], width_d).polygon()
                    )
                c_.show(lyrdb=db)
            raise ValueError(error_msg) from e
        raise

def route_bundle_dual_rails(
    c: KCell,
    start_ports: list[Port],
    end_ports: list[Port],
    separation: dbu,
    place_layer: kdb.LayerInfo | None = None,
    width_rails: dbu | None = None,
    separation_rails: dbu | None = None,
    bboxes: list[kdb.Box] | None = None,
    bbox_routing: Literal["minimal", "full"] = "minimal",
    sort_ports: bool = False,
    collision_check_layers: Sequence[kdb.LayerInfo] | None = None,
    on_collision: Literal["error", "show_error"] | None = "show_error",
    on_placer_error: Literal["error", "show_error"] | None = "show_error",
    waypoints: kdb.Trans | list[kdb.Point] | None = None,
    starts: dbu | list[dbu] | list[Step] | list[list[Step]] | None = None,
    ends: dbu | list[dbu] | list[Step] | list[list[Step]] | None = None,
    start_angles: int | list[int] | None = None,
    end_angles: int | list[int] | None = None,
    constraints: Sequence[Constraint] | None = None,
    route_debug: RouteDebug | None = None,
) -> list[ManhattanRoute]:
    r"""Connect multiple input ports to output ports.

    This function takes a list of input ports and assume they are all oriented in the
    same direction (could be any of W, S, E, N). The target ports have the opposite
    orientation, i.e. if input ports are oriented to north, and target ports should
    be oriented to south. The function will produce a routing to connect input ports
    to output ports without any crossings.

    Waypoints will create a front which will create ports in a 1D array. If waypoints
    are a transformation it will be like a point with a direction. If multiple points
    are passed, the direction will be invfered.
    For orientation of 0 degrees it will create the following front for 4 ports:

    ```
          │
          │
          │
          p1 ->
          │
          │
          │


          │
          │
          │
          p2 ->
          │
          │
          │
      ___\waypoint
         /
          │
          │
          │
          p3 ->
          │
          │
          │


          │
          │
          │
          p4 ->
          │
          │
          │
    ```

    Args:
        c: KCell to place the routes in.
        start_ports: List of start ports.
        end_ports: List of end ports.
        separation: Minimum space between wires. [dbu]
        starts: Minimal straight segment after `start_ports`.
        ends: Minimal straight segment before `end_ports`.
        place_layer: Override automatic detection of layers with specific layer.
        width_rails: Total width of the rails.
        separation_rails: Separation between the two rails.
        bboxes: List of boxes to consider. Currently only boxes overlapping ports will
            be considered.
        bbox_routing: "minimal": only route to the bbox so that it can be safely routed
            around, but start or end bends might encroach on the bounding boxes when
            leaving them.
        sort_ports: Automatically sort ports.
        collision_check_layers: Layers to check for actual errors if manhattan routes
            detect potential collisions.
        on_collision: Define what to do on routing collision. Default behaviour is to
            open send the layout of c to klive and open an error lyrdb with the
            collisions. "error" will simply raise an error. None will ignore any error.
        on_placer_error: If a placing of the components fails, use the strategy above to
            handle the error. show_error will visualize it in klayout with the intended
            route along the already placed parts of c. Error will just throw an error.
            None will ignore the error.
        waypoints: Bundle the ports and route them with minimal separation through
            the waypoints. The waypoints can either be a list of at least two points
            or a single transformation. If it's a transformation, the points will be
            routed through it as if it were a tunnel with length 0.
        start_angles: Overwrite the port orientation of all start_ports together
            (single value) or each one (list of values which is as long as start_ports).
        end_angles: Overwrite the port orientation of all start_ports together
            (single value) or each one (list of values which is as long as end_ports).
            If no waypoints are set, the target angles of all ends muts be the same
            (after the steps).
    """
    if ends is None:
        ends = []
    if starts is None:
        starts = []
    if bboxes is None:
        bboxes = []
    try:
        return route_bundle_generic(
            c=c,
            start_ports=[p.base for p in start_ports],
            end_ports=[p.base for p in end_ports],
            routing_function=route_smart,
            starts=starts,
            ends=ends,
            routing_kwargs={
                "separation": separation,
                "sort_ports": sort_ports,
                "bbox_routing": bbox_routing,
                "bboxes": list(bboxes),
                "bend90_radius": 0,
                "waypoints": waypoints,
            },
            placer_function=place_dual_rails,
            placer_kwargs={
                "separation_rails": separation_rails,
                "route_width": width_rails,
                "layer_info": place_layer,
            },
            on_collision=on_collision,
            on_placer_error=on_placer_error,
            collision_check_layers=collision_check_layers,
            start_angles=start_angles,
            end_angles=end_angles,
            constraints=constraints,
            route_debug=route_debug,
        )
    except ValueError as e:
        if str(e).startswith("Found non-manhattan waypoints."):
            waypoints = cast("list[kdb.Point]", waypoints)
            wp_old = waypoints[0]
            non_manhattan_wps: list[tuple[kdb.Point, kdb.Point, kdb.Vector]] = []
            for wp in waypoints[1:]:
                v = wp - wp_old
                if not _is_manhattan(v):
                    non_manhattan_wps.append((wp_old, wp, v))
                wp_old = wp
            error_msg = (
                "Found non-manhattan waypoints. route_smart only supports manhattan"
                " (orthogonal to the axes) routing.\n Non-manhattan waypoints "
                "(x,y)[dbu]:\n"
            )
            for error_wp in non_manhattan_wps:
                error_msg += (
                    f"Start point: {error_wp[0]} End point: {error_wp[1]} "
                    f"Resulting vector (end - start): {error_wp[2]}\n"
                )
            if on_placer_error == "show_error":
                c_: KCell | DKCell = c.dup()
                c_.name = c.kcl.future_cell_name or c.name
                db = rdb.ReportDatabase("Routing Waypoint Errors")
                err_cat = db.create_category("Waypoint Error")
                wp_cat = db.create_category("Waypoints")
                cell = db.create_cell(c_.name)
                wp_len = len(waypoints)

                width = width_rails or start_ports[0].width

                for i, wp in enumerate(waypoints):
                    it = db.create_item(cell=cell, category=wp_cat)
                    it.add_value(f"Waypoint {i + 1}/{wp_len}")
                    it.add_value(
                        kdb.DText(
                            f"Waypoint {i + 1}/{wp_len}",
                            kdb.Trans(wp.to_v()).to_dtype(c.kcl.dbu),
                        )
                    )
                    it.add_value(kdb.Box(width).moved(wp.to_v()).to_dtype(c.kcl.dbu))
                for error_wp in non_manhattan_wps:
                    it = db.create_item(cell=cell, category=err_cat)
                    it.add_value(
                        kdb.Path([error_wp[0], error_wp[1]], width)
                        .to_dtype(c.kcl.dbu)
                        .polygon()
                    )
                c_.show(lyrdb=db)
            raise ValueError(error_msg) from e
        raise