coords -> coordinate

Author: buck heroux

coordinates.go renamed to coordinate.go

@@ -5,20 +5,20 @@ import (
 	"math"
 )
 
-// Coords is a simple struct for hold WGS-84 Lat Lon coordinates in degrees
-type Coords struct {
+// Coordinate is a simple struct for hold WGS-84 Lat Lon coordinates in degrees
+type Coordinate struct {
 	Lat, Lon float64
 }
 
 // Equals checks if these coords are equal avoiding some float precision
-func (c Coords) Equals(that Coords) bool {
+func (c Coordinate) Equals(that Coordinate) bool {
 	eq := floatEquals(c.Lat, that.Lat)
 	eq = eq && floatEquals(c.Lon, that.Lon)
 	return eq
 }
 
 // ToPixel gets the Pixel of the coord at the zoom level
-func (c Coords) ToPixel(zoom int) Pixel {
+func (c Coordinate) ToPixel(zoom int) Pixel {
 	x := (c.Lon + 180) / 360.0
 	sinLat := math.Sin(c.Lat * math.Pi / 180.0)
 	y := 0.5 - math.Log((1+sinLat)/(1-sinLat))/(4*math.Pi)
@@ -31,13 +31,14 @@ func (c Coords) ToPixel(zoom int) Pixel {
 
 }
 
-func (c Coords) String() string {
+func (c Coordinate) String() string {
 	return fmt.Sprintf("(%v, %v)", c.Lat, c.Lon)
 }
 
 // ClippedCoords that have been clipped to Max/Min Lat/Lon
-func ClippedCoords(lat, lon float64) Coords {
-	return Coords{
+// This can be used as a constructor to assert bad values will be clipped
+func ClippedCoords(lat, lon float64) Coordinate {
+	return Coordinate{
 		Lat: clip(lat, MinLat, MaxLat),
 		Lon: clip(lon, MinLon, MaxLon),
 	}

coordinates_test.go renamed to coordinate_test.go

@@ -6,7 +6,7 @@ import (
 
 func TestToPixel(t *testing.T) {
 	pixelTests := []struct {
-		coords Coords
+		coords Coordinate
 		pixel  Pixel
 	}{
 		{ClippedCoords(40.0, -105.0), Pixel{6827, 12405, 7}},

index.go

@@ -32,13 +32,13 @@ func (idx *TileIndex) TileRange(zmin, zmax int) <-chan Tile {
 			n := idx.keys[i+1].qk
 			for z := zmin; z <= zmax && z <= len(q); z++ {
 				if !strings.HasPrefix(n, q[:z]) {
-					tiles <- TileFromQuadKey(q[:z])
+					tiles <- FromQuadKey(q[:z])
 				}
 			}
 		}
 		q := idx.keys[len(idx.keys)-1].qk
 		for z := zmin; z <= zmax && z <= len(q); z++ {
-			tiles <- TileFromQuadKey(q[:z])
+			tiles <- FromQuadKey(q[:z])
 		}
 	}()
 	return tiles

index_test.go

@@ -18,7 +18,7 @@ func TestTileIndexSimple(t *testing.T) {
 	}
 	idx := &TileIndex{}
 	for i, qk := range qks {
-		tile := TileFromQuadKey(qk)
+		tile := FromQuadKey(qk)
 		idx.Add(tile, i)
 	}
 	for tile := range idx.TileRange(1, 2) {
@@ -28,9 +28,9 @@ func TestTileIndexSimple(t *testing.T) {
 
 func TestTileIndex(t *testing.T) {
 	idx := &TileIndex{}
-	esb := CoordinateToTile(40.7484, -73.9857, 18)
-	sol := CoordinateToTile(40.6892, -74.0445, 18)
-	bbn := CoordinateToTile(51.5007, -0.1246, 18)
+	esb := FromCoordinate(40.7484, -73.9857, 18)
+	sol := FromCoordinate(40.6892, -74.0445, 18)
+	bbn := FromCoordinate(51.5007, -0.1246, 18)
 	idx.Add(esb, "EmpireStateBuilding")
 	idx.Add(sol, "StatueOfLiberty")
 	idx.Add(bbn, "BigBen")
@@ -51,9 +51,9 @@ func TestTileIndex(t *testing.T) {
 
 func ExampleTileIndex() {
 	idx := &TileIndex{}
-	esb := CoordinateToTile(40.7484, -73.9857, 18)
-	sol := CoordinateToTile(40.6892, -74.0445, 18)
-	bbn := CoordinateToTile(51.5007, -0.1246, 18)
+	esb := FromCoordinate(40.7484, -73.9857, 18)
+	sol := FromCoordinate(40.6892, -74.0445, 18)
+	bbn := FromCoordinate(51.5007, -0.1246, 18)
 	idx.Add(esb, "EmpireStateBuilding")
 	idx.Add(sol, "StatueOfLiberty")
 	idx.Add(bbn, "BigBen")

pixel.go

@@ -18,7 +18,7 @@ func (p Pixel) floatY() float64 {
 }
 
 // ToCoords converts to WGS84 coordaintes
-func (p Pixel) ToCoords() Coords {
+func (p Pixel) ToCoords() Coordinate {
 	size := float64(mapDimensions(p.Z))
 	x := (clip(p.floatX(), 0, size-1) / size) - 0.5
 	y := 0.5 - (clip(p.floatY(), 0, size-1) / size)
@@ -48,7 +48,7 @@ type TilePixel struct {
 	Tile *Tile
 }
 
-func (p TilePixel) toCoords() Coords {
+func (p TilePixel) toCoords() Coordinate {
 	panic("TilePixel.ToCoords() Not Implemented")
 	//return Coords{}
 }

pixel_test.go

@@ -7,9 +7,9 @@ import (
 func TestPixelToCoords(t *testing.T) {
 	coordTests := []struct {
 		pixel  Pixel
-		coords Coords
+		coords Coordinate
 	}{
-		{Pixel{6827, 12405, 7}, Coords{40.002372, -104.996338}},
+		{Pixel{6827, 12405, 7}, Coordinate{40.002372, -104.996338}},
 	}
 	errf := "Pixel%+v: %+v -> %+v"
 	for _, test := range coordTests {

tile.go

@@ -49,9 +49,9 @@ func (t Tile) QuadKey() string {
 	return qk.String()
 }
 
-// TileFromQuadKey returns a tile that represents the given quadkey
+// FromQuadKey returns a tile that represents the given quadkey
 // Panics on invalid keys
-func TileFromQuadKey(quadkey string) (tile Tile) {
+func FromQuadKey(quadkey string) (tile Tile) {
 	tile.Z = len(quadkey)
 	for i := tile.Z; i > 0; i-- {
 		mask := 1 << uint(i-1)
@@ -78,10 +78,11 @@ func TileFromQuadKey(quadkey string) (tile Tile) {
 	return
 }
 
-// CoordinateToTile take float lat/lons and a zoom and return a tile
-func CoordinateToTile(lat, lon float64, zoom int) Tile {
-	coord := ClippedCoords(lat, lon)
-	pixel := coord.ToPixel(zoom)
-	tile, _ := pixel.ToTile()
-	return tile
+// FromCoordinate take float lat/lons and a zoom and return a tile
+// Clips the coordinates if they are outside of Min/MaxLat/Lon
+func FromCoordinate(lat, lon float64, zoom int) Tile {
+	c := ClippedCoords(lat, lon)
+	p := c.ToPixel(zoom)
+	t, _ := p.ToTile()
+	return t
 }

tile_test.go

@@ -1,16 +1,18 @@
-package tiles
+package tiles_test
 
 import (
 	"fmt"
 	"testing"
+
+	"github.com/buckhx/tiles"
 )
 
 func TestTileToPixel(t *testing.T) {
 	tileTests := []struct {
-		tile  Tile
-		pixel Pixel
+		tile  tiles.Tile
+		pixel tiles.Pixel
 	}{
-		{Tile{26, 48, 7}, Pixel{6656, 12288, 7}},
+		{tiles.Tile{X: 26, Y: 48, Z: 7}, tiles.Pixel{X: 6656, Y: 12288, Z: 7}},
 		//{Tile{26, 48, 7}, Pixel{6827, 12405, 7}},
 	}
 	errf := "Tile%+v: %+v -> %+v"
@@ -24,10 +26,10 @@ func TestTileToPixel(t *testing.T) {
 
 func TestTileToQuadkey(t *testing.T) {
 	tileTests := []struct {
-		tile    Tile
+		tile    tiles.Tile
 		quadkey string
 	}{
-		{Tile{26, 48, 7}, "0231010"},
+		{tiles.Tile{X: 26, Y: 48, Z: 7}, "0231010"},
 	}
 	errf := "Tile%+v: %+v -> %+v"
 	for _, test := range tileTests {
@@ -41,22 +43,22 @@ func TestTileToQuadkey(t *testing.T) {
 func TestTileFromQuadkey(t *testing.T) {
 	tileTests := []struct {
 		quadkey string
-		tile    Tile
+		tile    tiles.Tile
 	}{
-		{"0231010", Tile{26, 48, 7}},
+		{"0231010", Tile{X: 26, Y: 48, Z: 7}},
 	}
 	errf := "QuadKey%+v: %+v -> %+v"
 	for _, test := range tileTests {
-		tile := TileFromQuadKey(test.quadkey)
+		tile := tiles.FromQuadKey(test.quadkey)
 		if tile != test.tile {
 			t.Errorf(errf, test.quadkey, test.tile, tile)
 		}
 	}
 }
 
-func ExampleCoordinateToTile() {
+func ExampleFromCoordinate() {
 	esbLat := 40.7484
 	esbLon := -73.9857
-	tile := CoordinateToTile(esbLat, esbLon, 18)
+	tile := tiles.FromCoordinate(esbLat, esbLon, 18)
 	fmt.Println(tile)
 }