shape

package
Version: v2.0.0+incompatible Latest Latest
Warning

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

Go to latest
Published: Feb 7, 2018 License: Apache-2.0 Imports: 5 Imported by: 25

Documentation

Overview

Package shape provides types to satisfy the Shape interface, which allows for containment and outline checks on two dimensional shapes.

Index

Constants

This section is empty.

Variables

View Source
var (
	// Square will return true for any [x][y]
	Square = JustIn(func(x, y int, sizes ...int) bool {
		return true
	})

	// Rectangle will return true for any [x][y] in w, h
	Rectangle = JustIn(func(x, y int, sizes ...int) bool {
		w := sizes[0]
		h := sizes[0]
		if len(sizes) > 1 {
			h = sizes[1]
		}
		if x < w && y < h && x >= 0 && y >= 0 {
			return true
		}
		return false
	})
	// Diamond has a shape like the following:
	// . . t . .
	// . t t t .
	// t t t t t
	// . t t t .
	// . . t . .
	Diamond = JustIn(func(x, y int, sizes ...int) bool {
		radius := sizes[0] / 2
		return math.Abs(float64(x-radius))+math.Abs(float64(y-radius)) < float64(radius)
	})
	// Circle has a shape like the following:
	// . . . . . . .
	// . . t t t . .
	// . t t t t t .
	// . t t t t t .
	// . t t t t t .
	// . . t t t . .
	// . . . . . . .
	Circle = JustIn(func(x, y int, sizes ...int) bool {
		radius := sizes[0] / 2
		dx := math.Abs(float64(x - radius))
		dy := math.Abs(float64(y - radius))
		radiusf64 := float64(radius)
		if dx+dy <= radiusf64 {
			return true
		}
		return math.Pow(dx, 2)+math.Pow(dy, 2) < math.Pow(radiusf64, 2)
	})
	// Checkered has a shape like the following:
	// t . t . t .
	// . t . t . t
	// t . t . t .
	// . t . t . t
	// t . t . t .
	// . t . t . t
	Checkered = JustIn(func(x, y int, sizes ...int) bool {
		return (x+y)%2 == 0
	})
)
View Source
var (
	// Heart has an shape like the following:
	// . . t . t . .
	// . t t t t t .
	// t t t t t t t
	// t t t t t t t
	// . t t t t t .
	// . . t t t . .
	// . . . . . . .
	Heart = JustIn(OrIn(
		AndIn(
			XRange(0, 0.5), hf1.Below(), hf3.Above()),
		AndIn(
			XRange(0.5, 1), hf2.Below(), hf4.Above()),
	))
)

Functions

func GetHoles added in v1.5.0

func GetHoles(sh Shape, w, h int) [][]intgeom.Point2

GetHoles finds sets of points which are not In this shape that are adjacent.

func ToOutline

func ToOutline(shape Shape) func(...int) ([]intgeom.Point2, error)

ToOutline returns the set of points along the input shape's outline, if one exists.

func ToOutline4 added in v1.5.0

func ToOutline4(shape Shape) func(...int) ([]intgeom.Point2, error)

ToOutline4 returns the set of points along the input shape's outline, if one exists, but will move only up, left, right, or down to form this outline.

Types

type Bezier added in v1.4.0

type Bezier interface {
	Pos(progress float64) (x, y float64)
}

A Bezier has a function indicating how far along a curve something is given some float64 progress between 0 and 1. This allows points, lines, and limitlessly complex bezier curves to be represented under this interface.

Beziers will not necessarily break if given an input outside of 0 to 1, but the results shouldn't be relied upon.

func BezierCurve added in v1.4.0

func BezierCurve(coords ...float64) (Bezier, error)

BezierCurve will form a Bezier on the given coordinates, expected in (x,y) pairs. If the inputs have an odd length, an error noting so is returned, and the Bezier returned is nil.

type BezierNode added in v1.4.0

type BezierNode struct {
	Left, Right Bezier
}

A BezierNode ties together and find points between two other Beziers

func (BezierNode) Pos added in v1.4.0

func (bn BezierNode) Pos(progress float64) (x, y float64)

Pos returns the a point progress percent between this node's left and right progress percent points.

type BezierPoint added in v1.4.0

type BezierPoint struct {
	X, Y float64
}

A BezierPoint covers cases where only 1 point is supplied, and serve as roots. Consider: merging with floatgeom.Point2

func (BezierPoint) Pos added in v1.4.0

func (bp BezierPoint) Pos(float64) (x, y float64)

Pos returns this point.

type Eq

type Eq func(x float64) (y float64)

Eq represents a basic equation-- a mapping of x values to y values. Specifically, this equation is expected to be significant to represent some part or all of a shape from -1 to 1. This range is chosen because it's often easier to write shape equations around the center of a graph.

func (Eq) Above

func (eq Eq) Above() In

Above returns an In which reports true for all x,y coordinates above the equation curve.

func (Eq) Below

func (eq Eq) Below() In

Below returns an In which reports true for all x,y coordinates below the equation curve.

type In

type In func(x, y int, sizes ...int) bool

In functions return whether the given coordinate lies in a shape.

func AndIn

func AndIn(is ...In) In

AndIn will combine multiple In functions into one, where if any of the shapes are false the result is false.

func NotIn

func NotIn(i In) In

NotIn returns the opposite of a given In function for any query.

func OrIn

func OrIn(is ...In) In

OrIn will combine multiple In functions into one, where if any of the shapes are true the result is true.

func XRange

func XRange(a, b float64) In

XRange is an example In utility which returns values within a given relative range (where 0 = 0 and 1 = size).

type JustIn

type JustIn In

A JustIn lets an In function serve as a shape by automatically wrapping it in assistant functions for other utilites.

func (JustIn) In

func (ji JustIn) In(x, y int, sizes ...int) bool

In acts as the underlying In function

func (JustIn) Outline

func (ji JustIn) Outline(sizes ...int) ([]intgeom.Point2, error)

Outline calls ToOutline on a JustIn

func (JustIn) Rect

func (ji JustIn) Rect(sizes ...int) [][]bool

Rect calls InToRect on a JustIn's In

type Rect

type Rect func(sizes ...int) [][]bool

A Rect is a function that returns a 2d boolean array of booleans for a given size, where true represents that the bounded shape contains the point [x][y].

func InToRect

func InToRect(i In) Rect

InToRect converts an In function into a Rect function. Know that, if you are planning on looping over this only once, it's better to just use the In function. The use case for this is if the same size rect will be queried on some function multiple times, and just having the booleans to re-access is needed.

type Shape

type Shape interface {
	In(x, y int, sizes ...int) bool
	Outline(sizes ...int) ([]intgeom.Point2, error)
	Rect(sizes ...int) [][]bool
}

A Shape represents a rectangle of width/height size where for each x,y coordinate, either that value lies inside the shape or outside of the shape, represented by true or false. Shapes can be fuzzed along their border to create gradients of floats, and shapes can be queried to just produce a 2d boolean array of width/height size. Todo: consider if the number of coordinate arguments should be variadic, if width/height should not be combined and/or variadic, for additional dimension support

type StrictRect added in v1.4.0

type StrictRect [][]bool

A StrictRect is a shape that ignores input width and height given to it.

func NewStrictRect added in v1.4.0

func NewStrictRect(w, h int) StrictRect

NewStrictRect returns a StrictRect with the given strict dimensions, all values set fo false.

func (StrictRect) In added in v1.4.0

func (sr StrictRect) In(x, y int, sizes ...int) bool

In returns whether the input x and y are within this StrictRect's shape. If the shape is undefined for the input values, it returns false.

func (StrictRect) Outline added in v1.4.0

func (sr StrictRect) Outline(sizes ...int) ([]intgeom.Point2, error)

Outline returns this StrictRect's outline, ignoring the input dimensions.

func (StrictRect) Rect added in v1.4.0

func (sr StrictRect) Rect(sizes ...int) [][]bool

Rect returns the StrictRect itself.

Jump to

Keyboard shortcuts

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