geo

package
v0.0.0-...-cda96b6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 13, 2025 License: BSD-3-Clause Imports: 5 Imported by: 0

README

geo

A collection of geometry primitives.

Why would you use this? You wouldn't. There are so many good math libraries. This is not one of them.

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	HorizontalSlope = Slope{Angle: Horizontal, M: 0.}
	VerticalSlope   = Slope{Angle: Vertical, M: math.MaxFloat64}
)
View Source 
var RngFUnit = RngF{Min: 0., Max: 1.}

Functions

func Abs 

func Abs[T constraints.Signed](x T) T

func Clamp 

func Clamp[T Number](n, low, high T) T

func DegreesToRadians 

func DegreesToRadians(degrees float64) float64

func Float64NearZero 

func Float64NearZero(v float64, tolerance float64) bool

func FloatsEqual 

func FloatsEqual(a, b float64) bool

func FloatsEqualTol 

func FloatsEqualTol(a, b, tolerance float64) bool

func Fmt 

func Fmt(a any, params any) fmt.Stringer

func IsCollinear 

func IsCollinear[T Number](p1, p2, p3 Point[T]) bool

IsCollinear checks if three points are collinear

func Max 

func Max[T Number](a, b T) T

func Min 

func Min[T Number](a, b T) T

Surely these are SOMEWHERE? TODO: Yes, builtin min() and max(), and they are highly optimized, perform the same as this. So remove these.

func Nearest 

func Nearest[T Number](base, a, b T) int

Nearest answers which value is nearest to base.

func NullHitTest 

func NullHitTest(PtF) bool

func OnSegment 

func OnSegment[T Number](p, start, end Point[T]) bool

OnSegment checks if a point lies on a line segment

func Orient 

func Orient[T Number](a, b, c Point[T]) T

Orient answers whether C is left / clockwise to direct segment AB. Response: 0: C is collinear < 0: C is left / clockwise > 0: C is right / counterclockwise

func Pt3EquaTol 

func Pt3EquaTol(a, b Pt3dF, tol float64) bool

func Pt3Equal 

func Pt3Equal(a, b Pt3dF) bool

func Pt3dNearZero 

func Pt3dNearZero(v Pt3dF, tolerance float64) bool

func RadiansToDegrees 

func RadiansToDegrees(radians float64) float64

func Ratio 

func Ratio(a, b float64) float64

Ratio answers a 0-1 value based on a's contributing factor to the final value.

func RectsEqual 

func RectsEqual[T Number](a, b Rectangle[T]) bool

func Sign 

func Sign[T SignedNumber](n T) T

func Sqr 

func Sqr[T Number](x T) T

func XAtY 

func XAtY(s SegF, y float64) (float64, bool)

XAtY answers the X value for this segment at the given Y value, or false if the line does not intersect y.

func XYToIndex 

func XYToIndex[T constraints.Integer](width, height T, pt Point[T]) (T, error)

XYToIndex converts an X, Y to a flat index.

func XYToIndexFast 

func XYToIndexFast[T constraints.Integer](x, y, width T) T

XYToIndexFast converts an X, Y to a flat index without any bounds checking.

Types

type Angle 

type Angle uint8
const (
	Oblique Angle = iota
	Horizontal
	Vertical
)

type BezF 

type BezF = QuadraticBezier

type CircleHitTest 

type CircleHitTest struct {
	// contains filtered or unexported fields
}

func (*CircleHitTest) Hit 

func (t *CircleHitTest) Hit(pt PtF) bool

func (*CircleHitTest) Set 

func (t *CircleHitTest) Set(center PtF, radius float64)

func (*CircleHitTest) String 

func (t *CircleHitTest) String() string

type CubicBezier 

type CubicBezier struct {
	P0, P1, P2, P3 PtF
}

CubicBezier represents a cubic Bezier curve.

func CubicBez 

func CubicBez(x0, y0, x1, y1, x2, y2, x3, y3 float64) CubicBezier

CubicBez is shorthand for creating a cubic bezier curve.

func (*CubicBezier) At 

func (bc *CubicBezier) At(t float64) PtF

At evaluates the Bezier curve at a given parameter t.

func (*CubicBezier) PointBounds 

func (bc *CubicBezier) PointBounds() RectF

PointBounds is the bounding box for my control points. It does not include any point that lies outside the controls.

type Float 

type Float interface {
	constraints.Float
}

type HitTest 

type HitTest func(PtF) bool

HitTest answers true if the point is a hit.

type InterpolatorReader 

type InterpolatorReader struct {
	Source PointInterpolator
	Step   float64
	// contains filtered or unexported fields
}

InterpolatorReader converts a PointInterpolator into a reader, supplying all interpolated points from 0 - 1 based on step.

func (*InterpolatorReader) ReadPoint 

func (r *InterpolatorReader) ReadPoint() (PtF, error)

func (*InterpolatorReader) Reset 

func (r *InterpolatorReader) Reset()

func (*InterpolatorReader) SetSource 

func (r *InterpolatorReader) SetSource(src PointInterpolator)

SetSource will also reset the state.

type InterpolatorReader3d 

type InterpolatorReader3d struct {
	Source PointInterpolator3d
	Step   float64
	// contains filtered or unexported fields
}

InterpolatorReader3d converts a PointInterpolator3d into a reader, supplying all interpolated points from 0 - 1 based on step.

func (*InterpolatorReader3d) ReadPoint 

func (r *InterpolatorReader3d) ReadPoint() (Pt3dF, error)

func (*InterpolatorReader3d) Reset 

func (r *InterpolatorReader3d) Reset()

func (*InterpolatorReader3d) SetSource 

func (r *InterpolatorReader3d) SetSource(src PointInterpolator3d)

SetSource will also reset the state.

type Line 

type Line[T Float] struct {
	V Point[T]
	C T
}

https://github.com/vlecomte/cp-geo/blob/master/basics/line.tex

func LineFromDir 

func LineFromDir[T Float](v Point[T], c T) Line[T]

From direction vector v and offset c

func LineFromPts 

func LineFromPts[T Float](p, q Point[T]) Line[T]

From points P and Q

func LineFromXys 

func LineFromXys[T Float](px, py, qx, qy T) Line[T]

From points P and Q as XYs.

type LnF 

type LnF = Line[float64]

type Mode 

type Mode = uint8
const (
	Lines Mode = iota
	Rays
	RayLine
	RaySegment
	Segments
)

type Number 

type Number interface {
	constraints.Integer | constraints.Float
}

type Orientation 

type Orientation uint8
const (
	Collinear Orientation = iota
	Clockwise
	CounterClockwise
)

func RadialDist 

func RadialDist(a, b float64) (float64, Orientation)

RadialDist answers the distance between two unit values, accounting for wrapping. Andswer 0 - 1, with 1 being the two values are closest. Examples: a=.1, b=.9, distance is .2, i.e. it wraps around 1.

type Point 

type Point[T Number] struct {
	X T
	Y T
}

func Centroid 

func Centroid[T Number](pts []Point[T]) Point[T]

func ConvertPoint 

func ConvertPoint[A Number, B Number](a Point[A]) Point[B]

func FindIntersection 

func FindIntersection[T Number](s1, s2 Segment[T]) (Point[T], bool)

FindIntersection finds the intersection between two line segments. Note: I am finding cases where this doesn't work, where an intersection is found on some segments but if you scale one of the points further out, no intersection. From https://github.com/vlecomte/cp-geo/blob/master/basics/segment.tex Further note: This doesn't seem to find intersections exactly on end points. Further review of that page shows yes this is correct, there's a different algorithm to account for endpoints.

func IndexToXY 

func IndexToXY[T constraints.Integer](width, height, index T) (Point[T], error)

IndexToXY converts a flat index into an array into an XY position.

func LerpPoint 

func LerpPoint[T Number](a, b Point[T], amount float64) Point[T]

func LerpPointXY 

func LerpPointXY[T Number](a, b Point[T], xAmount, yAmount float64) Point[T]

func PerpendicularIntersection 

func PerpendicularIntersection[T Float](seg Segment[T], pt Point[T]) (Point[T], bool)

PerpendicularIntersection finds the intersection of point to the line segment by drawing a perpendicular line from point to segment. Note: this is from Gemini. Seems to work but not heavily tested.

func Pt 

func Pt[T Number](x, y T) Point[T]

Pt is shorthand for creating a point from two values.

func Pts 

func Pts[T Number](xys ...T) []Point[T]

Pts creates a slice of Points from x y values.

func (Point[T]) Add 

func (a Point[T]) Add(b Point[T]) Point[T]

func (Point[T]) AddValue 

func (a Point[T]) AddValue(v T) Point[T]

func (Point[T]) Area 

func (p Point[T]) Area() T

func (Point[T]) Cross 

func (a Point[T]) Cross(b Point[T]) T

func (Point[T]) Degrees 

func (a Point[T]) Degrees(b Point[T]) float64

Degrees finds the angle of the segment with this point as the origin. Degrees will be 0-360, with 0/360 on the right, proceeding clockwise.

func (Point[T]) Dist 

func (a Point[T]) Dist(b Point[T]) float64

func (Point[T]) DistSquared 

func (a Point[T]) DistSquared(b Point[T]) T

Dist2 is the distance without the square root.

func (Point[T]) Dot 

func (a Point[T]) Dot(b Point[T]) float64

func (Point[T]) Inside 

func (a Point[T]) Inside(r Rectangle[T]) bool

func (Point[T]) Length 

func (a Point[T]) Length() float64

Length is the magnitude of the point. I *think* this is just more standard nomenclature than Magnitude.

func (Point[T]) Magnitude 

func (a Point[T]) Magnitude() float64

Magnitude is idental to Length, but I think that's a more common term.

func (Point[T]) MulScalar 

func (a Point[T]) MulScalar(scalar T) Point[T]

func (Point[T]) Mult 

func (a Point[T]) Mult(b Point[T]) Point[T]

func (Point[T]) Normalize 

func (a Point[T]) Normalize() Point[T]

Normalize normalizs the point to a unit. Can be negative if they are generated from a negative point, i.e. a negative direction vector.

func (Point[T]) Perpendicular 

func (v Point[T]) Perpendicular() Point[T]

Perpendicular returns a vector perpendicular to v (rotated 90 degrees clockwise).

func (Point[T]) Project 

func (a Point[T]) Project(m, dist float64) (Point[T], Point[T])

Given slope m and distance, project the positive and negative points on the line. Uses upper-left coordinate system.

func (Point[T]) ProjectDegree 

func (a Point[T]) ProjectDegree(deg, dist float64) Point[T]

ProjectDegree takes a degree and distance and projects a new point.

func (Point[T]) ProjectRadians 

func (a Point[T]) ProjectRadians(radians, dist float64) Point[T]

ProjectRadians takes a radian and distance and projects a new point.

func (Point[T]) Radians 

func (a Point[T]) Radians() float64

func (Point[T]) Rotate 

func (a Point[T]) Rotate(origin Point[T], angleInRads float64) Point[T]

Rotate the point. Rotation will be: In Quandrant 4 this rotates CW for positive angles and CCW for negative. TODO: API might be confusing, after not using it I've started thinking of the a point as the center and the point being passed in as the point to rotate. so might switch those.

func (Point[T]) Sub 

func (a Point[T]) Sub(b Point[T]) Point[T]

func (Point[T]) SubValue 

func (a Point[T]) SubValue(v T) Point[T]

func (Point[T]) To3d 

func (p Point[T]) To3d(z T) Point3d[T]

func (Point[T]) ToIndex 

func (p Point[T]) ToIndex(xy Point[T]) T

ToIndex converts the xy point into an index into a flat array as represented by this point.

type Point3d 

type Point3d[T Number] struct {
	X T
	Y T
	Z T
}

func ConvertPoint3 

func ConvertPoint3[A Number, B Number](a Point3d[A]) Point3d[B]

func LerpPoint3d 

func LerpPoint3d[T Number](a, b Point3d[T], amount float64) Point3d[T]

func LerpPoint3dXYZ 

func LerpPoint3dXYZ[T Number](a, b Point3d[T], xAmount, yAmount, zAmount float64) Point3d[T]

func Pt3 

func Pt3[T Number](x, y, z T) Point3d[T]

Pt3 is shorthand for creating a point3d from three values.

func Pt3d 

func Pt3d[T Number](x, y, z T) Point3d[T]

Pt3d is shorthand for creating a point3d from three values.

func (Point3d[T]) Add 

func (a Point3d[T]) Add(b Point3d[T]) Point3d[T]

func (Point3d[T]) ClampFast 

func (a Point3d[T]) ClampFast(rng Range[T]) Point3d[T]

func (Point3d[T]) Cross 

func (a Point3d[T]) Cross(b Point3d[T]) Point3d[T]

Cross calculates the cross product of two vectors and returns a new vector

func (Point3d[T]) Distance 

func (a Point3d[T]) Distance(b Point3d[T]) float64

func (Point3d[T]) Distance2 

func (a Point3d[T]) Distance2(b Point3d[T]) float64

Distance2 is the Distance function but only using 2 components.

func (Point3d[T]) DistanceSquared 

func (a Point3d[T]) DistanceSquared(b Point3d[T]) T

func (Point3d[T]) DistanceSquared2 

func (a Point3d[T]) DistanceSquared2(b Point3d[T]) T

DistanceSquared2 is the DistanceSquared2 function but only using 2 components.

func (Point3d[T]) Div 

func (a Point3d[T]) Div(b Point3d[T]) Point3d[T]

func (Point3d[T]) DivT 

func (a Point3d[T]) DivT(t T) Point3d[T]

func (Point3d[T]) Dot 

func (a Point3d[T]) Dot(b Point3d[T]) T

TODO: Replace with DotProduct

func (Point3d[T]) DotProduct 

func (a Point3d[T]) DotProduct(b Point3d[T]) T

func (Point3d[T]) LengthSq 

func (a Point3d[T]) LengthSq() float64

func (Point3d[T]) Magnitude 

func (a Point3d[T]) Magnitude() float64

func (Point3d[T]) Mult 

func (a Point3d[T]) Mult(b Point3d[T]) Point3d[T]

func (Point3d[T]) MultScalar 

func (a Point3d[T]) MultScalar(t T) Point3d[T]

func (Point3d[T]) MultT 

func (a Point3d[T]) MultT(t T) Point3d[T]

func (Point3d[T]) Normalize 

func (a Point3d[T]) Normalize() Point3d[T]

func (Point3d[T]) RotateX 

func (v Point3d[T]) RotateX(angle float64) Point3d[T]

RotateX rotates a Vector3 around the X-axis by a given angle (in radians).

func (Point3d[T]) RotateY 

func (v Point3d[T]) RotateY(angle float64) Point3d[T]

RotateY rotates a Vector3 around the Y-axis by a given angle (in radians).

func (Point3d[T]) RotateZ 

func (v Point3d[T]) RotateZ(angle float64) Point3d[T]

RotateZ rotates a Vector3 around the Z-axis by a given angle (in radians).

func (Point3d[T]) Scale 

func (a Point3d[T]) Scale(t T) Point3d[T]

func (Point3d[T]) Sub 

func (a Point3d[T]) Sub(b Point3d[T]) Point3d[T]

func (Point3d[T]) SubT 

func (a Point3d[T]) SubT(t T) Point3d[T]

func (Point3d[T]) XY 

func (a Point3d[T]) XY() Point[T]

type PointInterpolator 

type PointInterpolator interface {
	PointAt(float64) PtF
}

type PointInterpolator3d 

type PointInterpolator3d interface {
	PointAt(float64) Pt3dF
}

type PointReader 

type PointReader interface {
	ReadPoint() (PtF, error)
}

type PointReader3d 

type PointReader3d interface {
	ReadPoint() (Pt3dF, error)
}

type Poly 

type Poly[T Number] struct {
	Pts []Point[T]
}

type PolyF 

type PolyF = Poly[float64]

type PolyF64 

type PolyF64 = Poly[float64]

type PolyI 

type PolyI = Poly[int]

type PolyI64 

type PolyI64 = Poly[int64]

type PolyUI64 

type PolyUI64 = Poly[uint64]

type PolygonBB 

type PolygonBB[T Number] struct {
	Pts []Point[T]
	BB  Rectangle[T]
}

PolygonBB is a closed polygon that includes the computed bounding box.

func PolyBB 

func PolyBB[T Float](pts []Point[T]) PolygonBB[T]

type PolygonBBF64 

type PolygonBBF64 = PolygonBB[float64]

type ProcessPtF64Func 

type ProcessPtF64Func func(pt PtF) PtF

type Pt3dF 

type Pt3dF = Point3d[float64]

func LinePlaneIntersection 

func LinePlaneIntersection(lineA, lineB Pt3dF, planeNormal, planeOrigin Pt3dF) (Pt3dF, bool)

func NearestPointOnSegment3 

func NearestPointOnSegment3(segment Seg3dF, p Pt3dF) Pt3dF

NearestPointOnSegment3 finds the nearest point on a line segment to a given point.

func PointOnSegmentSquaredXY 

func PointOnSegmentSquaredXY(seg Seg3dF, p PtF) (Pt3dF, float64)

PointOnSegmentSquaredXY finds the nearest point from p to seg, but only considers the XY components, then interpolates the Z from the segment endpoints.

func PointOnSegmentXY 

func PointOnSegmentXY(seg Seg3dF, p PtF) (Pt3dF, float64)

func TrianglePlaneIntersection 

func TrianglePlaneIntersection(tri Tri3dF, triPt Pt3dF, planeTri Tri3dF, planePt Pt3dF) (Pt3dF, bool)

func TrianglePlaneIntersection2 

func TrianglePlaneIntersection2(tri Tri3dF, triPt Pt3dF, planeTri Tri3dF, planePt Pt3dF) (Pt3dF, bool)

func TrianglePlaneIntersection5 

func TrianglePlaneIntersection5(tri Tri3dF, triPt Pt3dF, planeTri Tri3dF, planePt Pt3dF) (Pt3dF, bool)

Proiject a ray perpendicular to triPt on tri to find its intersection with the plane (as defined by planeTri and planePt)

type Pt3dF32 

type Pt3dF32 = Point3d[float32]

type Pt3dF64 

type Pt3dF64 = Point3d[float64]

type Pt3dI 

type Pt3dI = Point3d[int]

type Pt3dI64 

type Pt3dI64 = Point3d[int64]

type PtF 

type PtF = Point[float64]

func CubicBezierDistance 

func CubicBezierDistance(cb CubicBezier, pt PtF) (float64, PtF)

CubicBezierDistance approximates the distance from a point to a Bezier curve

func CubicBezierDistanceSquared 

func CubicBezierDistanceSquared(cb CubicBezier, pt PtF) (float64, PtF)

CubicBezierDistanceSquared approximates the distance from a point to a Bezier curve

func DegreesToDirectionCw 

func DegreesToDirectionCw(degrees float64) PtF

DegreesToDirectionCcw converts degrees to a direction vector, where 0 = right and it continues clockwise, so 90 is down.

func DistPointToSegment 

func DistPointToSegment(seg SegF, p PtF) (float64, PtF)

DistPointToSegment answers the distance from the point to the segment, as well as the point found on the segment. From https://stackoverflow.com/questions/849211/shortest-distance-between-a-point-and-a-line-segment

func DistSquared 

func DistSquared(seg SegF, p PtF) (float64, PtF)

DistSquared answers the squared distance from the point to the segment, as well as the point found on the segment. From https://stackoverflow.com/questions/849211/shortest-distance-between-a-point-and-a-line-segment

func DistToPolyF 

func DistToPolyF(poly []PtF, pt PtF) (float64, PtF)

func LineLineIntersectionF 

func LineLineIntersectionF(l1, l2 LnF) (PtF, bool)

LineLineIntersectionF provides the intersection of two lines. https://github.com/vlecomte/cp-geo/blob/master/basics/line.tex

func LineToSegIntersection 

func LineToSegIntersection(A, B PtF, pq SegF) (PtF, bool)

https://stackoverflow.com/questions/34415671/intersection-of-a-line-with-a-line-segment-in-c line segment p-q intersect with line A-B. This looks a lot more efficient than the current seg-seg test I'm doing, but also I actually want a seg-seg test because this gives false positives. So... maybe I'll switch to it if I think of a way for it to make sense, but probably not because this is just a different operation.

func PtToSegIntersection 

func PtToSegIntersection(pt, direction PtF, seg SegF) (PtF, bool)

func PtToSegIntersection_Off 

func PtToSegIntersection_Off(pt, direction PtF, seg SegF) (PtF, bool)

func PtToSegIntersection_Off2 

func PtToSegIntersection_Off2(pt, direction PtF, seg SegF) (PtF, bool)

func QuadraticBezierDistanceBrute 

func QuadraticBezierDistanceBrute(cb QuadraticBezier, pt PtF) (float64, PtF)

QuadraticBezierDistanceBrute approximates the distance from a point to a Bezier curve

func QuadraticBezierDistanceSquared 

func QuadraticBezierDistanceSquared(cb QuadraticBezier, pt PtF) (float64, PtF)

QuadraticBezierDistanceSquared approximates the distance from a point to a Bezier curve

func QuadraticBezierDistanceSquaredBrute 

func QuadraticBezierDistanceSquaredBrute(cb QuadraticBezier, pt PtF) (float64, PtF)

QuadraticBezierDistanceSquaredBrute approximates the distance from a point to a Bezier curve

type PtF32 

type PtF32 = Point[float32]

type PtF64 

type PtF64 = Point[float64]

type PtI 

type PtI = Point[int]

type PtI64 

type PtI64 = Point[int64]

type QuadraticBezier 

type QuadraticBezier struct {
	P0, P1, P2 PtF
}

QuadraticBezier represents a quadratic Bezier curve.

func Bez 

func Bez(x0, y0, x1, y1, x2, y2 float64) QuadraticBezier

Bez is shorthand for creating a quadratic bezier curve.

func QuadraticBez 

func QuadraticBez(x0, y0, x1, y1, x2, y2 float64) QuadraticBezier

QuadraticBez is shorthand for creating a quadratic bezier curve.

func (*QuadraticBezier) At 

func (q *QuadraticBezier) At(t float64) PtF

At evaluates the Bezier curve at a given parameter t. deprecated, move to PointAt

func (QuadraticBezier) FirstDerivative 

func (q QuadraticBezier) FirstDerivative(t float64) PtF

FirstDerivative calculates the first derivative at t

func (*QuadraticBezier) PointAt 

func (q *QuadraticBezier) PointAt(t float64) PtF

PointAt evaluates the Bezier curve at a given parameter t. It satisfies the PointInterpolator interface.

func (*QuadraticBezier) PointBounds 

func (b *QuadraticBezier) PointBounds() RectF

PointBounds is the bounding box for my control points. It does not include any point that lies outside the controls.

func (*QuadraticBezier) PointOnCurve 

func (q *QuadraticBezier) PointOnCurve(t float64) PtF

deprecated, move to PointAt

func (QuadraticBezier) SecondDerivative 

func (q QuadraticBezier) SecondDerivative() PtF

SecondDerivative calculates the second derivative (constant for quadratic)

func (QuadraticBezier) String 

func (b QuadraticBezier) String() string

type QuadraticBezier3d 

type QuadraticBezier3d struct {
	P0, P1, P2 Pt3dF
}

QuadraticBezier3D is a 3D quadratic Bézier curve. defined by three control points.

func (QuadraticBezier3d) PointAt 

func (q QuadraticBezier3d) PointAt(t float64) Pt3dF

PointAt evaluates the Bezier curve at a given parameter t (0 <= t <= 1). It satisfies the PointInterpolator interface.

type Range 

type Range[T Number] struct {
	Min T
	Max T
}

func Rng 

func Rng[T Number](min, max T) Range[T]

func (Range[T]) Clamp 

func (p Range[T]) Clamp(value T) T

Clamp returns the value clipped to my range.

func (Range[T]) ClampFast 

func (r Range[T]) ClampFast(value T) T

ClampFast returns the value clipped to my range. It assumes Min is less than Max.

func (Range[T]) Clip 

func (p Range[T]) Clip(value T) T

Clip returns the value clipped to my range. TODO: Clamp() seems more common so switch to that.

func (Range[T]) Contains 

func (p Range[T]) Contains(value T) bool

Contains returns true if the value is contained in the range.

func (Range[T]) Intersection 

func (a Range[T]) Intersection(b Range[T]) Range[T]

Intersection returns the intersection of A and B ranges.

func (Range[T]) MapNormal 

func (p Range[T]) MapNormal(normal float64) T

MapNormal takes a normalized (0-1) value and maps it to my range.

func (Range[T]) Midpoint 

func (p Range[T]) Midpoint() T

Midpoint returns the center of the range.

func (Range[T]) Normalize 

func (p Range[T]) Normalize(value T) float64

Normalize returns the value clipped to my range and normalized to 0-1.

func (Range[T]) Overlaps 

func (a Range[T]) Overlaps(b Range[T]) bool

Overlaps returns true if the ranges overlap.

type RectF 

type RectF = Rectangle[float64]

type RectF32 

type RectF32 = Rectangle[float32]

type RectF64 

type RectF64 = Rectangle[float64]

type RectI 

type RectI = Rectangle[int]

type RectI64 

type RectI64 = Rectangle[int64]

type Rectangle 

type Rectangle[T Number] struct {
	L, T, R, B T
}

func ConvertRect 

func ConvertRect[A Number, B Number](a Rectangle[A]) Rectangle[B]

func PolygonBounds 

func PolygonBounds[T Float](ptss ...[]Point[T]) Rectangle[T]

func PtBounds 

func PtBounds[T Number](pts []Point[T]) Rectangle[T]

func Rect 

func Rect[T Number](left, top, right, bottom T) Rectangle[T]

func (Rectangle[T]) Add 

func (r1 Rectangle[T]) Add(l, t, r, b T) Rectangle[T]

func (Rectangle[T]) Area 

func (r Rectangle[T]) Area() T

func (Rectangle[T]) Center 

func (r Rectangle[T]) Center() Point[T]

func (Rectangle[T]) Clip 

func (r1 Rectangle[T]) Clip(r2 Rectangle[T]) Rectangle[T]

Clip returns r1 clipped by r2.

func (Rectangle[T]) Contains 

func (r1 Rectangle[T]) Contains(r2 Rectangle[T]) bool

func (Rectangle[T]) ContainsPoint 

func (r Rectangle[T]) ContainsPoint(pt Point[T]) bool

ContainsPoint returns true if the point is inside the half-closed rectangle.

func (Rectangle[T]) Height 

func (r Rectangle[T]) Height() T

func (Rectangle[T]) Inverted 

func (r Rectangle[T]) Inverted() bool

Inverted returns true if either the right is less than the left or the bottom is less than the top. It can be used as an "invalid" value in cases where a 0 rect is insufficient.

func (Rectangle[T]) IsZero 

func (r Rectangle[T]) IsZero() bool

func (Rectangle[T]) LT 

func (r Rectangle[T]) LT() Point[T]

func (Rectangle[T]) MergePoint 

func (r1 Rectangle[T]) MergePoint(x, y T) Rectangle[T]

MergePoint will expand the bounds to include the point.

func (Rectangle[T]) Overlaps 

func (r1 Rectangle[T]) Overlaps(r2 Rectangle[T]) bool

func (Rectangle[T]) RB 

func (r Rectangle[T]) RB() Point[T]

func (Rectangle[T]) Rounded 

func (r Rectangle[T]) Rounded() Rectangle[T]

Rounded answers the rect with all values rounded to the nearest whole number.

func (Rectangle[T]) Size 

func (r Rectangle[T]) Size() Point[T]

func (Rectangle[T]) String 

func (r Rectangle[T]) String() string

func (Rectangle[T]) Translate 

func (r Rectangle[T]) Translate(pt Point[T]) Rectangle[T]

func (Rectangle[T]) Union 

func (r1 Rectangle[T]) Union(r2 Rectangle[T]) Rectangle[T]

func (Rectangle[T]) Width 

func (r Rectangle[T]) Width() T

func (Rectangle[T]) WithExpand 

func (r Rectangle[T]) WithExpand(v T) Rectangle[T]

Expand adds the value to all edges.

func (Rectangle[T]) WithSize 

func (r Rectangle[T]) WithSize(pt Point[T]) Rectangle[T]

type RngF 

type RngF = Range[float64]

type RngF32 

type RngF32 = Range[float32]

type RngF64 

type RngF64 = Range[float64]

type RngI 

type RngI = Range[int]

type RngI64 

type RngI64 = Range[int64]

type Seg3dF 

type Seg3dF = Seg3dF64

type Seg3dF64 

type Seg3dF64 = Segment3d[float64]

type SegF 

type SegF = Segment[float64]

type SegF32 

type SegF32 = Segment[float32]

type SegF64 

type SegF64 = Segment[float64]

type SegFmtF 

type SegFmtF struct {
	Seg SegF
}

func (SegFmtF) String 

func (f SegFmtF) String() string

type SegI 

type SegI = Segment[int]

type SegI64 

type SegI64 = Segment[int64]

type Segment 

type Segment[T Number] struct {
	A Point[T]
	B Point[T]
}

Segment represents a line segment with start and end points

func ConvertSegment 

func ConvertSegment[A Number, B Number](seg Segment[A]) Segment[B]

func Seg 

func Seg[T Number](ax, ay, bx, by T) Segment[T]

Seg is shorthand for creating a segment from two points.

func (Segment[T]) AddPt 

func (s Segment[T]) AddPt(pt Point[T]) Segment[T]

AddPt adds the point and returns the new segment.

func (Segment[T]) AsArray 

func (s Segment[T]) AsArray() []Point[T]

AsArray returns my points in a slice.

func (Segment[T]) Degrees 

func (s Segment[T]) Degrees() float64

Degrees finds the angle of the segment with A as the origin. Degrees will be 0-360, with 0/360 on the right, proceeding clockwise.

func (Segment[T]) Dir 

func (s Segment[T]) Dir() Point[T]

Dir answers the direction vector of this segment.

func (Segment[T]) Interp 

func (s Segment[T]) Interp(unit T) Point[T]

Interp answers a new point at the unit position on this segment, where 0. = A and 1. = B. Note this really only works on floats, need a way to narrow that constraint.

func (Segment[T]) Len 

func (s Segment[T]) Len() T

Len answers the length of this segment.

func (Segment[T]) LenSquared 

func (s Segment[T]) LenSquared() T

LenSquared answers the squared length of this segment.

func (Segment[T]) Midpoint 

func (s Segment[T]) Midpoint() Point[T]

func (Segment[T]) PerpendicularSlope 

func (s Segment[T]) PerpendicularSlope() Slope

PerpendicularSlope answers the perpendicular of Slope.

func (Segment[T]) Slope 

func (s Segment[T]) Slope() Slope

Slope answers the slope of this line segment. Uses upper left coordinates.

type Segment3d 

type Segment3d[T Number] struct {
	A Point3d[T]
	B Point3d[T]
}

Segment represents a line segment with start and end points

func Seg3d 

func Seg3d[T Number](ax, ay, az, bx, by, bz T) Segment3d[T]

Seg is shorthand for creating a segment from two points.

func (Segment3d[T]) XY 

func (a Segment3d[T]) XY() Segment[T]

type SignedNumber 

type SignedNumber interface {
	constraints.Signed | constraints.Float
}

type Size 

type Size = Point[int]

type SliceReader 

type SliceReader struct {
	Pts []PtF
	// contains filtered or unexported fields
}

SliceReader wraps a point slice into a PointReader.

func (*SliceReader) ReadPoint 

func (r *SliceReader) ReadPoint() (PtF, error)

type SliceReader3d 

type SliceReader3d struct {
	Pts []PtF
	// contains filtered or unexported fields
}

SliceReader3d wraps a point slice into a PointReader.

func (*SliceReader3d) ReadPoint 

func (r *SliceReader3d) ReadPoint() (PtF, error)

type SliceSegFmtF 

type SliceSegFmtF struct {
	Segs []SegF
}

func (SliceSegFmtF) String 

func (f SliceSegFmtF) String() string

type Slope 

type Slope struct {
	Angle Angle
	M     float64
}

type Tri3dF 

type Tri3dF = Triangle3d[float64]

type Triangle3d 

type Triangle3d[T Number] struct {
	A Point3d[T]
	B Point3d[T]
	C Point3d[T]
}

func Tri3d 

func Tri3d[T Number](a, b, c Point3d[T]) Triangle3d[T]

Tri3d is shorthand for creating a triangle.

func Tri3dFlat 

func Tri3dFlat[T Number](ax, ay, az, bx, by, bz, cx, cy, cz T) Triangle3d[T]

func (Triangle3d[T]) Center 

func (t Triangle3d[T]) Center() Point3d[T]

func (Triangle3d[T]) SurfaceNormal 

func (t Triangle3d[T]) SurfaceNormal() Point3d[T]

https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal You will generally want to normalize the returned vector.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.