Refactor shorthand constructors and tests for geometric types, update naming conventions for clarity

Author: tomas-novotny

README.md

@@ -9,6 +9,8 @@
 
 Generic immutable 2D geometry library for game development.
 
+This library use top-left origin with +Y down and -Y up. It only affect human-readable getters like `(Top|Bottom)Left()`, `(Top|Bottom)Right()` and `(Up/Down)Vector`.
+
 
 ## Installation
 
@@ -25,6 +27,17 @@ package main
 import (
 	geom "github.com/gravitton/geometry"
 )
+
+type HexLayout struct {
+	Origin    geom.Point[float64]
+	Size      geom.Size[float64]
+	FromPixel geom.Matrix
+}
+
+// FromPoint converts a pixel point to a fractional hex (Q, R)
+func (l HexLayout) FromPixel(point geom.Point[float64]) (Q, R float64) {
+	return point.Subtract(l.Origin).DivideXY(l.Size.XY()).Transform(l.FromPixel).XY()
+}
 ```
 
 ## API
@@ -327,14 +340,15 @@ func (rp RegularPolygon[T]) ToPolygon() Polygon[T]
 Short constructors for convenience
 
 ```go
-func P[T Number](x, y T) Point[T]
-func V[T Number](x, y T) Vector[T]
-func S[T Number](w, h T) Size[T]
-func C[T Number](center Point[T], radius T) Circle[T]
-func R[T Number](center Point[T], size Size[T]) Rectangle[T]
-func L[T Number](start, end Point[T]) Line[T]
-func RP[T Number](center Point[T], size Size[T], n int, angle float64) RegularPolygon[T]
-func M(a, b, c, d, e, f float64) Matrix
+func Pt[T Number](x, y T) Point[T]
+func Vec[T Number](x, y T) Vector[T]
+func Sz[T Number](w, h T) Size[T]
+func Circ[T Number](center Point[T], radius T) Circle[T]
+func Rect[T Number](center Point[T], size Size[T]) Rectangle[T]
+func Ln[T Number](start, end Point[T]) Line[T]
+func Pol[T Number](vertices []Point[T]) Polygon[T]
+func RegPol[T Number](center Point[T], size Size[T], n int, angle float64) RegularPolygon[T]
+func Mat(a, b, c, d, e, f float64) Matrix
 ```
 
 

circle.go

@@ -11,8 +11,8 @@ type Circle[T Number] struct {
 	Radius T        `json:"r"`
 }
 
-// C is shorthand for Circle{center, radius}.
-func C[T Number](center Point[T], radius T) Circle[T] {
+// Circ is shorthand for Circle{center, radius}.
+func Circ[T Number](center Point[T], radius T) Circle[T] {
 	return Circle[T]{center, radius}
 }
 

circle_test.go

@@ -9,85 +9,85 @@ import (
 )
 
 func TestCircle_New(t *testing.T) {
-	testCircle(t, C(P(10, 16), 12), 10, 16, 12)
-	testCircle(t, C[float64](P(0.16, 204), 5.1), 0.16, 204.0, 5.1)
+	testCircle(t, Circ(Pt(10, 16), 12), 10, 16, 12)
+	testCircle(t, Circ[float64](Pt(0.16, 204), 5.1), 0.16, 204.0, 5.1)
 }
 
 func TestCircle_Translate(t *testing.T) {
-	testCircle(t, C(P(1, 2), 10).Translate(V(3, -2)), 4, 0, 10)
-	testCircle(t, C(P(0.4, -0.25), 1.2).Translate(V(100.1, -0.1)), 100.5, -0.35, 1.2)
+	testCircle(t, Circ(Pt(1, 2), 10).Translate(Vec(3, -2)), 4, 0, 10)
+	testCircle(t, Circ(Pt(0.4, -0.25), 1.2).Translate(Vec(100.1, -0.1)), 100.5, -0.35, 1.2)
 }
 
 func TestCircle_MoveTo(t *testing.T) {
-	testCircle(t, C(P(1, 2), 10).MoveTo(P(3, -2)), 3, -2, 10)
-	testCircle(t, C(P(0.4, -0.25), 1.2).MoveTo(P(100.1, -0.1)), 100.1, -0.1, 1.2)
+	testCircle(t, Circ(Pt(1, 2), 10).MoveTo(Pt(3, -2)), 3, -2, 10)
+	testCircle(t, Circ(Pt(0.4, -0.25), 1.2).MoveTo(Pt(100.1, -0.1)), 100.1, -0.1, 1.2)
 }
 
 func TestCircle_Scale(t *testing.T) {
-	testCircle(t, C(P(1, 2), 10).Scale(2.5), 1, 2, 25)
-	testCircle(t, C(P(0.4, -0.25), 1.2).Scale(2.5), 0.4, -0.25, 3.0)
+	testCircle(t, Circ(Pt(1, 2), 10).Scale(2.5), 1, 2, 25)
+	testCircle(t, Circ(Pt(0.4, -0.25), 1.2).Scale(2.5), 0.4, -0.25, 3.0)
 }
 
 func TestCircle_Resize(t *testing.T) {
-	testCircle(t, C(P(1, 2), 10).Resize(8), 1, 2, 8)
-	testCircle(t, C(P(0.4, -0.25), 1.2).Resize(3.1), 0.4, -0.25, 3.1)
+	testCircle(t, Circ(Pt(1, 2), 10).Resize(8), 1, 2, 8)
+	testCircle(t, Circ(Pt(0.4, -0.25), 1.2).Resize(3.1), 0.4, -0.25, 3.1)
 }
 
-func TestCircle_Expand(t *testing.T) {
-	testCircle(t, C(P(1, 2), 10).Grow(8), 1, 2, 18)
-	testCircle(t, C(P(0.4, -0.25), 1.2).Grow(3.1), 0.4, -0.25, 4.3)
+func TestCircle_Grow(t *testing.T) {
+	testCircle(t, Circ(Pt(1, 2), 10).Grow(8), 1, 2, 18)
+	testCircle(t, Circ(Pt(0.4, -0.25), 1.2).Grow(3.1), 0.4, -0.25, 4.3)
 }
 
-func TestCircle_Shrunk(t *testing.T) {
-	testCircle(t, C(P(1, 2), 10).Shrink(8), 1, 2, 2)
-	testCircle(t, C(P(0.4, -0.25), 1.2).Shrink(0.3), 0.4, -0.25, 0.9)
+func TestCircle_Shrink(t *testing.T) {
+	testCircle(t, Circ(Pt(1, 2), 10).Shrink(8), 1, 2, 2)
+	testCircle(t, Circ(Pt(0.4, -0.25), 1.2).Shrink(0.3), 0.4, -0.25, 0.9)
 }
 
 func TestCircle_Area(t *testing.T) {
-	assert.EqualDelta(t, C(P(1, 2), 10).Area(), math.Pi*100.0, Delta)
-	assert.EqualDelta(t, C(P(0.4, -0.25), 1.2).Area(), math.Pi*1.44, Delta)
+	assert.EqualDelta(t, Circ(Pt(1, 2), 10).Area(), math.Pi*100.0, Delta)
+	assert.EqualDelta(t, Circ(Pt(0.4, -0.25), 1.2).Area(), math.Pi*1.44, Delta)
 }
 
 func TestCircle_Circumference(t *testing.T) {
-	assert.EqualDelta(t, C(P(1, 2), 10).Circumference(), math.Pi*20.0, Delta)
-	assert.EqualDelta(t, C(P(0.4, -0.25), 1.2).Circumference(), math.Pi*2.4, Delta)
+	assert.EqualDelta(t, Circ(Pt(1, 2), 10).Circumference(), math.Pi*20.0, Delta)
+	assert.EqualDelta(t, Circ(Pt(0.4, -0.25), 1.2).Circumference(), math.Pi*2.4, Delta)
 }
 
 func TestCircle_Diameter(t *testing.T) {
-	assert.Equal(t, C(P(1, 2), 10).Diameter(), 20)
-	assert.EqualDelta(t, C(P(0.4, -0.25), 1.2).Diameter(), 2.4, Delta)
+	assert.Equal(t, Circ(Pt(1, 2), 10).Diameter(), 20)
+	assert.EqualDelta(t, Circ(Pt(0.4, -0.25), 1.2).Diameter(), 2.4, Delta)
 }
 
 func TestCircle_Bounds(t *testing.T) {
-	testRect(t, C(P(1, 2), 10).Bounds(), 1, 2, 10, 10)
-	testRect(t, C(P(0.4, -0.25), 1.2).Bounds(), 0.4, -0.25, 1.2, 1.2)
+	testRect(t, Circ(Pt(1, 2), 10).Bounds(), 1, 2, 10, 10)
+	testRect(t, Circ(Pt(0.4, -0.25), 1.2).Bounds(), 0.4, -0.25, 1.2, 1.2)
 }
 
 func TestCircle_Equal(t *testing.T) {
-	assert.False(t, C(P(1, 2), 10).Equal(C(P(3, -3), 10)))
-	assert.True(t, C(P(1, 2), 10).Equal(C(P(1, 2), 10)))
+	assert.False(t, Circ(Pt(1, 2), 10).Equal(Circ(Pt(3, -3), 10)))
+	assert.True(t, Circ(Pt(1, 2), 10).Equal(Circ(Pt(1, 2), 10)))
 
-	assert.False(t, C(P(0.4, -0.25), 1.2).Equal(C(P(100.1, -0.1), 1.2)))
-	assert.True(t, C(P(0.4, -0.25), 1.2).Equal(C(P(0.4, -0.25), 1.2)))
-	assert.True(t, C(P(0.4, -0.25), 1.2).Equal(C(P(0.4, -0.250001), 1.2)))
+	assert.False(t, Circ(Pt(0.4, -0.25), 1.2).Equal(Circ(Pt(100.1, -0.1), 1.2)))
+	assert.True(t, Circ(Pt(0.4, -0.25), 1.2).Equal(Circ(Pt(0.4, -0.25), 1.2)))
+	assert.True(t, Circ(Pt(0.4, -0.25), 1.2).Equal(Circ(Pt(0.4, -0.250001), 1.2)))
 }
 
 func TestCircle_Contains(t *testing.T) {
-	assert.False(t, C(P(1, 2), 10).Contains(P(1, 12)))
-	assert.True(t, C(P(1, 2), 10).Contains(P(4, 4)))
+	assert.False(t, Circ(Pt(1, 2), 10).Contains(Pt(1, 12)))
+	assert.True(t, Circ(Pt(1, 2), 10).Contains(Pt(4, 4)))
 
-	assert.False(t, C(P(0.4, -0.25), 1.2).Contains(P(0.0, 1.7)))
-	assert.True(t, C(P(0.4, -0.25), 1.2).Contains(P(0.1, 0.8)))
+	assert.False(t, Circ(Pt(0.4, -0.25), 1.2).Contains(Pt(0.0, 1.7)))
+	assert.True(t, Circ(Pt(0.4, -0.25), 1.2).Contains(Pt(0.1, 0.8)))
 }
 
 func TestCircle_String(t *testing.T) {
-	assert.Equal(t, C(P(10, 16), 5).String(), "C((10,16);5)")
-	assert.Equal(t, C(P(100, -34.0000115), 0.2).String(), "C((100,-34.00);0.20)")
+	assert.Equal(t, Circ(Pt(10, 16), 5).String(), "C((10,16);5)")
+	assert.Equal(t, Circ(Pt(100, -34.0000115), 0.2).String(), "C((100,-34.00);0.20)")
 }
 
 func TestCircle_Marshall(t *testing.T) {
-	assert.JSON(t, C(P(10, 16), 12), `{"x":10,"y":16,"r":12}`)
-	assert.JSON(t, C(P(100, -34.0000115), 0.2), `{"x":100.0,"y":-34.0000115,"r":0.2}`)
+	assert.JSON(t, Circ(Pt(10, 16), 12), `{"x":10,"y":16,"r":12}`)
+	assert.JSON(t, Circ(Pt(100, -34.0000115), 0.2), `{"x":100.0,"y":-34.0000115,"r":0.2}`)
 }
 
 func TestCircle_Unmarshall(t *testing.T) {
@@ -101,10 +101,10 @@ func TestCircle_Unmarshall(t *testing.T) {
 }
 
 func TestCircle_Immutable(t *testing.T) {
-	c1 := C(P(1, 2), 10)
+	c1 := Circ(Pt(1, 2), 10)
 
-	c1.Translate(V(3, -2))
-	c1.MoveTo(P(4, 3))
+	c1.Translate(Vec(3, -2))
+	c1.MoveTo(Pt(4, 3))
 	c1.Scale(2)
 	c1.Resize(15)
 	c1.Grow(1)

image.go

@@ -14,9 +14,9 @@ func SizeFromImage[T Number](r image.Rectangle) Size[T] {
 	return Size[T]{T(r.Dx()), T(r.Dy())}
 }
 
-// RectangleFromImage converts a Rectangle from an image.Rectangle.
-func RectangleFromImage[T Number](r image.Rectangle) Rectangle[T] {
-	return RectangleFromMin(PointFromImage[T](r.Min), SizeFromImage[T](r))
+// RectFromImage converts a Rectangle from an image.Rectangle.
+func RectFromImage[T Number](r image.Rectangle) Rectangle[T] {
+	return RectFromMin(PointFromImage[T](r.Min), SizeFromImage[T](r))
 }
 
 // ToImagePoint converts a Point to an image.Point.

line.go

@@ -10,8 +10,8 @@ type Line[T Number] struct {
 	End   Point[T] `json:"b"`
 }
 
-// L is shorthand for Line{start, end}.
-func L[T Number](start, end Point[T]) Line[T] {
+// Ln is shorthand for Line{start, end}.
+func Ln[T Number](start, end Point[T]) Line[T] {
 	return Line[T]{start, end}
 }
 
@@ -47,7 +47,7 @@ func (l Line[T]) Length() float64 {
 
 // Bounds returns the axis-aligned bounding rectangle.
 func (l Line[T]) Bounds() Rectangle[T] {
-	return Rectangle[T]{Center: l.Midpoint(), Size: S(l.Direction().Abs().XY())}
+	return Rectangle[T]{Center: l.Midpoint(), Size: Sz(l.Direction().Abs().XY())}
 }
 
 // Equal checks if the start and end points of the lines are equal.

line_test.go

@@ -9,76 +9,76 @@ import (
 )
 
 func TestLine_New(t *testing.T) {
-	testLine(t, L(P(1, -1), P(2, 0)), 1, -1, 2, 0)
-	testLine(t, L(P(0.5, -1.25), P(2.5, 3.75)), 0.5, -1.25, 2.5, 3.75)
+	testLine(t, Ln(Pt(1, -1), Pt(2, 0)), 1, -1, 2, 0)
+	testLine(t, Ln(Pt(0.5, -1.25), Pt(2.5, 3.75)), 0.5, -1.25, 2.5, 3.75)
 }
 
 func TestLine_Translate(t *testing.T) {
-	testLine(t, L(P(1, 2), P(3, 4)).Translate(V(3, -2)), 4, 0, 6, 2)
-	testLine(t, L(P(0.4, -0.25), P(1.2, 3.4)).Translate(V(100.1, -0.1)), 100.5, -0.35, 101.3, 3.3)
+	testLine(t, Ln(Pt(1, 2), Pt(3, 4)).Translate(Vec(3, -2)), 4, 0, 6, 2)
+	testLine(t, Ln(Pt(0.4, -0.25), Pt(1.2, 3.4)).Translate(Vec(100.1, -0.1)), 100.5, -0.35, 101.3, 3.3)
 }
 
 func TestLine_MoveTo(t *testing.T) {
-	testLine(t, L(P(1, 2), P(3, 4)).MoveTo(P(3, -2)), 3, -2, 5, 0)
-	testLine(t, L(P(0.4, -0.25), P(1.2, 3.4)).MoveTo(P(100.1, -0.1)), 100.1, -0.1, 100.9, 3.55)
+	testLine(t, Ln(Pt(1, 2), Pt(3, 4)).MoveTo(Pt(3, -2)), 3, -2, 5, 0)
+	testLine(t, Ln(Pt(0.4, -0.25), Pt(1.2, 3.4)).MoveTo(Pt(100.1, -0.1)), 100.1, -0.1, 100.9, 3.55)
 }
 
 func TestLine_Reversed(t *testing.T) {
-	testLine(t, L(P(1, 2), P(3, 4)).Reversed(), 3, 4, 1, 2)
-	testLine(t, L(P(0.4, -0.25), P(1.2, 3.4)).Reversed(), 1.2, 3.4, 0.4, -0.25)
+	testLine(t, Ln(Pt(1, 2), Pt(3, 4)).Reversed(), 3, 4, 1, 2)
+	testLine(t, Ln(Pt(0.4, -0.25), Pt(1.2, 3.4)).Reversed(), 1.2, 3.4, 0.4, -0.25)
 }
 
 func TestLine_Midpoint(t *testing.T) {
-	testPoint(t, L(P(1, 2), P(3, 4)).Midpoint(), 2, 3)
-	testPoint(t, L(P(0.4, -0.25), P(1.2, 3.4)).Midpoint(), 0.8, 1.575)
+	testPoint(t, Ln(Pt(1, 2), Pt(3, 4)).Midpoint(), 2, 3)
+	testPoint(t, Ln(Pt(0.4, -0.25), Pt(1.2, 3.4)).Midpoint(), 0.8, 1.575)
 }
 
 func TestLine_Direction(t *testing.T) {
-	testVector(t, L(P(1, 2), P(3, 4)).Direction(), 2, 2)
-	testVector(t, L(P(0.4, -0.25), P(1.2, 3.4)).Direction(), 0.8, 3.65)
+	testVector(t, Ln(Pt(1, 2), Pt(3, 4)).Direction(), 2, 2)
+	testVector(t, Ln(Pt(0.4, -0.25), Pt(1.2, 3.4)).Direction(), 0.8, 3.65)
 }
 
 func TestLine_Length(t *testing.T) {
-	assert.EqualDelta(t, L(P(1, 2), P(3, 5)).Length(), math.Sqrt(13), Delta)
-	assert.EqualDelta(t, L(P(0.4, -0.25), P(1.2, 3.4)).Length(), math.Sqrt(13.9625), Delta)
+	assert.EqualDelta(t, Ln(Pt(1, 2), Pt(3, 5)).Length(), math.Sqrt(13), Delta)
+	assert.EqualDelta(t, Ln(Pt(0.4, -0.25), Pt(1.2, 3.4)).Length(), math.Sqrt(13.9625), Delta)
 }
 
 func TestLine_Equal(t *testing.T) {
-	assert.False(t, L(P(1, 2), P(3, 4)).Equal(L(P(1, 2), P(3, 5))))
-	assert.True(t, L(P(1, 2), P(3, 4)).Equal(L(P(1, 2), P(3, 4))))
+	assert.False(t, Ln(Pt(1, 2), Pt(3, 4)).Equal(Ln(Pt(1, 2), Pt(3, 5))))
+	assert.True(t, Ln(Pt(1, 2), Pt(3, 4)).Equal(Ln(Pt(1, 2), Pt(3, 4))))
 
-	assert.False(t, L(P(0.4, -0.25), P(1.2, 3.4)).Equal(L(P(0.5, -0.25), P(1.2, 3.4))))
-	assert.True(t, L(P(0.4, -0.25), P(1.2, 3.4)).Equal(L(P(0.4, -0.25), P(1.2, 3.4))))
+	assert.False(t, Ln(Pt(0.4, -0.25), Pt(1.2, 3.4)).Equal(Ln(Pt(0.5, -0.25), Pt(1.2, 3.4))))
+	assert.True(t, Ln(Pt(0.4, -0.25), Pt(1.2, 3.4)).Equal(Ln(Pt(0.4, -0.25), Pt(1.2, 3.4))))
 }
 
 func TestLine_String(t *testing.T) {
-	assert.Equal(t, L(P(10, 16), P(1, 2)).String(), "L((10,16);(1,2))")
-	assert.Equal(t, L(P(100, -34.0000115), P(0.2, 0.4)).String(), "L((100,-34.00);(0.20,0.40))")
+	assert.Equal(t, Ln(Pt(10, 16), Pt(1, 2)).String(), "L((10,16);(1,2))")
+	assert.Equal(t, Ln(Pt(100, -34.0000115), Pt(0.2, 0.4)).String(), "L((100,-34.00);(0.20,0.40))")
 }
 
 func TestLine_Marshal_Unmarshal(t *testing.T) {
-	assert.JSON(t, L(P(10, 16), P(1, 2)), `{"a":{"x":10,"y":16},"b":{"x":1,"y":2}}`)
-	assert.JSON(t, L(P(100, -34.0000115), P(0.2, 0.4)), `{"a":{"x":100.0,"y":-34.0000115},"b":{"x":0.2,"y":0.4}}`)
+	assert.JSON(t, Ln(Pt(10, 16), Pt(1, 2)), `{"a":{"x":10,"y":16},"b":{"x":1,"y":2}}`)
+	assert.JSON(t, Ln(Pt(100, -34.0000115), Pt(0.2, 0.4)), `{"a":{"x":100.0,"y":-34.0000115},"b":{"x":0.2,"y":0.4}}`)
 }
 
 func TestLine_Unmarshal(t *testing.T) {
 	var l1 Line[int]
 	assert.NoError(t, json.Unmarshal([]byte(`{"a":{"x":10,"y":16},"b":{"x":1,"y":2}}`), &l1))
-	assert.True(t, l1.Equal(L(P(10, 16), P(1, 2))))
+	assert.True(t, l1.Equal(Ln(Pt(10, 16), Pt(1, 2))))
 
 	var l2 Line[float64]
 	assert.NoError(t, json.Unmarshal([]byte(`{"a":{"x":10.1,"y":-34.0000115},"b":{"x":0.2,"y":0.4}}`), &l2))
-	assert.True(t, l2.Equal(L(P(10.1, -34.0000115), P(0.2, 0.4))))
+	assert.True(t, l2.Equal(Ln(Pt(10.1, -34.0000115), Pt(0.2, 0.4))))
 }
 
 func TestLine_Immutable(t *testing.T) {
-	l := L(P(1, 2), P(3, 4))
+	l := Ln(Pt(1, 2), Pt(3, 4))
 
-	l.Translate(V(3, -2))
-	l.MoveTo(P(4, 3))
+	l.Translate(Vec(3, -2))
+	l.MoveTo(Pt(4, 3))
 	l.Reversed()
 
-	assert.True(t, l.Equal(L(P(1, 2), P(3, 4))))
+	assert.True(t, l.Equal(Ln(Pt(1, 2), Pt(3, 4))))
 }
 
 func testLine[T Number](t *testing.T, l Line[T], sx, sy, ex, ey T) {

matrix.go

@@ -11,8 +11,8 @@ type Matrix struct {
 	// [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 {
+// Mat is shorthand for Matrix{a, b, c, d, e, f}.
+func Mat(a, b, c, d, e, f float64) Matrix {
 	return Matrix{a, b, c, d, e, f}
 }
 
@@ -112,7 +112,7 @@ func (m Matrix) Equal(matrix Matrix) bool {
 func (m Matrix) IsZero() bool { return m.Equal(Matrix{}) }
 
 //func (m Matrix) String() string {
-//	return fmt.Sprintf("[[%.2f, %.2f, %.2f], [%.2f, %.2f, %.2f]]", m.A, m.B, m.C, m.D, m.E, m.F)
+//	return fmt.Sprintf("[[%.2f, %.2f, %.2f], [%.2f, %.2f, %.2f]]", m.A, m.B, m.Circ, m.D, m.E, m.F)
 //}
 
 // IdentityMatrix creates a new identity matrix.

padding.go

@@ -0,0 +1,31 @@
+package geom
+
+// Padding represents a 2D padding.
+type Padding[T Number] struct {
+	Top, Right, Bottom, Left T
+}
+
+// Pd is shorthand for Padding{top, right, bottom, left}.
+func Pd[T Number](top, right, bottom, left T) Padding[T] {
+	return Padding[T]{top, right, bottom, left}
+}
+
+// PdU is shorthand for Padding{padding, padding, padding, padding}.
+func PdU[T Number](padding T) Padding[T] {
+	return Padding[T]{padding, padding, padding, padding}
+}
+
+// Width returns the width of the padding.
+func (p Padding[T]) Width() T {
+	return p.Left + p.Right
+}
+
+// Height returns the height of the padding.
+func (p Padding[T]) Height() T {
+	return p.Top + p.Bottom
+}
+
+// XY returns the width and height of the padding.
+func (p Padding[T]) XY() (T, T) {
+	return p.Width(), p.Height()
+}