Reading the crane

This page reads a whole model: the traditional crane, folded flat, by the sequence Ida gives in her book ¹. It reaches the bird base with reverse folds and uses no petal fold, so it differs from the diagrams most folders learned the crane from, and ends in the same bird base. It assumes First folds, and it adds the rest of what the crane needs where it first appears. The full program is examples/crane.bel in the repository; the figures below build it up section by section, and each shows only the lines it adds.

Beloch describes paper that lies flat. The crane ends where its last flat step ends, with the wings still closed; spreading them makes the model three-dimensional, which the language does not model.

The base and its center line

The program starts where the first page ended: the preliminary base, with the center of the paper named .o.

Program

paper square
fold (map .a onto .c) as --bd
reverse (map .b onto .c) as --h
reverse (map .d onto .c) as --v
.o = --h * --v
--mid = (through .c .o)

Figure 1.1 The preliminary base. --mid runs from the loose corners at .c to the closed tip .o.

On the table the base is a small square. The four corners of the sheet lie together at one of its corners, .c, the loose corners. The center of the sheet is the opposite corner, .o, the closed tip, where no paper edge reaches. --mid is the line between them, the center line of the base. It is bound with =, so it has no crease under it. The next folds bring paper onto it, and a line you only fold onto never needs to be scored.

The side corners

The two remaining corners of the base square are its side corners. Each is two layers thick, one on the front of the base and one on the back, so there are four: .sr and .sl on the front, right and left, .br and .bl on the back. Each is reverse-folded inside, so that its edge lies along the center line.

Program

.sr = --ab * --h
reverse (map .sr onto --mid through .c) as --rsr
.sl = --da * --v
reverse (map .sl onto --mid through .c) as --rsl
.br = --bc * --h
reverse (map .br onto --mid through .c) as --rbr
.bl = --cd * --v
reverse (map .bl onto --mid through .c) as --rbl

Figure 2.1 The four side corners reversed onto the center line. Each crease runs from the loose corners at .c.

.sr = --ab * --h finds a side corner as a crossing on the unfolded sheet. First folds showed that --h left two scars, one of them running from the center down to the bottom edge. That scar meets the bottom edge --ab at $(1/2, 0)$, the middle of the bottom edge, and on the base this spot is the right side corner of the front layer. .sl, .br and .bl are the other three the same way, each where an edge of the sheet meets a scar of --h or --v.

(map .sr onto --mid through .c) is the axiom that folds a point onto a line with a fold line through a second point. It has up to two solutions. Here only one of them crosses the folded paper, so the program needs no item to choose.

The bird base

The front flap and the back flap are folded over along the same line, square to the center line through the side corners. That leaves the two long points, the future neck and tail, standing up in the middle: the bird base.

Program

fold (perp --mid through .sr) (moving .a) (up to #[.a .o]) as --pf
fold (perp --mid through .sr) (moving .c) (up to #[.c .o]) (mountain) as --pb

Figure 3.1 The bird base. --pf folds the front flap, --pb the back flap along the same line.

(perp --mid through .sr) is the axiom for the line through a point, square to another line.

The two folds follow the rule of Which layers move. Without up to each would take every layer below the line, front and back together. #[.a .o] is the flap that holds both the corner .a and the paper center .o: the center face of the front. (up to #[.a .o]) makes the valley fold take that face and the layers on top of it. The side corners reversed beneath it are joined to it by creases away from the fold line, so they go along, and the front flap moves whole. The second fold names the center face of the back, and (mountain) makes it fold away from the viewer, taking that face and the layers beneath it. Seen from the front, its crease is a ridge.

The two long points left standing are the legs of the bird base. Their tips are the corners .b and .d.

Narrowing the legs

Each of the two long points gets narrower by folding its outer edges onto the center line, on the front and on the back. That is four folds, and each has to move exactly one layer.

Program

.e1 = (--rsr & .b) * --pf
fold (map --rsr & .b onto --mid) (moving .e1) (up to #[.e1 .b .o]) as --n1
.e2 = (--rsl & .d) * --pf
fold (map --rsl & .d onto --mid) (moving .e2) (up to #[.e2 .d .o]) as --n2
.e3 = (--rbr & .b) * --pb
fold (map --rbr & .b onto --mid) (moving .e3) (up to #[.e3 .b .o]) (mountain) as --n3
.e4 = (--rbl & .d) * --pb
fold (map --rbl & .d onto --mid) (moving .e4) (up to #[.e4 .d .o]) (mountain) as --n4

Figure 4.1 The legs narrowed. The front edges fold as valleys (--n1, --n2), the back edges as mountains.

& does the work here, as it picked the rays of the collapse on the first page: it narrows a crease to one of its pieces. Once a crease has been folded over, its scars point in different directions, and "the line of --rsr" no longer names one line. --rsr & .b is the piece of --rsr that touches .b: the outer edge of the leg that ends in .b. That piece is straight, so it can be folded onto --mid.

Each fold names its side with moving on a point bound on the line before it, .e1 to .e4: the point where that edge meets the crease of the flap it lies on. Its up to names the layer of the leg that holds that point, the leg's tip and the paper center, so the valley fold takes the front layer and nothing beneath it. Without up to the fold would take the back layers too, because the edge runs through them as well. The two back folds name the back layer and fold as mountains.

Neck and tail

Each narrowed leg is inside reverse-folded, so that it turns up between the layers of the body: one becomes the neck, the other the tail.

Program

reverse (perp --n1 through .sr) (moving .b) as --neck
reverse (perp --n2 through .sr) (moving .d) as --tail

Figure 5.1 The neck and the tail, each reversed about a line square to its narrowed edge.

A perpendicular moves nothing by itself, so unlike a map, it does not say which side goes, and the reverse fold needs (moving .b): the tip of the leg that becomes the neck.

The head

The last fold bends the tip of the neck into a head. Where exactly it bends is a choice the folder makes by eye, and the program says so.

Program

.hp = free on --bd & .b from .b at 1/4
.ht = free on --rsl & .a from .a at 1/2
reverse (through .hp .ht) (moving .b) as --head

Figure 6.1 The finished crane. .hp is where the head bends, .ht sets its angle.

free on --bd & .b from .b at 1/4 names a spot a quarter of the way along the piece of --bd that touches .b, counted from .b, measured on the paper. As in the collapse on the first page, free records that the position was a choice and follows from no construction; the program folds with the point like with any other. Two such points pin down the line of the head fold.

Notes

1. Tetsuo Ida, An Introduction to Computational Origami, Texts & Monographs in Symbolic Computation (Springer, 2020), fig. 7, https://doi.org/10.1007/978-3-319-59189-6.19.↩

References

Ida, Tetsuo. An Introduction to Computational Origami. Texts & Monographs in Symbolic Computation. Springer, 2020. https://doi.org/10.1007/978-3-319-59189-6. ↑ a