geom

package

Go to main page

Versions in this module

v0

v0.7.4

Nov 10, 2025

Changes in this version

type Circle

+ func (c *Circle) MidPoint(c1 *Circle) *Point

type PointList

+ func RandomCyclicPolygon(x, y, radius float64, sides int) PointList

+ func (p PointList) ClosestPointOnPath(x, y float64, closed bool) *Point

+ func (p PointList) ConcavePoints() PointList

+ func (p PointList) ConvexPoints() PointList

+ func (p PointList) IsConvex() bool

+ func (p PointList) IsEar(i int) bool

+ func (p PointList) IsPointConvex(index int) bool

+ func (p PointList) PathIsClockwise() bool

+ func (p PointList) Triangulate() TriangleList

type SegmentList

+ func (s SegmentList) ClosestPoint(x, y float64) *Point

+ func (s SegmentList) DistToClosestSegment(x, y float64) float64

type Triangle

+ func (t *Triangle) Lines() []*Line

+ func (t *Triangle) Perpendiculars() []*Line

+ func (t *Triangle) SoddyCircles() (*Circle, *Circle)

+ func (t *Triangle) TangentCircles() (*Circle, *Circle, *Circle)

v0.7.2

Oct 26, 2025

Changes in this version

+ type Hexagon struct

+ func NewHexagon(x, y, size float64) Hexagon

+ type HexagonList []Hexagon

+ func HexList(x, y, w, h, res float64) HexagonList

+ func NewHexagonList() HexagonList

+ func (h *HexagonList) Noisify(sx, sy, z, w, offset float64)

type PointList

+ func HaltonPointList(count int, x, y, w, h float64) PointList

+ func HaltonPointListSeeded(count, seed int, x, y, w, h float64) PointList

+ func HexPoints(x, y, w, h, res float64) PointList

+ func PointCircle(x, y, r float64, count int) PointList

+ func PointListBetweenPoints(p0, p1 *Point, count int) PointList

+ func PointListBetweenPointsXY(x0, y0, x1, y1 float64, count int) PointList

+ func RandomPointsInCircle(count int, x, y, r float64, dist bool) PointList

+ func (p *PointList) NoisifyY(sx, sy, z, w, offset float64)

+ func (p *PointList) Remove(point *Point)

+ func (p *PointList) RemoveAll(list PointList)

+ func (p PointList) Average() *Point

+ func (p PointList) ClosestPoint(x, y float64) *Point

+ func (p PointList) DistToClosestPoint(x, y float64) float64

+ func (p PointList) Equals(q PointList) bool

+ func (p PointList) Kmeans(k int) []PointList

+ func (p PointList) MaxDist() float64

+ func (p PointList) MinDist() float64

+ func (p PointList) SortAngleFrom(x, y float64) PointList

+ type PointMap struct

+ func NewPointMap(width, height, res float64) *PointMap

+ func (m *PointMap) AddPoint(point *Point) error

+ func (m *PointMap) AddPointList(list PointList)

+ func (m *PointMap) AddPointXY(x, y float64) error

+ func (m *PointMap) ClosestPoint(p *Point) (*Point, error)

+ func (m *PointMap) ClosestPointXY(x, y float64) (*Point, error)

+ func (m *PointMap) DistToClosestPoint(p *Point) (float64, error)

+ func (m *PointMap) DistToClosestPointXY(x, y float64) (float64, error)

+ func (m *PointMap) GetNeighbors(point *Point) (PointList, error)

+ func (m *PointMap) GetNeighborsXY(x, y float64) (PointList, error)

type Triangle

+ func (t *Triangle) Clone() *Triangle

type TriangleList

+ func (t *TriangleList) Noisified(sx, sy, z, w, offset float64) TriangleList

+ func (t *TriangleList) Noisify(sx, sy, z, w, offset float64)

+ func (t TriangleList) Centroids() PointList

+ func (t TriangleList) Clone() TriangleList

v0.7.0

Aug 8, 2025

Changes in this version

+ func AngleFromTriangleSideLengths(a, b, c float64) float64

+ func BezLength(p0, p1, p2, p3 *Point, count float64) float64

+ func CircleOnCircle(x0, y0, r0, x1, y1, r1 float64) bool

+ func CircleToLine(x0, y0, x1, y1, cx, cy, r float64) (*Point, *Point, bool)

+ func Clockwise(p1, p2, p3 *Point) bool

+ func LineOnLine(x0, y0, x1, y1, x2, y2, x3, y3 float64) (float64, float64, bool)

+ func PointDistanceToLine(px, py, x0, y0, x1, y1 float64) float64

+ func PointDistanceToSegment(px, py, x0, y0, x1, y1 float64) float64

+ func PointInCircle(x, y, cx, cy, cr float64) bool

+ func PointInPolygon(x, y float64, points []float64) bool

+ func PointInRect(x, y, rx, ry, rw, rh float64) bool

+ func PolyInnerRadius(radius float64, sides int) float64

+ func RectOnRect(x0, y0, w0, h0, x1, y1, w1, h1 float64) bool

+ func SegmentOnLine(x0, y0, x1, y1, x2, y2, x3, y3 float64) (float64, float64, bool)

+ func SegmentOnRect(x0, y0, x1, y1, rx, ry, rw, rh float64) bool

+ func SegmentOnSegment(x0, y0, x1, y1, x2, y2, x3, y3 float64) (float64, float64, bool)

+ type BezierCurve struct

+ P0 *Point

+ P1 *Point

+ P2 *Point

+ P3 *Point

+ func NewBezierCurve(p0, p1, p2, p3 *Point) *BezierCurve

+ func (b *BezierCurve) GetPath() PointList

+ func (b *BezierCurve) GetSegmentCount() int

+ func (b *BezierCurve) LerpPoint(t float64) *Point

+ func (b *BezierCurve) LinearPoints(count int) PointList

+ func (b *BezierCurve) Point(t float64) *Point

+ func (b *BezierCurve) SetSegmentCount(count int)

+ func (b *BezierCurve) SlopeAtBezierT(t float64) float64

+ func (b *BezierCurve) SlopeAtLinearT(t float64) float64

+ type Circle struct

+ Radius float64

+ X float64

+ Y float64

+ func CircleThroughPointsWithArcHeight(x0, y0, x1, y1, height float64) (*Circle, error)

+ func CircleTouchingCircle(c0 *Circle, angle, radius float64) *Circle

+ func CircleTouchingTwoCircles(c0, c1 *Circle, radius float64, clockwise bool) *Circle

+ func NewCircle(x, y, r float64) *Circle

+ func NewCircleFromPoint(center *Point, r float64) *Circle

+ func NewCircleFromPoints(p0, p1, p2 *Point) *Circle

+ func (c *Circle) Contains(p *Point) bool

+ func (c *Circle) Hit(d *Circle) bool

+ func (c *Circle) InnerCircles(count int, rotation float64) CircleList

+ func (c *Circle) Intersection(c1 *Circle) (*Point, *Point, bool)

+ func (c *Circle) InvertPoint(p *Point) *Point

+ func (c *Circle) InvertXY(x, y float64) (float64, float64)

+ func (c *Circle) OuterCircles(count int, rotation float64) CircleList

+ func (c *Circle) RandomizePosition(amount float64)

+ func (c *Circle) RandomizeRadius(amount float64)

+ func (c *Circle) RandomizedPosition(amount float64) *Circle

+ func (c *Circle) RandomizedRadius(amount float64) *Circle

+ func (c *Circle) Rotate(angle float64)

+ func (c *Circle) RotateFrom(x, y float64, angle float64)

+ func (c *Circle) Rotated(angle float64) *Circle

+ func (c *Circle) RotatedFrom(x, y, angle float64) *Circle

+ func (c *Circle) Scale(scale float64)

+ func (c *Circle) ScaleFrom(x, y, scale float64)

+ func (c *Circle) ScaleLocal(scale float64)

+ func (c *Circle) Scaled(scale float64) *Circle

+ func (c *Circle) ScaledFrom(x, y, scale float64) *Circle

+ func (c *Circle) ScaledLocal(scale float64) *Circle

+ func (c *Circle) Translate(x float64, y float64)

+ func (c *Circle) Translated(tx, ty float64) *Circle

+ type CircleList []*Circle

+ func NewCircleList() CircleList

+ func (c *CircleList) Add(circle *Circle)

+ func (c *CircleList) AddXY(x, y, r float64)

+ func (c *CircleList) RandomizePosition(amount float64)

+ func (c *CircleList) RandomizeRadius(amount float64)

+ func (c *CircleList) Rotate(angle float64)

+ func (c *CircleList) RotateFrom(x, y float64, angle float64)

+ func (c *CircleList) Scale(scale float64)

+ func (c *CircleList) ScaleFrom(x, y, scale float64)

+ func (c *CircleList) ScaleLocal(scale float64)

+ func (c *CircleList) Translate(x, y float64)

+ type Line Segment

+ func NewLine(x0, y0, x1, y1 float64) *Line

+ func NewLineFromPoints(p0, p1 *Point) *Line

+ func NewLineFromSegment(seg *Segment) *Line

+ func (l *Line) Angle() float64

+ func (l *Line) ClosestPoint(p *Point) *Point

+ func (l *Line) DistanceTo(p *Point) float64

+ func (l *Line) HitLine(m *Line) (float64, float64, bool)

+ func (l *Line) HitSegment(s *Segment) (float64, float64, bool)

+ func (l *Line) Parallel(dist float64) *Line

+ func (l *Line) Perpendicular(p *Point) *Line

+ type Point struct

+ X float64

+ Y float64

+ func BezierPoint(t float64, p0 *Point, p1 *Point, p2 *Point, p3 *Point) *Point

+ func Bisect(pA, pB, pC *Point, length float64) *Point

+ func LerpPoint(t float64, p0, p1 *Point) *Point

+ func MidPoint(p0, p1 *Point) *Point

+ func NewPoint(x, y float64) *Point

+ func QuadraticPoint(t float64, p0 *Point, p1 *Point, p2 *Point) *Point

+ func RandomPointInCircle(x, y, r float64, dist bool) *Point

+ func RandomPointInRect(x, y, w, h float64) *Point

+ func RandomPointInTriangle(A, B, C *Point) *Point

+ func (p *Point) Angle() float64

+ func (p *Point) AngleBetween(p0, p1 *Point) float64

+ func (p *Point) AngleTo(o *Point) float64

+ func (p *Point) Clone() *Point

+ func (p *Point) Coords() (float64, float64)

+ func (p *Point) Distance(p1 *Point) float64

+ func (p *Point) Equals(other *Point) bool

+ func (p *Point) Magnitude() float64

+ func (p *Point) Normalize()

+ func (p *Point) Normalized() *Point

+ func (p *Point) Randomize(rx, ry float64)

+ func (p *Point) Randomized(rx, ry float64) *Point

+ func (p *Point) Rotate(angle float64)

+ func (p *Point) RotateFrom(x, y float64, angle float64)

+ func (p *Point) Rotated(angle float64) *Point

+ func (p *Point) RotatedFrom(x, y, angle float64) *Point

+ func (p *Point) Scale(scaleX float64, scaleY float64)

+ func (p *Point) ScaleFrom(x, y, scaleX float64, scaleY float64)

+ func (p *Point) Scaled(scaleX float64, scaleY float64) *Point

+ func (p *Point) ScaledFrom(x, y, scaleX, scaleY float64) *Point

+ func (p *Point) Translate(x float64, y float64)

+ func (p *Point) Translated(tx, ty float64) *Point

+ func (p *Point) UniScale(scale float64)

+ func (p *Point) UniScaleFrom(x, y, scale float64)

+ func (p *Point) UniScaled(scale float64) *Point

+ func (p *Point) UniScaledFrom(x, y, scale float64) *Point

+ type PointList []*Point

+ func ConvexHull(points PointList) PointList

+ func LineOnRect(lineX1, lineY1, lineX2, lineY2, rectX, rectY, rectW, rectH float64) PointList

+ func LinearBezierPoints(count int, p0, p1, p2, p3 *Point) PointList

+ func NewPointList() PointList

+ func PointGrid(x, y, w, h, xres, yres float64) PointList

+ func PoissonDiskSampling(x, y, width, height, radius float64, tries int) PointList

+ func RandomPointList(count int, x, y, w, h float64) PointList

+ func (p *PointList) Add(point *Point)

+ func (p *PointList) AddXY(x, y float64)

+ func (p *PointList) Cull(test func(*Point) bool)

+ func (p *PointList) Fisheye(radius float64)

+ func (p *PointList) FisheyeFromPoint(center *Point, radius float64)

+ func (p *PointList) FisheyeFromXY(x, y, radius float64)

+ func (p *PointList) Insert(index int, point *Point) error

+ func (p *PointList) Noisified(sx, sy, z, offset float64) PointList

+ func (p *PointList) Noisify(sx, sy, z, offset float64)

+ func (p *PointList) Normalize()

+ func (p *PointList) Normalized() PointList

+ func (p *PointList) Randomize(rx, ry float64)

+ func (p *PointList) Randomized(rx, ry float64) PointList

+ func (p *PointList) Rotate(angle float64)

+ func (p *PointList) RotateFrom(x, y float64, angle float64)

+ func (p *PointList) RotateLocal(angle float64)

+ func (p *PointList) Rotated(angle float64) PointList

+ func (p *PointList) RotatedFrom(x, y float64, angle float64) PointList

+ func (p *PointList) Scale(sx, sy float64)

+ func (p *PointList) ScaleFrom(x, y, sx, sy float64)

+ func (p *PointList) ScaleLocal(sx, sy float64)

+ func (p *PointList) Scaled(sx, sy float64) PointList

+ func (p *PointList) ScaledFrom(x, y, sx, sy float64) PointList

+ func (p *PointList) Split(test func(*Point) bool) PointList

+ func (p *PointList) Translate(x, y float64)

+ func (p *PointList) Translated(x, y float64) PointList

+ func (p *PointList) UniScale(scale float64)

+ func (p *PointList) UniScaleFrom(x, y, scale float64)

+ func (p *PointList) UniScaleLocal(scale float64)

+ func (p *PointList) UniScaled(scale float64) PointList

+ func (p *PointList) UniScaledFrom(x, y, scale float64) PointList

+ func (p *PointList) Vortex(radius float64)

+ func (p *PointList) VortexFromPoint(center *Point, radius float64)

+ func (p *PointList) VortexFromXY(x, y, radius float64)

+ func (p PointList) BoundingBox() *Rect

+ func (p PointList) Center() *Point

+ func (p PointList) Clone() PointList

+ func (p PointList) Culled(test func(*Point) bool) PointList

+ func (p PointList) First() *Point

+ func (p PointList) Get(index int) *Point

+ func (p PointList) Interpolate(t float64) *Point

+ func (p PointList) Last() *Point

+ func (p PointList) Length() float64

+ func (p PointList) SortDistFrom(x, y float64) PointList

+ func (p PointList) SortXY() PointList

+ func (p PointList) SortYX() PointList

+ func (p PointList) Unique() PointList

+ func (p PointList) Uniqued() PointList

+ type Rect struct

+ H float64

+ W float64

+ X float64

+ Y float64

+ func NewRect(x, y, w, h float64) *Rect

+ func NewRectFromPoints(p0, p1 *Point) *Rect

+ func (r *Rect) Contains(p *Point) bool

+ func (r *Rect) HitRect(s *Rect) bool

+ func (r *Rect) HitSegment(s *Segment) bool

+ func (r *Rect) Scaled(factor float64) *Rect

+ type Segment struct

+ PointA *Point

+ PointB *Point

+ func NewSegment(x0, y0, x1, y1 float64) *Segment

+ func NewSegmentFromPoints(p0, p1 *Point) *Segment

+ func TangentSegmentToCircles(c0, c1 *Circle, sign float64) *Segment

+ func (s *Segment) ClosestPoint(p *Point) *Point

+ func (s *Segment) DistanceTo(p *Point) float64

+ func (s *Segment) Equals(other *Segment) bool

+ func (s *Segment) HitLine(l *Line) (float64, float64, bool)

+ func (s *Segment) HitRect(r *Rect) bool

+ func (s *Segment) HitSegment(z *Segment) (float64, float64, bool)

+ func (s *Segment) Length() float64

+ func (s *Segment) Parallel(dist float64) *Line

+ func (s *Segment) Points() (*Point, *Point)

+ func (s *Segment) Randomize(amount float64)

+ func (s *Segment) Randomized(amount float64) *Segment

+ func (s *Segment) Rotate(angle float64)

+ func (s *Segment) RotateFrom(x, y, angle float64)

+ func (s *Segment) RotateLocal(angle float64)

+ func (s *Segment) Rotated(angle float64) *Segment

+ func (s *Segment) RotatedFrom(x, y, angle float64) *Segment

+ func (s *Segment) RotatedLocal(angle float64) *Segment

+ func (s *Segment) Scale(sx, sy float64)

+ func (s *Segment) ScaleFrom(x, y, sx, sy float64)

+ func (s *Segment) ScaleLocal(sx, sy float64)

+ func (s *Segment) Scaled(sx, sy float64) *Segment

+ func (s *Segment) ScaledFrom(x, y, sx, sy float64) *Segment

+ func (s *Segment) ScaledLocal(sx, sy float64) *Segment

+ func (s *Segment) Translate(x, y float64)

+ func (s *Segment) Translated(x, y float64) *Segment

+ func (s *Segment) UniScale(scale float64)

+ func (s *Segment) UniScaleFrom(x, y, scale float64)

+ func (s *Segment) UniScaleLocal(scale float64)

+ func (s *Segment) UniScaled(scale float64) *Segment

+ func (s *Segment) UniScaledFrom(x, y, scale float64) *Segment

+ func (s *Segment) UniScaledLocal(scale float64) *Segment

+ type SegmentList []*Segment

+ func NewSegmentList() SegmentList

+ func (s *SegmentList) Add(segment *Segment)

+ func (s *SegmentList) AddXY(x0, y0, x1, y1 float64)

+ func (s *SegmentList) Noisify(sx, sy, z, offset float64)

+ func (s *SegmentList) Randomize(amount float64)

+ func (s *SegmentList) Rotate(angle float64)

+ func (s *SegmentList) RotateFrom(x, y float64, angle float64)

+ func (s *SegmentList) RotateLocal(angle float64)

+ func (s *SegmentList) Scale(sx, sy float64)

+ func (s *SegmentList) ScaleFrom(x, y, sx, sy float64)

+ func (s *SegmentList) ScaleLocal(sx, sy float64)

+ func (s *SegmentList) Translate(x, y float64)

+ func (s *SegmentList) UniScale(scale float64)

+ func (s *SegmentList) UniScaleFrom(x, y, scale float64)

+ func (s *SegmentList) UniScaleLocal(scale float64)

+ type Triangle struct

+ PointA *Point

+ PointB *Point

+ PointC *Point

+ func EquilateralTriangleFromCenterAndPoint(c, p0 *Point) *Triangle

+ func EquilateralTriangleFromTwoPoints(p0, p1 *Point, clockwise bool) *Triangle

+ func IsoscoleseTriangle(point *Point, sideLength, angle float64) *Triangle

+ func NewTriangle(x0, y0, x1, y1, x2, y2 float64) *Triangle

+ func NewTriangleFromPoints(pA, pB, pC *Point) *Triangle

+ func (t *Triangle) Altitude(index int) float64

+ func (t *Triangle) AltitudeLine(index int) *Segment

+ func (t *Triangle) Angles() []float64

+ func (t *Triangle) Area() float64

+ func (t *Triangle) BisectorLine(index int) *Segment

+ func (t *Triangle) Centroid() *Point

+ func (t *Triangle) CircumCenter() *Point

+ func (t *Triangle) CircumCircle() *Circle

+ func (t *Triangle) Contains(p *Point) bool

+ func (t *Triangle) Edges() SegmentList

+ func (t *Triangle) Equals(other *Triangle) bool

+ func (t *Triangle) Foot(index int) *Point

+ func (t *Triangle) InCenter() *Point

+ func (t *Triangle) InCircle() *Circle

+ func (t *Triangle) Lengths() []float64

+ func (t *Triangle) MedianLine(index int) *Segment

+ func (t *Triangle) OrthicTriangle() *Triangle

+ func (t *Triangle) OrthoCenter() *Point

+ func (t *Triangle) Points() PointList

+ func (t *Triangle) Randomize(amount float64)

+ func (t *Triangle) Randomized(amount float64) *Triangle

+ func (t *Triangle) Rotate(angle float64)

+ func (t *Triangle) RotateFrom(x, y, angle float64)

+ func (t *Triangle) RotateLocal(angle float64)

+ func (t *Triangle) Rotated(angle float64) *Triangle

+ func (t *Triangle) RotatedFrom(x, y, angle float64) *Triangle

+ func (t *Triangle) RotatedLocal(angle float64) *Triangle

+ func (t *Triangle) Scale(sx, sy float64)

+ func (t *Triangle) ScaleFrom(x, y, sx, sy float64)

+ func (t *Triangle) ScaleLocal(sx, sy float64)

+ func (t *Triangle) Scaled(sx, sy float64) *Triangle

+ func (t *Triangle) ScaledFrom(x, y, sx, sy float64) *Triangle

+ func (t *Triangle) ScaledLocal(sx, sy float64) *Triangle

+ func (t *Triangle) String() string

+ func (t *Triangle) Translate(x, y float64)

+ func (t *Triangle) Translated(tx, ty float64) *Triangle

+ func (t *Triangle) UniScale(scale float64)

+ func (t *Triangle) UniScaleFrom(x, y, scale float64)

+ func (t *Triangle) UniScaleLocal(scale float64)

+ func (t *Triangle) UniScaled(scale float64) *Triangle

+ func (t *Triangle) UniScaledFrom(x, y, scale float64) *Triangle

+ func (t *Triangle) UniScaledLocal(scale float64) *Triangle

+ type TriangleList []*Triangle

+ func NewTriangleList() TriangleList

+ func (t *TriangleList) Add(triangle *Triangle)

+ func (t *TriangleList) Edges() SegmentList

+ func (t *TriangleList) Randomize(amount float64)

+ func (t *TriangleList) Rotate(angle float64)

+ func (t *TriangleList) RotateFrom(x, y float64, angle float64)

+ func (t *TriangleList) RotateLocal(angle float64)

+ func (t *TriangleList) Scale(sx, sy float64)

+ func (t *TriangleList) ScaleFrom(x, y, sx, sy float64)

+ func (t *TriangleList) ScaleLocal(sx, sy float64)

+ func (t *TriangleList) Translate(x, y float64)

+ func (t *TriangleList) UniScale(scale float64)

+ func (t *TriangleList) UniScaleFrom(x, y, scale float64)

+ func (t *TriangleList) UniScaleLocal(scale float64)

+ type Vector struct

+ U float64

+ V float64

+ func NewVector(u, v float64) *Vector

+ func VectorBetween(x0, y0, x1, y1 float64) *Vector

+ func VectorFromPoints(p0, p1 *Point) *Vector

+ func (v *Vector) Abs() *Vector

+ func (v *Vector) Add(w *Vector) *Vector

+ func (v *Vector) Angle() float64

+ func (v *Vector) AngleValueTo(w *Vector) float64

+ func (v *Vector) CrossProduct(w *Vector) float64

+ func (v *Vector) DotProduct(w *Vector) float64

+ func (v *Vector) Magnitude() float64

+ func (v *Vector) Max(other float64) *Vector

+ func (v *Vector) Min(other float64) *Vector

+ func (v *Vector) Norm() float64

+ func (v *Vector) Normalized() *Vector

+ func (v *Vector) Project(w *Vector) float64

+ func (v *Vector) Scaled(factor float64) *Vector

+ func (v *Vector) Subtract(w *Vector) *Vector

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL