Add type conversion methods for geometry primitives

Author: tomas-novotny

circle.go

@@ -81,6 +81,16 @@ func (c Circle[T]) Contains(point Point[T]) bool {
 	return c.Center.Subtract(point).Less(c.Radius)
 }
 
+// Int converts the circle to a [int] circle.
+func (c Circle[T]) Int() Circle[int] {
+	return Circle[int]{c.Center.Int(), Cast[int](float64(c.Radius))}
+}
+
+// Float converts the circle to a [float64] circle.
+func (c Circle[T]) Float() Circle[float64] {
+	return Circle[float64]{c.Center.Float(), float64(c.Radius)}
+}
+
 // String returns a string representation of the Circle.
 func (c Circle[T]) String() string {
 	return fmt.Sprintf("C(%s;%s)", c.Center.String(), String(c.Radius))

line.go

@@ -60,6 +60,16 @@ func (l Line[T]) IsZero() bool {
 	return l.Start.IsZero() && l.End.IsZero()
 }
 
+// Int converts the line to a [int] line.
+func (l Line[T]) Int() Line[int] {
+	return Line[int]{l.Start.Int(), l.End.Int()}
+}
+
+// Float converts the line to a [float64] line.
+func (l Line[T]) Float() Line[float64] {
+	return Line[float64]{l.Start.Float(), l.End.Float()}
+}
+
 // String returns a string representation of the Line.
 func (l Line[T]) String() string {
 	return fmt.Sprintf("L(%s;%s)", l.Start.String(), l.End.String())

padding.go

@@ -39,3 +39,13 @@ func (p Padding[T]) XY() (T, T) {
 func (p Padding[T]) Size() Size[T] {
 	return Size[T]{p.Width(), p.Height()}
 }
+
+// Int converts the padding to a [int] padding.
+func (p Padding[T]) Int() Padding[int] {
+	return Padding[int]{Cast[int](float64(p.Top)), Cast[int](float64(p.Right)), Cast[int](float64(p.Bottom)), Cast[int](float64(p.Left))}
+}
+
+// Float converts the padding to a [float64] padding.
+func (p Padding[T]) Float() Padding[float64] {
+	return Padding[float64]{float64(p.Top), float64(p.Right), float64(p.Bottom), float64(p.Left)}
+}

point.go

@@ -95,11 +95,21 @@ func (p Point[T]) XY() (T, T) {
 	return p.X, p.Y
 }
 
-// Vector converts the sipointze to a Vector.
+// Vector converts the point to a Vector.
 func (p Point[T]) Vector() Vector[T] {
 	return Vector[T]{p.X, p.Y}
 }
 
+// Int converts the point to a [int] point.
+func (p Point[T]) Int() Point[int] {
+	return Point[int]{Cast[int](float64(p.X)), Cast[int](float64(p.Y))}
+}
+
+// Float converts the point to a [float64] point.
+func (p Point[T]) Float() Point[float64] {
+	return Point[float64]{float64(p.X), float64(p.Y)}
+}
+
 // String returns a string representing the point.
 func (p Point[T]) String() string {
 	return fmt.Sprintf("(%s,%s)", String(p.X), String(p.Y))

polygon.go

@@ -57,3 +57,13 @@ func (p Polygon[T]) ScaleXY(factorX, factorY float64) Polygon[T] {
 func (p Polygon[T]) Empty() bool {
 	return len(p.Vertices) == 0
 }
+
+// Int converts the polygon to a [int] polygon.
+func (p Polygon[T]) Int() Polygon[int] {
+	return Polygon[int]{slices.Map(p.Vertices, (Point[T]).Int)}
+}
+
+// Float converts the polygon to a [float64] polygon.
+func (p Polygon[T]) Float() Polygon[float64] {
+	return Polygon[float64]{slices.Map(p.Vertices, (Point[T]).Float)}
+}

rectangle.go

@@ -187,11 +187,21 @@ 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] {
+// Polygon converts the rectangle into a generic Polygon with computed vertices.
+func (r Rectangle[T]) Polygon() Polygon[T] {
 	return Polygon[T]{r.Vertices()}
 }
 
+// Int converts the rectangle to a [int] rectangle.
+func (r Rectangle[T]) Int() Rectangle[int] {
+	return Rectangle[int]{r.Center.Int(), r.Size.Int()}
+}
+
+// Float converts the rectangle to a [float64] rectangle.
+func (r Rectangle[T]) Float() Rectangle[float64] {
+	return Rectangle[float64]{r.Center.Float(), r.Size.Float()}
+}
+
 // 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())

rectangle_test.go

@@ -137,7 +137,7 @@ func TestRectangle_Contains(t *testing.T) {
 
 func TestRectangle_ToPolygon(t *testing.T) {
 	r := Rect(Pt(0, 0), Sz(2, 2))
-	p := r.ToPolygon()
+	p := r.Polygon()
 
 	assert.Equal(t, p.Vertices, r.Vertices())
 	assert.NotSame(t, p.Vertices, r.Vertices())

regular_polygon.go

@@ -84,6 +84,16 @@ func (rp RegularPolygon[T]) Empty() bool {
 	return rp.N == 0
 }
 
+// Int converts the regular polygon to a [int] regular polygon.
+func (rp RegularPolygon[T]) Int() RegularPolygon[int] {
+	return RegularPolygon[int]{rp.Center.Int(), rp.Size.Int(), rp.N, rp.Angle}
+}
+
+// Float converts the regular polygon to a [float64] regular polygon.
+func (rp RegularPolygon[T]) Float() RegularPolygon[float64] {
+	return RegularPolygon[float64]{rp.Center.Float(), rp.Size.Float(), rp.N, rp.Angle}
+}
+
 type Orientation int
 
 const (

size.go

@@ -85,6 +85,16 @@ func (s Size[T]) Vector() Vector[T] {
 	return Vector[T]{s.Width, s.Height}
 }
 
+// Int converts the size to a [int] size.
+func (s Size[T]) Int() Size[int] {
+	return Size[int]{Cast[int](float64(s.Width)), Cast[int](float64(s.Height))}
+}
+
+// Float converts the size to a [float64] size.
+func (s Size[T]) Float() Size[float64] {
+	return Size[float64]{float64(s.Width), float64(s.Height)}
+}
+
 // String returns a string in the form "WxH" using the underlying number formatting.
 func (s Size[T]) String() string {
 	return fmt.Sprintf("%sx%s", String(s.Width), String(s.Height))

types/floats/types.go

@@ -3,7 +3,6 @@ package floats
 
 import (
 	geom "github.com/gravitton/geometry"
-	"github.com/gravitton/x/slices"
 )
 
 type Point = geom.Point[float64]
@@ -16,75 +15,47 @@ type Polygon = geom.Polygon[float64]
 type RegularPolygon = geom.RegularPolygon[float64]
 type Padding = geom.Padding[float64]
 
+// Pt is shorthand for geom.Pt(x, y).Float()
 func Pt[T geom.Number](x, y T) Point {
-	return Point{X: float64(x), Y: float64(y)}
-}
-
-func ToPoint[T geom.Number](point geom.Point[T]) Point {
-	return Pt(point.X, point.Y)
+	return geom.Pt(x, y).Float()
 }
 
+// Vec is shorthand for geom.Vec(x, y).Float()
 func Vec[T geom.Number](x, y T) Vector {
-	return Vector{X: float64(x), Y: float64(y)}
-}
-
-func ToVector[T geom.Number](vector geom.Vector[T]) Vector {
-	return Vec(vector.X, vector.Y)
+	return geom.Vec(x, y).Float()
 }
 
+// Sz is shorthand for geom.Sz(width, height).Float()
 func Sz[T geom.Number](width, height T) Size {
-	return Size{Width: float64(width), Height: float64(height)}
-}
-
-func ToSize[T geom.Number](size geom.Size[T]) Size {
-	return Sz(size.Width, size.Height)
+	return geom.Sz(width, height).Float()
 }
 
+// Circ is shorthand for geom.Circ(center, radius).Float()
 func Circ[T geom.Number](center geom.Point[T], radius T) Circle {
-	return Circle{Center: ToPoint(center), Radius: float64(radius)}
-}
-
-func ToCircle[T geom.Number](circle geom.Circle[T]) Circle {
-	return Circ(circle.Center, circle.Radius)
+	return geom.Circ(center, radius).Float()
 }
 
+// Ln is shorthand for geom.Ln(start, end).Float()
 func Ln[T geom.Number](start, end geom.Point[T]) Line {
-	return Line{Start: ToPoint(start), End: ToPoint(end)}
+	return geom.Ln(start, end).Float()
 }
 
-func ToLine[T geom.Number](line geom.Line[T]) Line {
-	return Ln(line.Start, line.End)
-}
+// Rect is shorthand for geom.Rect(center, size).Float()
 func Rect[T geom.Number](center geom.Point[T], size geom.Size[T]) Rectangle {
-	return Rectangle{Center: ToPoint(center), Size: ToSize(size)}
+	return geom.Rect(center, size).Float()
 }
 
-func ToRectangle[T geom.Number](rectangle geom.Rectangle[T]) Rectangle {
-	return Rect(rectangle.Center, rectangle.Size)
-}
-
-func Pol[T geom.Number](Vertices []geom.Point[T]) Polygon {
-	return Polygon{Vertices: slices.Map(Vertices, func(point geom.Point[T]) Point {
-		return ToPoint(point)
-	})}
-}
-
-func ToPolygon[T geom.Number](polygon geom.Polygon[T]) Polygon {
-	return Pol(polygon.Vertices)
+// Pol is shorthand for geom.Pol(vertices).Float()
+func Pol[T geom.Number](vertices []geom.Point[T]) Polygon {
+	return geom.Pol(vertices).Float()
 }
 
+// RegPol is shorthand for geom.RegPol(center, size, n, angle).Float()
 func RegPol[T geom.Number](center geom.Point[T], size geom.Size[T], n int, angle float64) RegularPolygon {
-	return RegularPolygon{Center: ToPoint(center), Size: ToSize(size), N: n, Angle: angle}
-}
-
-func ToRegularPolygon[T geom.Number](polygon geom.RegularPolygon[T]) RegularPolygon {
-	return RegPol(polygon.Center, polygon.Size, polygon.N, polygon.Angle)
-}
-
-func Pd[T geom.Number](top, right, bottom, left T) Padding {
-	return Padding{Top: float64(top), Right: float64(right), Bottom: float64(bottom), Left: float64(left)}
+	return geom.RegPol(center, size, n, angle).Float()
 }
 
-func ToPadding[T geom.Number](padding geom.Padding[T]) Padding {
-	return Pd(padding.Top, padding.Right, padding.Bottom, padding.Left)
+// Pad is shorthand for geom.Pad(top, right, bottom, left).Float()
+func Pad[T geom.Number](top, right, bottom, left T) Padding {
+	return geom.Pad(top, right, bottom, left).Float()
 }