Matrix updates

- Fix incorrect implementation of the Translate, Scale, Skew, and Rotate methods
- Removed helper methods that took geom.Point
- Assume degrees, not radians, and remove the ByDegrees variants in favor of the shorter name

Author: richardwilkes

collection/bitset/bitset.go

@@ -392,7 +392,7 @@ func (b *BitSet) Load(data []uint64) {
 	b.Trim()
 	b.set = 0
 	for i := len(b.data) - 1; i >= 0; i-- {
-		word := data[i]
+		word := data[i] //nolint:gosec // This is not a security issue.
 		if word != 0 {
 			for j := range dataBitsPerWord {
 				mask := wordMask(j)

geom/matrix.go

@@ -43,11 +43,6 @@ func NewTranslationMatrix(tx, ty float32) Matrix {
 	}
 }
 
-// NewTranslationMatrixPt creates a new Matrix that translates by translation.X and translation.Y.
-func NewTranslationMatrixPt(translation Point) Matrix {
-	return NewTranslationMatrix(translation.X, translation.Y)
-}
-
 // NewScaleMatrix creates a new Matrix that scales by 'sx' and 'sy'.
 func NewScaleMatrix(sx, sy float32) Matrix {
 	return Matrix{
@@ -56,16 +51,9 @@ func NewScaleMatrix(sx, sy float32) Matrix {
 	}
 }
 
-// NewScaleMatrixPt creates a new Matrix that scales by scale.X and scale.Y.
-func NewScaleMatrixPt(scale Point) Matrix {
-	return Matrix{
-		ScaleX: scale.X,
-		ScaleY: scale.Y,
-	}
-}
-
-// NewRotationMatrix creates a new Matrix that rotates by 'radians'. Positive values are clockwise.
-func NewRotationMatrix(radians float32) Matrix {
+// NewRotationMatrix creates a new Matrix that rotates by 'degrees'. Positive values are clockwise.
+func NewRotationMatrix(degrees float32) Matrix {
+	radians := degrees * xmath.DegreesToRadians
 	s := xmath.Sin(radians)
 	c := xmath.Cos(radians)
 	return Matrix{
@@ -76,9 +64,14 @@ func NewRotationMatrix(radians float32) Matrix {
 	}
 }
 
-// NewRotationByDegreesMatrix creates a new Matrix that rotates by 'degrees'. Positive values are clockwise.
-func NewRotationByDegreesMatrix(degrees float32) Matrix {
-	return NewRotationMatrix(degrees * xmath.DegreesToRadians)
+// NewSkewMatrix creates a new Matrix that skews by 'sx' and 'sy' degrees.
+func NewSkewMatrix(sx, sy float32) Matrix {
+	return Matrix{
+		ScaleX: 1,
+		SkewX:  xmath.Tan(sx * xmath.DegreesToRadians),
+		SkewY:  xmath.Tan(sy * xmath.DegreesToRadians),
+		ScaleY: 1,
+	}
 }
 
 // IsIdentity returns true if this is an identity matrix.
@@ -88,68 +81,27 @@ func (m Matrix) IsIdentity() bool {
 
 // Translate returns a new Matrix which is a copy of this Matrix translated by 'tx' and 'ty'.
 func (m Matrix) Translate(tx, ty float32) Matrix {
-	return Matrix{
-		ScaleX: m.ScaleX,
-		SkewX:  m.SkewX,
-		TransX: m.TransX + tx,
-		SkewY:  m.SkewY,
-		ScaleY: m.ScaleY,
-		TransY: m.TransY + ty,
-	}
-}
-
-// TranslatePt returns a new Matrix which is a copy of this Matrix translated by translate.X and translate.Y.
-func (m Matrix) TranslatePt(translate Point) Matrix {
-	return m.Translate(translate.X, translate.Y)
+	return NewTranslationMatrix(tx, ty).Multiply(m)
 }
 
 // Scale returns a new Matrix which is a copy of this Matrix scaled by 'sx' and 'sy'.
 func (m Matrix) Scale(sx, sy float32) Matrix {
-	return Matrix{
-		ScaleX: m.ScaleX * sx,
-		SkewX:  m.SkewX * sx,
-		TransX: m.TransX * sx,
-		SkewY:  m.SkewY * sy,
-		ScaleY: m.ScaleY * sy,
-		TransY: m.TransY * sy,
-	}
-}
-
-// ScalePt returns a new Matrix which is a copy of this Matrix scaled by scale.X and scale.Y.
-func (m Matrix) ScalePt(scale Point) Matrix {
-	return m.Scale(scale.X, scale.Y)
+	return NewScaleMatrix(sx, sy).Multiply(m)
 }
 
-// Skew returns a new Matrix which is a copy of this Matrix skewed by 'sx' and 'sy' radians.
+// Skew returns a new Matrix which is a copy of this Matrix skewed by 'sx' and 'sy' degrees.
 func (m Matrix) Skew(sx, sy float32) Matrix {
-	return m.Multiply(Matrix{
-		ScaleX: 1,
-		SkewX:  xmath.Tan(sx),
-		SkewY:  xmath.Tan(sy),
-		ScaleY: 1,
-	})
-}
-
-// SkewByDegrees returns a new Matrix which is a copy of this Matrix skewed by 'sx' and 'sy' degrees.
-func (m Matrix) SkewByDegrees(sx, sy float32) Matrix {
-	return m.Skew(xmath.DegreesToRadians*sx, xmath.DegreesToRadians*sy)
+	return NewSkewMatrix(sx, sy).Multiply(m)
 }
 
-// Rotate returns a new Matrix which is a copy of this Matrix rotated by 'radians'. Positive values are clockwise.
-func (m Matrix) Rotate(radians float32) Matrix {
-	s := xmath.Sin(radians)
-	c := xmath.Cos(radians)
-	return m.Multiply(Matrix{
-		ScaleX: c,
-		SkewX:  -s,
-		SkewY:  s,
-		ScaleY: c,
-	})
+// Rotate returns a new Matrix which is a copy of this Matrix rotated by 'degrees'. Positive values are clockwise.
+func (m Matrix) Rotate(degrees float32) Matrix {
+	return NewRotationMatrix(degrees).Multiply(m)
 }
 
-// RotateByDegrees returns a new Matrix which is a copy of this Matrix rotated by 'degrees'. Positive values are clockwise.
-func (m Matrix) RotateByDegrees(degrees float32) Matrix {
-	return m.Rotate(degrees * xmath.DegreesToRadians)
+// RotateAround returns a new Matrix which is a copy of this Matrix rotated by 'degrees' around the point (cx, cy).
+func (m Matrix) RotateAround(degrees, cx, cy float32) Matrix {
+	return m.Translate(-cx, -cy).Rotate(degrees).Translate(cx, cy)
 }
 
 // Multiply returns this Matrix multiplied by the other Matrix.

geom/matrix_test.go

@@ -10,7 +10,6 @@
 package geom_test
 
 import (
-	"math"
 	"testing"
 
 	"github.com/richardwilkes/toolbox/v2/check"
@@ -58,25 +57,11 @@ func TestNewScaleMatrix(t *testing.T) {
 func TestNewRotationMatrix(t *testing.T) {
 	c := check.New(t)
 
-	// Test 90 degree rotation (π/2 radians)
-	m := geom.NewRotationMatrix(math.Pi / 2)
-
-	// cos(π/2) = 0, sin(π/2) = 1
-	// For clockwise rotation: ScaleX = cos, SkewX = -sin, SkewY = sin, ScaleY = cos
-	c.True(xmath.Abs(m.ScaleX) < 0.0001)  // Should be ~0
-	c.True(xmath.Abs(m.SkewX+1) < 0.0001) // Should be ~-1
-	c.Equal(float32(0), m.TransX)
-	c.True(xmath.Abs(m.SkewY-1) < 0.0001) // Should be ~1
-	c.True(xmath.Abs(m.ScaleY) < 0.0001)  // Should be ~0
-	c.Equal(float32(0), m.TransY)
-}
-
-func TestNewRotationByDegreesMatrix(t *testing.T) {
-	c := check.New(t)
-
 	// Test 90 degree rotation
-	m := geom.NewRotationByDegreesMatrix(90)
+	m := geom.NewRotationMatrix(90)
 
+	// cos(90) = 0, sin(90) = 1
+	// For clockwise rotation: ScaleX = cos, SkewX = -sin, SkewY = sin, ScaleY = cos
 	c.True(xmath.Abs(m.ScaleX) < 0.0001)  // Should be ~0
 	c.True(xmath.Abs(m.SkewX+1) < 0.0001) // Should be ~-1
 	c.Equal(float32(0), m.TransX)
@@ -116,10 +101,10 @@ func TestMatrixScale(t *testing.T) {
 
 	c.Equal(float32(2), scaled.ScaleX)
 	c.Equal(float32(0), scaled.SkewX)
-	c.Equal(float32(20), scaled.TransX) // Translation is also scaled
+	c.Equal(float32(20), scaled.TransX)
 	c.Equal(float32(0), scaled.SkewY)
 	c.Equal(float32(3), scaled.ScaleY)
-	c.Equal(float32(60), scaled.TransY) // Translation is also scaled
+	c.Equal(float32(60), scaled.TransY)
 
 	// Original matrix should be unchanged
 	c.Equal(float32(1), m.ScaleX)
@@ -132,7 +117,7 @@ func TestMatrixRotate(t *testing.T) {
 	c := check.New(t)
 
 	m := geom.NewIdentityMatrix()
-	rotated := m.Rotate(math.Pi / 2) // 90 degrees
+	rotated := m.Rotate(90)
 
 	c.True(xmath.Abs(rotated.ScaleX) < 0.0001)  // Should be ~0
 	c.True(xmath.Abs(rotated.SkewX+1) < 0.0001) // Should be ~-1
@@ -146,20 +131,6 @@ func TestMatrixRotate(t *testing.T) {
 	c.Equal(float32(1), m.ScaleY)
 }
 
-func TestMatrixRotateByDegrees(t *testing.T) {
-	c := check.New(t)
-
-	m := geom.NewIdentityMatrix()
-	rotated := m.RotateByDegrees(90)
-
-	c.True(xmath.Abs(rotated.ScaleX) < 0.0001)  // Should be ~0
-	c.True(xmath.Abs(rotated.SkewX+1) < 0.0001) // Should be ~-1
-	c.Equal(float32(0), rotated.TransX)
-	c.True(xmath.Abs(rotated.SkewY-1) < 0.0001) // Should be ~1
-	c.True(xmath.Abs(rotated.ScaleY) < 0.0001)  // Should be ~0
-	c.Equal(float32(0), rotated.TransY)
-}
-
 func TestMatrixMultiply(t *testing.T) {
 	c := check.New(t)
 
@@ -181,13 +152,12 @@ func TestMatrixMultiply(t *testing.T) {
 
 	c.Equal(float32(2), combined.ScaleX)
 	c.Equal(float32(0), combined.SkewX)
-	c.Equal(float32(20), combined.TransX) // Translation after scale
+	c.Equal(float32(20), combined.TransX)
 	c.Equal(float32(0), combined.SkewY)
 	c.Equal(float32(3), combined.ScaleY)
-	c.Equal(float32(60), combined.TransY) // Translation after scale
+	c.Equal(float32(60), combined.TransY)
 }
 
-//nolint:gocritic // The "commented out code" is actually explanation
 func TestMatrixTransformPoint(t *testing.T) {
 	c := check.New(t)
 
@@ -214,7 +184,7 @@ func TestMatrixTransformPoint(t *testing.T) {
 	c.Equal(float32(21), result3.Y) // 7 * 3
 
 	// Test 90-degree rotation (point (1,0) should become (0,1))
-	rotation := geom.NewRotationByDegreesMatrix(90)
+	rotation := geom.NewRotationMatrix(90)
 	p2 := geom.NewPoint(1.0, 0.0)
 	result4 := rotation.TransformPoint(p2)
 
@@ -226,8 +196,8 @@ func TestMatrixTransformPoint(t *testing.T) {
 	p3 := geom.NewPoint(3.0, 4.0)
 	result5 := combined.TransformPoint(p3)
 
-	c.Equal(float32(16), result5.X) // (3 + 5) * 2 = 16
-	c.Equal(float32(18), result5.Y) // (4 + 5) * 2 = 18
+	c.Equal(float32(16), result5.X)
+	c.Equal(float32(18), result5.Y)
 }
 
 func TestMatrixString(t *testing.T) {