s2

package

Go to main page

Versions in this module

v0

v0.1.7

Feb 17, 2022

Changes in this version

type EdgeQuery

+ func (e *EdgeQuery) GetEdge(result EdgeQueryResult) Edge

+ func (e *EdgeQuery) Project(point Point, result EdgeQueryResult) Point

type Polygon

+ func (p *Polygon) Project(point *Point) Point

+ func (p *Polygon) ProjectToBoundary(point *Point) Point

v0.1.6

Jan 5, 2022

v0.1.5

Dec 16, 2021

Changes in this version

+ func FilterOutCoveringTerms(terms []string) []string

v0.1.4

Oct 29, 2021

Changes in this version

type Cap

+ func CapFromCenterAndRadius(centerLat, centerLon, dist float64) Cap

v0.1.3

Oct 28, 2021

Changes in this version

type Rect

+ func RectFromDegrees(latLo, lngLo, latHi, lngHi float64) Rect

v0.1.2

Jun 7, 2021

v0.1.1

Jun 7, 2021

Changes in this version

+ const SentinelCellID

+ var AvgAngleSpanMetric = Metric

+ var AvgAreaMetric = Metric

+ var AvgDiagMetric = Metric

+ var AvgEdgeMetric = Metric

+ var AvgWidthMetric = Metric

+ var MaxAngleSpanMetric = Metric

+ var MaxAreaMetric = Metric

+ var MaxDiagAspect = math.Sqrt(3)

+ var MaxDiagMetric = Metric

+ var MaxEdgeAspect = 1.442615274452682920

+ var MaxEdgeMetric = Metric

+ var MaxWidthMetric = Metric

+ var MinAngleSpanMetric = Metric

+ var MinAreaMetric = Metric

+ var MinDiagMetric = Metric

+ var MinEdgeMetric = Metric

+ var MinWidthMetric = Metric

+ func Angle(a, b, c Point) s1.Angle

+ func ChordAngleBetweenPoints(x, y Point) s1.ChordAngle

+ func ClipEdge(a, b r2.Point, clip r2.Rect) (aClip, bClip r2.Point, intersects bool)

+ func ClipToFace(a, b Point, face int) (aUV, bUV r2.Point, intersects bool)

+ func ClipToPaddedFace(a, b Point, f int, padding float64) (aUV, bUV r2.Point, intersects bool)

+ func CompareDistance(x, y Point, r s1.ChordAngle) int

+ func CompareDistances(x, a, b Point) int

+ func DistanceFraction(x, a, b Point) float64

+ func DistanceFromSegment(x, a, b Point) s1.Angle

+ func EdgeOrVertexCrossing(a, b, c, d Point) bool

+ func EdgePairClosestPoints(a0, a1, b0, b1 Point) (Point, Point)

+ func GirardArea(a, b, c Point) float64

+ func IsDistanceLess(x, a, b Point, limit s1.ChordAngle) bool

+ func IsInteriorDistanceLess(x, a, b Point, limit s1.ChordAngle) bool

+ func OrderedCCW(a, b, c, o Point) bool

+ func PointArea(a, b, c Point) float64

+ func Sign(a, b, c Point) bool

+ func SignedArea(a, b, c Point) float64

+ func TurnAngle(a, b, c Point) s1.Angle

+ func UpdateMaxDistance(x, a, b Point, maxDist s1.ChordAngle) (s1.ChordAngle, bool)

+ func UpdateMinDistance(x, a, b Point, minDist s1.ChordAngle) (s1.ChordAngle, bool)

+ func UpdateMinInteriorDistance(x, a, b Point, minDist s1.ChordAngle) (s1.ChordAngle, bool)

+ func VertexCrossing(a, b, c, d Point) bool

+ func WedgeContains(a0, ab1, a2, b0, b2 Point) bool

+ func WedgeIntersects(a0, ab1, a2, b0, b2 Point) bool

+ type Cap struct

+ func CapFromCenterAngle(center Point, angle s1.Angle) Cap

+ func CapFromCenterArea(center Point, area float64) Cap

+ func CapFromCenterChordAngle(center Point, radius s1.ChordAngle) Cap

+ func CapFromCenterHeight(center Point, height float64) Cap

+ func CapFromPoint(p Point) Cap

+ func EmptyCap() Cap

+ func FullCap() Cap

+ func (c *Cap) Decode(r io.Reader) error

+ func (c Cap) AddCap(other Cap) Cap

+ func (c Cap) AddPoint(p Point) Cap

+ func (c Cap) ApproxEqual(other Cap) bool

+ func (c Cap) Area() float64

+ func (c Cap) CapBound() Cap

+ func (c Cap) CellUnionBound() []CellID

+ func (c Cap) Center() Point

+ func (c Cap) Centroid() Point

+ func (c Cap) Complement() Cap

+ func (c Cap) Contains(other Cap) bool

+ func (c Cap) ContainsCell(cell Cell) bool

+ func (c Cap) ContainsPoint(p Point) bool

+ func (c Cap) Encode(w io.Writer) error

+ func (c Cap) Equal(other Cap) bool

+ func (c Cap) Expanded(distance s1.Angle) Cap

+ func (c Cap) Height() float64

+ func (c Cap) InteriorContainsPoint(p Point) bool

+ func (c Cap) InteriorIntersects(other Cap) bool

+ func (c Cap) Intersects(other Cap) bool

+ func (c Cap) IntersectsCell(cell Cell) bool

+ func (c Cap) IsEmpty() bool

+ func (c Cap) IsFull() bool

+ func (c Cap) IsValid() bool

+ func (c Cap) Radius() s1.Angle

+ func (c Cap) RectBound() Rect

+ func (c Cap) String() string

+ func (c Cap) Union(other Cap) Cap

+ type Cell struct

+ func CellFromCellID(id CellID) Cell

+ func CellFromLatLng(ll LatLng) Cell

+ func CellFromPoint(p Point) Cell

+ func (c *Cell) Decode(r io.Reader) error

+ func (c Cell) ApproxArea() float64

+ func (c Cell) AverageArea() float64

+ func (c Cell) BoundUV() r2.Rect

+ func (c Cell) BoundaryDistance(target Point) s1.ChordAngle

+ func (c Cell) CapBound() Cap

+ func (c Cell) CellUnionBound() []CellID

+ func (c Cell) Center() Point

+ func (c Cell) Children() ([4]Cell, bool)

+ func (c Cell) ContainsCell(oc Cell) bool

+ func (c Cell) ContainsPoint(p Point) bool

+ func (c Cell) Distance(target Point) s1.ChordAngle

+ func (c Cell) DistanceToCell(target Cell) s1.ChordAngle

+ func (c Cell) DistanceToEdge(a, b Point) s1.ChordAngle

+ func (c Cell) Edge(k int) Point

+ func (c Cell) Encode(w io.Writer) error

+ func (c Cell) ExactArea() float64

+ func (c Cell) Face() int

+ func (c Cell) ID() CellID

+ func (c Cell) IntersectsCell(oc Cell) bool

+ func (c Cell) IsLeaf() bool

+ func (c Cell) Level() int

+ func (c Cell) MaxDistance(target Point) s1.ChordAngle

+ func (c Cell) MaxDistanceToCell(target Cell) s1.ChordAngle

+ func (c Cell) MaxDistanceToEdge(a, b Point) s1.ChordAngle

+ func (c Cell) RectBound() Rect

+ func (c Cell) SizeIJ() int

+ func (c Cell) SizeST() float64

+ func (c Cell) Vertex(k int) Point

+ type CellID uint64

+ func CellIDFromFace(face int) CellID

+ func CellIDFromFacePosLevel(face int, pos uint64, level int) CellID

+ func CellIDFromLatLng(ll LatLng) CellID

+ func CellIDFromToken(s string) CellID

+ func FloodFillRegionCovering(region Region, start CellID) []CellID

+ func SimpleRegionCovering(region Region, start Point, level int) []CellID

+ func (ci *CellID) Decode(r io.Reader) error

+ func (ci CellID) Advance(steps int64) CellID

+ func (ci CellID) AdvanceWrap(steps int64) CellID

+ func (ci CellID) AllNeighbors(level int) []CellID

+ func (ci CellID) ChildBegin() CellID

+ func (ci CellID) ChildBeginAtLevel(level int) CellID

+ func (ci CellID) ChildEnd() CellID

+ func (ci CellID) ChildEndAtLevel(level int) CellID

+ func (ci CellID) ChildPosition(level int) int

+ func (ci CellID) Children() [4]CellID

+ func (ci CellID) CommonAncestorLevel(other CellID) (level int, ok bool)

+ func (ci CellID) Contains(oci CellID) bool

+ func (ci CellID) EdgeNeighbors() [4]CellID

+ func (ci CellID) Encode(w io.Writer) error

+ func (ci CellID) Face() int

+ func (ci CellID) Intersects(oci CellID) bool

+ func (ci CellID) IsLeaf() bool

+ func (ci CellID) IsValid() bool

+ func (ci CellID) LatLng() LatLng

+ func (ci CellID) Level() int

+ func (ci CellID) MaxTile(limit CellID) CellID

+ func (ci CellID) Next() CellID

+ func (ci CellID) NextWrap() CellID

+ func (ci CellID) Parent(level int) CellID

+ func (ci CellID) Point() Point

+ func (ci CellID) Pos() uint64

+ func (ci CellID) Prev() CellID

+ func (ci CellID) PrevWrap() CellID

+ func (ci CellID) RangeMax() CellID

+ func (ci CellID) RangeMin() CellID

+ func (ci CellID) String() string

+ func (ci CellID) ToToken() string

+ func (ci CellID) VertexNeighbors(level int) []CellID

+ type CellIndex struct

+ func (c *CellIndex) Add(id CellID, label int32)

+ func (c *CellIndex) AddCellUnion(cu CellUnion, label int32)

+ func (c *CellIndex) Build()

+ func (c *CellIndex) GetIntersectingLabels(target CellUnion) []int32

+ func (c *CellIndex) IntersectingLabels(target CellUnion, labels *[]int32)

+ func (c *CellIndex) VisitIntersectingCells(target CellUnion, visitor CellVisitor) bool

+ type CellIndexContentsIterator struct

+ func NewCellIndexContentsIterator(index *CellIndex) *CellIndexContentsIterator

+ func (c *CellIndexContentsIterator) CellID() CellID

+ func (c *CellIndexContentsIterator) Clear()

+ func (c *CellIndexContentsIterator) Done() bool

+ func (c *CellIndexContentsIterator) Label() int32

+ func (c *CellIndexContentsIterator) Next()

+ func (c *CellIndexContentsIterator) StartUnion(r *CellIndexRangeIterator)

+ type CellIndexIterator struct

+ func NewCellIndexIterator(index *CellIndex) *CellIndexIterator

+ func (c *CellIndexIterator) CellID() CellID

+ func (c *CellIndexIterator) Done() bool

+ func (c *CellIndexIterator) Label() int32

+ func (c *CellIndexIterator) Next()

+ type CellIndexRangeIterator struct

+ func NewCellIndexNonEmptyRangeIterator(index *CellIndex) *CellIndexRangeIterator

+ func NewCellIndexRangeIterator(index *CellIndex) *CellIndexRangeIterator

+ func (c *CellIndexRangeIterator) Advance(n int) bool

+ func (c *CellIndexRangeIterator) Begin()

+ func (c *CellIndexRangeIterator) Done() bool

+ func (c *CellIndexRangeIterator) Finish()

+ func (c *CellIndexRangeIterator) IsEmpty() bool

+ func (c *CellIndexRangeIterator) LimitID() CellID

+ func (c *CellIndexRangeIterator) Next()

+ func (c *CellIndexRangeIterator) Prev() bool

+ func (c *CellIndexRangeIterator) Seek(target CellID)

+ func (c *CellIndexRangeIterator) StartID() CellID

+ type CellRelation int

+ const Disjoint

+ const Indexed

+ const Subdivided

+ type CellUnion []CellID

+ func CellUnionFromDifference(x, y CellUnion) CellUnion

+ func CellUnionFromIntersection(x, y CellUnion) CellUnion

+ func CellUnionFromIntersectionWithCellID(x CellUnion, id CellID) CellUnion

+ func CellUnionFromRange(begin, end CellID) CellUnion

+ func CellUnionFromUnion(cellUnions ...CellUnion) CellUnion

+ func (cu *CellUnion) ApproxArea() float64

+ func (cu *CellUnion) AverageArea() float64

+ func (cu *CellUnion) CapBound() Cap

+ func (cu *CellUnion) CellUnionBound() []CellID

+ func (cu *CellUnion) Contains(o CellUnion) bool

+ func (cu *CellUnion) ContainsCell(c Cell) bool

+ func (cu *CellUnion) ContainsCellID(id CellID) bool

+ func (cu *CellUnion) ContainsPoint(p Point) bool

+ func (cu *CellUnion) Decode(r io.Reader) error

+ func (cu *CellUnion) Denormalize(minLevel, levelMod int)

+ func (cu *CellUnion) Encode(w io.Writer) error

+ func (cu *CellUnion) ExactArea() float64

+ func (cu *CellUnion) ExpandAtLevel(level int)

+ func (cu *CellUnion) ExpandByRadius(minRadius s1.Angle, maxLevelDiff int)

+ func (cu *CellUnion) Intersects(o CellUnion) bool

+ func (cu *CellUnion) IntersectsCell(c Cell) bool

+ func (cu *CellUnion) IntersectsCellID(id CellID) bool

+ func (cu *CellUnion) IsNormalized() bool

+ func (cu *CellUnion) IsValid() bool

+ func (cu *CellUnion) LeafCellsCovered() int64

+ func (cu *CellUnion) Normalize()

+ func (cu *CellUnion) RectBound() Rect

+ func (cu CellUnion) Equal(o CellUnion) bool

+ type CellVisitor func(CellID, int32) bool

+ type Chain struct

+ Length int

+ Start int

+ type ChainPosition struct

+ ChainID int

+ Offset int

+ type ContainsPointQuery struct

+ func NewContainsPointQuery(index *ShapeIndex, model VertexModel) *ContainsPointQuery

+ func (q *ContainsPointQuery) ContainingShapes(p Point) []Shape

+ func (q *ContainsPointQuery) Contains(p Point) bool

+ func (q *ContainsPointQuery) ShapeContains(shape Shape, p Point) bool

+ type ContainsVertexQuery struct

+ func NewContainsVertexQuery(target Point) *ContainsVertexQuery

+ func (q *ContainsVertexQuery) AddEdge(v Point, direction int)

+ func (q *ContainsVertexQuery) ContainsVertex() int

+ type ConvexHullQuery struct

+ func NewConvexHullQuery() *ConvexHullQuery

+ func (q *ConvexHullQuery) AddLoop(l *Loop)

+ func (q *ConvexHullQuery) AddPoint(p Point)

+ func (q *ConvexHullQuery) AddPolygon(p *Polygon)

+ func (q *ConvexHullQuery) AddPolyline(p *Polyline)

+ func (q *ConvexHullQuery) CapBound() Cap

+ func (q *ConvexHullQuery) ConvexHull() *Loop

+ type Crossing int

+ const Cross

+ const DoNotCross

+ const MaybeCross

+ func CrossingSign(a, b, c, d Point) Crossing

+ func (c Crossing) String() string

+ type CrossingEdgeQuery struct

+ func NewCrossingEdgeQuery(index *ShapeIndex) *CrossingEdgeQuery

+ func (c *CrossingEdgeQuery) Crossings(a, b Point, shape Shape, crossType CrossingType) []int

+ func (c *CrossingEdgeQuery) CrossingsEdgeMap(a, b Point, crossType CrossingType) EdgeMap

+ type CrossingType int

+ const CrossingTypeAll

+ const CrossingTypeInterior

+ const CrossingTypeNonAdjacent

+ type Direction int

+ const Clockwise

+ const CounterClockwise

+ const Indeterminate

+ func RobustSign(a, b, c Point) Direction

+ type Edge struct

+ V0 Point

+ V1 Point

+ func (e Edge) Cmp(other Edge) int

+ type EdgeCrosser struct

+ func NewChainEdgeCrosser(a, b, c Point) *EdgeCrosser

+ func NewEdgeCrosser(a, b Point) *EdgeCrosser

+ func (e *EdgeCrosser) ChainCrossingSign(d Point) Crossing

+ func (e *EdgeCrosser) CrossingSign(c, d Point) Crossing

+ func (e *EdgeCrosser) EdgeOrVertexChainCrossing(d Point) bool

+ func (e *EdgeCrosser) EdgeOrVertexCrossing(c, d Point) bool

+ func (e *EdgeCrosser) RestartAt(c Point)

+ type EdgeIterator struct

+ func NewEdgeIterator(index *ShapeIndex) *EdgeIterator

+ func (e *EdgeIterator) Done() bool

+ func (e *EdgeIterator) Edge() Edge

+ func (e *EdgeIterator) EdgeID() int32

+ func (e *EdgeIterator) Next()

+ func (e *EdgeIterator) ShapeEdgeID() ShapeEdgeID

+ func (e *EdgeIterator) ShapeID() int32

+ type EdgeMap map[Shape][]int

+ type EdgeQuery struct

+ func NewClosestEdgeQuery(index *ShapeIndex, opts *EdgeQueryOptions) *EdgeQuery

+ func NewFurthestEdgeQuery(index *ShapeIndex, opts *EdgeQueryOptions) *EdgeQuery

+ func (e *EdgeQuery) Distance(target distanceTarget) s1.ChordAngle

+ func (e *EdgeQuery) FindEdges(target distanceTarget) []EdgeQueryResult

+ func (e *EdgeQuery) IsConservativeDistanceGreaterOrEqual(target distanceTarget, limit s1.ChordAngle) bool

+ func (e *EdgeQuery) IsConservativeDistanceLessOrEqual(target distanceTarget, limit s1.ChordAngle) bool

+ func (e *EdgeQuery) IsDistanceGreater(target distanceTarget, limit s1.ChordAngle) bool

+ func (e *EdgeQuery) IsDistanceLess(target distanceTarget, limit s1.ChordAngle) bool

+ func (e *EdgeQuery) Reset()

+ type EdgeQueryOptions struct

+ func NewClosestEdgeQueryOptions() *EdgeQueryOptions

+ func NewFurthestEdgeQueryOptions() *EdgeQueryOptions

+ func (e *EdgeQueryOptions) DistanceLimit(limit s1.ChordAngle) *EdgeQueryOptions

+ func (e *EdgeQueryOptions) IncludeInteriors(x bool) *EdgeQueryOptions

+ func (e *EdgeQueryOptions) MaxError(dist s1.ChordAngle) *EdgeQueryOptions

+ func (e *EdgeQueryOptions) MaxResults(n int) *EdgeQueryOptions

+ func (e *EdgeQueryOptions) UseBruteForce(x bool) *EdgeQueryOptions

+ type EdgeQueryResult struct

+ func (e EdgeQueryResult) Distance() s1.ChordAngle

+ func (e EdgeQueryResult) EdgeID() int32

+ func (e EdgeQueryResult) IsEmpty() bool

+ func (e EdgeQueryResult) IsInterior() bool

+ func (e EdgeQueryResult) Less(other EdgeQueryResult) bool

+ func (e EdgeQueryResult) ShapeID() int32

+ type EdgeTessellator struct

+ func NewEdgeTessellator(p Projection, tolerance s1.Angle) *EdgeTessellator

+ func (e *EdgeTessellator) AppendProjected(a, b Point, vertices []r2.Point) []r2.Point

+ func (e *EdgeTessellator) AppendUnprojected(pa, pb r2.Point, vertices []Point) []Point

+ type FaceSegment struct

+ func FaceSegments(a, b Point) []FaceSegment

+ type LatLng struct

+ Lat s1.Angle

+ Lng s1.Angle

+ func LatLngFromDegrees(lat, lng float64) LatLng

+ func LatLngFromPoint(p Point) LatLng

+ func (ll LatLng) ApproxEqual(other LatLng) bool

+ func (ll LatLng) Distance(ll2 LatLng) s1.Angle

+ func (ll LatLng) IsValid() bool

+ func (ll LatLng) Normalized() LatLng

+ func (ll LatLng) String() string

+ type Loop struct

+ func EmptyLoop() *Loop

+ func FullLoop() *Loop

+ func LoopFromCell(c Cell) *Loop

+ func LoopFromPoints(pts []Point) *Loop

+ func RegularLoop(center Point, radius s1.Angle, numVertices int) *Loop

+ func RegularLoopForFrame(frame matrix3x3, radius s1.Angle, numVertices int) *Loop

+ func (l *Loop) Area() float64

+ func (l *Loop) BoundaryEqual(o *Loop) bool

+ func (l *Loop) CanonicalFirstVertex() (firstIdx, direction int)

+ func (l *Loop) CapBound() Cap

+ func (l *Loop) CellUnionBound() []CellID

+ func (l *Loop) Centroid() Point

+ func (l *Loop) Chain(chainID int) Chain

+ func (l *Loop) ChainEdge(chainID, offset int) Edge

+ func (l *Loop) ChainPosition(edgeID int) ChainPosition

+ func (l *Loop) Contains(o *Loop) bool

+ func (l *Loop) ContainsCell(target Cell) bool

+ func (l *Loop) ContainsNested(other *Loop) bool

+ func (l *Loop) ContainsOrigin() bool

+ func (l *Loop) ContainsPoint(p Point) bool

+ func (l *Loop) Decode(r io.Reader) error

+ func (l *Loop) Dimension() int

+ func (l *Loop) Edge(i int) Edge

+ func (l *Loop) Equal(other *Loop) bool

+ func (l *Loop) Intersects(o *Loop) bool

+ func (l *Loop) IntersectsCell(target Cell) bool

+ func (l *Loop) Invert()

+ func (l *Loop) IsEmpty() bool

+ func (l *Loop) IsFull() bool

+ func (l *Loop) IsHole() bool

+ func (l *Loop) IsNormalized() bool

+ func (l *Loop) Normalize()

+ func (l *Loop) NumChains() int

+ func (l *Loop) NumEdges() int

+ func (l *Loop) NumVertices() int

+ func (l *Loop) OrientedVertex(i int) Point

+ func (l *Loop) RectBound() Rect

+ func (l *Loop) ReferencePoint() ReferencePoint

+ func (l *Loop) Sign() int

+ func (l *Loop) TurningAngle() float64

+ func (l *Loop) Validate() error

+ func (l *Loop) Vertex(i int) Point

+ func (l *Loop) Vertices() []Point

+ func (l Loop) Encode(w io.Writer) error

+ type MaxDistanceToCellTarget struct

+ func NewMaxDistanceToCellTarget(cell Cell) *MaxDistanceToCellTarget

+ type MaxDistanceToEdgeTarget struct

+ func NewMaxDistanceToEdgeTarget(e Edge) *MaxDistanceToEdgeTarget

+ type MaxDistanceToPointTarget struct

+ func NewMaxDistanceToPointTarget(point Point) *MaxDistanceToPointTarget

+ type MaxDistanceToShapeIndexTarget struct

+ func NewMaxDistanceToShapeIndexTarget(index *ShapeIndex) *MaxDistanceToShapeIndexTarget

+ type MercatorProjection struct

+ func (p *MercatorProjection) FromLatLng(ll LatLng) r2.Point

+ func (p *MercatorProjection) Interpolate(f float64, a, b r2.Point) r2.Point

+ func (p *MercatorProjection) Project(pt Point) r2.Point

+ func (p *MercatorProjection) ToLatLng(pt r2.Point) LatLng

+ func (p *MercatorProjection) Unproject(pt r2.Point) Point

+ func (p *MercatorProjection) WrapDestination(a, b r2.Point) r2.Point

+ func (p *MercatorProjection) WrapDistance() r2.Point

+ type Metric struct

+ Deriv float64

+ Dim int

+ func (m Metric) ClosestLevel(val float64) int

+ func (m Metric) MaxLevel(val float64) int

+ func (m Metric) MinLevel(val float64) int

+ func (m Metric) Value(level int) float64

+ type MinDistanceToCellTarget struct

+ func NewMinDistanceToCellTarget(cell Cell) *MinDistanceToCellTarget

+ type MinDistanceToEdgeTarget struct

+ func NewMinDistanceToEdgeTarget(e Edge) *MinDistanceToEdgeTarget

+ type MinDistanceToPointTarget struct

+ func NewMinDistanceToPointTarget(point Point) *MinDistanceToPointTarget

+ type MinDistanceToShapeIndexTarget struct

+ func NewMinDistanceToShapeIndexTarget(index *ShapeIndex) *MinDistanceToShapeIndexTarget

+ type Options struct

+ func (o *Options) LevelMod() int

+ func (o *Options) MaxCells() int

+ func (o *Options) MaxLevel() int

+ func (o *Options) MinLevel() int

+ func (o *Options) SetLevelMod(lm int)

+ func (o *Options) SetMaxCells(mc int)

+ func (o *Options) SetMaxLevel(ml int)

+ func (o *Options) SetMinLevel(ml int)

+ func (o *Options) SetOptimizeSpace(v bool)

+ func (o *Options) SetPointsOnly(v bool)

+ type PaddedCell struct

+ func PaddedCellFromCellID(id CellID, padding float64) *PaddedCell

+ func PaddedCellFromParentIJ(parent *PaddedCell, i, j int) *PaddedCell

+ func (p *PaddedCell) Middle() r2.Rect

+ func (p *PaddedCell) ShrinkToFit(rect r2.Rect) CellID

+ func (p PaddedCell) Bound() r2.Rect

+ func (p PaddedCell) CellID() CellID

+ func (p PaddedCell) Center() Point

+ func (p PaddedCell) ChildIJ(pos int) (i, j int)

+ func (p PaddedCell) EntryVertex() Point

+ func (p PaddedCell) ExitVertex() Point

+ func (p PaddedCell) Level() int

+ func (p PaddedCell) Padding() float64

+ type PlateCarreeProjection struct

+ func (p *PlateCarreeProjection) FromLatLng(ll LatLng) r2.Point

+ func (p *PlateCarreeProjection) Interpolate(f float64, a, b r2.Point) r2.Point

+ func (p *PlateCarreeProjection) Project(pt Point) r2.Point

+ func (p *PlateCarreeProjection) ToLatLng(pt r2.Point) LatLng

+ func (p *PlateCarreeProjection) Unproject(pt r2.Point) Point

+ func (p *PlateCarreeProjection) WrapDestination(a, b r2.Point) r2.Point

+ func (p *PlateCarreeProjection) WrapDistance() r2.Point

+ type Point struct

+ func EdgeTrueCentroid(a, b Point) Point

+ func Interpolate(t float64, a, b Point) Point

+ func InterpolateAtDistance(ax s1.Angle, a, b Point) Point

+ func Intersection(a0, a1, b0, b1 Point) Point

+ func OriginPoint() Point

+ func PlanarCentroid(a, b, c Point) Point

+ func PointFromCoords(x, y, z float64) Point

+ func PointFromLatLng(ll LatLng) Point

+ func Project(x, a, b Point) Point

+ func Rotate(p, axis Point, angle s1.Angle) Point

+ func TrueCentroid(a, b, c Point) Point

+ func (p *Point) Decode(r io.Reader) error

+ func (p Point) ApproxEqual(other Point) bool

+ func (p Point) CapBound() Cap

+ func (p Point) CellUnionBound() []CellID

+ func (p Point) Contains(other Point) bool

+ func (p Point) ContainsCell(c Cell) bool

+ func (p Point) ContainsPoint(other Point) bool

+ func (p Point) Distance(b Point) s1.Angle

+ func (p Point) Encode(w io.Writer) error

+ func (p Point) IntersectsCell(c Cell) bool

+ func (p Point) PointCross(op Point) Point

+ func (p Point) RectBound() Rect

+ type PointVector []Point

+ func (p *PointVector) Chain(i int) Chain

+ func (p *PointVector) ChainEdge(i, j int) Edge

+ func (p *PointVector) ChainPosition(e int) ChainPosition

+ func (p *PointVector) Dimension() int

+ func (p *PointVector) Edge(i int) Edge

+ func (p *PointVector) IsEmpty() bool

+ func (p *PointVector) IsFull() bool

+ func (p *PointVector) NumChains() int

+ func (p *PointVector) NumEdges() int

+ func (p *PointVector) ReferencePoint() ReferencePoint

+ type Polygon struct

+ func FullPolygon() *Polygon

+ func PolygonFromCell(cell Cell) *Polygon

+ func PolygonFromLoops(loops []*Loop) *Polygon

+ func PolygonFromOrientedLoops(loops []*Loop) *Polygon

+ func (p *Polygon) Area() float64

+ func (p *Polygon) CapBound() Cap

+ func (p *Polygon) CellUnionBound() []CellID

+ func (p *Polygon) Chain(chainID int) Chain

+ func (p *Polygon) ChainEdge(i, j int) Edge

+ func (p *Polygon) ChainPosition(edgeID int) ChainPosition

+ func (p *Polygon) Contains(o *Polygon) bool

+ func (p *Polygon) ContainsCell(cell Cell) bool

+ func (p *Polygon) ContainsPoint(point Point) bool

+ func (p *Polygon) Decode(r io.Reader) error

+ func (p *Polygon) Dimension() int

+ func (p *Polygon) Edge(e int) Edge

+ func (p *Polygon) Encode(w io.Writer) error

+ func (p *Polygon) Intersects(o *Polygon) bool

+ func (p *Polygon) IntersectsCell(cell Cell) bool

+ func (p *Polygon) Invert()

+ func (p *Polygon) IsEmpty() bool

+ func (p *Polygon) IsFull() bool

+ func (p *Polygon) LastDescendant(k int) int

+ func (p *Polygon) Loop(k int) *Loop

+ func (p *Polygon) Loops() []*Loop

+ func (p *Polygon) NumChains() int

+ func (p *Polygon) NumEdges() int

+ func (p *Polygon) NumLoops() int

+ func (p *Polygon) Parent(k int) (index int, ok bool)

+ func (p *Polygon) RectBound() Rect

+ func (p *Polygon) ReferencePoint() ReferencePoint

+ func (p *Polygon) Validate() error

+ type Polyline []Point

+ func PolylineFromLatLngs(points []LatLng) *Polyline

+ func (p *Polyline) ApproxEqual(o *Polyline) bool

+ func (p *Polyline) CapBound() Cap

+ func (p *Polyline) CellUnionBound() []CellID

+ func (p *Polyline) Centroid() Point

+ func (p *Polyline) Chain(chainID int) Chain

+ func (p *Polyline) ChainEdge(chainID, offset int) Edge

+ func (p *Polyline) ChainPosition(edgeID int) ChainPosition

+ func (p *Polyline) ContainsCell(cell Cell) bool

+ func (p *Polyline) ContainsPoint(point Point) bool

+ func (p *Polyline) Decode(r io.Reader) error

+ func (p *Polyline) Dimension() int

+ func (p *Polyline) Edge(i int) Edge

+ func (p *Polyline) Equal(b *Polyline) bool

+ func (p *Polyline) Interpolate(fraction float64) (Point, int)

+ func (p *Polyline) Intersects(o *Polyline) bool

+ func (p *Polyline) IntersectsCell(cell Cell) bool

+ func (p *Polyline) IsEmpty() bool

+ func (p *Polyline) IsFull() bool

+ func (p *Polyline) IsOnRight(point Point) bool

+ func (p *Polyline) Length() s1.Angle

+ func (p *Polyline) NumChains() int

+ func (p *Polyline) NumEdges() int

+ func (p *Polyline) Project(point Point) (Point, int)

+ func (p *Polyline) RectBound() Rect

+ func (p *Polyline) ReferencePoint() ReferencePoint

+ func (p *Polyline) Reverse()

+ func (p *Polyline) SubsampleVertices(tolerance s1.Angle) []int

+ func (p *Polyline) Uninterpolate(point Point, nextVertex int) float64

+ func (p *Polyline) Validate() error

+ func (p Polyline) Encode(w io.Writer) error

+ type Projection interface

+ FromLatLng func(ll LatLng) r2.Point

+ Interpolate func(f float64, a, b r2.Point) r2.Point

+ Project func(p Point) r2.Point

+ ToLatLng func(p r2.Point) LatLng

+ Unproject func(p r2.Point) Point

+ WrapDestination func(a, b r2.Point) r2.Point

+ WrapDistance func() r2.Point

+ func NewMercatorProjection(maxLng float64) Projection

+ func NewPlateCarreeProjection(xScale float64) Projection

+ type Rect struct

+ Lat r1.Interval

+ Lng s1.Interval

+ func EmptyRect() Rect

+ func ExpandForSubregions(bound Rect) Rect

+ func FullRect() Rect

+ func RectFromCenterSize(center, size LatLng) Rect

+ func RectFromLatLng(p LatLng) Rect

+ func (r *Rect) Decode(rd io.Reader) error

+ func (r Rect) AddPoint(ll LatLng) Rect

+ func (r Rect) ApproxEqual(other Rect) bool

+ func (r Rect) Area() float64

+ func (r Rect) CapBound() Cap

+ func (r Rect) CellUnionBound() []CellID

+ func (r Rect) Center() LatLng

+ func (r Rect) Centroid() Point

+ func (r Rect) Contains(other Rect) bool

+ func (r Rect) ContainsCell(c Cell) bool

+ func (r Rect) ContainsLatLng(ll LatLng) bool

+ func (r Rect) ContainsPoint(p Point) bool

+ func (r Rect) DirectedHausdorffDistance(other Rect) s1.Angle

+ func (r Rect) DistanceToLatLng(ll LatLng) s1.Angle

+ func (r Rect) Encode(w io.Writer) error

+ func (r Rect) HausdorffDistance(other Rect) s1.Angle

+ func (r Rect) Hi() LatLng

+ func (r Rect) Intersection(other Rect) Rect

+ func (r Rect) Intersects(other Rect) bool

+ func (r Rect) IntersectsCell(c Cell) bool

+ func (r Rect) IsEmpty() bool

+ func (r Rect) IsFull() bool

+ func (r Rect) IsPoint() bool

+ func (r Rect) IsValid() bool

+ func (r Rect) Lo() LatLng

+ func (r Rect) PolarClosure() Rect

+ func (r Rect) RectBound() Rect

+ func (r Rect) Size() LatLng

+ func (r Rect) String() string

+ func (r Rect) Union(other Rect) Rect

+ func (r Rect) Vertex(i int) LatLng

+ type RectBounder struct

+ func NewRectBounder() *RectBounder

+ func (r *RectBounder) AddPoint(b Point)

+ func (r *RectBounder) RectBound() Rect

+ type ReferencePoint struct

+ Contained bool

+ Point Point

+ func OriginReferencePoint(contained bool) ReferencePoint

+ type Region interface

+ CapBound func() Cap

+ CellUnionBound func() []CellID

+ ContainsCell func(c Cell) bool

+ ContainsPoint func(p Point) bool

+ IntersectsCell func(c Cell) bool

+ RectBound func() Rect

+ type RegionCoverer struct

+ LevelMod int

+ MaxCells int

+ MaxLevel int

+ MinLevel int

+ func NewRegionCoverer() *RegionCoverer

+ func (rc *RegionCoverer) CellUnion(region Region) CellUnion

+ func (rc *RegionCoverer) Covering(region Region) CellUnion

+ func (rc *RegionCoverer) FastCovering(region Region) CellUnion

+ func (rc *RegionCoverer) InteriorCellUnion(region Region) CellUnion

+ func (rc *RegionCoverer) InteriorCovering(region Region) CellUnion

+ func (rc *RegionCoverer) IsCanonical(covering CellUnion) bool

+ type RegionTermIndexer struct

+ func NewRegionTermIndexer() *RegionTermIndexer

+ func NewRegionTermIndexerWithOptions(option Options) *RegionTermIndexer

+ func (rti *RegionTermIndexer) GetIndexTermsForCanonicalCovering(covering CellUnion, prefix string) []string

+ func (rti *RegionTermIndexer) GetIndexTermsForPoint(p Point, prefix string) []string

+ func (rti *RegionTermIndexer) GetIndexTermsForRegion(region Region, prefix string) []string

+ func (rti *RegionTermIndexer) GetQueryTermsForCanonicalCovering(covering CellUnion, prefix string) []string

+ func (rti *RegionTermIndexer) GetQueryTermsForPoint(p Point, prefix string) []string

+ func (rti *RegionTermIndexer) GetQueryTermsForRegion(region Region, prefix string) []string

+ func (rti *RegionTermIndexer) GetTerm(termTyp TermType, id CellID, prefix string) string

+ type RegionUnion []Region

+ func (ru RegionUnion) CapBound() Cap

+ func (ru RegionUnion) CellUnionBound() []CellID

+ func (ru RegionUnion) ContainsCell(c Cell) bool

+ func (ru RegionUnion) ContainsPoint(p Point) bool

+ func (ru RegionUnion) IntersectsCell(c Cell) bool

+ func (ru RegionUnion) RectBound() Rect

+ type Shape interface

+ Chain func(chainID int) Chain

+ ChainEdge func(chainID, offset int) Edge

+ ChainPosition func(edgeID int) ChainPosition

+ Dimension func() int

+ Edge func(i int) Edge

+ IsEmpty func() bool

+ IsFull func() bool

+ NumChains func() int

+ NumEdges func() int

+ ReferencePoint func() ReferencePoint

+ type ShapeEdge struct

+ Edge Edge

+ ID ShapeEdgeID

+ type ShapeEdgeID struct

+ EdgeID int32

+ ShapeID int32

+ func (s ShapeEdgeID) Cmp(other ShapeEdgeID) int

+ type ShapeIndex struct

+ func NewShapeIndex() *ShapeIndex

+ func (s *ShapeIndex) Add(shape Shape) int32

+ func (s *ShapeIndex) Begin() *ShapeIndexIterator

+ func (s *ShapeIndex) Build()

+ func (s *ShapeIndex) End() *ShapeIndexIterator

+ func (s *ShapeIndex) IsFresh() bool

+ func (s *ShapeIndex) Iterator() *ShapeIndexIterator

+ func (s *ShapeIndex) Len() int

+ func (s *ShapeIndex) NumEdges() int

+ func (s *ShapeIndex) NumEdgesUpTo(limit int) int

+ func (s *ShapeIndex) Remove(shape Shape)

+ func (s *ShapeIndex) Reset()

+ func (s *ShapeIndex) Shape(id int32) Shape

+ type ShapeIndexCell struct

+ func NewShapeIndexCell(numShapes int) *ShapeIndexCell

+ type ShapeIndexIterator struct

+ func NewShapeIndexIterator(index *ShapeIndex, pos ...ShapeIndexIteratorPos) *ShapeIndexIterator

+ func (s *ShapeIndexIterator) Begin()

+ func (s *ShapeIndexIterator) CellID() CellID

+ func (s *ShapeIndexIterator) Center() Point

+ func (s *ShapeIndexIterator) Done() bool

+ func (s *ShapeIndexIterator) End()

+ func (s *ShapeIndexIterator) IndexCell() *ShapeIndexCell

+ func (s *ShapeIndexIterator) LocateCellID(target CellID) CellRelation

+ func (s *ShapeIndexIterator) LocatePoint(p Point) bool

+ func (s *ShapeIndexIterator) Next()

+ func (s *ShapeIndexIterator) Prev() bool

+ type ShapeIndexIteratorPos int

+ const IteratorBegin

+ const IteratorEnd

+ type TermType int

+ const ANCESTOR

+ const COVERING

+ type VertexModel int

+ const VertexModelClosed

+ const VertexModelOpen

+ const VertexModelSemiOpen

+ type WedgeRel int

+ const WedgeEquals

+ const WedgeIsDisjoint

+ const WedgeIsProperlyContained

+ const WedgeProperlyContains

+ const WedgeProperlyOverlaps

+ func WedgeRelation(a0, ab1, a2, b0, b2 Point) WedgeRel

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