Lecture 26: Sweeps: extrude and revolve

Parts I to VI gave us the raw material: curves and surfaces with honest enclosures, a B-rep to hold them, booleans to combine them, and sketches to draw profiles. This part is about the operations a designer actually asks for. We begin with the two oldest ones. An extrude pushes a flat profile along a straight line, and a revolve turns one about an axis. Nearly every mechanical part begins with one of these.

The usual way of teaching them is as two operations with two sets of formulas. Geop has one. They are the same algorithm with a different path, and so are a screw thread and a sweep along a curve. Seeing why that works is the main thing to take from this lecture, and the rest of Part VII reuses it.

A sweep is a grid

Let a profile be a closed loop of $n$ curves $c_0,\dots,c_{n-1}$, drawn in a plane, joined at $n$ joints. Carry it through a path: a list of stations, where the profile is placed, and between consecutive stations a span, which says how it gets from one to the next. Now list what that creates:

where $s$ is the number of stations and $m$ the number of spans. On an open path, $s=m+1$; on a closed path, a full turn, $s=m$, and there are no caps.

That is the whole topology, for any path whatever. The geometry can differ from station to station but the shape of the description never does. Check the count on a box, with a square profile extruded through one span: $n=4,\ m=1,\ s=2$ gives $V=8$, $E=8+4=12$, $F=4+2=6$. A closed path gives a torus-like solid: $n=4,\ m=s=4$ gives $V=16,\ E=32,\ F=16$.

Why the counts must come out

A closed surface without holes in its faces satisfies Euler’s formula $V-E+F=2-2g$, where $g$ is the genus, the number of handles. In general, with $R$ extra loops (“rings”) in faces, $S$ shells and $G$ total genus, the Euler–Poincaré formula says

$$V-E+F-R=2(S-G).$$

For the open grid, $V-E+F = ns-(ns+nm)+(nm+2)=2$. For the closed one, $V-E+F=ns-(ns+nm)+nm=0$. The first is a sphere’s characteristic and the second a torus’s. The formula is a useful habit. When you build topology by rule, count it first, and let the count catch errors in the rule. Lecture 20 does the same with validation, on the built model rather than the plan.

Placing the profile: frames

A station is a Frame: an origin and two axes. A profile point $(x,y)$ lies at

$$p = o + x\,e_1 + y\,e_2.$$

Placing a profile curve at a station is then an affine map of its control points, so by the affine invariance of Lecture 6 it is exact, whatever the curve is. Frame::curve does just that, through NurbCurve::embed. Note that this works in homogeneous coordinates: a control point $(wx,wy,w)$ maps to $(w o + wx\,e_1 + wy\,e_2,\ w)$, weights untouched, which is why a rational profile stays exact.

Extruding along $w$ through heights $h_0<h_1<\dots$ means stations with the same axes and origins $o+h_jw$, as extrusion in lib/geop-lib-sweep/src/extrude.rs builds. The profile’s plane need not be square to the path in general. Revolving about an axis means stations whose origin stays put and whose $e_1$ turns: revolution in lib/geop-lib-sweep/src/revolve.rs uses

$$e_1(a)=\cos a\,u+\sin a\,v,\qquad e_2=w,$$

so the profile is read in $(r,z)$: $r$ away from the axis, $z$ along it.

Walls are tensor products

The wall a curve sweeps through a span is a tensor-product surface, $u$ along the span and $v$ along the curve. In the code, Path::wall lays one row of control points for every control point of the span, each row being the curve’s control points placed by that row’s frame. Consider what that gives in the two basic cases.

A straight span. Degree 1 along $u$, knots $[0,0,1,1]$, and two rows: the curve at the first station and the curve at the last. Between them lies a ruled surface, exactly the translated curve at each $u$.

A circular span. Every point $p$ of the profile moves along a circle about the axis. Recall from Lecture 8 that an arc of angle $\theta$ is a rational quadratic: end points, a middle control point where the end tangents meet, and middle weight $\cos(\theta/2)$. For a profile point at radius $r$, the middle control point is at radius $r/\cos(\theta/2)$, at the mid angle. That is linear in $r$, so one frame serves the whole row: a middle frame whose $e_1$ is the sum of the two end $e_1$s scaled to length $1/\cos(\theta/2)$. Its $z$ is unscaled, because the height stays put.

Let us check that with a quarter turn. Then $\theta=90°$, $w=\cos45°=\tfrac{\sqrt2}{2}$, and $e_1^{(0)}=u,\ e_1^{(1)}=v$. The sum $u+v$ has length $\sqrt2=1/\cos45°$, so the sum is already the right vector. In general, $e_1^{(0)}+e_1^{(1)}$ has length $2\cos(\theta/2)$, so the factor needed is $1/(2\cos^2(\theta/2))=1/(1+\cos\theta)$. That is arc_span’s second result, called outwards in revolution, computed from the step angle. For the profile point $(r,z)=(2,1)$, the wall’s control points for the quarter turn are:

At the middle parameter, the rational quadratic gives $\dfrac{\tfrac14(2,0,1)+\tfrac12\cdot\tfrac{\sqrt2}{2}(2,2,1)+\tfrac14(0,2,1)}{\tfrac14+\tfrac12\cdot\tfrac{\sqrt2}{2}+\tfrac14}=(\sqrt2,\sqrt2,1)$, at radius exactly 2. The cylinder, cone, sphere and torus are therefore no special case. They are what such walls come to for a line or arc as the profile curve, and no code knows their names.

The span’s rows are always the first section placed by each row’s frame, and Path::rows makes that a single loop. Because a row is Row::First(frame, weight) with None for “no weight given”, the station rows are not multiplied by anything, for a reason we shall come to.

Why at most a quarter turn per span? The formula $\cos(\theta/2)$ is positive up to a half turn, and vanishes there, so a rational quadratic cannot reach $180°$ with a positive weight, and the weights get small before that. revolution takes $\lceil|\text{sweep}|/90°\rceil$ equal spans for a partial turn, and always four for a full one.

Which way do the walls point

A solid’s faces must point out of the material. For a wall, the normal is $\partial_u S\times\partial_v S$. Take the square from the box example, wound counter-clockwise in $(x,y)$, on a path along $-z$. Along its bottom side the curve runs $+x$, with material on the $+y$ side. Then $\partial_u\times\partial_v=(-z)\times x=-y$, which points out of the material. So:

The walls point out when the profile runs counter-clockwise in $(e_1,e_2)$ and the path runs along $-(e_1\times e_2)$, or clockwise and along $e_1\times e_2$.

Path::along_normal records which of the two a path does, and sweep_drawn reverses the loops when it has to, so callers draw profiles with the ordinary convention: outer loops counter-clockwise and holes clockwise. The kernel has no “flipped” flag on a face. As we saw in Lecture 17, orientation lives in the parametrization.

Caps

An open path needs two caps, flat faces trimmed by the profile. A cap needs a surface, which for us is a flat bilinear patch, and the patch has to lie around the profile. FlatPatch::around in core/geop-core-geometry/src/nurb_surface/flat.rs makes a box around the curves, in the plane’s coordinates, and gives each curve its pcurve on it. The trim loops are the profile’s curves again, so the wall’s edge and the cap’s edge are the very same edge. areas in sweep.rs decides which loops share a cap: going through the loops in order, one winding like the first starts a new area, and the following ones winding the other way are its holes. It reads winding by loop_signed_area, by integration, not sampling (Lecture 19). So a text’s several letters give several caps, and hence several lumps.

An axis degenerates the grid

Revolve a profile that touches its axis and two entries of the table collapse.

A joint on the axis is a pole. It does not move, so it is one vertex at all stations and has no lateral edges. The wall next to it has a whole side collapsed to a point. To keep the wall’s loop closing in $(u,v)$, a coedge runs along that side, attached to no edge: CoedgeOn::Vertex. Lecture 18 discusses what these are for.

A curve on the axis sweeps nothing. It has no wall. With caps it is the one edge both caps share, and on a full turn it does not exist at all.

The counts become, with $p=2$ poles and one curve on the axis:

$$V=(n-2)s+2,\qquad E=(n-1)s+\epsilon+(n-2)m,\qquad F=(n-1)m+c,$$

where $\epsilon$ is 1 with caps and 0 without, and $c$ the number of caps. For a full turn, $s=m$, $\epsilon=c=0$, and $V-E+F=(n-2)m+2-(n-1)m-(n-2)m+(n-1)m=2$. It is a sphere topologically, as it should be: the profile closes against the axis, and a solid cylinder is such a body. For a half-disc of two quarter arcs and a side on the axis, $n=3,\ m=4$ gives $F=8$, the sphere’s eight octants. sphere_solid in lib/geop-lib-sweep/src/shapes/sphere.rs writes that same body out directly: “2 rows (north pole to equator, and equator to south pole) x 4 quadrants”.

Which flags apply is the caller’s business: SweepLoop carries poles and on_axis, one flag per joint and per curve. The grid obeys them. The revolve operation (ops/geop-ops-extrude-revolve/src/revolve.rs) measures them from the solved geometry too: a point is on the axis if the constraints say so, or if the solved sketch cannot tell it from the axis, since a corner there is a pole however it got there.

Holes, voids and shells

A hole in the profile is a second loop, swept the same way. On an extrude its wall is the inside of a tube, and the caps get a ring each, which is the $R$ in Euler–Poincaré. Now revolve the same thing a full turn: there are no caps to connect the hole’s walls to the outer walls. The hole’s walls form a closed set of faces of their own, a void. Nothing was programmed for this. connected_faces groups the faces that share an edge into spec.shells, and two groups come out. The count agrees: $V-E+F-R=0$, two shells, and each of them a torus gives $2(S-G)=2(2-2)=0$.

Try “full turn” with “with a hole” in the demo.

Naming

Later steps refer to what a sweep built, so every entity gets a name, derived from the names of the things that made it. With N the step’s namer, X a curve of the profile, P a joint, q a span and s a station:

An extrude’s stations are start, l1, l2, …, end. A partial turn’s are a0, a1, … and its spans q0, q1, …. A full turn has a curiosity, which is worth knowing because you will see it in names: it always runs backwards, q3 from a0 to a3, then q2, q1, q0, so that a1 lies a quarter turn on from a0 as the angle increases. revolution documents the order, and Path::along_normal follows from it.

Why does a chapter on geometry dwell on names? Because a parametric program’s whole promise (Lecture 2) is that fillet(extrude(box,c3,start)) still means the same edge after an earlier dimension changed. That is only possible if the sweep names things by where they came from, never by index or position.

Described whole: BodySpec

You could imagine building a sweep incrementally, adding a vertex here, an edge there, a face when its loop is complete. The kernel does not. A sweep comes in many shapes (one span or several, closed or not, with poles, with holes, with caps) and each is much simpler to describe at once. BodySpec in core/geop-core-topology/src/build.rs is a plain list of vertices, edges, faces and shells, referring to each other by index. BodySpec::check then says whether the description is a consistent body before anything is inserted:

• every index names something;
• every loop closes up, each coedge ending where the next starts;
• every face is in exactly one shell;
• every edge and vertex is used;
• an edge is used twice, in opposite senses, or, where two lumps of a solid touch along it, four times or more, as often one way as the other; only an edge of a sheet may be used once.

Only then does Model::build_body insert it. NamedModel::build_body adds the names. So an error in a sweep’s topology is an error at the source that mentions a loop and a coedge, not a validation failure two operations later.

“Used twice” is the test in the demo too: book/scripts/demo_tests/sweep-grid.test.mjs checks it over hundreds of configurations of the same rules.

Construction code is sensitive at the last bit

Here is a story from AGENTS.md worth knowing by heart. Extrude and revolve used to be separate builders. They were rewritten as the one sweep builder of this lecture, with identical geometry, and six “inscribed cylinder” boolean tests broke (for instance cube_minus_inscribed_cylinder in lib/geop-lib-booleans/src/boolean.rs).

Nothing about the shape had changed, and in floating-point terms the numbers were equal to within rounding. What had changed was the following. The new builder multiplied every station’s row by that row’s weight. At a station that weight is 1, and an exact 1. In f64, $x\cdot1=x$ and all is well. But Scalar is an interval, and its multiplication rounds outward. So $x\cdot1$ comes out an ulp wider than $x$, on every coordinate of every control point. An inscribed cylinder touches the cube’s face tangentially, and whether a search can settle that configuration depends on interval widths down to the last ulp. The width was the only thing that mattered, and it was the thing that had changed.

The fix is the shape of Path::rows: a station row is Row::First(a, None), “no weight”, and weighted does nothing for None. Its doc comment states the reason: “A station’s row has no weight: multiplying by one would only widen every enclosure by rounding.”

You can see the same care throughout construction code. helix_rows, for instance, takes $\text{rise}(0)=0$ and $\text{rise}(\text{spans})=\text{total}$ as they are, “rather than multiplied by 0 or 1”. The rules from AGENTS.md:

• Never multiply or add by exact constants needlessly in construction code.
• When you change how a shape is built, diff old and new models entity by entity (build both from a git worktree of HEAD outside the repo), comparing interval bounds, not only midpoints.

Exercises

1. Count $V,E,F$ of a hexagonal prism extruded through three heights. Check with Euler’s formula. What is $R$ if the hexagon has a circular hole made of four arcs?

2. Prove the $n,m,s$ count for a partial revolve with one side on the axis: show $V-E+F=2$.

3. A revolved span of 60°. Give its middle weight and the length of its middle frame’s $e_1$. Verify that the arc’s midpoint lies at radius $r$ for the profile point at radius $r$.

4. Why does Frame::curve not need to sample a rational curve to place it, and why would a projective map (a perspective view) be different?

5. A designer draws a square profile on $z=0$, wound counter-clockwise when seen from $+z$, and extrudes along $+z$. Use the wall rule to decide whether sweep alone or sweep_drawn gives outward walls, and what the latter does.

6. (Reading.) Find in lib/geop-lib-sweep/src/skin.rs what an apex is, and how it differs from a pole. What operation uses it?