Many ways to express geometry

The only thing the solver sees is the edge list from build_wires(). How you produce that list is entirely up to you — and there is rarely one right way. To make that concrete, here is one delta loop, one knob-set, laid out four ways — from writing every corner as coordinates to flying the whole shape with a Drone.

Every one exposes the same three knobs and produces byte-identical wires:

• base — the top-edge height, where you hang it;
• length_factor — the total wire length in wavelengths (resonant near ~1);
• angle_deg — the slant tilt from horizontal.

So this isn’t a tour of parameterizations — the knobs never change. It’s a tour of geometry construction: the four builds differ only in how they lay the wires to hit the same corners.

A delta loop is a triangle fed by a short gap at the bottom:

        B-----------A      top corner A (the one that "needs trig")
         \         /
          \       /        two equal slanted sides
           \     /
            T~~~~S          short driven feed gap at the bottom

Only the first build (delta_loop) sizes the loop in closed form (a direct formula for the top corner); the three drone builds have no such formula, so each solves the side length with brentq until the total wire hits length_factor * wavelength.

1. Coordinates

delta_loop — the reference that defines the knobs, and the version the catalog ships. Write the four corners down directly: a closed-form expression for the top corner’s y sizes the loop straight from the total wire length, and the top is anchored at base.

y = (cos(t) * (d - 2 * eps) + 2 * eps) / (2 * (cos(t) + 1))  # top corner's y (half the top width), from perimeter d
S = (0, eps, base - (y - eps) * tan(t))   # right feed terminal
A = (0, y, base)                          # top-right corner, anchored at base
B, T = ry(A), ry(S)                       # left half mirrors y = 0

Every corner is on the page. No solve, no flight — just coordinates from the one closed form. The other three reach these same corners without writing them.

2. Flyby

delta_loop_flyby — fly the whole perimeter with a Drone, the 3D turtle, writing no coordinates at all. Build it up from the feed: tilt onto the right slant and forward(side), lay the top with forward_through_plane((0, 1, 0, 0)) (through the symmetry plane y = 0 to the mirror corner — no length computed, no reflection), fly the left slant, then close() the feed gap.

drone.face(heading=(0, 1, 0), up=(1, 0, 0)).yaw(angle)
drone.pay_out().forward(side).yaw(ext)               # S -> A  (right slant)
drone.forward_through_plane((0, 1, 0, 0)).yaw(ext)   # A -> B  (through y=0 to the mirror)
drone.forward(side).feed(1 + 0j).close()             # B -> T, then the feed

The flight is anchored at the feed (z = 0), so a z-offset pass at the end lifts every z to seat the top at base. Not a scrap of trig on the page — it lives in the drone’s matrices.

3. Reflection

delta_loop_reflected — the drone as a trig-free point finder: fly pen-up (laying no wire) up the right slant to read off corner A, let an ry reflection mirror the right half to B and T for free, and build_path (the same helper delta_loop uses) stitch the four points.

A = (Drone(position=S)
     .face(heading=(0, 1, 0), up=(1, 0, 0))
     .yaw(angle).forward(side).position)   # pen up: just read A
B, T = ry(A), ry(S)                          # reflect across y = 0
wires = build_path([S, A, B, T], ...) + build_path([T, S], ...)   # feed at z=0

Built up from the feed, same as #2 — solve the side, then the z-offset pass seats the top at base. Three idioms working together: fly, reflect, stitch.

4. Top-down

delta_loop_topdown — the same reflection hybrid as #3 — point finder, ry mirror, build_path — with one thing changed: start the flight at the top (clockwise) so the top height is right from move one. From the top centre fly out to the corner, then forward_to_plane drops down the slant until it crosses the feed plane y = eps (the feed height is emergent), and ry mirrors the left half.

A = drone.move_to((0, 0, base)).forward(half_top).position   # top corner
S = drone.yaw(180 + angle).forward_to_plane((0, 1, 0, eps)).position
B, T = ry(A), ry(S)                                          # reflect across y = 0
wires = build_path([S, A, B, T], ...) + build_path([T, S], ...)   # stitch, top at base
# half_top solved so the perimeter hits length_factor * wavelength

Because the flight starts at the top, the corners are already at the right height — so there’s no z-offset pass. That anchor is the only thing separating this from #3: same point finder, same reflection, same build_path stitch.

The point

Four builds, one delta loop, one knob-set — (base, length_factor, angle_deg) — and byte-identical wires from every one. Nothing here is about parameterization; it’s about how you specify the geometry: writing every corner as coordinates (#1), flying the whole shape (#2), flying to find one corner and reflecting the rest (#3), or flying it top-down (#4). The Drone isn’t a sidebar; it’s how you lay wire without computing coordinates at all. Designs are starting points; reach for whichever style makes your next antenna clearest.

The Drone

The Drone is a pen-carrying 3D turtle. It carries a pose (position + orientation as a single homogeneous transform) and compiles to the same edge list build_wires() returns:

Verb	What it does
pay_out() / cut()	pen down / up (start / stop laying structural wire)
feed(excitation)	like pay_out, but the wire is the driven segment
forward(dist) / jump(dist)	fly along the nose, with / without laying wire
forward_to_plane(plane)	fly along the nose until the path meets plane=(nx, ny, nz, d) (distance solved, not given) — trims a leg to a boundary
forward_through_plane(plane)	fly through plane to an equal distance past it — lands on the mirror across a symmetry plane, no length computed
yaw / pitch / roll	turn in the body frame (degrees)
face(heading, up)	point the nose along heading (handy to start a planar figure)
mark(label) / line_to(label)	pin a node, then lay a wire straight to it
close()	fly back to where the current stroke began

Because orientation is a single rotation matrix, the Drone composes with the existing Transform machinery and has no gimbal-lock failure in the representation itself.