fix pointer error on region interface

Author: Philiphil

s2/cellunion.go

@@ -295,25 +295,25 @@ func (cu *CellUnion) Denormalize(minLevel, levelMod int) {
 }
 
 // RectBound returns a Rect that bounds this entity.
-func (cu *CellUnion) RectBound() Rect {
+func (cu CellUnion) RectBound() Rect {
 	bound := EmptyRect()
-	for _, c := range *cu {
+	for _, c := range cu {
 		bound = bound.Union(CellFromCellID(c).RectBound())
 	}
 	return bound
 }
 
 // CapBound returns a Cap that bounds this entity.
-func (cu *CellUnion) CapBound() Cap {
-	if len(*cu) == 0 {
+func (cu CellUnion) CapBound() Cap {
+	if len(cu) == 0 {
 		return EmptyCap()
 	}
 
 	// Compute the approximate centroid of the region. This won't produce the
 	// bounding cap of minimal area, but it should be close enough.
 	var centroid Point
 
-	for _, ci := range *cu {
+	for _, ci := range cu {
 		area := AvgAreaMetric.Value(ci.Level())
 		centroid = Point{centroid.Add(ci.Point().Mul(area))}
 	}
@@ -329,30 +329,30 @@ func (cu *CellUnion) CapBound() Cap {
 	// *not* sufficient to just bound all the cell vertices because the bounding
 	// cap may be concave (i.e. cover more than one hemisphere).
 	c := CapFromPoint(centroid)
-	for _, ci := range *cu {
+	for _, ci := range cu {
 		c = c.AddCap(CellFromCellID(ci).CapBound())
 	}
 
 	return c
 }
 
 // ContainsCell reports whether this cell union contains the given cell.
-func (cu *CellUnion) ContainsCell(c Cell) bool {
+func (cu CellUnion) ContainsCell(c Cell) bool {
 	return cu.ContainsCellID(c.id)
 }
 
 // IntersectsCell reports whether this cell union intersects the given cell.
-func (cu *CellUnion) IntersectsCell(c Cell) bool {
+func (cu CellUnion) IntersectsCell(c Cell) bool {
 	return cu.IntersectsCellID(c.id)
 }
 
 // ContainsPoint reports whether this cell union contains the given point.
-func (cu *CellUnion) ContainsPoint(p Point) bool {
+func (cu CellUnion) ContainsPoint(p Point) bool {
 	return cu.ContainsCell(CellFromPoint(p))
 }
 
 // CellUnionBound computes a covering of the CellUnion.
-func (cu *CellUnion) CellUnionBound() []CellID {
+func (cu CellUnion) CellUnionBound() []CellID {
 	return cu.CapBound().CellUnionBound()
 }
 

s2/convex_hull_query.go

@@ -105,7 +105,7 @@ func (q *ConvexHullQuery) AddPolygon(p *Polygon) {
 //
 // Note that this method does not clear the geometry; you can continue
 // adding to it and call this method again if desired.
-func (q *ConvexHullQuery) CapBound() Cap {
+func (q ConvexHullQuery) CapBound() Cap {
 	// We keep track of a rectangular bound rather than a spherical cap because
 	// it is easy to compute a tight bound for a union of rectangles, whereas it
 	// is quite difficult to compute a tight bound around a union of caps.

s2/loop.go

@@ -542,14 +542,14 @@ func (l *Loop) Vertices() []Point {
 
 // RectBound returns a tight bounding rectangle. If the loop contains the point,
 // the bound also contains it.
-func (l *Loop) RectBound() Rect {
+func (l Loop) RectBound() Rect {
 	return l.bound
 }
 
 // CapBound returns a bounding cap that may have more padding than the corresponding
 // RectBound. The bound is conservative such that if the loop contains a point P,
 // the bound also contains it.
-func (l *Loop) CapBound() Cap {
+func (l Loop) CapBound() Cap {
 	return l.bound.CapBound()
 }
 
@@ -596,7 +596,7 @@ func (l *Loop) bruteForceContainsPoint(p Point) bool {
 }
 
 // ContainsPoint returns true if the loop contains the point.
-func (l *Loop) ContainsPoint(p Point) bool {
+func (l Loop) ContainsPoint(p Point) bool {
 	if !l.index.IsFresh() && !l.bound.ContainsPoint(p) {
 		return false
 	}
@@ -627,7 +627,7 @@ func (l *Loop) ContainsPoint(p Point) bool {
 }
 
 // ContainsCell reports whether the given Cell is contained by this Loop.
-func (l *Loop) ContainsCell(target Cell) bool {
+func (l Loop) ContainsCell(target Cell) bool {
 	it := l.index.Iterator()
 	relation := it.LocateCellID(target.ID())
 
@@ -651,7 +651,7 @@ func (l *Loop) ContainsCell(target Cell) bool {
 }
 
 // IntersectsCell reports whether this Loop intersects the given cell.
-func (l *Loop) IntersectsCell(target Cell) bool {
+func (l Loop) IntersectsCell(target Cell) bool {
 	it := l.index.Iterator()
 	relation := it.LocateCellID(target.ID())
 
@@ -679,7 +679,7 @@ func (l *Loop) IntersectsCell(target Cell) bool {
 }
 
 // CellUnionBound computes a covering of the Loop.
-func (l *Loop) CellUnionBound() []CellID {
+func (l Loop) CellUnionBound() []CellID {
 	return l.CapBound().CellUnionBound()
 }
 

s2/polygon.go

@@ -38,16 +38,16 @@ import (
 //
 // Polygons have the following restrictions:
 //
-//  - Loops may not cross, i.e. the boundary of a loop may not intersect
-//    both the interior and exterior of any other loop.
+//   - Loops may not cross, i.e. the boundary of a loop may not intersect
+//     both the interior and exterior of any other loop.
 //
-//  - Loops may not share edges, i.e. if a loop contains an edge AB, then
-//    no other loop may contain AB or BA.
+//   - Loops may not share edges, i.e. if a loop contains an edge AB, then
+//     no other loop may contain AB or BA.
 //
-//  - Loops may share vertices, however no vertex may appear twice in a
-//    single loop (see Loop).
+//   - Loops may share vertices, however no vertex may appear twice in a
+//     single loop (see Loop).
 //
-//  - No loop may be empty. The full loop may appear only in the full polygon.
+//   - No loop may be empty. The full loop may appear only in the full polygon.
 type Polygon struct {
 	loops []*Loop
 
@@ -581,13 +581,13 @@ func (p *Polygon) LastDescendant(k int) int {
 }
 
 // CapBound returns a bounding spherical cap.
-func (p *Polygon) CapBound() Cap { return p.bound.CapBound() }
+func (p Polygon) CapBound() Cap { return p.bound.CapBound() }
 
 // RectBound returns a bounding latitude-longitude rectangle.
-func (p *Polygon) RectBound() Rect { return p.bound }
+func (p Polygon) RectBound() Rect { return p.bound }
 
 // ContainsPoint reports whether the polygon contains the point.
-func (p *Polygon) ContainsPoint(point Point) bool {
+func (p Polygon) ContainsPoint(point Point) bool {
 	// NOTE: A bounds check slows down this function by about 50%. It is
 	// worthwhile only when it might allow us to delay building the index.
 	if !p.index.IsFresh() && !p.bound.ContainsPoint(point) {
@@ -611,7 +611,7 @@ func (p *Polygon) ContainsPoint(point Point) bool {
 }
 
 // ContainsCell reports whether the polygon contains the given cell.
-func (p *Polygon) ContainsCell(cell Cell) bool {
+func (p Polygon) ContainsCell(cell Cell) bool {
 	it := p.index.Iterator()
 	relation := it.LocateCellID(cell.ID())
 
@@ -635,7 +635,7 @@ func (p *Polygon) ContainsCell(cell Cell) bool {
 }
 
 // IntersectsCell reports whether the polygon intersects the given cell.
-func (p *Polygon) IntersectsCell(cell Cell) bool {
+func (p Polygon) IntersectsCell(cell Cell) bool {
 	it := p.index.Iterator()
 	relation := it.LocateCellID(cell.ID())
 
@@ -663,7 +663,7 @@ func (p *Polygon) IntersectsCell(cell Cell) bool {
 }
 
 // CellUnionBound computes a covering of the Polygon.
-func (p *Polygon) CellUnionBound() []CellID {
+func (p Polygon) CellUnionBound() []CellID {
 	// TODO(roberts): Use ShapeIndexRegion when it's available.
 	return p.CapBound().CellUnionBound()
 }

s2/polyline.go

@@ -107,7 +107,7 @@ func (p *Polyline) approxEqual(o *Polyline, maxError s1.Angle) bool {
 }
 
 // CapBound returns the bounding Cap for this Polyline.
-func (p *Polyline) CapBound() Cap {
+func (p Polyline) CapBound() Cap {
 	return p.RectBound().CapBound()
 }
 
@@ -318,19 +318,19 @@ func findEndVertex(p Polyline, tolerance s1.Angle, index int) int {
 //
 // Some useful properties of the algorithm:
 //
-//  - It runs in linear time.
+//   - It runs in linear time.
 //
-//  - The output always represents a valid polyline. In particular, adjacent
-//    output vertices are never identical or antipodal.
+//   - The output always represents a valid polyline. In particular, adjacent
+//     output vertices are never identical or antipodal.
 //
-//  - The method is not optimal, but it tends to produce 2-3% fewer
-//    vertices than the Douglas-Peucker algorithm with the same tolerance.
+//   - The method is not optimal, but it tends to produce 2-3% fewer
+//     vertices than the Douglas-Peucker algorithm with the same tolerance.
 //
-//  - The output is parametrically equivalent to the original polyline to
-//    within the given tolerance. For example, if a polyline backtracks on
-//    itself and then proceeds onwards, the backtracking will be preserved
-//    (to within the given tolerance). This is different than the
-//    Douglas-Peucker algorithm which only guarantees geometric equivalence.
+//   - The output is parametrically equivalent to the original polyline to
+//     within the given tolerance. For example, if a polyline backtracks on
+//     itself and then proceeds onwards, the backtracking will be preserved
+//     (to within the given tolerance). This is different than the
+//     Douglas-Peucker algorithm which only guarantees geometric equivalence.
 func (p *Polyline) SubsampleVertices(tolerance s1.Angle) []int {
 	var result []int