Routes

struct Route{T<:RouteRule, S<:Coordinate}
Route(rule, startpoint::Point{S}, endpoint::Point, start_direction, end_direction; waypoints=Point{S}[], waydirs=[])
Route(rule, path0::Path, endpoint::Point, end_direction)

A Route implicitly defines a Path between two points with given start and end directions.

Use Path(r::Route, sty::Paths.Style) to create the explicit path.

Contains a RouteRule to determine how the Path should be drawn.

May contain waypoints and waydirs that additionally constrain the route. The RouteRule determines how these are handled, by default routing waypoint-to-waypoint such that the path starts at p0, passes through each point in waypoints in order, and then ends at p1.

If waydirs is not nothing, it should have the same length as waypoints. If waydirs is provided and is not ignored by the RouteRule (check the specific rule documentation), then waypoints[i] will be reached with the path pointing along waydirs[i].

abstract type RouteRule end

Controls how a Route is turned into a Path.

A RouteRule may contain parameters or be used only for dispatch. It should implement one of the following two methods:

_route!(p::Path, p1::Point, α1, rule::MyRouteRule, sty, waypoints, waydirs)
_route_leg!(p::Path, next::Point, rule::MyRouteRule,
    sty::Paths.Style=Paths.contstyle1(p))

It may also implement

reconcile!(path::Path, endpoint::Point,
    end_direction, rule::RouteRule, waypoints, waydirs; initialize_waydirs)

If only _route_leg! is implemented, then a Path drawn from r::Route with MyRouteRule will first call reconcile! to validate constraints and insert waypoints if necessary. (The default implementation of reconcile! does nothing.) The Path will then be routed waypoint-to-waypoint such that the path starts at r.p0, passes through each point in r.waypoints in order, and then ends at r.p1, ignoring waydirs. Alternatively, _route! can be implemented to use r.waypoints and/or r.waydirs all at once as desired.

Base.@kwdef struct BSplineRouting <: RouteRule
    endpoints_speed = 2500μm
    auto_speed = false
    endpoints_curvature = nothing
    auto_curvature = false
end

Specifies rules for routing from one point to another using BSplines.

Ignores waydirs.

Base.@kwdef struct StraightAnd90 <: RouteRule
    min_bend_radius = 200μm
    max_bend_radius = Inf*μm
end
StraightAnd90(r) = StraightAnd90(min_bend_radius=r, max_bend_radius=r)

Specifies rules for routing from one point to another using straight segments and 90° bends.

Can be used with no waydirs if each waypoint is reachable from the previous with a single turn and the endpoint is reachable with a single turn or two turns in opposite directions.

If waydirs are used, then any waypoint may be reachable with two turns in opposite directions if that satisfies the corresponding waydirection.

Base.@kwdef struct StraightAnd45 <: RouteRule
    min_bend_radius = 200μm
    max_bend_radius = Inf*μm
end
StraightAnd45(r) = StraightAnd45(min_bend_radius=r, max_bend_radius=r)

Specifies rules for routing from one point to another using using straight segments and 45° bends.

Can be used with no waydirs if each waypoint is reachable from the previous with a single turn and the endpoint is reachable with one or two turns.

If waydirs are used, then any waypoint may be reachable with two turns if that satisfies the corresponding waydirection.

CompoundRouteRule <: RouteRule
CompoundRouteRule(rules::Vector{RouteRule}, leg_length::Vector{Int}=ones(length(rules)))

Specifies a sequence of rules for routing from one point to another, where rules[i] is used to route through the next leg_length[i] waypoints and/or endpoint.

struct SingleChannelRouting{T <: Coordinate} <: AbstractChannelRouting
SingleChannelRouting(ch::RouteChannel, transition_rule::RouteRule, margin::T)
SingleChannelRouting(ch::RouteChannel, transition_rules, margins)

A RouteRule for guiding routed paths along tracks in a Paths.RouteChannel.

Tracks

"Tracks" are offsets of the channel's path, with equal spacing between each other and the extents of the channel's trace width. Tracks are ordered from left to right when facing along the channel. For example, track 1 is the top track (most positive offset) for a channel directed along the positive x axis, while the highest track index is its bottom track.

The user manually assigns tracks to paths that will be routed with rule::SingleChannelRouting using Paths.set_track!(rule, path, track_idx) for each path, prior to calling route!(path, ...). Because the track offset depends on the total number of tracks, and the number of tracks is determined by the maximum track index of any path added to rule, all paths should be assigned tracks before any route! call.

If used for schematic routing, the track is supplied as a keyword argument, defaulting to a new track added at the bottom of the channel: route!(g::SchematicGraph, rule, ...; track=num_tracks(rule)+1).

Routing

A path routed from p0 to p1 using this rule will enter the channel at the channel's closest point to p0 and exit at the closest point to p1 if margin is zero. For nonzero margin, the entry and exit points are each shifted towards the other along the channel by margin, allowing more space for the transitions into and out of the channel.

The middle "tracked" section is offset from the channel's center line according to the path's track, the maximum track assigned to any path by the rule, and the channel width.

The path is routed from p0 to the tracked section and from the tracked section to p1 using transition_rule.

Transition rules and margins can also be supplied as tuples to the constructor to allow different parameters for entry and exit transitions.

RouteChannel{T} <: AbstractComponent{T}
RouteChannel(pa::Path)

A channel that routes can be guided through along parallel tracks.

Used in route! with Paths.SingleChannelRouting.

The Path used to construct a RouteChannel should use Trace styles only.

A RouteChannel is an AbstractComponent with the same hooks as its Path and an empty geometry.

Path(r::Route, sty)

The explicit Path defined by r, with style sty.

function route!(path::Path{S}, p_end::Point, α_end, rule::RouteRule, sty=Paths.contstyle1(path);
                waypoints=Point{S}[], waydirs=Vector{typeof(1.0°)}(undef, length(waypoints)))) where {S}

Extend path to p_end with arrival angle α_end according to RouteRule. The default implementation is

reconcile!(path, p_end, α_end, rule, waypoints, waydirs)
_route!(path, p_end, α_end, rule, sty, waypoints, waydirs)

followed by checking that the endpoint was successfully reached.

route!(g::SchematicGraph, rule::RouteRule,
    nodehook1::Pair{ComponentNode,Symbol}, nodehook2::Pair{ComponentNode,Symbol},
    sty, meta;
    waypoints=[], waydirs=[], global_waypoints=false,
    name=uniquename("r_$(component(nodehook1.first).name)_$(component(nodehook2.first).name)"),
    kwargs...)
route!(g::SchematicGraph, rule::RouteRule, node1::ComponentNode, nodehook2::Pair{ComponentNode,Symbol}, sty, meta; kwargs...)
route!(g::SchematicGraph, rule::RouteRule, nodehook1::Pair{ComponentNode,Symbol}, node2::ComponentNode, sty, meta; kwargs...)
route!(g::SchematicGraph, rule::RouteRule, node1::ComponentNode, node2::ComponentNode, sty, meta; kwargs...)

Creates a RouteComponent with given style sty and metadata meta, and fuses it between the specified nodes and hooks in g.

Returns the resulting ComponentNode in g.

Example usage: route!(g, BSplineRouting(), zline_node=>:feedline, z_launcher_node=>:line, Paths.CPW(10μm, 6μm), GDSMeta(1, 2))

If one or both hook symbols are not specified, then matching_hook or matching_hooks will be used to attempt to automatically find the correct hook or hooks.

The route will have start and endpoints at the origin until a method like plan! is called. waypoints and waydirs are in component-local coordinates (unless global_waypoints is true), and rule determines how they will be used.

Additional keyword arguments will become vertex properties for the RouteComponent's node.

name should be unique.

reconcile!(path::Path, endpoint::Point, end_direction, rule::RouteRule, waypoints, waydirs;
    initialize_waydirs = false)

Ensure that path can be routed to endpoint at end_direction using rule, waypoints, waydirs, or throw an error.

Does nothing for a generic RouteRule. Subtypes of RouteRule may implement specialized methods to do their own validation when route! is called.

May insert inferred constraints to waypoints and waydirs to allow the path to be drawn leg-by-leg. For example, reconcile! with rule::StraightAnd90, no waypoints, and α1(path) == end_direction will insert a waypoint halfway between p1(path) and endpoint, allowing two successive StraightAnd90 legs with opposite bends.

p0(s::Segment{T}) where {T}

Return the first point in a segment (calculated).

p0(r::Route)

First point of a route, returns r.p0.

α0(s::Segment)

Return the first angle in a segment (calculated).

α0(r::Route)

First angle of a route, returns r.α0.

p1(s::Segment{T}) where {T}

Return the last point in a segment (calculated).

p1(r::Route)

Last point of a route, returns r.p1.

α1(r::Route)

Last angle of a route, returns r.α1.