Introduce Matrix type and refactor geometry transformations

Author: tomas-novotny

CHANGELOG.md

@@ -16,3 +16,4 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - `Rectangle`
 - `Polygon`
 - `RegularPolygon`
+- `Matrix`

internal/slices.go

@@ -0,0 +1,11 @@
+package internal
+
+// Map applies a function to each element in a slice and returns a new slice.
+func Map[S ~[]E, E any, T any](input S, fn func(E) T) []T {
+	output := make([]T, len(input))
+	for i, v := range input {
+		output[i] = fn(v)
+	}
+
+	return output
+}

math.go

@@ -10,8 +10,7 @@ const (
 
 	Delta float64 = 1e-6
 
-	Sqrt3          = 1.732050807568877293527446341505872367
-	OneOverSqrtTwo = 1 / math.Sqrt2
+	Sqrt3 = 1.732050807568877293527446341505872367
 )
 
 // ToRadians converts degrees to radians
@@ -79,13 +78,3 @@ func EqualDelta[T Number](a, b T, delta float64) bool {
 func equalDelta(a, b, delta float64) bool {
 	return math.Abs(a-b) <= delta
 }
-
-// Transform applies a function to each element in a slice and returns a new slice.
-func Transform[S ~[]E, E any, T any](input S, fn func(E) T) []T {
-	output := make([]T, len(input))
-	for i, v := range input {
-		output[i] = fn(v)
-	}
-
-	return output
-}

matrix.go

@@ -0,0 +1,108 @@
+package geom
+
+import (
+	"math"
+)
+
+// Matrix is a 2D matrix.
+type Matrix struct {
+	A, B, C float64 // scale X, shear Y, translate X
+	D, E, F float64 // shear X, scale Y, translate Y
+	// [0 0 1] implicit third row
+}
+
+// M is shorthand for Matrix{a, b, c, d, e, f}.
+func M(a, b, c, d, e, f float64) Matrix {
+	return Matrix{a, b, c, d, e, f}
+}
+
+// Multiply creates a new matrix by multiplying the current matrix with given matrix.
+func (m Matrix) Multiply(matrix Matrix) Matrix {
+	return Matrix{
+		m.A*matrix.A + m.B*matrix.D,
+		m.A*matrix.B + m.B*matrix.E,
+		m.A*matrix.C + m.B*matrix.F + m.C,
+		m.D*matrix.A + m.E*matrix.D,
+		m.D*matrix.B + m.E*matrix.E,
+		m.D*matrix.C + m.E*matrix.F + m.F,
+	}
+}
+
+// Inverse creates a new inverse affine matrix. If non-invertible (det ~ 0), returns the same matrix.
+func (m Matrix) Inverse() Matrix {
+	det := m.Determinant()
+	if Equal(det, 0.0) {
+		return m
+	}
+
+	invDet := 1.0 / det
+	return Matrix{
+		m.E * invDet,
+		-m.B * invDet,
+		(m.B*m.F - m.C*m.E) * invDet,
+		-m.D * invDet,
+		m.A * invDet,
+		(m.C*m.D - m.A*m.F) * invDet,
+	}
+}
+
+// Determinant calculates the determinant of the 2x2 matrix.
+func (m Matrix) Determinant() float64 {
+	return m.A*m.E - m.B*m.D
+}
+
+// Translate creates a new matrix by translating the current matrix.
+func (m Matrix) Translate(deltaX, deltaY float64) Matrix {
+	return m.Multiply(TranslationMatrix(deltaX, deltaY))
+}
+
+// Rotate creates a new matrix by rotating the current matrix.
+func (m Matrix) Rotate(angle float64) Matrix {
+	return m.Multiply(RotationMatrix(angle))
+}
+
+// Scale creates a new matrix by scaling the current matrix.
+func (m Matrix) Scale(factorX, factorY float64) Matrix {
+	return m.Multiply(ScaleMatrix(factorX, factorY))
+}
+
+// Equal checks for equal values.
+func (m Matrix) Equal(other Matrix) bool {
+	return Equal(m.A, other.A) && Equal(m.B, other.B) && Equal(m.C, other.C) && Equal(m.D, other.D) && Equal(m.E, other.E) && Equal(m.F, other.F)
+}
+
+// IsZero checks if values are zero.
+func (m Matrix) IsZero() bool { return m.Equal(Matrix{}) }
+
+// IdentityMatrix creates a new identity matrix.
+func IdentityMatrix() Matrix {
+	return Matrix{
+		1, 0, 0,
+		0, 1, 0,
+	}
+}
+
+// TranslationMatrix creates a new translation matrix.
+func TranslationMatrix(deltaX, deltaY float64) Matrix {
+	return Matrix{
+		1, 0, deltaX,
+		0, 1, deltaY,
+	}
+}
+
+// RotationMatrix creates a new rotation matrix.
+func RotationMatrix(angle float64) Matrix {
+	sin, cos := math.Sincos(angle)
+	return Matrix{
+		cos, -sin, 0,
+		sin, cos, 0,
+	}
+}
+
+// ScaleMatrix creates a new scale matrix.
+func ScaleMatrix(factorX, factorY float64) Matrix {
+	return Matrix{
+		factorX, 0, 0,
+		0, factorY, 0,
+	}
+}

point.go

@@ -15,6 +15,14 @@ func P[T Number](x, y T) Point[T] {
 	return Point[T]{x, y}
 }
 
+// Transform creates a new Point by applying the given matrix to the current point.
+func (p Point[T]) Transform(matrix Matrix) Point[T] {
+	return Point[T]{
+		Cast[T](matrix.A*float64(p.X) + matrix.B*float64(p.Y) + matrix.C),
+		Cast[T](matrix.D*float64(p.X) + matrix.E*float64(p.Y) + matrix.F),
+	}
+}
+
 // Add creates a new Point by adding the given vector to the current point.
 func (p Point[T]) Add(vector Vector[T]) Point[T] {
 	return Point[T]{p.X + vector.X, p.Y + vector.Y}
@@ -80,7 +88,7 @@ func (p Point[T]) Equal(point Point[T]) bool {
 	return Equal(p.X, point.X) && Equal(p.Y, point.Y)
 }
 
-// IsZero checks if X and Y values are 0.
+// IsZero checks if X and Y values are zero.
 func (p Point[T]) IsZero() bool {
 	return p.Equal(Point[T]{})
 }

polygon.go

@@ -1,5 +1,7 @@
 package geom
 
+import "github.com/gravitton/geometry/internal"
+
 // Polygon is a 2D polygon with 3+ vertices.
 type Polygon[T Number] struct {
 	Vertices []Point[T]
@@ -18,7 +20,7 @@ func (p Polygon[T]) Center() Point[T] {
 
 // Translate creates a new Polygon translated by the given vector (applied to all vertices).
 func (p Polygon[T]) Translate(vector Vector[T]) Polygon[T] {
-	return Polygon[T]{Transform(p.Vertices, func(e Point[T]) Point[T] {
+	return Polygon[T]{internal.Map(p.Vertices, func(e Point[T]) Point[T] {
 		return e.Add(vector)
 	})}
 }
@@ -31,15 +33,15 @@ func (p Polygon[T]) MoveTo(point Point[T]) Polygon[T] {
 // Scale creates a new Polygon uniformly scaled about its centroid by the factor.
 func (p Polygon[T]) Scale(factor float64) Polygon[T] {
 	center := p.Center()
-	return Polygon[T]{Transform(p.Vertices, func(point Point[T]) Point[T] {
+	return Polygon[T]{internal.Map(p.Vertices, func(point Point[T]) Point[T] {
 		return center.Add(point.Subtract(center).Multiply(factor))
 	})}
 }
 
 // ScaleXY creates a new Polygon scaled about its centroid by the factors.
 func (p Polygon[T]) ScaleXY(factorX, factorY float64) Polygon[T] {
 	center := p.Center()
-	return Polygon[T]{Transform(p.Vertices, func(point Point[T]) Point[T] {
+	return Polygon[T]{internal.Map(p.Vertices, func(point Point[T]) Point[T] {
 		return center.Add(point.Subtract(center).MultiplyXY(factorX, factorY))
 	})}
 }

regular_polygon.go

@@ -9,55 +9,48 @@ type RegularPolygon[T Number] struct {
 	Center Point[T]
 	Size   Size[T]
 	N      int
+	Angle  float64
 }
 
-// RP is shorthand for RegularPolygon{center, size, n}.
-func RP[T Number](center Point[T], size Size[T], n int) RegularPolygon[T] {
-	return RegularPolygon[T]{center, size, n}
-}
-
-// Triangle creates a RegularPolygon with 3 vertices.
-func Triangle[T Number](center Point[T], size Size[T]) RegularPolygon[T] {
-	return RegularPolygon[T]{center, size, 3}
-}
-
-// Square creates a RegularPolygon with 4 vertices.
-func Square[T Number](center Point[T], size Size[T]) RegularPolygon[T] {
-	return RegularPolygon[T]{center, size, 4}
-}
-
-// Hexagon creates a RegularPolygon with 6 vertices.
-func Hexagon[T Number](center Point[T], size Size[T]) RegularPolygon[T] {
-	return RegularPolygon[T]{center, size, 6}
+// RP is shorthand for RegularPolygon{center, size, n, angle}.
+func RP[T Number](center Point[T], size Size[T], n int, angle float64) RegularPolygon[T] {
+	return RegularPolygon[T]{center, size, n, angle}
 }
 
 // Translate creates a new RegularPolygon translated by the given vector.
 func (rp RegularPolygon[T]) Translate(change Vector[T]) RegularPolygon[T] {
-	return RegularPolygon[T]{rp.Center.Add(change), rp.Size, rp.N}
+	return RegularPolygon[T]{rp.Center.Add(change), rp.Size, rp.N, rp.Angle}
 }
 
 // MoveTo creates a new RegularPolygon with center at point.
 func (rp RegularPolygon[T]) MoveTo(point Point[T]) RegularPolygon[T] {
-	return RegularPolygon[T]{point, rp.Size, rp.N}
+	return RegularPolygon[T]{point, rp.Size, rp.N, rp.Angle}
 }
 
 // Multiple creates a new RegularPolygon with size scaled by the given factor.
 func (rp RegularPolygon[T]) Scale(factor float64) RegularPolygon[T] {
-	return RegularPolygon[T]{rp.Center, rp.Size.Scale(factor), rp.N}
+	return RegularPolygon[T]{rp.Center, rp.Size.Scale(factor), rp.N, rp.Angle}
 }
 
 // Multiple creates a new RegularPolygon with size scaled by the given factors.
 func (rp RegularPolygon[T]) ScaleXY(factorX, factorY float64) RegularPolygon[T] {
-	return RegularPolygon[T]{rp.Center, rp.Size.ScaleXY(factorX, factorY), rp.N}
+	return RegularPolygon[T]{rp.Center, rp.Size.ScaleXY(factorX, factorY), rp.N, rp.Angle}
+}
+
+// Rotate creates a new RegularPolygon rotated by the given angle (in radians).
+func (rp RegularPolygon[T]) Rotate(angle float64) RegularPolygon[T] {
+	// TODO: normalize angle to [0, 2*pi]
+	return RegularPolygon[T]{rp.Center, rp.Size, rp.N, rp.Angle + angle}
 }
 
 // Vertices returns the polygon vertices in order starting from angle 0, counter-clockwise.
 func (rp RegularPolygon[T]) Vertices() []Point[T] {
-	initAngle := 0.0
-	angleStep := 2 * math.Pi / float64(rp.N)
+	initAngle := rp.Angle
+	angleStep := (2 * math.Pi) / float64(rp.N)
 
 	vertices := make([]Point[T], rp.N)
 	for i := 0; i < rp.N; i++ {
+		// TODO: V(1,0).Rotate(angle)
 		vertices[i] = rp.Center.Add(VecFromAngle[T](initAngle+float64(i)*angleStep, 1).MultiplyXY(float64(rp.Size.Width), float64(rp.Size.Height)))
 	}
 
@@ -66,7 +59,9 @@ func (rp RegularPolygon[T]) Vertices() []Point[T] {
 
 // Bounds returns the axis-aligned bounding rectangle.
 func (rp RegularPolygon[T]) Bounds() Rectangle[T] {
-	return Rectangle[T]{rp.Center, rp.Size}
+	// TODO: calculate
+	maxAbsCos, maxAbsSin := 1.0, 1.0
+	return Rectangle[T]{rp.Center, rp.Size.ScaleXY(2.0*maxAbsCos, 2.0*maxAbsSin)}
 }
 
 // ToPolygon converts the regular polygon into a generic Polygon with computed vertices.
@@ -88,3 +83,38 @@ func (rp RegularPolygon[T]) IsZero() bool {
 func (rp RegularPolygon[T]) Empty() bool {
 	return rp.N == 0
 }
+
+type Orientation int
+
+const (
+	FlatTop Orientation = iota
+	PointTop
+)
+
+func RegularPolygonAngle(n int, orientation Orientation) float64 {
+	switch orientation {
+	case FlatTop:
+		// 90 - 180/n degrees
+		return math.Pi * float64(n-2) / (2 * float64(n))
+	case PointTop:
+		// 90 degrees
+		return math.Pi / 2
+	default:
+		return 0
+	}
+}
+
+// Triangle creates a RegularPolygon with 3 vertices.
+func Triangle[T Number](center Point[T], size Size[T], orientation Orientation) RegularPolygon[T] {
+	return RegularPolygon[T]{center, size, 3, RegularPolygonAngle(3, orientation)}
+}
+
+// Square creates a RegularPolygon with 4 vertices.
+func Square[T Number](center Point[T], size Size[T], orientation Orientation) RegularPolygon[T] {
+	return RegularPolygon[T]{center, size, 4, RegularPolygonAngle(4, orientation)}
+}
+
+// Hexagon creates a RegularPolygon with 6 vertices.
+func Hexagon[T Number](center Point[T], size Size[T], orientation Orientation) RegularPolygon[T] {
+	return RegularPolygon[T]{center, size, 6, RegularPolygonAngle(6, orientation)}
+}