Routing API

def route_single(
    component: Component,
    port1: Port,
    port2: Port,
    cross_section: CrossSectionSpec | None = None,
    layer: LayerSpec | None = None,
    bend: ComponentSpec = "bend_euler",
    straight: ComponentSpec = "straight",
    start_straight_length: float = 0.0,
    end_straight_length: float = 0.0,
    waypoints: WayPoints | None = None,
    steps: Sequence[Step] | None = None,
    port_type: str | None = None,
    allow_width_mismatch: bool = False,
    radius: float | None = None,
    route_width: float | None = None,
    auto_taper: bool = True,
    on_error: Literal["error"] | None = None,
    layer_transitions: LayerTransitions | None = None,
) -> ManhattanRoute:
    """Returns a Manhattan Route between 2 ports.

    The references are straights, bends and tapers.

    Args:
        component: to place the route into.
        port1: start port.
        port2: end port.
        cross_section: spec.
        layer: layer spec.
        bend: bend spec.
        straight: straight spec.
        start_straight_length: length of starting straight.
        end_straight_length: length of end straight.
        waypoints: optional list of points to pass through.
        steps: optional list of steps to pass through.
            Each step is a dict with keys: x (absolute), y (absolute), dx (relative), dy (relative).
            Use x/y to set an absolute coordinate and dx/dy to shift relative to the current position.
        port_type: port type to route.
        allow_width_mismatch: allow different port widths.
        radius: bend radius. If None, defaults to cross_section.radius.
        route_width: width of the route in um. If None, defaults to cross_section.width.
        auto_taper: add auto tapers.
        on_error: what to do on error. If error, raises an error. If None ignores the error.
        layer_transitions: dictionary of layer transitions to use for the routing when auto_taper=True.

    Example:
        ```python
        import gdsfactory as gf

        c = gf.Component()
        mmi1 = c << gf.components.mmi1x2()
        mmi2 = c << gf.components.mmi1x2()
        mmi2.move((40, 20))
        gf.routing.route_single(c, mmi1.ports["o2"], mmi2.ports["o1"], radius=5, cross_section="strip")
        c.plot()
        ```
    """
    if cross_section is None and (layer is None or route_width is None):
        raise ValueError(
            f"Either {cross_section=} or {layer=} and route_width must be provided"
        )

    c = component
    p1 = port1
    p2 = port2
    port_type = port_type or p1.port_type

    if cross_section is None:
        cross_section = gf.cross_section.cross_section(
            layer=cast("LayerSpec", layer),
            width=cast("float", route_width),
            port_names=("e1", "e2") if port_type == "electrical" else ("o1", "o2"),
            port_types=(port_type, port_type),
        )

    if route_width:
        xs = gf.get_cross_section(cross_section, width=route_width)
    else:
        xs = gf.get_cross_section(cross_section)
    width = route_width or xs.width

    radius = radius or xs.radius
    bend90 = gf.get_component(bend, cross_section=xs, radius=radius, width=width)
    if auto_taper:
        p1 = add_auto_tapers(component, [p1], xs, layer_transitions)[0]
        p2 = add_auto_tapers(component, [p2], xs, layer_transitions)[0]

    def straight_(width: float, length: float, **kwargs: Any) -> gf.Component:
        return gf.get_component(straight, length=length, **kwargs)

    def straight_dbu(width: int, length: int, **kwargs: Any) -> gf.Component:
        return straight_(c.kcl.to_um(width), c.kcl.to_um(length), **kwargs)

    if steps and waypoints:
        raise ValueError("Provide only one of steps or waypoints")

    waypoints_list = [] if waypoints is None else list(waypoints)

    if steps:
        x, y = p1.center
        for d in steps:
            if isinstance(d, dict):
                if not STEP_DIRECTIVES.issuperset(d):
                    raise ValueError(
                        f"Invalid step directives: {list(d.keys() - STEP_DIRECTIVES)}."
                        f"Valid directives are {list(STEP_DIRECTIVES)}"
                    )
                x = d.get("x", x) + d.get("dx", 0)
                y = d.get("y", y) + d.get("dy", 0)
            else:
                raise ValueError(
                    f"Invalid step {d!r}. Each step must be a dict with keys (x, y, dx, dy)."
                )
            waypoints_list.append((x, y))

    if waypoints_list and steps and len(waypoints_list) < 2:
        p = waypoints_list[-1]
        x, y = (p.x, p.y) if isinstance(p, kf.kdb.DPoint) else (p[0], p[1])
        x1, y1 = p1.center
        x2, y2 = p2.center
        orientation = p2.orientation
        if orientation is not None and int(orientation) in {0, 180}:
            yt = y1 + (y2 - y1) / 3
            ytt = y1 + 2 * (y2 - y1) / 3
            waypoints_list = [(x, yt), (x, ytt)]
        elif orientation is not None and int(orientation) in {90, 270}:
            xt = x1 + (x2 - x1) / 3
            xtt = x1 + 2 * (x2 - x1) / 3
            waypoints_list = [(xt, y), (xtt, y)]

    if waypoints_list:
        w: list[kf.kdb.Point] = []
        if not isinstance(waypoints_list[0], kf.kdb.DPoint):
            w.append(c.kcl.to_dbu(kf.kdb.DPoint(*p1.center)))
            for p in waypoints_list:
                if isinstance(p, tuple):
                    w.append(c.kcl.to_dbu(kf.kdb.DPoint(p[0], p[1])))
                else:
                    w.append(p.to_itype(c.kcl.dbu))
            w.append(c.kcl.to_dbu(kf.kdb.DPoint(*p2.center)))
        else:
            w = [
                p.to_itype(c.kcl.dbu)
                for p in cast("Sequence[gf.kdb.DPoint]", waypoints_list)
            ]

        try:
            return place_manhattan(
                component.to_itype(),
                p1=p1.to_itype(),
                p2=p2.to_itype(),
                straight_factory=straight_dbu,
                bend90_cell=bend90.to_itype(),
                pts=w,
                port_type=port_type,
                allow_width_mismatch=allow_width_mismatch,
                route_width=c.kcl.to_dbu(width),
            )
        except Exception as e:
            # error_route((ps, pe, router.start.pts, router.width))
            ps = p1
            pe = p2
            c = component
            pts = w
            db = kf.rdb.ReportDatabase("Route Placing Errors")
            cell = db.create_cell(
                (
                    c.kcl._future_cell_name or c.name
                    if c.name is not None and c.name.startswith("Unnamed_")
                    else c.name
                )
                or ""
            )
            cat = db.create_category(f"{ps.name} - {pe.name}")
            it = db.create_item(cell=cell, category=cat)
            it.add_value(
                f"Error while trying to place route from {ps.name} to {pe.name} at"
                f" points (dbu): {pts}"
            )
            it.add_value(f"Exception: {e}")
            if route_width is not None:
                path = kf.kdb.Path(pts, c.kcl.to_dbu(route_width))
            else:
                path = kf.kdb.Path(pts, c.kcl.to_dbu(ps.width))

            it.add_value(c.kcl.to_um(path.polygon()))
            if on_error == "error":
                c.name = (
                    c.kcl._future_cell_name or c.name
                    if c.name is not None and c.name.startswith("Unnamed_")
                    else c.name
                ) or ""
                c.show(lyrdb=db)
                raise kf.routing.generic.PlacerError(
                    f"Error while trying to place route from {ps.name} to {pe.name} at"
                    f" points (dbu): {pts}"
                ) from e
            layer_error = gf.CONF.layer_error_path
            layer_index = c.kcl.layer(*layer_error)
            c.shapes(layer_index).insert(path)
            return ManhattanRoute(
                backbone=pts,
                start_port=p1.to_itype(),
                end_port=p2.to_itype(),
            )

    else:
        return kf.routing.optical.route_bundle(
            c=component,
            start_ports=[p1],
            end_ports=[p2],
            straight_factory=straight_,
            bend90_cell=bend90,
            starts=start_straight_length,
            ends=end_straight_length,
            separation=0,
            place_port_type=port_type,
            allow_width_mismatch=allow_width_mismatch,
            route_width=route_width,
        )[0]

def route_single_electrical(
    component: Component,
    port1: Port,
    port2: Port,
    start_straight_length: float | None = None,
    end_straight_length: float | None = None,
    layer: LayerSpec | None = None,
    width: float | None = None,
    cross_section: CrossSectionSpec = "metal_routing",
) -> None:
    """Places a route between two electrical ports.

    Args:
        component: The cell to place the route in.
        port1: The first port.
        port2: The second port.
        start_straight_length: The length of the straight at the start of the route.
        end_straight_length: The length of the straight at the end of the route.
        layer: The layer of the route.
        width: The width of the route.
        cross_section: The cross section of the route.

    """
    xs = gf.get_cross_section(cross_section)
    layer = layer or xs.layer
    width = width or xs.width
    layer = gf.get_layer(layer)
    kf.routing.electrical.route_bundle(
        c=component,
        start_ports=[port1],
        end_ports=[port2],
        separation=0,
        route_width=width,
        place_layer=kf.kdb.LayerInfo(layer[0], layer[1])
        if isinstance(layer, tuple)
        else None,
        starts=start_straight_length,
        ends=end_straight_length,
    )

def route_quad(
    component: gf.Component,
    port1: Port,
    port2: Port,
    width1: float | None = None,
    width2: float | None = None,
    layer: gf.typings.LayerSpec = "M1",
    manhattan_target_step: float | None = None,
) -> None:
    """Routes a basic quadrilateral polygon directly between two ports.

    Args:
        component: Component to add the route to.
        port1: Port to start route.
        port2 : Port objects to end route.
        width1: Width of quadrilateral at ports. If None, uses port widths.
        width2: Width of quadrilateral at ports. If None, uses port widths.
        layer: Layer to put the route on.
        manhattan_target_step: if not none, min step to manhattanize the polygon

    Example:
        ```python
        import gdsfactory as gf

        c = gf.Component()
        pad1 = c << gf.components.pad(size=(50, 50))
        pad2 = c << gf.components.pad(size=(10, 10))
        pad2.movex(100)
        pad2.movey(50)
        gf.routing.route_quad(
        c,
        pad1.ports["e2"],
        pad2.ports["e4"],
        width1=None,
        width2=None,
        )
        c.plot()
        ```
    """

    def get_port_edges(
        port: Port, width: float
    ) -> tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]]:
        _, e1 = _get_rotated_basis(port.orientation)
        pt1 = port.center + e1 * width / 2
        pt2 = port.center - e1 * width / 2
        return pt1, pt2

    if width1 is None:
        width1 = port1.width
    if width2 is None:
        width2 = port2.width
    vertices = np.array(get_port_edges(port1, width1) + get_port_edges(port2, width2))
    center = np.mean(vertices, axis=0)
    displacements = vertices - center
    # sort vertices by angle from center of quadrilateral to make convex polygon
    angles = np.arctan2(displacements[:, 0], displacements[:, 1])
    sorted_vertices: npt.NDArray[np.floating[Any]] = np.array(
        [
            vert
            for _, vert in sorted(
                zip(angles, vertices, strict=False), key=lambda x: x[0]
            )
        ],
        dtype=np.float64,
    )

    if manhattan_target_step:
        component.add_polygon(
            sorted_vertices,
            layer=layer,
        )
    else:
        component.add_polygon(points=sorted_vertices, layer=layer)

def path_C(
    port1: typings.Port,
    port2: typings.Port,
    length1: float = 100,
    left1: float = 100,
    length2: float = 100,
) -> Path:
    """Return waypoint path between port1 and port2 in a C shape. Useful when ports are parallel and face away from each other.

    Args:
        port1: start port.
        port2: end port.
        length1: Length of route segment coming out of port1. Should be larger than bend radius.
        left1: Length of route segment that turns left (or right if negative) from port1. Should be larger than twice the bend radius.
        length2: Length of route segment coming out of port2. Should be larger than bend radius.

    """
    delta_orientation = np.round(
        np.abs(np.mod(port1.orientation - port2.orientation, 360)), 3
    )
    if delta_orientation not in (0, 180, 360):
        raise ValueError("path_C(): ports must be parallel.")
    e1, e_left = _get_rotated_basis(port1.orientation)
    e2, _ = _get_rotated_basis(port2.orientation)
    # assemble route points
    pt1 = port1.center
    pt2 = pt1 + length1 * e1  # outward from port1 by length1
    pt3 = pt2 + left1 * e_left  # leftward by left1
    pt6 = port2.center
    pt5 = pt6 + length2 * e2  # outward from port2 by length2
    delta_vec = pt5 - pt3
    pt4 = pt3 + np.dot(delta_vec, e1) * e1  # move orthogonally in e1 direction
    return Path(np.array([pt1, pt2, pt3, pt4, pt5, pt6]))

def path_J(
    port1: typings.Port, port2: typings.Port, length1: float = 200, length2: float = 200
) -> Path:
    """Return waypoint path between port1 and port2 in a J shape.

    Useful when  orthogonal ports cannot be connected directly with an L shape.

    Args:
        port1: start port.
        port2: end port.
        length1: Length of segment exiting port1. Should be larger than bend radius.
        length2: Length of segment exiting port2. Should be larger than bend radius.
    """
    delta_orientation = np.round(
        np.abs(np.mod(port1.orientation - port2.orientation, 360)), 3
    )
    if delta_orientation not in (90, 270):
        raise ValueError("path_J(): ports must be orthogonal.")
    e1, _ = _get_rotated_basis(port1.orientation)
    e2, _ = _get_rotated_basis(port2.orientation)
    # assemble waypoints
    pt1 = port1.center
    pt2 = pt1 + length1 * e1  # outward from port1 by length1
    pt5 = port2.center
    pt4 = pt5 + length2 * e2  # outward from port2 by length2
    delta_vec = pt4 - pt2
    pt3 = pt2 + np.dot(delta_vec, e2) * e2  # move orthogonally in e2 direction
    return Path(np.array([pt1, pt2, pt3, pt4, pt5]))

def path_L(port1: typings.Port, port2: typings.Port) -> Path:
    """Return waypoint path between port1 and port2 in an L shape.

    Useful when orthogonal ports can be directly connected with one turn.

    Args:
        port1: start port.
        port2: end port.

    """
    delta_orientation = np.round(
        np.abs(np.mod(port1.orientation - port2.orientation, 360)), 3
    )
    if delta_orientation not in (90, 270):
        raise ValueError("path_L(): ports must be orthogonal.")
    e1, _e2 = _get_rotated_basis(port1.orientation)

    # assemble waypoints
    pt1 = np.asarray(port1.center)
    pt3 = port2.center
    delta_vec = pt3 - pt1
    pt2 = pt1 + np.dot(delta_vec, e1) * e1
    return Path(np.array([pt1, pt2, pt3]))

def path_U(port1: typings.Port, port2: typings.Port, length1: float = 200) -> Path:
    """Return waypoint path between port1 and port2 in a U shape.

    Useful when ports face the same direction or toward each other.

    Args:
        port1: start port.
        port2: end port.
        length1: Length of segment exiting port1. Should be larger than bend radius.

    """
    delta_orientation = np.round(
        np.abs(np.mod(port1.orientation - port2.orientation, 360)), 3
    )
    if delta_orientation not in (0, 180, 360):
        raise ValueError("path_U(): ports must be parallel.")
    theta = np.radians(port1.orientation)
    e1 = np.array([np.cos(theta), np.sin(theta)])
    e2 = np.array([-1 * np.sin(theta), np.cos(theta)])
    # assemble waypoints
    pt1 = port1.center
    pt4 = port2.center
    pt2 = pt1 + length1 * e1  # outward by length1 distance
    delta_vec = pt4 - pt2
    pt3 = pt2 + np.dot(delta_vec, e2) * e2
    return Path(np.array([pt1, pt2, pt3, pt4]))

def path_V(port1: typings.Port, port2: typings.Port) -> Path:
    """Return waypoint path between port1 and port2 in a V shape.

    Useful when ports point to a single connecting point.

    Args:
        port1: Start port.
        port2: End port.
    """
    # Get basis vectors in port directions
    e1, _ = _get_rotated_basis(port1.orientation)
    e2, _ = _get_rotated_basis(port2.orientation)

    # Assemble route points
    pt1 = port1.center
    pt3 = port2.center

    # Solve for intersection
    e = np.column_stack((e1, -1 * e2))
    distance = np.linalg.solve(e, np.asarray(pt3) - pt1)[0]
    pt2 = distance * e1 + pt1
    return Path(np.array([pt1, pt2, pt3]))

def path_Z(
    port1: typings.Port, port2: typings.Port, length1: float = 100, length2: float = 100
) -> Path:
    """Return waypoint path between port1 and port2 in a Z shape.

    Ports can have any relative orientation.

    Args:
        port1: start port.
        port2: end port.
        length1: Length of route segment coming out of port1.
        length2: Length of route segment coming out of port2.

    """
    # get basis vectors in port directions
    e1, _ = _get_rotated_basis(port1.orientation)
    e2, _ = _get_rotated_basis(port2.orientation)
    # assemble route  points
    pt1 = port1.center
    pt2 = pt1 + length1 * e1  # outward from port1 by length1
    pt4 = port2.center
    pt3 = pt4 + length2 * e2  # outward from port2 by length2
    return Path(np.array([pt1, pt2, pt3, pt4]))

def path_manhattan(port1: typings.Port, port2: typings.Port, radius: float) -> Path:
    """Return waypoint path between port1 and port2 using manhattan routing.

    Routing uses straight, L, U, J, or C waypoint path as needed.
    Ports must face orthogonal or parallel directions.

    Args:
        port1: start port.
        port2: end port.
        radius: Bend radius for 90 degree bend.
    """
    radius += 0.1
    e1, e2 = _get_rotated_basis(port1.orientation)
    displacement = np.asarray(port2.center) - np.asarray(port1.center)
    xrel = np.round(
        np.dot(displacement, e1), 3
    )  # port2 position, forward(+)/backward(-) from port 1
    yrel = np.round(
        np.dot(displacement, e2), 3
    )  # port2 position, left(+)/right(-) from port1
    orel = np.round(
        np.abs(np.mod(port2.orientation - port1.orientation, 360)), 3
    )  # relative orientation
    if orel not in (0, 90, 180, 270, 360):
        raise ValueError(
            "path_manhattan(): ports must face parallel or orthogonal directions."
        )
    if orel in (90, 270):
        # Orthogonal case
        if (
            (orel == 90 and yrel < -1 * radius) or (orel == 270 and yrel > radius)
        ) and xrel > radius:
            pts = path_L(port1, port2)
        else:
            # Adjust length1 and length2 to ensure intermediate segments fit bend radius
            direction = -1 if (orel == 270) else 1
            length2 = (
                2 * radius - direction * yrel
                if (np.abs(radius + direction * yrel) < 2 * radius)
                else radius
            )
            length1 = (
                2 * radius + xrel if (np.abs(radius - xrel) < 2 * radius) else radius
            )
            pts = path_J(port1, port2, length1=float(length1), length2=float(length2))
    elif orel == 180 and yrel == 0 and xrel > 0:
        pts = path_straight(port1, port2)
    elif (orel == 180 and xrel <= 2 * radius) or (np.abs(yrel) < 2 * radius):
        # Adjust length1 and left1 to ensure intermediate segments fit bend radius
        left1 = np.abs(yrel) + 2 * radius if (np.abs(yrel) < 4 * radius) else 2 * radius
        y_direction = -1 if (yrel < 0) else 1
        left1 = y_direction * left1
        length2 = radius
        x_direction = -1 if (orel == 180) else 1
        segmentx_length = np.abs(xrel + x_direction * length2 - radius)
        length1 = (
            xrel + x_direction * length2 + 2 * radius
            if segmentx_length < 2 * radius
            else radius
        )

        pts = path_C(
            port1,
            port2,
            length1=float(length1),
            length2=float(length2),
            left1=float(left1),
        )
    else:
        # Adjust length1 to ensure segment comes out of port2
        length1 = radius + xrel if (orel == 0 and xrel > 0) else radius
        pts = path_U(port1, port2, length1=float(length1))
    return pts

def path_straight(port1: typings.Port, port2: typings.Port) -> Path:
    """Return waypoint path between port1 and port2 in a straight line.

    Useful when ports point directly at each other.

    Args:
        port1: start port.
        port2: end port.

    """
    delta_orientation = np.round(
        np.abs(np.mod(port1.orientation - port2.orientation, 360)), 3
    )
    e1, e2 = _get_rotated_basis(port1.orientation)
    displacement = np.asarray(port2.center) - np.asarray(port1.center)
    xrel = np.round(
        np.dot(displacement, e1), 3
    )  # relative position of port 2, forward/backward
    yrel = np.round(
        np.dot(displacement, e2), 3
    )  # relative position of port 2, left/right
    if (delta_orientation not in (0, 180, 360)) or (yrel != 0) or (xrel <= 0):
        raise ValueError("path_straight(): ports must point directly at each other.")
    return Path(np.array([port1.center, port2.center]))

def route_sharp(
    component: Component,
    port1: typings.Port,
    port2: typings.Port,
    width: float | None = None,
    path_type: str = "manhattan",
    manual_path: Path | None = None,
    layer: LayerSpec | None = None,
    cross_section: CrossSectionSpec | None = None,
    port_names: tuple[str, str] = ("o1", "o2"),
    **kwargs: Any,
) -> None:
    """Returns Component route between ports.

    Args:
        component: Component to add the route to.
        port1: start port.
        port2: end port.
        width: None, int, float, array-like[2], or CrossSection. \
                If None, the route linearly tapers between the widths the ports \
                If set to a single number (e.g. `width=1.7`): makes a fixed-width route \
                If set to a 2-element array (e.g. `width=[1.8,2.5]`): makes a route \
                whose width varies linearly from width[0] to width[1] \
                If set to a CrossSection: uses the CrossSection parameters for the route.
        path_type : {'manhattan', 'L', 'U', 'J', 'C', 'V', 'Z', 'straight', 'manual'}.
        manual_path: array-like[N][2] or Path Waypoint for  manual route.
        layer: Layer to put route on.
        cross_section: CrossSection to use for the route.
        port_names: Tuple of port names for the start and end of the route.
        kwargs: Keyword arguments passed to the waypoint path function.

    Method of waypoint path creation. Should be one of:

     - manhattan: automatic manhattan routing (see path_manhattan() ).
     - L: L-shaped path for orthogonal ports that can be directly connected.
     - U: U-shaped path for parallel or facing ports.
     - J: J-shaped path for orthogonal ports that cannot be directly connected.
     - C: C-shaped path for ports that face away from each other.
     - Z: Z-shaped path with three segments for ports at any angles.
     - V: V-shaped path with two segments for ports at any angles.
     - straight: straight path for ports that face each other.
     - manual: use an explicit waypoint path provided in manual_path.

    Example:
        ```python
        import gdsfactory as gf

        c = gf.Component()
        c1 = c << gf.components.pad(port_orientation=None)
        c2 = c << gf.components.pad(port_orientation=None)

        c2.movex(400)
        c2.movey(-200)

        gf.routing.route_sharp(c, c1.ports["e4"], c2.ports["e1"], path_type="L")
        c.plot()
        ```
    """
    if path_type == "C":
        p = path_C(port1, port2, **kwargs)
    elif path_type == "J":
        p = path_J(port1, port2, **kwargs)
    elif path_type == "L":
        p = path_L(port1, port2)
    elif path_type == "U":
        p = path_U(port1, port2, **kwargs)
    elif path_type == "V":
        p = path_V(port1, port2)
    elif path_type == "Z":
        p = path_Z(port1, port2, **kwargs)
    elif path_type == "manhattan":
        radius = max(port1.width, port2.width)
        p = path_manhattan(port1, port2, radius=radius)
    elif path_type == "manual":
        p = manual_path if isinstance(manual_path, Path) else Path(manual_path)
    elif path_type == "straight":
        p = path_straight(port1, port2)
    else:
        raise ValueError(
            f"route_sharp() received invalid path_type {path_type} not in "
            "{'manhattan', 'L', 'U', 'J', 'C', 'V', 'Z', 'straight', 'manual'}"
        )

    if cross_section:
        cross_section = gf.get_cross_section(cross_section)
        d = p.extrude(cross_section=cross_section)
    elif width is None:
        layer = layer or port1.layer
        s1 = Section(
            width=port1.width,
            port_names=port_names,
            layer=layer,
        )
        s2 = Section(
            width=port2.width,
            port_names=port_names,
            layer=layer,
        )
        x1 = CrossSection(sections=(s1,))
        x2 = CrossSection(sections=(s2,))
        trans = transition(cross_section1=x1, cross_section2=x2, width_type="linear")
        d = p.extrude_transition(transition=trans)
    else:
        if layer is None:
            raise ValueError("layer is required for width")
        d = p.extrude(width=width, layer=layer)

    component << d

def get_min_spacing(
    ports1: Ports,
    ports2: Ports,
    separation: float = 5.0,
    radius: float = 5.0,
    sort_ports: bool = True,
) -> float:
    """Returns the minimum amount of spacing in um required to create a fanout.

    Args:
        ports1: first list of ports.
        ports2: second list of ports.
        separation: minimum separation between two straights in um.
        radius: bend radius in um.
        sort_ports: sort the ports according to the axis.

    """
    if not ports1 or not ports2:
        raise ValueError("ports1 and ports2 must be non-empty")
    if len(ports1) != len(ports2):
        raise ValueError(f"ports1={len(ports1)} and ports2={len(ports2)} must be equal")

    axis = "X" if ports1[0].orientation in [0, 180] else "Y"
    j = 0
    min_j = 0
    max_j = 0
    if sort_ports:
        if axis in {"X", "x"}:
            ports1 = sorted(ports1, key=get_port_y)
            ports2 = sorted(ports2, key=get_port_y)
        else:
            ports1 = sorted(ports1, key=get_port_x)
            ports2 = sorted(ports2, key=get_port_x)

    for port1, port2 in zip(ports1, ports2, strict=False):
        if axis in {"X", "x"}:
            x1 = get_port_y(port1)
            x2 = get_port_y(port2)
        else:
            x1 = get_port_x(port1)
            x2 = get_port_x(port2)
        if x2 >= x1:
            j += 1
        else:
            j -= 1
        if j < min_j:
            min_j = j
        if j > max_j:
            max_j = j
    return (max_j - min_j) * separation + 2 * radius + 1.0