Init image conversions and add mathematical utility functions

Author: tomas-novotny

constraints.go

@@ -5,6 +5,7 @@ import (
 	"math"
 )
 
+// Number is a generic number type supported by all types and functions in this package.
 type Number interface {
 	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~float32 | ~float64
 }
@@ -21,9 +22,9 @@ func Cast[T Number](a float64) T {
 // ToString format Number as numeric string
 func ToString[T Number](value T) string {
 	if isIntValue(value) {
-		return fmt.Sprintf("%+d", int64(value))
+		return fmt.Sprintf("%d", int64(value))
 	} else {
-		return fmt.Sprintf("%+.2f", float64(value))
+		return fmt.Sprintf("%.2f", float64(value))
 	}
 }
 

go.mod

@@ -1,5 +1,5 @@
 module github.com/gravitton/geometry
 
-go 1.24
+go 1.25
 
 require github.com/gravitton/assert v0.4.0

image.go

@@ -0,0 +1,29 @@
+package geom
+
+import (
+	"image"
+)
+
+func PointFromImage[T Number](p image.Point) Point[T] {
+	return Point[T]{T(p.X), T(p.Y)}
+}
+
+func SizeFromImage[T Number](r image.Rectangle) Size[T] {
+	return Size[T]{T(r.Dx()), T(r.Dy())}
+}
+
+func RectangleFromImage[T Number](r image.Rectangle) Rectangle[T] {
+	return RectangleFromMin(PointFromImage[T](r.Min), SizeFromImage[T](r))
+}
+
+func (p Point[T]) ToImagePoint() image.Point {
+	return image.Point{int(p.X), int(p.Y)}
+}
+
+func (s Size[T]) ToImageRectangle() image.Rectangle {
+	return image.Rectangle{image.Point{0, 0}, image.Point{int(s.Width), int(s.Height)}}
+}
+
+func (r Rectangle[T]) ToImageRectangle() image.Rectangle {
+	return image.Rectangle{r.Min().ToImagePoint(), r.Max().ToImagePoint()}
+}

math.go

@@ -9,6 +9,9 @@ const (
 	DegToRad float64 = math.Pi / 180.0
 
 	Delta float64 = 1e-6
+
+	Sqrt3          = 1.732050807568877293527446341505872367
+	OneOverSqrtTwo = 1 / math.Sqrt2
 )
 
 // ToRadians converts degrees to radians
@@ -21,19 +24,27 @@ func ToDegrees(radians float64) float64 {
 	return radians * RadToDeg
 }
 
-// Scale multiple number by scale factor
-func Scale[T Number](a T, scale float64) T {
+// Multiple multiple number by scale factor
+func Multiple[T Number](a T, scale float64) T {
 	return Cast[T](float64(a) * scale)
 }
 
+// Divide divide number by scale factor
+func Divide[T Number](a T, scale float64) T {
+	if scale == 0 {
+		return a
+	}
+
+	return Cast[T](float64(a) / scale)
+}
+
 // Abs returns absolute value
 func Abs[T Number](a T) T {
 	return Cast[T](math.Abs(float64(a)))
 }
 
 // Midpoint calculate midpoint (point exactly halfway between two points)
 // Shorthand for `lerp(a, b, 0.5)`
-// TODO: fix rounding for int numbers
 func Midpoint[T Number](a, b T) T {
 	// return Cast(lerp(float64(a), float64(b), 0.5))
 	return Cast[T](midpoint(float64(a), float64(b)))
@@ -46,7 +57,6 @@ func midpoint(a, b float64) float64 {
 }
 
 // Lerp calculate linear interpolation (point along a line between two points based on a given ratio)
-// TODO: fix rounding for int numbers
 func Lerp[T Number](a, b T, t float64) T {
 	return Cast[T](lerp(float64(a), float64(b), t))
 }