vendor/assets/leaflet/leaflet.polyline.js

   1 /*
   2  * L.PolylineUtil contains utilify functions for polylines, two methods
   3  * are added to the L.Polyline object to support creation of polylines
   4  * from an encoded string and converting existing polylines to an
   5  * encoded string.
   6  *
   7  *  - L.Polyline.fromEncoded(encoded [, options]) returns a L.Polyline
   8  *  - L.Polyline.encodePath() returns a string
   9  *
  10  * Actual code from:
  11  * http://facstaff.unca.edu/mcmcclur/GoogleMaps/EncodePolyline/\
  12  */
  13
  14 /*jshint browser:true, debug: true, strict:false, globalstrict:false, indent:4, white:true, smarttabs:true*/
  15 /*global L:true, console:true*/
  16
  17
  18 // Inject functionality into Leaflet
  19 (function (L) {
  20         if (!(L.Polyline.prototype.fromEncoded)) {
  21                 L.Polyline.fromEncoded = function (encoded, options) {
  22                         return new L.Polyline(L.PolylineUtil.decode(encoded), options);
  23                 };
  24         }
  25         if (!(L.Polygon.prototype.fromEncoded)) {
  26                 L.Polygon.fromEncoded = function (encoded, options) {
  27                         return new L.Polygon(L.PolylineUtil.decode(encoded), options);
  28                 };
  29         }
  30
  31         var encodeMixin = {
  32                 encodePath: function () {
  33                         return L.PolylineUtil.encode(this.getLatLngs());
  34                 }
  35         };
  36
  37         if (!L.Polyline.prototype.encodePath) {
  38                 L.Polyline.include(encodeMixin);
  39         }
  40         if (!L.Polygon.prototype.encodePath) {
  41                 L.Polygon.include(encodeMixin);
  42         }
  43 })(L);
  44
  45 // Utility functions.
  46 L.PolylineUtil = {};
  47
  48 L.PolylineUtil.encode = function (latlngs) {
  49         var i, dlat, dlng;
  50         var plat = 0;
  51         var plng = 0;
  52         var encoded_points = "";
  53
  54         for (i = 0; i < latlngs.length; i++) {
  55                 var lat = latlngs[i].lat;
  56                 var lng = latlngs[i].lng;
  57                 var late5 = Math.floor(lat * 1e5);
  58                 var lnge5 = Math.floor(lng * 1e5);
  59                 dlat = late5 - plat;
  60                 dlng = lnge5 - plng;
  61                 plat = late5;
  62                 plng = lnge5;
  63                 encoded_points +=
  64                         L.PolylineUtil.encodeSignedNumber(dlat) +
  65                         L.PolylineUtil.encodeSignedNumber(dlng);
  66         }
  67         return encoded_points;
  68 };
  69
  70 // This function is very similar to Google's, but I added
  71 // some stuff to deal with the double slash issue.
  72 L.PolylineUtil.encodeNumber = function (num) {
  73         var encodeString = "";
  74         var nextValue, finalValue;
  75         while (num >= 0x20) {
  76                 nextValue = (0x20 | (num & 0x1f)) + 63;
  77                 encodeString += (String.fromCharCode(nextValue));
  78                 num >>= 5;
  79         }
  80         finalValue = num + 63;
  81         encodeString += (String.fromCharCode(finalValue));
  82         return encodeString;
  83 };
  84
  85 // This one is Google's verbatim.
  86 L.PolylineUtil.encodeSignedNumber = function (num) {
  87         var sgn_num = num << 1;
  88         if (num < 0) {
  89                 sgn_num = ~(sgn_num);
  90         }
  91         return (L.PolylineUtil.encodeNumber(sgn_num));
  92 };
  93
  94 L.PolylineUtil.decode = function (encoded) {
  95         var len = encoded.length;
  96         var index = 0;
  97         var latlngs = [];
  98         var lat = 0;
  99         var lng = 0;
 100
 101         while (index < len) {
 102                 var b;
 103                 var shift = 0;
 104                 var result = 0;
 105                 do {
 106                         b = encoded.charCodeAt(index++) - 63;
 107                         result |= (b & 0x1f) << shift;
 108                         shift += 5;
 109                 } while (b >= 0x20);
 110                 var dlat = ((result & 1) ? ~(result >> 1) : (result >> 1));
 111                 lat += dlat;
 112
 113                 shift = 0;
 114                 result = 0;
 115                 do {
 116                         b = encoded.charCodeAt(index++) - 63;
 117                         result |= (b & 0x1f) << shift;
 118                         shift += 5;
 119                 } while (b >= 0x20);
 120                 var dlng = ((result & 1) ? ~(result >> 1) : (result >> 1));
 121                 lng += dlng;
 122
 123                 latlngs.push(new L.LatLng(lat * 1e-5, lng * 1e-5));
 124         }
 125
 126         return latlngs;
 127 };