regular_polygon_test.go

package geom

import (
	"encoding/json"
	"fmt"
	"math"
	"slices"
	"testing"

	"github.com/gravitton/assert"
)

func TestRegularPolygon_Constructor(t *testing.T) {
	t.Run("int", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(0, 0), Sz(2, 2), 4, 0), RegularPolygon[int]{Center: Pt(0, 0), Size: Sz(2, 2), N: 4, Angle: 0})
	})
	t.Run("float", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(0.5, -1.25), Sz(2.5, 3.75), 6, Pi/3), RegularPolygon[float64]{Center: Pt(0.5, -1.25), Size: Sz(2.5, 3.75), N: 6, Angle: Pi / 3})
	})
	t.Run("a negative size is taken absolute", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(0, 0), Sz(-2, 3), 4, 0), RegPol(Pt(0, 0), Sz(2, 3), 4, 0))
		AssertRegularPolygon(t, Square(Pt(0.0, 0.0), Sz(-2.0, -3.0), OrientationPointyTop), Square(Pt(0.0, 0.0), Sz(2.0, 3.0), OrientationPointyTop))
	})
}

func TestRegularPolygonWithOrientation(t *testing.T) {
	center, size := Pt(0, 0), Sz(10, 10)
	pointy := RegularPolygonWithOrientation(center, size, 6, OrientationPointyTop)
	flat := RegularPolygonWithOrientation(center, size, 6, OrientationFlatTop)

	t.Run("carries the orientation angle", func(t *testing.T) {
		AssertRegularPolygon(t, pointy, RegPol(center, size, 6, RegularPolygonOrientationAngle(6, OrientationPointyTop)))
		AssertRegularPolygon(t, flat, RegPol(center, size, 6, RegularPolygonOrientationAngle(6, OrientationFlatTop)))

		assert.NotEqual(t, pointy.Angle, flat.Angle)
	})
	t.Run("pointy top starts above the center", func(t *testing.T) {
		assert.True(t, slices.Collect(pointy.Vertices())[0].Y < center.Y)
	})
	t.Run("flat top starts left of and above the center", func(t *testing.T) {
		first := slices.Collect(flat.Vertices())[0]

		assert.True(t, first.X < center.X)
		assert.True(t, first.Y < center.Y)
	})
}

func TestTriangle(t *testing.T) {
	triangle := Triangle(Pt(1, -1), Sz(3, 3), OrientationPointyTop)

	t.Run("has three sides at the orientation angle", func(t *testing.T) {
		AssertRegularPolygon(t, triangle, RegPol(Pt(1, -1), Sz(3, 3), 3, RegularPolygonOrientationAngle(3, OrientationPointyTop)))
	})
	t.Run("integer vertices round after scaling", func(t *testing.T) {
		// vertices 1 and 2 land within one unit of the exact (3.598, 0.5) and (-1.598, 0.5);
		// their Y of 0.5 falls just below the .5 tie in float64 and rounds down to 0
		AssertVertices(t, slices.Collect(triangle.Vertices()), []Point[int]{Pt(1, -4), Pt(4, 0), Pt(-2, 0)})
	})
}

func TestSquare(t *testing.T) {
	square := Square(Pt(50.0, 50.0), Sz(100.0, 100.0), OrientationPointyTop)

	t.Run("has four sides at the orientation angle", func(t *testing.T) {
		AssertRegularPolygon(t, square, RegPol(Pt(50.0, 50.0), Sz(100.0, 100.0), 4, RegularPolygonOrientationAngle(4, OrientationPointyTop)))
	})
	t.Run("pointy top starts at the visual top and winds to the right", func(t *testing.T) {
		AssertVertices(t, slices.Collect(square.Vertices()), []Point[float64]{Pt(50.0, -50.0), Pt(150.0, 50.0), Pt(50.0, 150.0), Pt(-50.0, 50.0)})
	})
}

func TestHexagon(t *testing.T) {
	// float64 avoids the int-rounding collapse where sin(±π/6) ≈ 0.4999 would truncate to 0
	hexagon := Hexagon(Pt(0.0, 0.0), Sz(10.0, 10.0), OrientationPointyTop)

	t.Run("has six sides at the orientation angle", func(t *testing.T) {
		AssertRegularPolygon(t, hexagon, RegPol(Pt(0.0, 0.0), Sz(10.0, 10.0), 6, RegularPolygonOrientationAngle(6, OrientationPointyTop)))
	})
	t.Run("pointy top has vertices at top and bottom and flat sides left and right", func(t *testing.T) {
		AssertVertices(t, slices.Collect(hexagon.Vertices()), []Point[float64]{
			Pt(0.0, -10.0),
			Pt(5*Sqrt3, -5.0),
			Pt(5*Sqrt3, 5.0),
			Pt(0.0, 10.0),
			Pt(-5*Sqrt3, 5.0),
			Pt(-5*Sqrt3, -5.0),
		})
	})
}

func TestRegularPolygon_Anchor(t *testing.T) {
	t.Run("a flat-top hexagon anchors the top edge midpoint", func(t *testing.T) {
		hex := Hexagon(Pt(0.0, 0.0), SzU(10.0), OrientationFlatTop)

		AssertPoint(t, hex.Anchor(Top), Pt(0.0, -10*math.Cos(Pi/6)))
		AssertPoint(t, hex.Anchor(Bottom), Pt(0.0, 10*math.Cos(Pi/6)))
		AssertPoint(t, hex.Anchor(Right), Pt(10.0, 0.0))
	})
	t.Run("a pointy-top hexagon anchors the top vertex", func(t *testing.T) {
		hex := Hexagon(Pt(0.0, 0.0), SzU(10.0), OrientationPointyTop)

		AssertPoint(t, hex.Anchor(Top), Pt(0.0, -10.0))
		AssertPoint(t, hex.Anchor(Right), Pt(10*math.Cos(Pi/6), 0.0))
	})
	t.Run("a diagonal leaves through the edge on the diagonal", func(t *testing.T) {
		diamond := RegPol(Pt(0.0, 0.0), Sz(10.0, 4.0), 4, 0)
		reach := 1 / (1/10.0 + 1/4.0)

		AssertPoint(t, diamond.Anchor(DirectionDownRight), Pt(reach, reach))
		AssertPoint(t, diamond.Anchor(DirectionUpLeft), Pt(-reach, -reach))
	})
	t.Run("the direction is taken in the world, so a turn moves the anchor along the boundary", func(t *testing.T) {
		square := RegPol(Pt(0.0, 0.0), SzU(10.0), 4, 0)

		AssertPoint(t, square.Anchor(Right), Pt(10.0, 0.0))
		AssertPoint(t, square.Rotate(Pi/4).Anchor(Right), Pt(10*OneOverSqrt2, 0.0))
		AssertPoint(t, square.Rotate(Pi/2).Anchor(Right), Pt(10.0, 0.0))
	})
	t.Run("int lands on the rounded edge", func(t *testing.T) {
		hex := Hexagon(Pt(0, 0), SzU(10), OrientationPointyTop)

		AssertPoint(t, hex.Anchor(Top), Pt(0, -10))
		assert.True(t, hex.Contains(hex.Anchor(DirectionDownRight)))
	})
	t.Run("none is the center", func(t *testing.T) {
		AssertPoint(t, Hexagon(Pt(1.0, 2.0), SzU(10.0), OrientationFlatTop).Anchor(DirectionNone), Pt(1.0, 2.0))
	})
	t.Run("fewer than three vertices anchor at the center", func(t *testing.T) {
		AssertPoint(t, RegPol(Pt(1.0, 2.0), SzU(10.0), 2, 0).Anchor(Right), Pt(1.0, 2.0))
		AssertPoint(t, RegPol(Pt(1.0, 2.0), SzU(10.0), 0, 0).Anchor(Right), Pt(1.0, 2.0))
	})
	t.Run("a semi-axis along the ray anchors at the center", func(t *testing.T) {
		AssertPoint(t, RegPol(Pt(1.0, 2.0), Sz(10.0, 0.0), 4, 0).Anchor(Right), Pt(1.0, 2.0))
		AssertPoint(t, RegPol(Pt(1.0, 2.0), Sz(10.0, 0.0), 4, 0).Anchor(Top), Pt(1.0, 2.0))
	})
}

func TestRegularPolygon_Vertices(t *testing.T) {
	t.Run("fewer than one side yields nothing", func(t *testing.T) {
		assert.Nil(t, slices.Collect(RegPol(Pt(0, 0), Sz(1, 1), 0, 0).Vertices()))
		assert.Nil(t, slices.Collect(RegPol(Pt(0.0, 0.0), Sz(1.0, 1.0), -3, 0).Vertices()))
	})
	t.Run("int", func(t *testing.T) {
		AssertVertices(t, slices.Collect(RegPol(Pt(0, 0), Sz(1, 1), 4, 0).Vertices()), []Point[int]{
			Pt(1, 0),
			Pt(0, 1),
			Pt(-1, 0),
			Pt(0, -1),
		})
	})
	t.Run("non-square size stretches the ellipse", func(t *testing.T) {
		AssertVertices(t, slices.Collect(RegPol(Pt(0, 0), Sz(2, 3), 4, 0).Vertices()), []Point[int]{
			Pt(2, 0),
			Pt(0, 3),
			Pt(-2, 0),
			Pt(0, -3),
		})
	})
	t.Run("float", func(t *testing.T) {
		AssertVertices(t, slices.Collect(RegPol(Pt(0.0, 0.0), Sz(2.0, 3.0), 6, 0).Vertices()), []Point[float64]{
			Pt(2.0, 0.0),
			Pt(1.0, 1.5*Sqrt3),
			Pt(-1.0, 1.5*Sqrt3),
			Pt(-2.0, 0.0),
			Pt(-1.0, -1.5*Sqrt3),
			Pt(1.0, -1.5*Sqrt3),
		})
	})
	t.Run("stops where the caller breaks", func(t *testing.T) {
		for vertex := range RegPol(Pt(0, 0), Sz(1, 1), 4, 0).Vertices() {
			AssertPoint(t, vertex, Pt(1, 0))

			break
		}
	})
	t.Run("ranging allocates nothing", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertNumber(t, testing.AllocsPerRun(100, func() {
				for vertex := range rp.Vertices() {
					sinkBool = vertex.IsZero()
				}
			}), 0, fmt.Sprintf("%s: ", rp))
		}
	})
}

func TestRegularPolygon_Edges(t *testing.T) {
	t.Run("closes back to the first vertex", func(t *testing.T) {
		edges := slices.Collect(RegPol(Pt(0, 0), Sz(1, 1), 4, 0).Edges())

		assert.Equal(t, len(edges), 4)
		AssertSegment(t, edges[0], Seg(Pt(1, 0), Pt(0, 1)))
		AssertSegment(t, edges[3], Seg(Pt(0, -1), Pt(1, 0)))
	})
	t.Run("single vertex is one zero-length edge", func(t *testing.T) {
		edges := slices.Collect(RegPol(Pt(0.0, 0.0), Sz(1.0, 1.0), 1, 0).Edges())

		assert.Equal(t, len(edges), 1)
		AssertSegment(t, edges[0], Seg(Pt(1.0, 0.0), Pt(1.0, 0.0)))
	})
	t.Run("fewer than one side yields nothing", func(t *testing.T) {
		assert.Nil(t, slices.Collect(RegPol(Pt(0, 0), Sz(1, 1), 0, 0).Edges()))
		assert.Nil(t, slices.Collect(RegPol(Pt(0.0, 0.0), Sz(1.0, 1.0), -3, 0).Edges()))
	})
	t.Run("stops where the caller breaks", func(t *testing.T) {
		for edge := range RegPol(Pt(0, 0), Sz(1, 1), 4, 0).Edges() {
			AssertSegment(t, edge, Seg(Pt(1, 0), Pt(0, 1)))

			break
		}
	})
	t.Run("are the edges of the polygon", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			edges, expected := slices.Collect(rp.Edges()), slices.Collect(rp.Polygon().Edges())

			assert.Equal(t, len(edges), len(expected), fmt.Sprintf("%s: ", rp))
			for i := range edges {
				AssertSegment(t, edges[i], expected[i], fmt.Sprintf("%s #%d: ", rp, i))
			}
		}
	})
	t.Run("ranging allocates nothing", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertNumber(t, testing.AllocsPerRun(100, func() {
				for edge := range rp.Edges() {
					sinkBool = edge.IsZero()
				}
			}), 0, fmt.Sprintf("%s: ", rp))
		}
	})
}

func TestRegularPolygon_Centroid(t *testing.T) {
	AssertPoint(t, Hexagon(Pt(1, 2), SzU(10), OrientationFlatTop).Centroid(), Pt(1, 2))
}

func TestRegularPolygon_Area(t *testing.T) {
	t.Run("agrees with the polygon", func(t *testing.T) {
		hexagon := Hexagon(Pt(0.0, 0.0), SzU(2.0), OrientationFlatTop)

		AssertNumber(t, hexagon.Area(), hexagon.Polygon().Area())
		AssertNumber(t, hexagon.Area(), 3*Sqrt3/2*4) // 3√3/2 · r²
	})
	t.Run("a square of semi-axis r encloses 2r²", func(t *testing.T) {
		AssertNumber(t, Square(Pt(0.0, 0.0), SzU(3.0), OrientationPointyTop).Area(), 18.0)
	})
	t.Run("an ellipse scales the area by both semi-axes", func(t *testing.T) {
		AssertNumber(t, Square(Pt(0.0, 0.0), Sz(2.0, 5.0), OrientationPointyTop).Area(), 20.0)
	})
	t.Run("fewer than three vertices enclose nothing", func(t *testing.T) {
		AssertNumber(t, RegPol(Pt(3.0, 4.0), SzU(10.0), 0, 0).Area(), 0.0)
		AssertNumber(t, RegPol(Pt(3.0, 4.0), SzU(10.0), 2, 0).Area(), 0.0)
	})
	t.Run("agrees with the polygon at any angle and size", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertNumber(t, rp.Area(), rp.Polygon().Area(), rp.String())
		}
	})
}

func TestRegularPolygon_Perimeter(t *testing.T) {
	t.Run("agrees with the polygon", func(t *testing.T) {
		hexagon := Hexagon(Pt(0.0, 0.0), SzU(2.0), OrientationFlatTop)

		AssertNumber(t, hexagon.Perimeter(), hexagon.Polygon().Perimeter())
		AssertNumber(t, hexagon.Perimeter(), 12.0) // six edges of length r
	})
	t.Run("a square of semi-axis r has edges of r√2", func(t *testing.T) {
		AssertNumber(t, Square(Pt(0.0, 0.0), SzU(3.0), OrientationPointyTop).Perimeter(), 12*Sqrt2)
	})
	t.Run("an ellipse sums chords of different lengths", func(t *testing.T) {
		square := Square(Pt(0.0, 0.0), Sz(2.0, 5.0), OrientationPointyTop)

		AssertNumber(t, square.Perimeter(), 4*math.Hypot(2, 5))
		AssertNumber(t, square.Perimeter(), square.Polygon().Perimeter())
	})
	t.Run("fewer than two vertices have no edge", func(t *testing.T) {
		AssertNumber(t, RegPol(Pt(3.0, 4.0), SzU(10.0), 0, 0).Perimeter(), 0.0)
		AssertNumber(t, RegPol(Pt(3.0, 4.0), SzU(10.0), 1, 0).Perimeter(), 0.0)
		AssertNumber(t, RegPol(Pt(3.0, 4.0), SzU(10.0), 2, 0).Perimeter(), 40.0)
	})
	t.Run("int measures the exact polygon, not the rounded vertices", func(t *testing.T) {
		hexagon := Hexagon(Pt(0, 0), SzU(1), OrientationPointyTop)

		AssertNumber(t, hexagon.Perimeter(), 6.0)
		assert.NotEqual(t, hexagon.Polygon().Perimeter(), 6.0)
	})
	t.Run("agrees with the polygon at any angle and size", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertNumber(t, rp.Perimeter(), rp.Polygon().Perimeter(), rp.String())
		}
	})
}

func TestRegularPolygon_Inertia(t *testing.T) {
	t.Run("agrees with the polygon", func(t *testing.T) {
		hexagon := Hexagon(Pt(0.0, 0.0), SzU(2.0), OrientationFlatTop)

		AssertNumber(t, hexagon.Inertia(), hexagon.Polygon().Inertia())
		AssertNumber(t, hexagon.Inertia(), 5*Sqrt3/8*16) // 5√3/8 · r⁴
	})
	t.Run("a square of semi-axis r has the moment 2r⁴/3", func(t *testing.T) {
		AssertNumber(t, Square(Pt(0.0, 0.0), SzU(3.0), OrientationPointyTop).Inertia(), 54.0)
	})
	t.Run("an ellipse scales each axis by the cube of one semi-axis", func(t *testing.T) {
		square := Square(Pt(0.0, 0.0), Sz(2.0, 5.0), OrientationPointyTop)

		AssertNumber(t, square.Inertia(), square.Polygon().Inertia())
		AssertNumber(t, square.Inertia(), 4*10*(16+100)/48.0) // a rhombus of diagonals p, q: pq(p²+q²)/48
	})
	t.Run("fewer than three vertices enclose nothing", func(t *testing.T) {
		AssertNumber(t, RegPol(Pt(3.0, 4.0), SzU(10.0), 0, 0).Inertia(), 0.0)
		AssertNumber(t, RegPol(Pt(3.0, 4.0), SzU(10.0), 2, 0).Inertia(), 0.0)
	})
	t.Run("agrees with the polygon at any angle and size", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertNumber(t, rp.Inertia(), rp.Polygon().Inertia(), rp.String())
		}
	})
}

func TestRegularPolygon_Bounds(t *testing.T) {
	t.Run("vertices on the axes", func(t *testing.T) {
		AssertBox(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Bounds(), BoxFromMinMax(Pt(-1, 0), Pt(3, 4)))
	})
	t.Run("hexagon is tight around its vertices", func(t *testing.T) {
		// width = 2r, height = √3 r
		bounds := Hexagon(Pt(0.0, 0.0), Sz(2.0, 2.0), OrientationFlatTop).Bounds()

		AssertNumber(t, bounds.Width(), 4.0)
		AssertNumber(t, bounds.Height(), 2.0*Sqrt3)
	})
	t.Run("one and two vertices reach only where they lie", func(t *testing.T) {
		AssertBox(t, RegPol(Pt(0.0, 0.0), SzU(2.0), 1, Pi/2).Bounds(), BoxFromMinMax(Pt(0.0, 2.0), Pt(0.0, 2.0)))
		AssertBox(t, RegPol(Pt(0.0, 0.0), SzU(2.0), 2, Pi/4).Bounds(), BoxFromMinMax(Pt(-Sqrt2, -Sqrt2), Pt(Sqrt2, Sqrt2)))
	})
	t.Run("no vertices is the zero rectangle", func(t *testing.T) {
		AssertBox(t, RegPol(Pt(3, 4), Sz(10, 10), 0, 0).Bounds(), Box[int]{})
	})
	t.Run("is exactly the box around the vertices, rounded alike for int", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, angle := range []float64{0, 0.3, Pi / 3, 2, -1} {
				turned := rp.Rotate(angle)

				AssertBox(t, turned.Bounds(), turned.Polygon().Bounds(), turned.String())
				assert.Equal(t, turned.Int().Bounds(), turned.Int().Polygon().Bounds(), turned.String())
			}
		}
	})
}

func TestRegularPolygon_Translate(t *testing.T) {
	AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Translate(Vec(1, -2)), RegPol(Pt(2, 0), Sz(2, 2), 4, 0))
}

func TestRegularPolygon_MoveTo(t *testing.T) {
	AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).MoveTo(Pt(-3, 5)), RegPol(Pt(-3, 5), Sz(2, 2), 4, 0))
}

func TestRegularPolygon_Scale(t *testing.T) {
	t.Run("uniform factor", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Scale(0.5), RegPol(Pt(1, 2), Sz(1, 1), 4, 0))
	})
	t.Run("per-axis factor", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).ScaleXY(2, 3), RegPol(Pt(1, 2), Sz(4, 6), 4, 0))
	})
	t.Run("a negative factor scales by its absolute value", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Scale(-2), RegPol(Pt(1, 2), Sz(4, 4), 4, 0))
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).ScaleXY(-2, 3), RegPol(Pt(1, 2), Sz(4, 6), 4, 0))
	})
}

func TestRegularPolygon_Unscale(t *testing.T) {
	t.Run("uniform factor", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(4, 4), 4, 0).Unscale(2), RegPol(Pt(1, 2), Sz(2, 2), 4, 0))
	})
	t.Run("per-axis factor", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(4, 6), 4, 0).UnscaleXY(2, 3), RegPol(Pt(1, 2), Sz(2, 2), 4, 0))
	})
	t.Run("a negative factor scales by its absolute value", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(4, 4), 4, 0).Unscale(-2), RegPol(Pt(1, 2), Sz(2, 2), 4, 0))
	})
	t.Run("zero factor panics", func(t *testing.T) {
		assert.Panics(t, func() {
			RegPol(Pt(1, 2), Sz(4, 4), 4, 0).Unscale(0)
		}, "geom: division by zero")
		assert.Panics(t, func() {
			RegPol(Pt(1, 2), Sz(4, 4), 4, 0).UnscaleXY(0, 2)
		}, "geom: division by zero")
	})
}

func TestRegularPolygon_Resize(t *testing.T) {
	t.Run("int", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).Resize(Sz(3, 7)), RegPol(Pt(1, 2), Sz(3, 7), 6, 0))
	})
	t.Run("a negative semi-axis is taken absolute", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).Resize(Sz(-3, 7)), RegPol(Pt(1, 2), Sz(3, 7), 6, 0))
	})
	t.Run("keeps the vertex count and the angle", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			resized := rp.Resize(Sz(3.0, 7.0))

			AssertRegularPolygon(t, resized, RegPol(rp.Center, Sz(3.0, 7.0), rp.N, rp.Angle), rp.String())
			AssertRegularPolygon(t, resized.Resize(rp.Size), rp, rp.String())
		}
	})
}

func TestRegularPolygon_Canonical(t *testing.T) {
	t.Run("takes a literal negative size absolute and keeps the rest", func(t *testing.T) {
		AssertRegularPolygon(t, RegularPolygon[int]{Pt(1, 2), Sz(-2, 3), 6, Pi / 3}.Canonical(), RegPol(Pt(1, 2), Sz(2, 3), 6, Pi/3))
	})
	t.Run("is the polygon RegPol builds", func(t *testing.T) {
		rp := RegularPolygon[float64]{Pt(0.5, -1.25), Sz(-2.5, -3.75), 5, 1}

		AssertRegularPolygon(t, rp.Canonical(), RegPol(rp.Center, rp.Size, rp.N, rp.Angle))
		AssertVertices(t, slices.Collect(rp.Canonical().Vertices()), slices.Collect(RegPol(rp.Center, rp.Size, rp.N, rp.Angle).Vertices()))
	})
	t.Run("normalizes the angle the way Rotate stores it", func(t *testing.T) {
		AssertRegularPolygon(t, RegularPolygon[float64]{Pt(0.0, 0.0), SzU(2.0), 4, 7}.Canonical(), RegPol(Pt(0.0, 0.0), SzU(2.0), 4, 7-2*Pi))
		AssertNumber(t, RegularPolygon[float64]{Pt(0.0, 0.0), SzU(2.0), 4, -Pi / 2}.Canonical().Angle, 3*Pi/2)
	})
	t.Run("snaps a residue of turning back to exactly zero, where Rotate does not", func(t *testing.T) {
		drifted := RegPol(Pt(0.0, 0.0), SzU(2.0), 4, 0).Rotate(0.1).Rotate(0.2).Rotate(-0.3)

		assert.True(t, drifted.Angle != 0)
		assert.Equal(t, drifted.Canonical().Angle, 0.0)
		assert.Equal(t, RegularPolygon[int]{Pt(0, 0), SzU(2), 4, -Delta / 2}.Canonical().Angle, 0.0)
		assert.Equal(t, RegularPolygon[int]{Pt(0, 0), SzU(2), 4, 2 * Delta}.Canonical().Angle, 2*Delta)
	})
	t.Run("a well-formed polygon is unchanged", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertRegularPolygon(t, rp.Canonical(), rp, rp.String())
			AssertRegularPolygon(t, rp.Rotate(0).Canonical(), rp.Rotate(0), rp.String())
		}
	})
}

func TestRegularPolygon_Grow(t *testing.T) {
	t.Run("int", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).Grow(2), RegPol(Pt(1, 2), Sz(12, 6), 6, 0))
	})
	t.Run("clamped at zero", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).Grow(-6), RegPol(Pt(1, 2), Sz(4, 0), 6, 0))
	})
	t.Run("shrink undoes it", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertRegularPolygon(t, rp.Grow(1.5).Shrink(1.5), rp, rp.String())
		}
	})
}

func TestRegularPolygon_GrowXY(t *testing.T) {
	t.Run("int", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).GrowXY(2, 3), RegPol(Pt(1, 2), Sz(12, 7), 6, 0))
	})
	t.Run("clamped at zero", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).GrowXY(0, -6), RegPol(Pt(1, 2), Sz(10, 0), 6, 0))
	})
}

func TestRegularPolygon_Shrink(t *testing.T) {
	t.Run("int", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).Shrink(2), RegPol(Pt(1, 2), Sz(8, 2), 6, 0))
	})
	t.Run("clamped at zero", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).Shrink(6), RegPol(Pt(1, 2), Sz(4, 0), 6, 0))
	})
}

func TestRegularPolygon_ShrinkXY(t *testing.T) {
	t.Run("int", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).ShrinkXY(2, 3), RegPol(Pt(1, 2), Sz(8, 1), 6, 0))
	})
	t.Run("clamped at zero", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).ShrinkXY(0, 6), RegPol(Pt(1, 2), Sz(10, 0), 6, 0))
	})
}

func TestRegularPolygon_Lerp(t *testing.T) {
	a, b := RegPol(Pt(0.0, 0.0), SzU(2.0), 6, 0), RegPol(Pt(10.0, 20.0), Sz(8.0, 4.0), 6, Pi/2)

	t.Run("moves the center, the size and the angle together", func(t *testing.T) {
		AssertRegularPolygon(t, a.Lerp(b, 0.5), RegPol(Pt(5.0, 10.0), Sz(5.0, 3.0), 6, Pi/4))
	})
	t.Run("turns along the shorter arc across the seam", func(t *testing.T) {
		from, to := RegPol(Pt(0, 0), SzU(2), 4, ToRadians(350)), RegPol(Pt(0, 0), SzU(2), 4, ToRadians(10))

		AssertRegularPolygon(t, from.Lerp(to, 0.5), RegPol(Pt(0, 0), SzU(2), 4, 0))
		AssertRegularPolygon(t, to.Lerp(from, 0.5), RegPol(Pt(0, 0), SzU(2), 4, 0))
	})
	t.Run("the ends are the polygons themselves", func(t *testing.T) {
		AssertRegularPolygon(t, a.Lerp(b, 0), a)
		AssertRegularPolygon(t, a.Lerp(b, 1), b)
	})
	t.Run("extrapolates and keeps the size absolute", func(t *testing.T) {
		AssertRegularPolygon(t, a.Lerp(b, 2), RegPol(Pt(20.0, 40.0), Sz(14.0, 6.0), 6, Pi))
		AssertRegularPolygon(t, b.Lerp(a, 2), RegPol(Pt(-10.0, -20.0), Sz(4.0, 0.0), 6, 3*Pi/2))
	})
	t.Run("int rounds the center and the size", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(0, 0), SzU(2), 4, 0).Lerp(RegPol(Pt(5, 5), SzU(5), 4, 0), 0.5), RegPol(Pt(3, 3), SzU(4), 4, 0))
	})
	t.Run("a different vertex count panics", func(t *testing.T) {
		assert.PanicsWith(t, func() {
			a.Lerp(RegPol(Pt(10.0, 20.0), Sz(8.0, 4.0), 5, Pi/2), 0.5)
		}, "geom: lerp between polygons of 6 and 5 vertices")
	})
	t.Run("the ends hold over the fixtures and the angle never turns more than half a turn", func(t *testing.T) {
		for _, from := range regularPolygonFixtures {
			for _, to := range regularPolygonFixtures {
				if from.N != to.N {
					continue
				}

				AssertRegularPolygon(t, from.Lerp(to, 0), from, fmt.Sprintf("%s → %s: ", from, to))
				AssertRegularPolygon(t, from.Lerp(to, 1), to, fmt.Sprintf("%s → %s: ", from, to))
				assert.True(t, AngleDistance(from.Lerp(to, 0.5).Angle, from.Angle) <= Pi/2+Delta, fmt.Sprintf("%s → %s: ", from, to))
			}
		}
	})
}

func TestRegularPolygon_Transform(t *testing.T) {
	hexagon := Hexagon(Pt(2.0, 3.0), SzU(4.0), OrientationFlatTop)

	t.Run("the identity keeps the polygon", func(t *testing.T) {
		AssertRegularPolygon(t, hexagon.Transform(IdentityMatrix[float64]()), hexagon)
	})
	t.Run("a translation moves the center and keeps the vertex count", func(t *testing.T) {
		moved := hexagon.Transform(TranslationMatrix(1.0, -1.0))

		AssertRegularPolygon(t, moved, hexagon.Translate(Vec(1.0, -1.0)))
		assert.Equal(t, moved.N, 6)
	})
	t.Run("a uniform scale scales the semi-axes", func(t *testing.T) {
		AssertRegularPolygon(t, hexagon.Transform(ScaleMatrix(2.0, 2.0)), Hexagon(Pt(4.0, 6.0), SzU(8.0), OrientationFlatTop))
	})
	t.Run("a rotation turns the angle", func(t *testing.T) {
		AssertRegularPolygon(t, hexagon.Transform(RotationMatrix[float64](Pi/2)), Hexagon(Pt(-3.0, 2.0), SzU(4.0), OrientationFlatTop).Rotate(Pi/2))
	})
	t.Run("a reflection mirrors the angle about the axis of the matrix", func(t *testing.T) {
		turned := hexagon.Rotate(Pi / 6)

		AssertRegularPolygon(t, turned.Transform(ReflectionMatrix[float64](AxisHorizontal)), RegPol(Pt(2.0, -3.0), SzU(4.0), 6, -turned.Angle))
	})
	t.Run("a shear gives the nearest polygon", func(t *testing.T) {
		AssertRegularPolygon(t, hexagon.Transform(ShearMatrix(1.0, 0.0)), Hexagon(Pt(5.0, 3.0), SzU(4.0), OrientationFlatTop))
	})
	t.Run("an empty polygon stays empty", func(t *testing.T) {
		assert.True(t, RegPol(Pt(1.0, 1.0), SzU(2.0), 0, 0).Transform(ScaleMatrix(2.0, 2.0)).IsEmpty())
	})
	t.Run("int rounds the center and the semi-axes once", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 1), SzU(3), 6, 0).Transform(ScaleMatrix(1.5, 1.5)), RegPol(Pt(2, 2), SzU(5), 6, 0))
	})
	t.Run("a turn of unequal semi-axes is exact too", func(t *testing.T) {
		ellipse := RegPol(Pt(0.0, 0.0), Sz(2.0, 4.0), 5, 0)
		turn := RotationMatrix[float64](Pi / 2)

		AssertRegularPolygon(t, ellipse.Transform(turn), RegPol(Pt(0.0, 0.0), Sz(2.0, 4.0), 5, Pi/2))
		AssertPolygon(t, ellipse.Transform(turn).Polygon(), ellipse.Polygon().Transform(turn))
	})
	t.Run("axes scaled by different factors turn the polygon into one it cannot hold", func(t *testing.T) {
		turned := RegPol(Pt(0.0, 0.0), SzU(4.0), 5, Pi/4)
		squeeze := ScaleMatrix(2.0, 3.0)

		assert.False(t, turned.Transform(squeeze).Polygon().Equal(turned.Polygon().Transform(squeeze)))
	})
	t.Run("matches the polygon of the vertices wherever the matrix keeps one", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			matrices := []Matrix[float64]{
				IdentityMatrix[float64](),
				TranslationMatrix(3.0, -2.0),
				ScaleMatrix(2.0, 2.0),
				RotationMatrix[float64](Pi / 3),
				RotationMatrix[float64](Pi / 3).Multiply(ScaleMatrix(2.0, 2.0)),
			}

			if rp.Angle == 0 {
				matrices = append(matrices, ScaleMatrix(2.0, 3.0))
			}

			for _, m := range matrices {
				AssertPolygon(t, rp.Transform(m).Polygon(), rp.Polygon().Transform(m), fmt.Sprintf("%s → %s: ", rp, m))
			}
		}
	})
}

func TestRegularPolygon_Rotate(t *testing.T) {
	t.Run("adds to the stored angle", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Rotate(Pi), RegPol(Pt(1, 2), Sz(2, 2), 4, Pi))
	})
	t.Run("normalizes to the unit turn", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Rotate(3*Pi), RegPol(Pt(1, 2), Sz(2, 2), 4, Pi))      // 0 + 3π → π
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Rotate(-Pi/2), RegPol(Pt(1, 2), Sz(2, 2), 4, 3*Pi/2)) // 0 − π/2 → 3π/2
	})
}

func TestRegularPolygon_AlignTo(t *testing.T) {
	hex := Hexagon(Pt(0.0, 0.0), SzU(10.0), OrientationPointyTop)

	t.Run("an anchor lands on the point", func(t *testing.T) {
		AssertRegularPolygon(t, hex.AlignTo(Top, Pt(5.0, 5.0)), Hexagon(Pt(5.0, 15.0), SzU(10.0), OrientationPointyTop))
	})
	t.Run("none aligns the center", func(t *testing.T) {
		AssertRegularPolygon(t, hex.AlignTo(DirectionNone, Pt(5.0, 5.0)), Hexagon(Pt(5.0, 5.0), SzU(10.0), OrientationPointyTop))
	})
}

func TestRegularPolygon_Contains(t *testing.T) {
	diamond := RegPol(Pt(0, 0), Sz(2, 2), 4, 0)

	t.Run("inside", func(t *testing.T) {
		assert.True(t, diamond.Contains(Pt(0, 0)))
		assert.True(t, diamond.Contains(Pt(1, 0)))
	})
	t.Run("on an edge and on a vertex", func(t *testing.T) {
		assert.True(t, diamond.Contains(Pt(1, 1)))
		assert.True(t, diamond.Contains(Pt(2, 0)))
	})
	t.Run("outside", func(t *testing.T) {
		assert.False(t, diamond.Contains(Pt(2, 2)))
		assert.False(t, diamond.Contains(Pt(3, 0)))
	})
	t.Run("within the tolerance of an edge", func(t *testing.T) {
		assert.True(t, RegPol(Pt(0.0, 0.0), Sz(2.0, 2.0), 4, 0).Contains(Pt(1.0, 1.0+Delta/2)))
		assert.False(t, RegPol(Pt(0.0, 0.0), Sz(2.0, 2.0), 4, 0).Contains(Pt(1.0, 1.0+2*Delta)))
	})
	t.Run("an empty polygon contains nothing", func(t *testing.T) {
		assert.False(t, RegPol(Pt(0, 0), Sz(2, 2), 0, 0).Contains(Pt(0, 0)))
	})
	t.Run("matches the polygon of the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, p := range pointFixtures {
				assert.Equal(t, rp.Contains(p), rp.Polygon().Contains(p), fmt.Sprintf("%s → %s: ", rp, p))
			}
		}
	})
	t.Run("int matches the polygon of the rounded vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, p := range pointFixtures {
				assert.Equal(t, rp.Int().Contains(p.Int()), rp.Int().Polygon().Contains(p.Int()), fmt.Sprintf("%s → %s: ", rp.Int(), p.Int()))
			}
		}
	})
}

func BenchmarkRegularPolygon_Contains(b *testing.B) {
	hexagon := Hexagon(Pt(0.0, 0.0), SzU(10.0), OrientationFlatTop)
	inside, outside := Pt(1.0, 2.0), Pt(9.0, 9.0)

	b.Run("inside", func(b *testing.B) {
		for b.Loop() {
			sinkBool = hexagon.Contains(inside)
		}
	})
	b.Run("outside within the extent", func(b *testing.B) {
		for b.Loop() {
			sinkBool = hexagon.Contains(outside)
		}
	})
}

func TestRegularPolygon_DistanceTo(t *testing.T) {
	diamond := RegPol(Pt(0, 0), Sz(2, 2), 4, 0)

	t.Run("zero within the polygon", func(t *testing.T) {
		assert.Equal(t, diamond.DistanceTo(Pt(0, 0)), 0.0)
		assert.Equal(t, diamond.DistanceTo(Pt(1, 1)), 0.0)
	})
	t.Run("to the nearest edge", func(t *testing.T) {
		AssertNumber(t, diamond.DistanceTo(Pt(2, 2)), Sqrt2)
	})
	t.Run("to the nearest vertex", func(t *testing.T) {
		AssertNumber(t, diamond.DistanceTo(Pt(3, 0)), 1.0)
	})
	t.Run("an empty polygon is infinitely far", func(t *testing.T) {
		assert.Equal(t, RegPol(Pt(0, 0), Sz(2, 2), 0, 0).DistanceTo(Pt(0, 0)), math.Inf(1))
	})
	t.Run("matches the polygon of the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, p := range pointFixtures {
				AssertNumber(t, rp.DistanceTo(p), rp.Polygon().DistanceTo(p), fmt.Sprintf("%s → %s: ", rp, p))
			}
		}
	})
}

func TestRegularPolygon_DistanceSquaredTo(t *testing.T) {
	diamond := RegPol(Pt(0, 0), Sz(2, 2), 4, 0)

	t.Run("is the square of DistanceTo", func(t *testing.T) {
		AssertNumber(t, diamond.DistanceSquaredTo(Pt(2, 2)), 2.0)
		AssertNumber(t, diamond.DistanceSquaredTo(Pt(3, 0)), 1.0)
		assert.Equal(t, diamond.DistanceSquaredTo(Pt(0, 1)), 0.0)
	})
	t.Run("agrees with DistanceTo", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, p := range pointFixtures {
				AssertNumber(t, rp.DistanceSquaredTo(p), rp.DistanceTo(p)*rp.DistanceTo(p), fmt.Sprintf("%s → %s: ", rp, p))
			}
		}
	})
}

func TestRegularPolygon_Nearest(t *testing.T) {
	diamond := RegPol(Pt(0, 0), Sz(2, 2), 4, 0)

	t.Run("the foot on the nearest edge", func(t *testing.T) {
		AssertPoint(t, diamond.Nearest(Pt(2, 2)), Pt(1, 1))
		AssertPoint(t, diamond.Nearest(Pt(3, 0)), Pt(2, 0))
	})
	t.Run("a point inside is its own nearest point", func(t *testing.T) {
		AssertPoint(t, diamond.Nearest(Pt(0, 1)), Pt(0, 1))
	})
	t.Run("an empty polygon returns the zero point", func(t *testing.T) {
		AssertPoint(t, RegPol(Pt(1, 1), Sz(2, 2), 0, 0).Nearest(Pt(3, 4)), Pt(0, 0))
	})
	t.Run("over the fixtures", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, p := range pointFixtures {
				assertNearest[float64](t, rp, p)
			}
		}
	})
}

func TestRegularPolygon_EnclosesCircle(t *testing.T) {
	square := RegPol(Pt(0.0, 0.0), Sz(2.0, 2.0), 4, Pi/4)

	t.Run("the inscribed circle touches every side from inside", func(t *testing.T) {
		assert.True(t, square.EnclosesCircle(Circ(Pt(0.0, 0.0), math.Sqrt2)))
		assert.False(t, square.EnclosesCircle(Circ(Pt(0.0, 0.0), 1.5)))
	})
	t.Run("an empty polygon encloses nothing", func(t *testing.T) {
		assert.False(t, RegPol(Pt(0, 0), Sz(2, 2), 0, 0).EnclosesCircle(Circ(Pt(0, 0), 0)))
	})
	t.Run("matches the polygon of the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, c := range circleFixtures {
				assert.Equal(t, rp.EnclosesCircle(c), rp.Polygon().EnclosesCircle(c), fmt.Sprintf("%s → %s: ", rp, c))
			}
		}
	})
}

func TestRegularPolygon_EnclosesSegment(t *testing.T) {
	diamond := RegPol(Pt(0, 0), Sz(2, 2), 4, 0)

	t.Run("a diagonal counts, a segment past a vertex not", func(t *testing.T) {
		assert.True(t, diamond.EnclosesSegment(Seg(Pt(-2, 0), Pt(2, 0))))
		assert.False(t, diamond.EnclosesSegment(Seg(Pt(-2, 0), Pt(3, 0))))
	})
	t.Run("matches the polygon of the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, s := range segmentFixtures {
				assert.Equal(t, rp.EnclosesSegment(s), rp.Polygon().EnclosesSegment(s), fmt.Sprintf("%s → %s: ", rp, s))
			}
		}
	})
}

func TestRegularPolygon_EnclosesPolygon(t *testing.T) {
	t.Run("inside, inscribed and outside", func(t *testing.T) {
		assert.True(t, RegPol(Pt(1, 1), Sz(2, 2), 4, Pi/4).EnclosesPolygon(Pol(squareVertices())))
		assert.True(t, RegPol(Pt(1, 1), Sz(2, 2), 4, 0).EnclosesPolygon(Pol(squareVertices())))
		assert.False(t, RegPol(Pt(1, 1), Sz(1, 1), 4, 0).EnclosesPolygon(Pol(squareVertices())))
	})
	t.Run("an empty polygon is enclosed by nothing", func(t *testing.T) {
		assert.False(t, RegPol(Pt(0, 0), Sz(2, 2), 4, 0).EnclosesPolygon(Pol[int](nil)))
	})
	t.Run("matches the polygon of the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, p := range polygonFixtures() {
				assert.Equal(t, rp.EnclosesPolygon(p), rp.Polygon().EnclosesPolygon(p), fmt.Sprintf("%s → %s: ", rp, p))
			}
		}
	})
}

func TestRegularPolygon_EnclosesRectangle(t *testing.T) {
	t.Run("a square rotated into a diamond", func(t *testing.T) {
		diamond := RegPol(Pt(0.0, 0.0), Sz(2.0, 2.0), 4, 0)

		assert.True(t, diamond.EnclosesRectangle(Rect(Pt(0.0, 0.0), Sz(2.0, 2.0))))
		assert.False(t, diamond.EnclosesRectangle(Rect(Pt(0.0, 0.0), Sz(2.0, 2.2))))
	})
	t.Run("matches the polygon of the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, r := range rectFixtures {
				assert.Equal(t, rp.EnclosesRectangle(r), rp.Polygon().EnclosesRectangle(r), fmt.Sprintf("%s → %s: ", rp, r))
			}
		}
	})
}

func TestRegularPolygon_EnclosesRegularPolygon(t *testing.T) {
	hexagon := Hexagon(Pt(0.0, 0.0), SzU(10.0), OrientationFlatTop)

	t.Run("a smaller one and a turned one of the same size", func(t *testing.T) {
		assert.True(t, hexagon.EnclosesRegularPolygon(hexagon.Unscale(2)))
		assert.False(t, hexagon.EnclosesRegularPolygon(hexagon.Rotate(Pi/6)))
	})
	t.Run("an empty polygon on either side encloses nothing", func(t *testing.T) {
		assert.False(t, hexagon.EnclosesRegularPolygon(RegPol(Pt(0.0, 0.0), Sz(1.0, 1.0), 0, 0)))
		assert.False(t, RegPol(Pt(0.0, 0.0), Sz(1.0, 1.0), 0, 0).EnclosesRegularPolygon(hexagon))
	})
	t.Run("matches the polygon of the vertices", func(t *testing.T) {
		for _, a := range regularPolygonFixtures {
			for _, b := range regularPolygonFixtures {
				assert.Equal(t, a.EnclosesRegularPolygon(b), a.Polygon().EnclosesRegularPolygon(b), fmt.Sprintf("%s → %s: ", a, b))
			}
		}
	})
}

func TestRegularPolygon_EnclosesBox(t *testing.T) {
	t.Run("matches the polygon of the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, b := range boxFixtures {
				assert.Equal(t, rp.EnclosesBox(b), rp.Polygon().EnclosesBox(b), fmt.Sprintf("%s → %s: ", rp, b))
			}
		}
	})
}

func TestRegularPolygon_IntersectsCircle(t *testing.T) {
	t.Run("mirrors Circle.IntersectsRegularPolygon", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, c := range circleFixtures {
				assert.Equal(t, rp.IntersectsCircle(c), c.IntersectsRegularPolygon(rp), fmt.Sprintf("%s → %s: ", rp, c))
			}
		}
	})
}

func TestRegularPolygon_IntersectsSegment(t *testing.T) {
	t.Run("mirrors Segment.IntersectsRegularPolygon", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, s := range segmentFixtures {
				assert.Equal(t, rp.IntersectsSegment(s), s.IntersectsRegularPolygon(rp), fmt.Sprintf("%s → %s: ", rp, s))
			}
		}
	})
}

func TestRegularPolygon_IntersectionSegment(t *testing.T) {
	t.Run("mirrors Segment.IntersectionRegularPolygon", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, s := range segmentFixtures {
				AssertVertices(t, rp.IntersectionSegment(s), s.IntersectionRegularPolygon(rp), fmt.Sprintf("%s → %s: ", rp, s))
			}
		}
	})
}

func TestRegularPolygon_IntersectsPolygon(t *testing.T) {
	t.Run("mirrors Polygon.IntersectsRegularPolygon", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, p := range polygonFixtures() {
				assert.Equal(t, rp.IntersectsPolygon(p), p.IntersectsRegularPolygon(rp), fmt.Sprintf("%s → %s: ", rp, p))
			}
		}
	})
}

func TestRegularPolygon_IntersectsRectangle(t *testing.T) {
	t.Run("mirrors Rectangle.IntersectsRegularPolygon", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, r := range rectFixtures {
				assert.Equal(t, rp.IntersectsRectangle(r), r.IntersectsRegularPolygon(rp), fmt.Sprintf("%s → %s: ", rp, r))
			}
		}
	})
}

func TestRegularPolygon_IntersectsRegularPolygon(t *testing.T) {
	diamond := RegPol(Pt(0, 0), Sz(2, 2), 4, 0)

	t.Run("overlapping", func(t *testing.T) {
		assert.True(t, diamond.IntersectsRegularPolygon(diamond.Translate(Vec(1, 1))))
	})
	t.Run("apart", func(t *testing.T) {
		assert.False(t, diamond.IntersectsRegularPolygon(diamond.Translate(Vec(5, 0))))
	})
	t.Run("a shared vertex counts", func(t *testing.T) {
		assert.True(t, diamond.IntersectsRegularPolygon(diamond.Translate(Vec(4, 0))))
	})
	t.Run("one contained in the other", func(t *testing.T) {
		assert.True(t, diamond.IntersectsRegularPolygon(RegPol(Pt(0, 0), Sz(1, 1), 3, 0)))
		assert.True(t, RegPol(Pt(0, 0), Sz(1, 1), 3, 0).IntersectsRegularPolygon(diamond))
	})
	t.Run("edges crossing without a vertex inside", func(t *testing.T) {
		assert.True(t, RegPol(Pt(0.0, 0.0), Sz(2.0, 2.0), 4, 0).IntersectsRegularPolygon(RegPol(Pt(0.0, 0.0), Sz(2.0, 2.0), 4, Pi/4)))
	})
	t.Run("an empty polygon intersects nothing", func(t *testing.T) {
		assert.False(t, diamond.IntersectsRegularPolygon(RegPol(Pt(0, 0), Sz(2, 2), 0, 0)))
		assert.False(t, RegPol(Pt(0, 0), Sz(2, 2), 0, 0).IntersectsRegularPolygon(diamond))
	})
	t.Run("symmetric", func(t *testing.T) {
		for _, a := range regularPolygonFixtures {
			for _, b := range regularPolygonFixtures {
				assert.Equal(t, a.IntersectsRegularPolygon(b), b.IntersectsRegularPolygon(a), fmt.Sprintf("%s → %s: ", a, b))
			}
		}
	})
	t.Run("matches the polygons of the vertices", func(t *testing.T) {
		for _, a := range regularPolygonFixtures {
			for _, b := range regularPolygonFixtures {
				assert.Equal(t, a.IntersectsRegularPolygon(b), a.Polygon().IntersectsPolygon(b.Polygon()), fmt.Sprintf("%s → %s: ", a, b))
				assert.Equal(t, a.IntersectsRegularPolygon(b.Translate(Vec(3.0, -2.0))), a.Polygon().IntersectsPolygon(b.Translate(Vec(3.0, -2.0)).Polygon()), fmt.Sprintf("%s → %s: ", a, b))
			}
		}
	})
}

func TestRegularPolygon_IntersectsBox(t *testing.T) {
	diamond := RegPol(Pt(0, 0), Sz(2, 2), 4, 0)

	t.Run("overlapping", func(t *testing.T) {
		assert.True(t, diamond.IntersectsBox(BoxFromMinMax(Pt(0, 0), Pt(2, 2))))
	})
	t.Run("apart within overlapping bounds", func(t *testing.T) {
		assert.False(t, diamond.IntersectsBox(BoxFromMinMax(Pt(2, 2), Pt(3, 3))))
	})
	t.Run("an empty polygon intersects nothing", func(t *testing.T) {
		assert.False(t, RegPol(Pt(0, 0), Sz(2, 2), 0, 0).IntersectsBox(BoxFromMinMax(Pt(-1, -1), Pt(1, 1))))
	})
	t.Run("matches the polygon of the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, b := range boxFixtures {
				assert.Equal(t, rp.IntersectsBox(b), rp.Polygon().IntersectsBox(b), fmt.Sprintf("%s → %s: ", rp, b))
			}
		}
	})
}

func TestRegularPolygon_Equal(t *testing.T) {
	t.Run("same polygon", func(t *testing.T) {
		assert.True(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Equal(RegPol(Pt(1, 2), Sz(2, 2), 4, 0)))
	})
	t.Run("different polygon", func(t *testing.T) {
		assert.False(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Equal(RegPol(Pt(0, 0), Sz(2, 2), 6, 0)))
		assert.False(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Equal(RegPol(Pt(1, 2), Sz(3, 3), 4, 0)))
	})
	t.Run("the angle is compared", func(t *testing.T) {
		assert.False(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Equal(RegPol(Pt(1, 2), Sz(2, 2), 4, Pi)))
		assert.True(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0.5).Equal(RegPol(Pt(1, 2), Sz(2, 2), 4, 0.5)))
	})
	t.Run("the angle is compared normalized", func(t *testing.T) {
		hexagon := Hexagon(Pt(0.0, 0.0), SzU(10.0), OrientationPointyTop)

		assert.True(t, hexagon.Equal(hexagon.Rotate(0)))
		assert.True(t, hexagon.Equal(hexagon.Rotate(2*Pi)))
		assert.True(t, RegPol(Pt(1, 2), Sz(2, 2), 4, -Pi/2).Equal(RegPol(Pt(1, 2), Sz(2, 2), 4, 3*Pi/2)))
	})
	t.Run("the angle is compared across the seam", func(t *testing.T) {
		hexagon := Hexagon(Pt(0.0, 0.0), SzU(10.0), OrientationPointyTop)

		assert.True(t, hexagon.Equal(hexagon.Rotate(-1e-9)))
		assert.True(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Equal(RegPol(Pt(1, 2), Sz(2, 2), 4, 2*Pi-1e-9)))
	})
}

func TestRegularPolygon_IsZero(t *testing.T) {
	t.Run("zero polygon", func(t *testing.T) {
		assert.True(t, RegularPolygon[int]{}.IsZero())
		assert.True(t, RegularPolygon[float64]{}.IsZero())
	})
	t.Run("a full turn is a zero angle, like Equal", func(t *testing.T) {
		assert.True(t, RegPol(Pt(0, 0), Sz(0, 0), 0, 2*Pi).IsZero())
	})
	t.Run("only one field is zero", func(t *testing.T) {
		assert.False(t, RegPol(Pt(0, 0), Sz(0, 0), 4, 0).IsZero())
		assert.False(t, RegPol(Pt(1, 2), Sz(0, 0), 0, 0).IsZero())
		assert.False(t, RegPol(Pt(0, 0), Sz(2, 2), 0, 0).IsZero())
		assert.False(t, RegPol(Pt(0, 0), Sz(0, 0), 0, 1).IsZero())
	})
	t.Run("non-zero polygon", func(t *testing.T) {
		assert.False(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).IsZero())
	})
}

func TestRegularPolygon_IsEmpty(t *testing.T) {
	t.Run("no sides", func(t *testing.T) {
		assert.True(t, RegularPolygon[int]{}.IsEmpty())
		assert.True(t, RegPol(Pt(1, 2), Sz(2, 2), 0, 0).IsEmpty())
		assert.True(t, RegPol(Pt(1, 2), Sz(2, 2), -1, 0).IsEmpty())
	})
	t.Run("with sides", func(t *testing.T) {
		assert.False(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).IsEmpty())
	})
}

func TestRegularPolygon_IsAligned(t *testing.T) {
	t.Run("no turn", func(t *testing.T) {
		assert.True(t, RegPol(Pt(1, 2), Sz(3, 4), 6, 0).IsAligned())
	})

	t.Run("turned", func(t *testing.T) {
		assert.False(t, RegPol(Pt(1, 2), Sz(3, 4), 6, Pi/6).IsAligned())
	})

	t.Run("a full turn is exactly zero again", func(t *testing.T) {
		assert.True(t, RegPol(Pt(1.0, 2.0), Sz(3.0, 4.0), 6, 0).Rotate(2*Pi).IsAligned())
	})

	t.Run("no tolerance", func(t *testing.T) {
		assert.False(t, RegPol(Pt(1.0, 2.0), Sz(3.0, 4.0), 6, 1e-9).IsAligned())
		assert.True(t, RegPol(Pt(1.0, 2.0), Sz(3.0, 4.0), 6, 1e-9).Canonical().IsAligned())
	})
}

func TestRegularPolygon_Polygon(t *testing.T) {
	rp := RegPol(Pt(0.0, 0.0), Sz(1.0, 1.0), 5, 0)
	p := rp.Polygon()

	t.Run("carries the vertices", func(t *testing.T) {
		AssertVertices(t, p.Points, slices.Collect(rp.Vertices()))
	})
	t.Run("owns its slice", func(t *testing.T) {
		assert.NotSame(t, p.Points, rp.Polygon().Points)
	})
	t.Run("fewer than one side is the zero polygon", func(t *testing.T) {
		assert.True(t, RegPol(Pt(0, 0), Sz(1, 1), 0, 0).Polygon().IsZero())
		assert.True(t, RegPol(Pt(0.0, 0.0), Sz(1.0, 1.0), -3, 0).Polygon().IsZero())
	})
}

func TestRegularPolygon_Ellipse(t *testing.T) {
	t.Run("the same center, semi-axes and angle", func(t *testing.T) {
		AssertEllipse(t, RegPol(Pt(1, 2), Sz(10, 4), 6, 0).Ellipse(), Ell(Pt(1, 2), Sz(10, 4), 0))
		AssertEllipse(t, RegPol(Pt(1.0, 2.0), Sz(10.0, 4.0), 6, 1.0).Ellipse(), Ell(Pt(1.0, 2.0), Sz(10.0, 4.0), 1.0))
	})
	t.Run("every vertex lies on it", func(t *testing.T) {
		rp := RegPol(Pt(-3.5, 0.25), Sz(2.0, 3.0), 5, Pi/7)

		for vertex := range rp.Vertices() {
			AssertNumber(t, rp.Ellipse().DistanceTo(vertex), 0.0, fmt.Sprintf("%s: ", vertex))
		}
	})
	t.Run("an empty polygon still names its ellipse", func(t *testing.T) {
		AssertEllipse(t, RegPol(Pt(1, 2), Sz(10, 4), 0, 0).Ellipse(), Ell(Pt(1, 2), Sz(10, 4), 0))
	})
}

func TestRegularPolygon_Circle(t *testing.T) {
	t.Run("the circumscribed circle of a polygon of equal semi-axes", func(t *testing.T) {
		AssertCircle(t, Hexagon(Pt(1, 2), SzU(10), OrientationFlatTop).Circle(), Circ(Pt(1, 2), 10))
	})
	t.Run("the circle around an elliptical polygon", func(t *testing.T) {
		AssertCircle(t, RegPol(Pt(1, 2), Sz(4, 10), 5, 0).Circle(), Circ(Pt(1, 2), 10))
	})
}

func TestRegularPolygon_Cast(t *testing.T) {
	rp := RegPol(Pt(1.5, -2.5), Sz(3.5, 4.5), 6, Pi/6)

	t.Run("matches Int and Float", func(t *testing.T) {
		AssertRegularPolygon(t, rp.Cast[int](), rp.Int())
		AssertRegularPolygon(t, rp.Cast[float64](), rp.Float())
	})
	t.Run("a type the other conversions cannot name, and N and the angle are kept", func(t *testing.T) {
		AssertRegularPolygon(t, rp.Cast[int8](), RegPol(Pt[int8](2, -3), Sz[int8](4, 5), 6, Pi/6))
	})
}

func TestRegularPolygon_Int(t *testing.T) {
	t.Run("int is a no-op", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Int(), RegPol(Pt(1, 2), Sz(2, 2), 4, 0))
	})
	t.Run("float rounds but keeps the angle", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(0.6, -0.25), Sz(1.2, 3.6), 6, Pi/3).Int(), RegPol(Pt(1, 0), Sz(1, 4), 6, Pi/3))
	})
}

func TestRegularPolygon_Float(t *testing.T) {
	t.Run("int widens", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).Float(), RegPol(Pt(1.0, 2.0), Sz(2.0, 2.0), 4, 0))
	})
	t.Run("float is a no-op", func(t *testing.T) {
		AssertRegularPolygon(t, RegPol(Pt(0.6, -0.25), Sz(1.2, 3.6), 6, Pi/3).Float(), RegPol(Pt(0.6, -0.25), Sz(1.2, 3.6), 6, Pi/3))
	})
}

func TestRegularPolygon_String(t *testing.T) {
	t.Run("int", func(t *testing.T) {
		assert.Equal(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0).String(), "RegPol((1,2);2x2;4)")
	})
	t.Run("float", func(t *testing.T) {
		assert.Equal(t, RegPol(Pt(0.5, -1.25), Sz(2.5, 3.75), 6, Pi).String(), "RegPol((0.50,-1.25);2.50x3.75;6;3.14)")
	})
}

func TestRegularPolygon_JSON(t *testing.T) {
	t.Run("int wire format omits a zero angle", func(t *testing.T) {
		assert.JSON(t, RegPol(Pt(1, 2), Sz(2, 2), 4, 0), `{"x":1,"y":2,"w":2,"h":2,"n":4}`)

		var rp RegularPolygon[int]
		assert.NoError(t, json.Unmarshal([]byte(`{"x":1,"y":2,"w":2,"h":2,"n":4}`), &rp))
		AssertRegularPolygon(t, rp, RegPol(Pt(1, 2), Sz(2, 2), 4, 0))
		assert.NoError(t, json.Unmarshal([]byte(`{"x":1,"y":2,"w":2,"h":2,"n":4,"a":0}`), &rp))
		AssertRegularPolygon(t, rp, RegPol(Pt(1, 2), Sz(2, 2), 4, 0))
	})
	t.Run("float wire format", func(t *testing.T) {
		assert.JSON(t, RegPol(Pt(0.5, -1.25), Sz(2.5, 3.75), 6, 0.5), `{"x":0.50,"y":-1.25,"w":2.50,"h":3.75,"n":6,"a":0.5}`)

		var rp RegularPolygon[float64]
		assert.NoError(t, json.Unmarshal([]byte(`{"x":0.50,"y":-1.25,"w":2.50,"h":3.75,"n":6,"a":0.5}`), &rp))
		AssertRegularPolygon(t, rp, RegPol(Pt(0.5, -1.25), Sz(2.5, 3.75), 6, 0.5))
	})
	t.Run("round-trip", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			data, err := json.Marshal(rp)
			assert.NoError(t, err)

			var decoded RegularPolygon[float64]
			assert.NoError(t, json.Unmarshal(data, &decoded))
			assert.Equal(t, decoded, rp)
		}
	})
}

func TestRegularPolygonOrientationAngle(t *testing.T) {
	t.Run("pointy top points at -Y", func(t *testing.T) {
		// in +Y-down screen coordinates, "top" means minimum Y, so the first vertex
		// has to point in the -Y direction: angle = -π/2, stored normalized as 3π/2
		AssertNumber(t, RegularPolygonOrientationAngle(3, OrientationPointyTop), 270*DegToRad)
		AssertNumber(t, RegularPolygonOrientationAngle(4, OrientationPointyTop), 270*DegToRad)
		AssertNumber(t, RegularPolygonOrientationAngle(6, OrientationPointyTop), 270*DegToRad)
	})
	t.Run("flat top sits half a step before the top", func(t *testing.T) {
		AssertNumber(t, RegularPolygonOrientationAngle(3, OrientationFlatTop), 210*DegToRad)
		AssertNumber(t, RegularPolygonOrientationAngle(4, OrientationFlatTop), 225*DegToRad)
		AssertNumber(t, RegularPolygonOrientationAngle(5, OrientationFlatTop), 234*DegToRad)
		AssertNumber(t, RegularPolygonOrientationAngle(6, OrientationFlatTop), 240*DegToRad)
	})
	t.Run("flat top puts an edge midpoint at the top for any n", func(t *testing.T) {
		for n := 3; n <= 9; n++ {
			vertices := slices.Collect(RegularPolygonWithOrientation(Pt(0.0, 0.0), SzU(10.0), n, OrientationFlatTop).Vertices())

			AssertPoint(t, vertices[0].Midpoint(vertices[1]), Pt(0.0, -10*math.Cos(Pi/float64(n))), fmt.Sprintf("n=%d: ", n))
		}
	})
	t.Run("an orientation that is neither panics", func(t *testing.T) {
		assert.PanicsWith(t, func() {
			RegularPolygonOrientationAngle(6, Orientation(99))
		}, "geom: unknown orientation 99")

		assert.PanicsWith(t, func() {
			RegularPolygonOrientationAngle(6, OrientationNone)
		}, "geom: unknown orientation -1")
	})
	t.Run("no vertices give the top angle instead of dividing by n", func(t *testing.T) {
		AssertNumber(t, RegularPolygonOrientationAngle(0, OrientationFlatTop), 270*DegToRad)
		AssertNumber(t, RegularPolygonOrientationAngle(-1, OrientationFlatTop), 270*DegToRad)
		AssertNumber(t, RegularPolygonOrientationAngle(0, OrientationPointyTop), 270*DegToRad)

		empty := RegularPolygonWithOrientation(Pt(0.0, 0.0), SzU(10.0), 0, OrientationFlatTop)
		assert.True(t, empty.Equal(empty))
	})
}

func TestRegularPolygon_Properties(t *testing.T) {
	t.Run("vertex count matches the side count", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			assert.Equal(t, len(slices.Collect(rp.Vertices())), rp.N, fmt.Sprintf("%s: ", rp))
		}
	})
	t.Run("vertices lie on the ellipse of the size, in the frame before the turn", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for vertex := range rp.Vertices() {
				offset := vertex.Subtract(rp.Center).Rotate(-rp.Angle)
				normalized := offset.X*offset.X/(rp.Size.Width*rp.Size.Width) + offset.Y*offset.Y/(rp.Size.Height*rp.Size.Height)

				AssertNumber(t, normalized, 1.0, fmt.Sprintf("%s: ", rp))
			}
		}
	})
	t.Run("every anchor is on the boundary in its direction", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, direction := range Directions() {
				anchor := rp.Anchor(direction)

				AssertNumber(t, rp.DistanceTo(anchor), 0.0, fmt.Sprintf("%s → %s: ", rp, direction))
				AssertAngle(t, rp.Center.AngleTo(anchor), direction.Angle(), fmt.Sprintf("%s → %s: ", rp, direction))
				AssertRegularPolygon(t, rp.AlignTo(direction, anchor), rp, fmt.Sprintf("%s → %s: ", rp, direction))
			}
		}
	})
	t.Run("a full turn restores the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertVertices(t, slices.Collect(rp.Rotate(2*Pi).Vertices()), slices.Collect(rp.Vertices()), fmt.Sprintf("%s: ", rp))
		}
	})
	t.Run("rotating by one step permutes the vertices of equal semi-axes", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			if rp.Size.Width != rp.Size.Height {
				continue // a turned ellipse is a different shape, not the same ring one step on
			}

			rotated := slices.Collect(rp.Rotate(2 * Pi / float64(rp.N)).Vertices())
			vertices := slices.Collect(rp.Vertices())

			for i := range vertices {
				assert.True(t, rotated[i].Equal(vertices[(i+1)%rp.N]), fmt.Sprintf("%s #%d: ", rp, i))
			}
		}
	})
	t.Run("translate keeps the shape", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for _, vector := range vectorFixtures {
				moved := rp.Translate(vector)

				assert.True(t, moved.Center.Equal(rp.Center.Add(vector)), fmt.Sprintf("%s → %s: ", rp, vector))
				assert.True(t, moved.Size.Equal(rp.Size), fmt.Sprintf("%s → %s: ", rp, vector))
				AssertNumber(t, moved.Angle, rp.Angle, fmt.Sprintf("%s → %s: ", rp, vector))
			}
		}
	})
	t.Run("bounds enclose every vertex", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			bounds := rp.Bounds()

			for vertex := range rp.Vertices() {
				assert.True(t, vertex.X >= bounds.Min.X-Delta && vertex.X <= bounds.Max.X+Delta, fmt.Sprintf("%s: ", rp))
				assert.True(t, vertex.Y >= bounds.Min.Y-Delta && vertex.Y <= bounds.Max.Y+Delta, fmt.Sprintf("%s: ", rp))
			}
		}
	})
	t.Run("polygon carries the vertices", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertVertices(t, rp.Polygon().Points, slices.Collect(rp.Vertices()), fmt.Sprintf("%s: ", rp))
		}
	})
	t.Run("every vertex lies on the ellipse", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for vertex := range rp.Vertices() {
				AssertNumber(t, rp.Ellipse().DistanceTo(vertex), 0.0, fmt.Sprintf("%s → %s: ", rp, vertex))
			}
		}
	})
	t.Run("the ellipse round-trips through the polygon", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			AssertRegularPolygon(t, rp.Ellipse().RegularPolygon(rp.N), rp, fmt.Sprintf("%s: ", rp))
		}
	})
	t.Run("the circle around holds every vertex", func(t *testing.T) {
		for _, rp := range regularPolygonFixtures {
			for vertex := range rp.Vertices() {
				assert.True(t, rp.Circle().Contains(vertex), fmt.Sprintf("%s → %s: ", rp, vertex))
			}
		}
	})
}

func TestRegularPolygon_Immutable(t *testing.T) {
	rp := RegPol(Pt(0, 1), Sz(2, 3), 4, 0)

	rp.Translate(Vec(2, 3))
	rp.MoveTo(Pt(1, 1))
	rp.Scale(2)
	rp.ScaleXY(2, 3)
	rp.Rotate(Pi / 3)

	AssertRegularPolygon(t, rp, RegPol(Pt(0, 1), Sz(2, 3), 4, 0))
}

// regularPolygonFixtures span the triangle, square, and hexagon at both orientations.
var regularPolygonFixtures = []RegularPolygon[float64]{
	Triangle(Pt(0.0, 0.0), Sz(3.0, 3.0), OrientationPointyTop),
	Square(Pt(50.0, 50.0), Sz(100.0, 100.0), OrientationPointyTop),
	Hexagon(Pt(0.0, 0.0), Sz(10.0, 10.0), OrientationFlatTop),
	RegPol(Pt(-3.5, 0.25), Sz(2.0, 3.0), 5, Pi/7),
	RegPol(Pt(12.5, -0.1), Sz(0.5, 0.5), 8, 0),
}

func ExampleRegPol() {
	fmt.Println(RegPol(Pt(1, 2), Sz(2, 2), 4, 0))
	// Output: RegPol((1,2);2x2;4)
}