Init Polygon and RegularPolygon

Author: tomas-novotny

polygon.go

@@ -0,0 +1,54 @@
+package geom
+
+// Polygon is a 2D polygon with 3+ transform.
+type Polygon[T Number] struct {
+	Vertices []Point[T]
+}
+
+// Center returns the polygon centroid computed as the average of its transform.
+func (p Polygon[T]) Center() Point[T] {
+	var x, y T
+	l := T(len(p.Vertices))
+	for _, v := range p.Vertices {
+		x, y = x+v.X, y+v.Y
+	}
+
+	return Point[T]{x / l, y / l}
+}
+
+// Translate creates a new Polygon translated by the given vector (applied to all transform).
+func (p Polygon[T]) Translate(vector Vector[T]) Polygon[T] {
+	return Polygon[T]{transform(p.Vertices, func(e Point[T]) Point[T] {
+		return e.Add(vector)
+	})}
+}
+
+// MoveTo creates a new Polygon whose centroid is moved to point, preserving shape.
+func (p Polygon[T]) MoveTo(point Point[T]) Polygon[T] {
+	return p.Translate(point.Subtract(p.Center()))
+}
+
+// Scale creates a new Polygon uniformly scaled about its centroid by the factor.
+func (p Polygon[T]) Scale(scale float64) Polygon[T] {
+	center := p.Center()
+	return Polygon[T]{transform(p.Vertices, func(point Point[T]) Point[T] {
+		return center.Add(point.Subtract(center).Multiply(scale))
+	})}
+}
+
+// ScaleXY creates a new Polygon scaled about its centroid by the factors.
+func (p Polygon[T]) ScaleXY(scaleX, scaleY float64) Polygon[T] {
+	center := p.Center()
+	return Polygon[T]{transform(p.Vertices, func(point Point[T]) Point[T] {
+		return center.Add(point.Subtract(center).MultiplyXY(scaleX, scaleY))
+	})}
+}
+
+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
+}

polygon_regular.go

@@ -0,0 +1,70 @@
+package geom
+
+import (
+	"math"
+)
+
+// RegularPolygon is a polygon with equally spaced transform around a center.
+type RegularPolygon[T Number] struct {
+	Center Point[T]
+	Size   Size[T]
+	N      int
+}
+
+// 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 transform.
+func Triangle[T Number](center Point[T], size Size[T]) RegularPolygon[T] {
+	return RegularPolygon[T]{center, size, 3}
+}
+
+// Square creates a RegularPolygon with 4 transform.
+func Square[T Number](center Point[T], size Size[T]) RegularPolygon[T] {
+	return RegularPolygon[T]{center, size, 4}
+}
+
+// Hexagon creates a RegularPolygon with 6 transform.
+func Hexagon[T Number](center Point[T], size Size[T]) RegularPolygon[T] {
+	return RegularPolygon[T]{center, size, 6}
+}
+
+// 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}
+}
+
+// MoveTo creates a new RegularPolygon with the same size and sides centered at point.
+func (rp RegularPolygon[T]) MoveTo(point Point[T]) RegularPolygon[T] {
+	return RegularPolygon[T]{point, rp.Size, rp.N}
+}
+
+// Multiple creates a new RegularPolygon with size scaled by the given factor.
+func (rp RegularPolygon[T]) Scale(scale float64) RegularPolygon[T] {
+	return RegularPolygon[T]{rp.Center, rp.Size.Scale(scale), rp.N}
+}
+
+// Multiple creates a new RegularPolygon with size scaled by the given factors.
+func (rp RegularPolygon[T]) ScaleXY(scaleX, scaleY float64) RegularPolygon[T] {
+	return RegularPolygon[T]{rp.Center, rp.Size.ScaleXY(scaleX, scaleY), rp.N}
+}
+
+// Vertices returns the polygon transform 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)
+
+	vertices := make([]Point[T], rp.N)
+	for i := 0; i < rp.N; i++ {
+		vertices[i] = rp.Center.Add(VecFromAngle[T](initAngle+float64(i)*angleStep, 1).MultiplyXY(float64(rp.Size.Width), float64(rp.Size.Height)))
+	}
+
+	return vertices
+}
+
+// ToPolygon converts the regular polygon into a generic Polygon with computed vertices.
+func (rp RegularPolygon[T]) ToPolygon() Polygon[T] {
+	return Polygon[T]{rp.Vertices()}
+}

rectangle.go

@@ -13,19 +13,14 @@ func R[T Number](center Point[T], size Size[T]) Rectangle[T] {
 	return Rectangle[T]{center, size}
 }
 
-// RectMin creates a Rectangle from min point and size.
-func RectMin[T Number](min Point[T], size Size[T]) Rectangle[T] {
+// RectangleFromMin creates a Rectangle from min point and size.
+func RectangleFromMin[T Number](min Point[T], size Size[T]) Rectangle[T] {
 	return Rectangle[T]{min.AddXY(size.Scale(0.5).XY()), size}
 }
 
-// RectMinMax creates a Rectangle from min and max points.
-func RectMinMax[T Number](min, max Point[T]) Rectangle[T] {
-	return RectMin(min, S(max.Subtract(min).XY()))
-}
-
-// RectFromSize creates a Rectangle centered at (0,0) with the given size.
-func RectFromSize[T Number](size Size[T]) Rectangle[T] {
-	return Rectangle[T]{Point[T]{0, 0}, size}
+// RectangleFromMinMax creates a Rectangle from min and max points.
+func RectangleFromMinMax[T Number](min, max Point[T]) Rectangle[T] {
+	return RectangleFromMin(min, S(max.Subtract(min).XY()))
 }
 
 // Translate creates a new Rectangle translated by the given vector.
@@ -122,7 +117,7 @@ func (r Rectangle[T]) Edges() []Line[T] {
 	return []Line[T]{}
 }
 
-// Vertices returns the four corner points in clockwise order starting from Min (bottom-left).
+// Vertices returns the polygon vertices in order starting Min point, counter-clockwise.
 func (r Rectangle[T]) Vertices() []Point[T] {
 	return []Point[T]{
 		r.BottomLeft(),
@@ -159,8 +154,12 @@ func (r Rectangle[T]) Contains(point Point[T]) bool {
 	return minPoint.X <= point.X && point.X <= maxPoint.X && minPoint.Y <= point.Y && point.Y <= maxPoint.Y
 }
 
+// ToPolygon converts the rectangle into a generic Polygon with computed vertices.
+func (r Rectangle[T]) ToPolygon() Polygon[T] {
+	return Polygon[T]{r.Vertices()}
+}
+
 // String returns a string representation of the Rectangle using min and max.
 func (r Rectangle[T]) String() string {
 	return fmt.Sprintf("%s-%s", r.Min().String(), r.Max().String())
-
 }