Using J/Link to decode Google Maps Polyline strings

Question

I would like to use this java code inside Mathematica using J/Link. It converts Google Maps API Encoded Polylines to a list of points. I tried the Mathematica tutorial but got lost.

There is the Java code:

private List<GeoPoint> decodePoly(String encoded) {

List<GeoPoint> poly = new ArrayList<GeoPoint>();
int index = 0, len = encoded.length();
int lat = 0, lng = 0;

while (index < len) {
    int b, shift = 0, result = 0;
    do {
        b = encoded.charAt(index++) - 63;
        result |= (b & 0x1f) << shift;
        shift += 5;
    } while (b >= 0x20);
    int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
    lat += dlat;

    shift = 0;
    result = 0;
    do {
        b = encoded.charAt(index++) - 63;
        result |= (b & 0x1f) << shift;
        shift += 5;
    } while (b >= 0x20);
    int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
    lng += dlng;

    GeoPoint p = new GeoPoint((int) (((double) lat / 1E5) * 1E6),
         (int) (((double) lng / 1E5) * 1E6));


      poly.add(p);
    }

    return poly;
}

As example:

wjiGtdpcNrAlBJZ

should return

43.64175, -79.38651
43.64133, -79.38706
43.64127, -79.3872

I have no experience in Java. The code came from here.

Answer 1

Comment

I've placed a Notebook version of this post on my webspace here: http://facstaff.unca.edu/mcmcclur/polylineDecoder.zip

The Notebook is actually contained in a ZIP file that also contains all the Java class files necessary to get this code to work. The Notebook sets the Java class relative to it's own directory using AddToClassPath[NotebookDirectory[]], so everything should just run without difficulty.

Answer

Here's my preferred java polyline decoder: https://github.com/scoutant/polyline-decoder

The advantage of this version is that it is self-contained, while Jeffery's depends on a GeoPoint class defined in a rather large SDK.

After compiling the files in src/main/java/org/scoutant/polyline, you can use the decoder like so:

Needs["JLink`"];
InstallJava[];
AddToClassPath["scoutant-polyline-decoder-76406ba/src/main/java/"];
polylineDecoder = JavaNew["org.scoutant.polyline.PolylineDecoder"];
decoded = polylineDecoder@decode["wjiGtdpcNrAlBJZ"];
length = decoded@size[];
Table[
 point = decoded@get[k];
 {point@getLat[], point@getLng[]},
 {k, 0, length - 1}]

(* Out:
   {{1.3638, -79.3865}, {1.36338, -79.3871}, {1.36332, -79.3872}}
*)

While the latitudes all disagree with your expected result, it agrees with my javascript decoder: http://facstaff.unca.edu/mcmcclur/GoogleMaps/EncodePolyline/decode.html

It also agrees with Google's own polyline decoder utility: https://developers.google.com/maps/documentation/utilities/polylineutility

An example using imported directions

As a fun example, we could download some driving directions from Google Maps, extract the encoded polyline string, and display it on a CountryData map.

Needs["JLink`"];
InstallJava[];
AddToClassPath[NotebookDirectory[]];
polylineDecoder = JavaNew[
 "org.scoutant.polyline.PolylineDecoder"
];
jsonString = StringDrop[Import[
  "https://maps.google.com/maps?saddr=NY,+NY&daddr=LA,+CA&output=json"
], 9];
json = ImportString[jsonString, "JSON"];
polylines = "polylines" /. 
  Cases[json, HoldPattern["polylines" -> _], Infinity];
pointStrings = Table["points" /. polyline, {polyline, polylines}];
pointString = First[pointStrings];
pointString = StringReplace[pointString, "\\\\" -> "\\"];
decoded = polylineDecoder@decode[pointString];
length = decoded@size[];
pts = {#@getLng[], #@getLat[]} & /@ decoded@toArray[];
Show[{
  CountryData["UnitedStates", {"Shape", "Equirectangular"}],
  Graphics[{{Blue, Line[pts]},
   {PointSize[Large], Green, Point[First[pts]], Red, 
    Point[Last[pts]]}}]
}]

Answer 2

I recently implemented a native Mathematica decoder for the encoded Google polyline strings returned during a request to its API. This uses Compile and I found it faster than the above J/Link based solution. I guess it could have been even faster if we could compile the BitShiftLeft and BitShiftRight. But I guess these two functions are pretty optimized in Mathematica. My compiled version for these two functions were slower so decided to stick with the built-ins.

The decoder:

Clear[Com];
Com = Compile[ {{barray, _Integer, 1}},
   Module[ {index = 1, lat = 0, lang = 0, latlng = {{0., 0.}}, b, 
     shift, result, dlat, bRight},
    While[index <=  Length@barray,
     b = shift = result = 0;
     b = -63 + barray[[index++]];
     result = BitXor[result, BitShiftLeft[BitAnd[b, 31], shift]];
     shift += 5;
     While[b >= 32,
      b = -63 + barray[[index++]];
      result = BitXor[result, BitShiftLeft[BitAnd[b, 31], shift]];
      shift += 5;];
     bRight = BitShiftRight[result, 1];
     lat += If[BitAnd[result, 1] > 0, BitNot[bRight], bRight];
     shift = result = 0;
     b = -63 + barray[[index++]];
     result = BitXor[result, BitShiftLeft[BitAnd[b, 31], shift]];
     shift += 5;
     While[b >= 32,
      b = -63 + barray[[index++]];
      result = BitXor[result, BitShiftLeft[BitAnd[b, 31], shift]];
      shift += 5;];
     bRight = BitShiftRight[result, 1];
     lang += If[BitAnd[result, 1] > 0, BitNot[bRight], bRight];
     AppendTo[latlng, {lang*10.^-5, lat*10.^-5}];
     ]; latlng], RuntimeOptions -> "Speed", CompilationTarget -> "C", 
   RuntimeAttributes -> {Listable}
         , CompilationOptions -> {"ExpressionOptimization" -> True}
   ];
MathematicaDecode[encoded_?StringQ] := Block[{barray},
   barray = ToCharacterCode@encoded;
   (Rest@Com[barray])
   ];

Utility Function:

Lets take a route connecting several cities given as a list.

route2 = {"Vienna,Austria", "Erlangen,Germany","Nurnberg,Germany","Heilbronn,Germany",
"Heidelberg,Germany", "Mannheim,Germany","Ludwigshafen,Germany", "Berlin,Germany"};

Here is a function that takes routes like above as input and forms the API request URL and do a respective data fetch from Google. For free users the map API serves up to 11-13 way-points requests in one single call.

UrlData[route_?(VectorQ[#, StringQ] &)] /; (2 <=  Length@route < 11) :=
   Block[{WaypointSeperatorPosition, url, urlData, encoded},
   WaypointSeperatorPosition = 
    Transpose@{1 + Range[-2 + Length@route]};
   url = "http://maps.googleapis.com/maps/api/directions/json" <>
     "?origin=" <> First@route <>
     "&destination=" <> Last@route <>
     "&waypoints=" <> 
     StringJoin[Most@Insert[route[[2 ;; -2]], "|", WaypointSeperatorPosition]] <>
   "&sensor=false&mode=driving&units=metric";
   URLFetch[url]
   ];

Testing:

Now we can test our decoder to extract the longitude and latitude pairs of each points that constitute the Google polyline.

dat = UrlData[route2];
strings=(Flatten@(
ImportString[dat,{"JSON","Data","routes",1,"legs",All,"steps",All,"polyline","points"}]));
res = MathematicaDecode[#] & /@strings; // AbsoluteTiming

{2.685532, Null}

The J/Link version

res1 = With[{pointString = #}, 
      decoded = polylineDecoder@decode[pointString];
      pts = {#@getLng[], #@getLat[]} & /@ decoded@toArray[];
      pts] & /@ strings; // AbsoluteTiming

{9.156631, Null}

Both the results agree with each other.

Norm@(Chop@(Flatten[res1, 1] - Flatten[res, 1]))

0

Visualize:

Here goes the route from Vienna to Berlin. With all the points on the polygon one could compute the road curvature/bending at each subsequent stretches on the polyline.