extrusion improvements (#165)

Author: EliCDavis

modeling/extrude/frame_test.go

@@ -0,0 +1,90 @@
+package extrude
+
+import (
+	"math"
+	"testing"
+
+	"github.com/EliCDavis/vector/vector3"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// The frame may only rotate as much as the path itself turns. Deriving per
+// from the cross product of neighbouring segments instead flips it a full
+// 180 degrees where a straight run meets a bend.
+func TestPathFramesTurnOnlyAsMuchAsThePath(t *testing.T) {
+	straight := []vector3.Float64{}
+	for i := 0; i <= 6; i++ {
+		straight = append(straight, vector3.New(0., float64(i)*0.5, 0.))
+	}
+
+	helix := []vector3.Float64{}
+	for i := 0; i <= 24; i++ {
+		a := float64(i) * 0.4
+		helix = append(helix, vector3.New(math.Cos(a)*2, float64(i)*0.2, math.Sin(a)*2))
+	}
+
+	loop, saddle, trefoil := []vector3.Float64{}, []vector3.Float64{}, []vector3.Float64{}
+	for i := 0; i < 24; i++ {
+		a := math.Pi * 2 * float64(i) / 24
+		loop = append(loop, vector3.New(math.Cos(a)*3, 0, math.Sin(a)*3))
+		saddle = append(saddle, vector3.New(math.Cos(a)*3, math.Sin(2*a)*1.2, math.Sin(a)*3))
+		trefoil = append(trefoil, vector3.New(
+			math.Sin(a)+2*math.Sin(2*a), -math.Sin(3*a), math.Cos(a)-2*math.Cos(2*a)))
+	}
+
+	for name, tc := range map[string]struct {
+		path   []vector3.Float64
+		closed bool
+	}{
+		"straight run": {straight, false},
+		"straight run into a bend": {[]vector3.Float64{
+			vector3.New(0., 0., 0.), vector3.New(0., 1., 0.), vector3.New(0., 2., 0.),
+			vector3.New(1., 3., 0.), vector3.New(2.5, 3.5, 0.), vector3.New(4.5, 3.5, 0.),
+		}, false},
+		"collinear but not axis aligned": {[]vector3.Float64{
+			vector3.New(0., 0., 0.),
+			vector3.New(0., 1.3001528736574441, -0.37084847944351573),
+			vector3.New(0., 2.6003057473148883, -0.7416969588870315),
+		}, false},
+		"helix":                  {helix, false},
+		"closed loop":            {loop, true},
+		"closed non planar loop": {saddle, true},
+		"closed trefoil":         {trefoil, true},
+	} {
+		t.Run(name, func(t *testing.T) {
+			frames := pathFrames(tc.path, tc.closed)
+			require.Len(t, frames, len(tc.path))
+
+			for i, f := range frames {
+				require.InDeltaf(t, 1, f.per.Length(), 1e-9, "ring %d per is not a unit vector", i)
+				require.InDeltaf(t, 1, f.dir.Length(), 1e-9, "ring %d dir is not a unit vector", i)
+				assert.InDeltaf(t, 0, f.per.Dot(f.dir), 1e-9, "ring %d per is not square to dir", i)
+
+				// A closed path has to hold at the seam too, where the last
+				// ring meets the first.
+				previous := i - 1
+				if i == 0 {
+					if !tc.closed {
+						continue
+					}
+					previous = len(frames) - 1
+				}
+
+				// A closed loop cannot be swept without any twist at all: the
+				// leftover is topological. It only has to be shared out, not
+				// dumped on the segment that closes the loop.
+				allowed := 1e-9
+				if tc.closed {
+					allowed = 1 * math.Pi / 180
+				}
+
+				turned := frames[previous].dir.Angle(f.dir)
+				twisted := frames[previous].per.Angle(f.per)
+				assert.LessOrEqualf(t, twisted, turned+allowed,
+					"ring %d twisted %.2f degrees while the path only turned %.2f",
+					i, twisted*180/math.Pi, turned*180/math.Pi)
+			}
+		})
+	}
+}

modeling/extrude/line.go

@@ -23,6 +23,17 @@ func directionsOfLinePoints(points []LinePoint) []vector3.Float64 {
 	return directionOfPoints(pointVec)
 }
 
+func facingUp(v, up vector3.Float64) vector3.Float64 {
+	if v.Length() == 0 {
+		return up
+	}
+	v = v.Normalized()
+	if v.Dot(up) < 0 {
+		return v.Scale(-1)
+	}
+	return v
+}
+
 func Line(linePoints []LinePoint) modeling.Mesh {
 	if len(linePoints) < 2 {
 		panic("extruding a line requires 2 or more points")
@@ -44,8 +55,8 @@ func Line(linePoints []LinePoint) modeling.Mesh {
 		leftNormal := p.Up
 
 		if p.Width != 0 {
-			rightNormal = rightPoint.Sub(p.Point).Normalized().Cross(directions[i]).Scale(-1)
-			leftNormal = leftPoint.Sub(p.Point).Normalized().Cross(directions[i]).Scale(-1)
+			rightNormal = facingUp(rightPoint.Sub(p.Point).Cross(directions[i]), p.Up)
+			leftNormal = facingUp(leftPoint.Sub(p.Point).Cross(directions[i]), p.Up)
 		}
 
 		vertices = append(

modeling/extrude/normals_test.go

@@ -0,0 +1,106 @@
+package extrude_test
+
+import (
+	"testing"
+
+	"github.com/EliCDavis/polyform/modeling"
+	"github.com/EliCDavis/polyform/modeling/extrude"
+	"github.com/EliCDavis/vector/vector2"
+	"github.com/EliCDavis/vector/vector3"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// A vertex normal is averaged across the faces that share it, so it drifts
+// away from any one of them. Reaching a right angle means it stopped being a
+// normal: ProjectFace used to hand back the ring's edge tangent, and Line
+// negated both flanks when only one needed it.
+func requireNormalsAgreeWithFaces(t *testing.T, m modeling.Mesh) {
+	t.Helper()
+
+	require.True(t, m.HasFloat3Attribute(modeling.NormalAttribute), "no normal attribute")
+	idx := m.Indices()
+	pos := m.Float3Attribute(modeling.PositionAttribute)
+	nrm := m.Float3Attribute(modeling.NormalAttribute)
+	require.Equal(t, pos.Len(), nrm.Len())
+
+	for i := 0; i < idx.Len(); i += 3 {
+		a, b, c := pos.At(idx.At(i)), pos.At(idx.At(i+1)), pos.At(idx.At(i+2))
+		face := b.Sub(a).Cross(c.Sub(a))
+		if face.Length() == 0 {
+			continue
+		}
+		face = face.Normalized()
+
+		for k := 0; k < 3; k++ {
+			vertex := idx.At(i + k)
+			normal := nrm.At(vertex)
+			require.NotZerof(t, normal.Length(), "vertex %d has a zero normal", vertex)
+			assert.Positivef(t, face.Dot(normal.Normalized()),
+				"vertex %d carries a normal at or past a right angle to its face", vertex)
+		}
+	}
+}
+
+func TestExtrudersEmitUsableNormals(t *testing.T) {
+	square := []vector2.Float64{
+		vector2.New(-1., -1.), vector2.New(1., -1.),
+		vector2.New(1., 1.), vector2.New(-1., 1.),
+	}
+	bent := []vector3.Float64{
+		vector3.New(0., 0., 0.), vector3.New(0., 2., 0.), vector3.New(1.5, 3.5, 0.),
+	}
+
+	outline, err := extrude.Outline{Shape: square, Path: bent}.Extrude()
+	require.NoError(t, err)
+
+	for name, mesh := range map[string]modeling.Mesh{
+		"shape": extrude.Shape(square, bent),
+		"closed shape": extrude.ClosedShape(square, []vector3.Float64{
+			vector3.New(2., 0., 0.), vector3.New(-1., 0., 1.7), vector3.New(-1., 0., -1.7),
+		}),
+		"polygon": extrude.Polygon(8, []extrude.ExtrusionPoint{
+			{Point: vector3.New(0., 0., 0.), Thickness: 1},
+			{Point: vector3.New(0., 2., 0.), Thickness: 1},
+			{Point: vector3.New(1.5, 3.5, 0.), Thickness: .7},
+		}),
+		"circle": extrude.Circle{Radius: 1, Resolution: 12, Path: bent}.Extrude(),
+		"line": extrude.Line([]extrude.LinePoint{
+			{Point: vector3.New(0., 0., 0.), Up: vector3.Up[float64](), Width: 1, Height: .2},
+			{Point: vector3.New(0., 0., 2.), Up: vector3.Up[float64](), Width: 1, Height: .2},
+			{Point: vector3.New(1., 0., 4.), Up: vector3.Up[float64](), Width: 1, Height: .2},
+		}),
+		"screw":   lathedTube(t),
+		"outline": outline,
+	} {
+		t.Run(name, func(t *testing.T) { requireNormalsAgreeWithFaces(t, mesh) })
+	}
+}
+
+// The outline decides which way is out, so the same shape wound either way
+// has to produce normals pointing the same direction.
+func TestProjectFaceFacesOutwardEitherWinding(t *testing.T) {
+	square := []vector2.Float64{
+		vector2.New(-1., -1.), vector2.New(1., -1.),
+		vector2.New(1., 1.), vector2.New(-1., 1.),
+	}
+	backwards := make([]vector2.Float64, len(square))
+	for i, p := range square {
+		backwards[len(square)-1-i] = p
+	}
+
+	center := vector3.New(0., 0., 0.)
+	up := vector3.Up[float64]()
+	perpendicular := vector3.Forward[float64]()
+
+	points, normals := extrude.ProjectFace(center, up, perpendicular, square)
+	flippedPoints, flippedNormals := extrude.ProjectFace(center, up, perpendicular, backwards)
+
+	for i, p := range points {
+		assert.Positivef(t, normals[i].Dot(p.Sub(center).Normalized()), "vertex %d points inward", i)
+	}
+	for i, p := range flippedPoints {
+		assert.Positivef(t, flippedNormals[i].Dot(p.Sub(center).Normalized()),
+			"reversed winding, vertex %d points inward", i)
+	}
+}