send dist in KM

Author: mfbx9da4

bin/main

@@ -65,10 +65,12 @@ func main() {
 		isHighway := geojson.Features[i].Properties.Highway != ""
 		hasSidewalk := geojson.Features[i].Properties.Sidewalk == "" || geojson.Features[i].Properties.Sidewalk != "none"
 		isPath := geojson.Features[i].Properties.Highway == "path"
-		isValidPath := geojson.Features[i].Properties.Highway == "path" && (geojson.Features[i].Properties.Access == "no" || geojson.Features[i].Properties.Access == "private")
-		isNotPathOrIsValidPath := !isPath || isValidPath
+		isPathWithAccess := geojson.Features[i].Properties.Highway == "path" && (geojson.Features[i].Properties.Access == "no" || geojson.Features[i].Properties.Access == "private")
+		isNotPathOrIsValidPath := !isPath || isPathWithAccess
 		isLit := geojson.Features[i].Properties.Lit != "" || geojson.Features[i].Properties.Lit == "yes"
 		shouldInclude := isHighway && isLineString && hasSidewalk && isNotPathOrIsValidPath && isLit
+		// TODO: exclude footways for cycling
+		// isFootway := geojson.Features[i].Properties.Highway == "footway"
 		// shouldInclude := true
 		var feature = geojson.Features[i]
 		if shouldInclude && len(feature.Geometry.Coordinates) > 0 {

geojson-cleaner/geojson-cleaner.go

@@ -157,6 +157,13 @@ type Route struct {
 	Distance float64
 }
 
+// calcDistance between coords in coords unit
+func calcDistance(src, dest *Node) float64 {
+	dx := src[0] - dest[0]
+	dy := src[1] - dest[1]
+	return math.Sqrt(dx*dx + dy*dy)
+}
+
 /*
 FindPath Uses A* routing to find shortest path
 (Keeps a min heap sorted by elapsed + remaing distance).
@@ -188,14 +195,8 @@ func (graph *Graph) FindPath(src, dest Node) Route {
 		visited[node] = true
 
 		for child := range graph.edges[*node] {
-			// TODO: Calculate in km
-			// https://stackoverflow.com/a/1253545/1376627
-			dx := (node[0] - child[0])
-			dy := (node[1] - child[1])
-			remaingDx := (dest[0] - child[0])
-			remainingDy := (dest[1] - child[1])
-			elapsed := math.Sqrt(dx*dx+dy*dy) + cur.Distance
-			remaining := math.Sqrt(remaingDx*remaingDx + remainingDy*remainingDy)
+			elapsed := calcDistance(node, child) + cur.Distance
+			remaining := calcDistance(child, &dest)
 
 			if *child == dest {
 				path := append(cur.Path, *child)

graph.go

@@ -17,7 +17,7 @@ type Property struct {
 	Sidewalk string `json:"sidewalk"`
 }
 
-// Coordinate pair of lat, lng
+// Coordinate pair of lng, lat
 type Coordinate [2]float64
 
 // Geometry Geojson Geometry

parse-geojson.go

@@ -87,7 +87,7 @@ func TestPaths(t *testing.T) {
 			t.Errorf("Incorrect path. Got: %v Expected: %v -- %s", path, expected.ShortestPath, filenames[i])
 		}
 		if route.Distance != expected.Distance {
-			t.Errorf("Incorrect distance. Got: %f Want: %f -- %s", route.Distance, expected.Distance, filenames[i])
+			t.Errorf("Incorrect distance. Got: %.11f Want: %.11f -- %s", route.Distance, expected.Distance, filenames[i])
 		}
 	}
 

routing_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"log"
+	"math"
 	"net/http"
 	"os"
 
@@ -25,6 +26,53 @@ func getCoordinates(nodes []Node) []Coordinate {
 	return result
 }
 
+//:::    unit = the unit you desire for results                               :::
+//:::           where: 'M' is statute miles (default)                         :::
+//:::                  'K' is kilometers                                      :::
+//:::                  'N' is nautical miles                                  :::
+func distance(coord1 Coordinate, coord2 Coordinate, unit ...string) float64 {
+	lng1 := coord1[0]
+	lat1 := coord1[1]
+	lng2 := coord2[0]
+	lat2 := coord2[1]
+	const PI float64 = 3.141592653589793
+	radlat1 := float64(PI * lat1 / 180)
+	radlat2 := float64(PI * lat2 / 180)
+
+	theta := float64(lng1 - lng2)
+	radtheta := float64(PI * theta / 180)
+
+	dist := math.Sin(radlat1)*math.Sin(radlat2) + math.Cos(radlat1)*math.Cos(radlat2)*math.Cos(radtheta)
+
+	if dist > 1 {
+		dist = 1
+	}
+
+	dist = math.Acos(dist)
+	dist = dist * 180 / PI
+	dist = dist * 60 * 1.1515
+
+	if len(unit) > 0 {
+		if unit[0] == "K" {
+			dist = dist * 1.609344
+		} else if unit[0] == "N" {
+			dist = dist * 0.8684
+		}
+	}
+
+	return dist
+}
+
+func calcTotalDistance(coords []Coordinate) float64 {
+	sum := 0.0
+	for i := 0; i < len(coords); i++ {
+		if i > 0 {
+			sum += distance(coords[i-1], coords[i], "K")
+		}
+	}
+	return sum
+}
+
 func setJSONHeader(w *http.ResponseWriter) {
 	(*w).Header().Set("Content-Type", "application/json")
 }
@@ -50,6 +98,7 @@ func findpathHandler(w http.ResponseWriter, r *http.Request) {
 
 	route := graph.CalculatePath(newRequestBody.FromLocation, newRequestBody.ToLocation)
 	coords := getCoordinates(route.Path)
+	distance := calcTotalDistance(coords)
 
 	geometry := Geometry{Type: "LineString", Coordinates: coords}
 	featureOut := Feature{Type: "Feature", ID: "1234", Properties: Property{}, Geometry: geometry}
@@ -62,9 +111,7 @@ func findpathHandler(w http.ResponseWriter, r *http.Request) {
 		Features: features,
 	}
 
-	response := FindPathResponse{
-		Data:     data,
-		Distance: route.Distance}
+	response := FindPathResponse{data, distance}
 
 	geojsonDataInJSON, _ := json.Marshal(&response)