# How to find total distance covered when I have a list of GeoPositions?

So I have a list of GeoPositions and I need to find the distance covered in that order? I know I can find the distance from each city and then add them all up but I was wondering if there is any easier way to do it?

GeoGraphics[{Red, GeoPath[{GeoPosition[{18.96, 72.82}],
GeoPosition[{18.98, 73.27}], GeoPosition[{17.92, 73.67}],
GeoPosition[{15.42, 73.78}], GeoPosition[{15.33, 76.46}],
GeoPosition[{13.21, 75.99}], GeoPosition[{12.3, 76.6}],
GeoPosition[{11.411746, 76.69466}],
GeoPosition[{11.58, 75.59}], GeoPosition[{12.88, 74.84}],
GeoPosition[{12.97, 77.56}], GeoPosition[{13.63, 79.41}],
GeoPosition[{13.09, 80.27}], GeoPosition[{12.62, 80.1994}],
GeoPosition[{9.92, 78.12}], GeoPosition[{10.23, 77.48}],
GeoPosition[{10.08, 77.0597}], GeoPosition[{9.61, 77.15}],
GeoPosition[{8.51, 76.95}], GeoPosition[{8.078, 77.541}],
GeoPosition[{17.400000000000002, 78.48}],
GeoPosition[{19.89, 75.32000000000001}],
GeoPosition[{24.580000000000002, 73.69}],
GeoPosition[{24.6, 72.7}], GeoPosition[{26.92, 70.9}],
GeoPosition[{26.92, 75.8}], GeoPosition[{27.1, 77.67}],
GeoPosition[{27.19, 78.01}], GeoPosition[{28.6, 77.22}],
GeoPosition[{29.98, 78.16}], GeoPosition[{30.34, 78.05}],
GeoPosition[{30.73, 79.07000000000001}],
GeoPosition[{29.400000000000002, 79.12}],
GeoPosition[{29.38, 79.45}], GeoPosition[{31.1033, 77.1722}],
GeoPosition[{32.27, 77.17}], GeoPosition[{34.17, 77.58}],
GeoPosition[{32.71, 74.85000000000001}],
GeoPosition[{31.64, 74.87}], GeoPosition[{26.85, 80.92}],
GeoPosition[{24.85, 79.93}], GeoPosition[{23.17, 79.94}],
GeoPosition[{25.32, 83.01}], GeoPosition[{24.71, 84.98}],
GeoPosition[{22.57, 88.36}], GeoPosition[{25.57, 91.87}],
GeoPosition[{26.35, 92.67}], GeoPosition[{27.34, 88.61}],
GeoPosition[{27.05, 88.26}], GeoPosition[{17.73, 83.3}]}, "Rhumb"]}]


That is the code for how I graphed it.

Also, I used the FindShortestTour function to find the shortest route and I found it. Now I want to find the total distance covered using that route.

    locs = {GeoPosition[{18.96, 72.82}], GeoPosition[{12.97, 77.56}], GeoPosition[{27.19, 78.01}],
GeoPosition[{19.89, 75.32000000000001}],
GeoPosition[{24.85, 79.93}],
GeoPosition[{32.71, 74.85000000000001}],
GeoPosition[{15.42, 73.78}], GeoPosition[{26.92, 75.8}],
GeoPosition[{24.580000000000002, 73.69}],
GeoPosition[{26.92, 70.9}], GeoPosition[{34.17, 77.58}],
GeoPosition[{32.27, 77.17}], GeoPosition[{31.1033, 77.1722}],
GeoPosition[{27.34, 88.61}], GeoPosition[{27.05, 88.26}],
GeoPosition[{8.078, 77.541}], GeoPosition[{29.98, 78.16}],
GeoPosition[{29.38, 79.45}], GeoPosition[{28.6, 77.22}],
GeoPosition[{30.34, 78.05}], GeoPosition[{31.64, 74.87}],
GeoPosition[{27.1, 77.67}],
GeoPosition[{17.400000000000002, 78.48}],
GeoPosition[{12.88, 74.84}], GeoPosition[{25.57, 91.87}],
GeoPosition[{17.73, 83.3}],
GeoPosition[{30.73, 79.07000000000001}],
GeoPosition[{13.63, 79.41}], GeoPosition[{10.23, 77.48}],
GeoPosition[{22.57, 88.36}], GeoPosition[{18.98, 73.27}],
GeoPosition[{25.32, 83.01}], GeoPosition[{17.92, 73.67}],
GeoPosition[{24.71, 84.98}], GeoPosition[{26.85, 80.92}],
GeoPosition[{9.92, 78.12}], GeoPosition[{23.17, 79.94}],
GeoPosition[{24.6, 72.7}],
GeoPosition[{29.400000000000002, 79.12}],
GeoPosition[{11.411746, 76.69466}], GeoPosition[{8.51, 76.95}],
GeoPosition[{13.09, 80.27}], GeoPosition[{12.3, 76.6}],
GeoPosition[{13.21, 75.99}], GeoPosition[{9.61, 77.15}],
GeoPosition[{10.08, 77.0597}], GeoPosition[{15.33, 76.46}],
GeoPosition[{12.62, 80.1994}], GeoPosition[{26.35, 92.67}],
GeoPosition[{11.58, 75.59}]}

(* locs are used in FindShortestTour function *)
tour = FindShortestTour[locs][[2]]

{1, 33, 7, 24, 50, 40, 29, 46, 45, 41, 16, 36, 48, 42, 28, 2, 43, 44, \
47, 23, 26, 30, 25, 49, 14, 15, 34, 32, 37, 5, 35, 18, 39, 27, 12, \
11, 6, 21, 13, 20, 17, 19, 3, 22, 8, 10, 38, 9, 4, 31, 1}


And then I graphed it:

GeoGraphics[GeoPath[locs[[tour]]], GeoRange -> Automatic]


Pretty much, I want to compare the two distances and see which one is the better route.

I don't know any direct way to do what you wantand I agree that it would be an improvement if in a future release GeoDistance will supports a GeoPath as argument.

But even now it's not so difficult to compute the distance along a path with with a not-so-"brute" way and this definition:

geoPathDistance[locations:{__GeoPosition}] :=
Total[GeoDistance @@@ Partition[locations, 2, 1]]


For example for the original localtions list

geoPathDistance @ locs


Quantity[49069.6, "Kilometers"]

Or for the shortest tour (as @MichaelE2 shown it's enoug to permute the list of locations according to the permutation returned by FindShortestTour):

geoPathDistance @ locs[[tour]]


Quantity[11102.5, "Kilometers"]

• How do I find it for the path that was found using FindShortestTour ? @unlikely – Sarah Apr 29 '15 at 21:21

Another way:

Module[{dist = 0},
Fold[
(dist += GeoDistance[##]; #2) &,
locs[[tour]]];
dist]
(*  Quantity[6898.75, "Miles"]  *)


If locs is the other path to compare with:

Module[{dist = 0},
Fold[
(dist += GeoDistance[##]; #2) &,
locs];
dist]
(*  Quantity[30490.5, "Miles"]  *)