leaflet.geometryutil.js

  1. // Packaging/modules magic dance.
  2. (function (factory) {
  3.     var L;
  4.     if (typeof define === 'function' && define.amd) {
  5.         // AMD
  6.         define(['leaflet'], factory);
  7.     } else if (typeof module !== 'undefined') {
  8.         // Node/CommonJS
  9.         L = require('leaflet');
  10.         module.exports = factory(L);
  11.     } else {
  12.         // Browser globals
  13.         if (typeof window.L === 'undefined')
  14.             throw 'Leaflet must be loaded first';
  15.         factory(window.L);
  16.     }
  17. }(function (L) {
  18. "use strict";
  20. L.Polyline._flat = L.LineUtil.isFlat || L.Polyline._flat || function (latlngs) {
  21.     // true if it's a flat array of latlngs; false if nested
  22.     return !L.Util.isArray(latlngs[0]) || (typeof latlngs[0][0] !== 'object' && typeof latlngs[0][0] !== 'undefined');
  23. };
  25. /**
  26.  * @fileOverview Leaflet Geometry utilities for distances and linear referencing.
  27.  * @name L.GeometryUtil
  28.  */
  30. L.GeometryUtil = L.extend(L.GeometryUtil || {}, {
  32.     /**
  33.         Shortcut function for planar distance between two {L.LatLng} at current zoom.
  35.         @tutorial distance-length
  37.         @param {L.Map} map Leaflet map to be used for this method
  38.         @param {L.LatLng} latlngA geographical point A
  39.         @param {L.LatLng} latlngB geographical point B
  40.         @returns {Number} planar distance
  41.      */
  42.     distance: function (map, latlngA, latlngB) {
  43.         return map.latLngToLayerPoint(latlngA).distanceTo(map.latLngToLayerPoint(latlngB));
  44.     },
  46.     /**
  47.         Shortcut function for planar distance between a {L.LatLng} and a segment (A-B).
  48.         @param {L.Map} map Leaflet map to be used for this method
  49.         @param {L.LatLng} latlng - The position to search
  50.         @param {L.LatLng} latlngA geographical point A of the segment
  51.         @param {L.LatLng} latlngB geographical point B of the segment
  52.         @returns {Number} planar distance
  53.     */
  54.     distanceSegment: function (map, latlng, latlngA, latlngB) {
  55.         var p = map.latLngToLayerPoint(latlng),
  56.            p1 = map.latLngToLayerPoint(latlngA),
  57.            p2 = map.latLngToLayerPoint(latlngB);
  58.         return L.LineUtil.pointToSegmentDistance(p, p1, p2);
  59.     },
  61.     /**
  62.         Shortcut function for converting distance to readable distance.
  63.         @param {Number} distance distance to be converted
  64.         @param {String} unit 'metric' or 'imperial'
  65.         @returns {String} in yard or miles
  66.     */
  67.     readableDistance: function (distance, unit) {
  68.         var isMetric = (unit !== 'imperial'),
  69.             distanceStr;
  70.         if (isMetric) {
  71.             // show metres when distance is < 1km, then show km
  72.             if (distance > 1000) {
  73.                 distanceStr = (distance  / 1000).toFixed(2) + ' km';
  74.             }
  75.             else {
  76.                 distanceStr = Math.ceil(distance) + ' m';
  77.             }
  78.         }
  79.         else {
  80.             distance *= 1.09361;
  81.             if (distance > 1760) {
  82.                 distanceStr = (distance / 1760).toFixed(2) + ' miles';
  83.             }
  84.             else {
  85.                 distanceStr = Math.ceil(distance) + ' yd';
  86.             }
  87.         }
  88.         return distanceStr;
  89.     },
  91.     /**
  92.         Returns true if the latlng belongs to segment A-B
  93.         @param {L.LatLng} latlng - The position to search
  94.         @param {L.LatLng} latlngA geographical point A of the segment
  95.         @param {L.LatLng} latlngB geographical point B of the segment
  96.         @param {?Number} [tolerance=0.2] tolerance to accept if latlng belongs really
  97.         @returns {boolean}
  98.      */
  99.     belongsSegment: function(latlng, latlngA, latlngB, tolerance) {
  100.         tolerance = tolerance === undefined ? 0.2 : tolerance;
  101.         var hypotenuse = latlngA.distanceTo(latlngB),
  102.             delta = latlngA.distanceTo(latlng) + latlng.distanceTo(latlngB) - hypotenuse;
  103.         return delta/hypotenuse < tolerance;
  104.     },
  106.     /**
  107.      * Returns total length of line
  108.      * @tutorial distance-length
  109.      *
  110.      * @param {L.Polyline|Array<L.Point>|Array<L.LatLng>} coords Set of coordinates
  111.      * @returns {Number} Total length (pixels for Point, meters for LatLng)
  112.      */
  113.     length: function (coords) {
  114.         var accumulated = L.GeometryUtil.accumulatedLengths(coords);
  115.         return accumulated.length > 0 ? accumulated[accumulated.length-1] : 0;
  116.     },
  118.     /**
  119.      * Returns a list of accumulated length along a line.
  120.      * @param {L.Polyline|Array<L.Point>|Array<L.LatLng>} coords Set of coordinates
  121.      * @returns {Array<Number>} Array of accumulated lengths (pixels for Point, meters for LatLng)
  122.      */
  123.     accumulatedLengths: function (coords) {
  124.         if (typeof coords.getLatLngs == 'function') {
  125.             coords = coords.getLatLngs();
  126.         }
  127.         if (coords.length === 0)
  128.             return [];
  129.         var total = 0,
  130.             lengths = [0];
  131.         for (var i = 0, n = coords.length - 1; i< n; i++) {
  132.             total += coords[i].distanceTo(coords[i+1]);
  133.             lengths.push(total);
  134.         }
  135.         return lengths;
  136.     },
  138.     /**
  139.         Returns the closest point of a {L.LatLng} on the segment (A-B)
  141.         @tutorial closest
  143.         @param {L.Map} map Leaflet map to be used for this method
  144.         @param {L.LatLng} latlng - The position to search
  145.         @param {L.LatLng} latlngA geographical point A of the segment
  146.         @param {L.LatLng} latlngB geographical point B of the segment
  147.         @returns {L.LatLng} Closest geographical point
  148.     */
  149.     closestOnSegment: function (map, latlng, latlngA, latlngB) {
  150.         var maxzoom = map.getMaxZoom();
  151.         if (maxzoom === Infinity)
  152.             maxzoom = map.getZoom();
  153.         var p = map.project(latlng, maxzoom),
  154.            p1 = map.project(latlngA, maxzoom),
  155.            p2 = map.project(latlngB, maxzoom),
  156.            closest = L.LineUtil.closestPointOnSegment(p, p1, p2);
  157.         return map.unproject(closest, maxzoom);
  158.     },
  160.     /**
  161.         Returns the closest latlng on layer.
  163.         Accept nested arrays
  165.         @tutorial closest
  167.         @param {L.Map} map Leaflet map to be used for this method
  168.         @param {Array<L.LatLng>|Array<Array<L.LatLng>>|L.PolyLine|L.Polygon} layer - Layer that contains the result
  169.         @param {L.LatLng} latlng - The position to search
  170.         @param {?boolean} [vertices=false] - Whether to restrict to path vertices.
  171.         @returns {L.LatLng} Closest geographical point or null if layer param is incorrect
  172.     */
  173.     closest: function (map, layer, latlng, vertices) {
  175.         var latlngs,
  176.             mindist = Infinity,
  177.             result = null,
  178.             i, n, distance, subResult;
  180.         if (layer instanceof Array) {
  181.             // if layer is Array<Array<T>>
  182.             if (layer[0] instanceof Array && typeof layer[0][0] !== 'number') {
  183.                 // if we have nested arrays, we calc the closest for each array
  184.                 // recursive
  185.                 for (i = 0; i < layer.length; i++) {
  186.                     subResult = L.GeometryUtil.closest(map, layer[i], latlng, vertices);
  187.                     if (subResult && subResult.distance < mindist) {
  188.                         mindist = subResult.distance;
  189.                         result = subResult;
  190.                     }
  191.                 }
  192.                 return result;
  193.             } else if (layer[0] instanceof L.LatLng
  194.                         || typeof layer[0][0] === 'number'
  195.                         || typeof layer[0].lat === 'number') { // we could have a latlng as [x,y] with x & y numbers or {lat, lng}
  196.                 layer = L.polyline(layer);
  197.             } else {
  198.                 return result;
  199.             }
  200.         }
  202.         // if we don't have here a Polyline, that means layer is incorrect
  203.         // see https://github.com/makinacorpus/Leaflet.GeometryUtil/issues/23
  204.         if (! ( layer instanceof L.Polyline ) )
  205.             return result;
  207.         // deep copy of latlngs
  208.         latlngs = JSON.parse(JSON.stringify(layer.getLatLngs().slice(0)));
  210.         // add the last segment for L.Polygon
  211.         if (layer instanceof L.Polygon) {
  212.             // add the last segment for each child that is a nested array
  213.             var addLastSegment = function(latlngs) {
  214.                 if (L.Polyline._flat(latlngs)) {
  215.                     latlngs.push(latlngs[0]);
  216.                 } else {
  217.                     for (var i = 0; i < latlngs.length; i++) {
  218.                         addLastSegment(latlngs[i]);
  219.                     }
  220.                 }
  221.             };
  222.             addLastSegment(latlngs);
  223.         }
  225.         // we have a multi polygon / multi polyline / polygon with holes
  226.         // use recursive to explore and return the good result
  227.         if ( ! L.Polyline._flat(latlngs) ) {
  228.             for (i = 0; i < latlngs.length; i++) {
  229.                 // if we are at the lower level, and if we have a L.Polygon, we add the last segment
  230.                 subResult = L.GeometryUtil.closest(map, latlngs[i], latlng, vertices);
  231.                 if (subResult.distance < mindist) {
  232.                     mindist = subResult.distance;
  233.                     result = subResult;
  234.                 }
  235.             }
  236.             return result;
  238.         } else {
  240.             // Lookup vertices
  241.             if (vertices) {
  242.                 for(i = 0, n = latlngs.length; i < n; i++) {
  243.                     var ll = latlngs[i];
  244.                     distance = L.GeometryUtil.distance(map, latlng, ll);
  245.                     if (distance < mindist) {
  246.                         mindist = distance;
  247.                         result = ll;
  248.                         result.distance = distance;
  249.                     }
  250.                 }
  251.                 return result;
  252.             }
  254.             // Keep the closest point of all segments
  255.             for (i = 0, n = latlngs.length; i < n-1; i++) {
  256.                 var latlngA = latlngs[i],
  257.                     latlngB = latlngs[i+1];
  258.                 distance = L.GeometryUtil.distanceSegment(map, latlng, latlngA, latlngB);
  259.                 if (distance <= mindist) {
  260.                     mindist = distance;
  261.                     result = L.GeometryUtil.closestOnSegment(map, latlng, latlngA, latlngB);
  262.                     result.distance = distance;
  263.                 }
  264.             }
  265.             return result;
  266.         }
  268.     },
  270.     /**
  271.         Returns the closest layer to latlng among a list of layers.
  273.         @tutorial closest
  275.         @param {L.Map} map Leaflet map to be used for this method
  276.         @param {Array<L.ILayer>} layers Set of layers
  277.         @param {L.LatLng} latlng - The position to search
  278.         @returns {object} ``{layer, latlng, distance}`` or ``null`` if list is empty;
  279.     */
  280.     closestLayer: function (map, layers, latlng) {
  281.         var mindist = Infinity,
  282.             result = null,
  283.             ll = null,
  284.             distance = Infinity;
  286.         for (var i = 0, n = layers.length; i < n; i++) {
  287.             var layer = layers[i];
  288.             if (layer instanceof L.LayerGroup) {
  289.                 // recursive
  290.                 var subResult = L.GeometryUtil.closestLayer(map, layer.getLayers(), latlng);
  291.                 if (subResult.distance < mindist) {
  292.                     mindist = subResult.distance;
  293.                     result = subResult;
  294.                 }
  295.             } else {
  296.                 // Single dimension, snap on points, else snap on closest
  297.                 if (typeof layer.getLatLng == 'function') {
  298.                     ll = layer.getLatLng();
  299.                     distance = L.GeometryUtil.distance(map, latlng, ll);
  300.                 }
  301.                 else {
  302.                     ll = L.GeometryUtil.closest(map, layer, latlng);
  303.                     if (ll) distance = ll.distance;  // Can return null if layer has no points.
  304.                 }
  305.                 if (distance < mindist) {
  306.                     mindist = distance;
  307.                     result = {layer: layer, latlng: ll, distance: distance};
  308.                 }
  309.             }
  310.         }
  311.         return result;
  312.     },
  314.     /**
  315.         Returns the n closest layers to latlng among a list of input layers.
  317.         @param {L.Map} map - Leaflet map to be used for this method
  318.         @param {Array<L.ILayer>} layers - Set of layers
  319.         @param {L.LatLng} latlng - The position to search
  320.         @param {?Number} [n=layers.length] - the expected number of output layers.
  321.         @returns {Array<object>} an array of objects ``{layer, latlng, distance}`` or ``null`` if the input is invalid (empty list or negative n)
  322.     */
  323.     nClosestLayers: function (map, layers, latlng, n) {
  324.         n = typeof n === 'number' ? n : layers.length;
  326.         if (n < 1 || layers.length < 1) {
  327.             return null;
  328.         }
  330.         var results = [];
  331.         var distance, ll;
  333.         for (var i = 0, m = layers.length; i < m; i++) {
  334.             var layer = layers[i];
  335.             if (layer instanceof L.LayerGroup) {
  336.                 // recursive
  337.                 var subResult = L.GeometryUtil.closestLayer(map, layer.getLayers(), latlng);
  338.                 results.push(subResult);
  339.             } else {
  340.                 // Single dimension, snap on points, else snap on closest
  341.                 if (typeof layer.getLatLng == 'function') {
  342.                     ll = layer.getLatLng();
  343.                     distance = L.GeometryUtil.distance(map, latlng, ll);
  344.                 }
  345.                 else {
  346.                     ll = L.GeometryUtil.closest(map, layer, latlng);
  347.                     if (ll) distance = ll.distance;  // Can return null if layer has no points.
  348.                 }
  349.                 results.push({layer: layer, latlng: ll, distance: distance});
  350.             }
  351.         }
  353.         results.sort(function(a, b) {
  354.             return a.distance - b.distance;
  355.         });
  357.         if (results.length > n) {
  358.             return results.slice(0, n);
  359.         } else  {
  360.             return results;
  361.         }
  362.     },
  364.     /**
  365.      * Returns all layers within a radius of the given position, in an ascending order of distance.
  366.        @param {L.Map} map Leaflet map to be used for this method
  367.        @param {Array<ILayer>} layers - A list of layers.
  368.        @param {L.LatLng} latlng - The position to search
  369.        @param {?Number} [radius=Infinity] - Search radius in pixels
  370.        @return {object[]} an array of objects including layer within the radius, closest latlng, and distance
  371.      */
  372.     layersWithin: function(map, layers, latlng, radius) {
  373.       radius = typeof radius == 'number' ? radius : Infinity;
  375.       var results = [];
  376.       var ll = null;
  377.       var distance = 0;
  379.       for (var i = 0, n = layers.length; i < n; i++) {
  380.         var layer = layers[i];
  382.         if (typeof layer.getLatLng == 'function') {
  383.             ll = layer.getLatLng();
  384.             distance = L.GeometryUtil.distance(map, latlng, ll);
  385.         }
  386.         else {
  387.             ll = L.GeometryUtil.closest(map, layer, latlng);
  388.             if (ll) distance = ll.distance;  // Can return null if layer has no points.
  389.         }
  391.         if (ll && distance < radius) {
  392.             results.push({layer: layer, latlng: ll, distance: distance});
  393.         }
  394.       }
  396.       var sortedResults = results.sort(function(a, b) {
  397.           return a.distance - b.distance;
  398.       });
  400.       return sortedResults;
  401.     },
  403.     /**
  404.         Returns the closest position from specified {LatLng} among specified layers,
  405.         with a maximum tolerance in pixels, providing snapping behaviour.
  407.         @tutorial closest
  409.         @param {L.Map} map Leaflet map to be used for this method
  410.         @param {Array<ILayer>} layers - A list of layers to snap on.
  411.         @param {L.LatLng} latlng - The position to snap
  412.         @param {?Number} [tolerance=Infinity] - Maximum number of pixels.
  413.         @param {?boolean} [withVertices=true] - Snap to layers vertices or segment points (not only vertex)
  414.         @returns {object} with snapped {LatLng} and snapped {Layer} or null if tolerance exceeded.
  415.     */
  416.     closestLayerSnap: function (map, layers, latlng, tolerance, withVertices) {
  417.         tolerance = typeof tolerance == 'number' ? tolerance : Infinity;
  418.         withVertices = typeof withVertices == 'boolean' ? withVertices : true;
  420.         var result = L.GeometryUtil.closestLayer(map, layers, latlng);
  421.         if (!result || result.distance > tolerance)
  422.             return null;
  424.         // If snapped layer is linear, try to snap on vertices (extremities and middle points)
  425.         if (withVertices && typeof result.layer.getLatLngs == 'function') {
  426.             var closest = L.GeometryUtil.closest(map, result.layer, result.latlng, true);
  427.             if (closest.distance < tolerance) {
  428.                 result.latlng = closest;
  429.                 result.distance = L.GeometryUtil.distance(map, closest, latlng);
  430.             }
  431.         }
  432.         return result;
  433.     },
  435.     /**
  436.         Returns the Point located on a segment at the specified ratio of the segment length.
  437.         @param {L.Point} pA coordinates of point A
  438.         @param {L.Point} pB coordinates of point B
  439.         @param {Number} the length ratio, expressed as a decimal between 0 and 1, inclusive.
  440.         @returns {L.Point} the interpolated point.
  441.     */
  442.     interpolateOnPointSegment: function (pA, pB, ratio) {
  443.         return L.point(
  444.             (pA.x * (1 - ratio)) + (ratio * pB.x),
  445.             (pA.y * (1 - ratio)) + (ratio * pB.y)
  446.         );
  447.     },
  449.     /**
  450.         Returns the coordinate of the point located on a line at the specified ratio of the line length.
  451.         @param {L.Map} map Leaflet map to be used for this method
  452.         @param {Array<L.LatLng>|L.PolyLine} latlngs Set of geographical points
  453.         @param {Number} ratio the length ratio, expressed as a decimal between 0 and 1, inclusive
  454.         @returns {Object} an object with latLng ({LatLng}) and predecessor ({Number}), the index of the preceding vertex in the Polyline
  455.         (-1 if the interpolated point is the first vertex)
  456.     */
  457.     interpolateOnLine: function (map, latLngs, ratio) {
  458.         latLngs = (latLngs instanceof L.Polyline) ? latLngs.getLatLngs() : latLngs;
  459.         var n = latLngs.length;
  460.         if (n < 2) {
  461.             return null;
  462.         }
  464.         // ensure the ratio is between 0 and 1;
  465.         ratio = Math.max(Math.min(ratio, 1), 0);
  467.         if (ratio === 0) {
  468.             return {
  469.                 latLng: latLngs[0] instanceof L.LatLng ? latLngs[0] : L.latLng(latLngs[0]),
  470.                 predecessor: -1
  471.             };
  472.         }
  473.         if (ratio == 1) {
  474.             return {
  475.                 latLng: latLngs[latLngs.length -1] instanceof L.LatLng ? latLngs[latLngs.length -1] : L.latLng(latLngs[latLngs.length -1]),
  476.                 predecessor: latLngs.length - 2
  477.             };
  478.         }
  480.         // project the LatLngs as Points,
  481.         // and compute total planar length of the line at max precision
  482.         var maxzoom = map.getMaxZoom();
  483.         if (maxzoom === Infinity)
  484.             maxzoom = map.getZoom();
  485.         var pts = [];
  486.         var lineLength = 0;
  487.         for(var i = 0; i < n; i++) {
  488.             pts[i] = map.project(latLngs[i], maxzoom);
  489.             if(i > 0)
  490.               lineLength += pts[i-1].distanceTo(pts[i]);
  491.         }
  493.         var ratioDist = lineLength * ratio;
  495. 		// follow the line segments [ab], adding lengths,
  496.         // until we find the segment where the points should lie on
  497. 		var cumulativeDistanceToA = 0, cumulativeDistanceToB = 0;
  498. 		for (var i = 0; cumulativeDistanceToB < ratioDist; i++) {
  499. 			var pointA = pts[i], pointB = pts[i+1];
  501. 			cumulativeDistanceToA = cumulativeDistanceToB;
  502. 			cumulativeDistanceToB += pointA.distanceTo(pointB);
  503. 		}
  504. 		
  505. 		if (pointA == undefined && pointB == undefined) { // Happens when line has no length
  506. 			var pointA = pts[0], pointB = pts[1], i = 1;
  507. 		}
  509. 		// compute the ratio relative to the segment [ab]
  510. 		var segmentRatio = ((cumulativeDistanceToB - cumulativeDistanceToA) !== 0) ? ((ratioDist - cumulativeDistanceToA) / (cumulativeDistanceToB - cumulativeDistanceToA)) : 0;
  511. 		var interpolatedPoint = L.GeometryUtil.interpolateOnPointSegment(pointA, pointB, segmentRatio);
  512. 		return {
  513. 			latLng: map.unproject(interpolatedPoint, maxzoom),
  514. 			predecessor: i-1
  515. 		};
  516.     },
  518.     /**
  519.         Returns a float between 0 and 1 representing the location of the
  520.         closest point on polyline to the given latlng, as a fraction of total line length.
  521.         (opposite of L.GeometryUtil.interpolateOnLine())
  522.         @param {L.Map} map Leaflet map to be used for this method
  523.         @param {L.PolyLine} polyline Polyline on which the latlng will be search
  524.         @param {L.LatLng} latlng The position to search
  525.         @returns {Number} Float between 0 and 1
  526.     */
  527.     locateOnLine: function (map, polyline, latlng) {
  528.         var latlngs = polyline.getLatLngs();
  529.         if (latlng.equals(latlngs[0]))
  530.             return 0.0;
  531.         if (latlng.equals(latlngs[latlngs.length-1]))
  532.             return 1.0;
  534.         var point = L.GeometryUtil.closest(map, polyline, latlng, false),
  535.             lengths = L.GeometryUtil.accumulatedLengths(latlngs),
  536.             total_length = lengths[lengths.length-1],
  537.             portion = 0,
  538.             found = false;
  539.         for (var i=0, n = latlngs.length-1; i < n; i++) {
  540.             var l1 = latlngs[i],
  541.                 l2 = latlngs[i+1];
  542.             portion = lengths[i];
  543.             if (L.GeometryUtil.belongsSegment(point, l1, l2, 0.001)) {
  544.                 portion += l1.distanceTo(point);
  545.                 found = true;
  546.                 break;
  547.             }
  548.         }
  549.         if (!found) {
  550.             throw "Could not interpolate " + latlng.toString() + " within " + polyline.toString();
  551.         }
  552.         return portion / total_length;
  553.     },
  555.     /**
  556.         Returns a clone with reversed coordinates.
  557.         @param {L.PolyLine} polyline polyline to reverse
  558.         @returns {L.PolyLine} polyline reversed
  559.     */
  560.     reverse: function (polyline) {
  561.         return L.polyline(polyline.getLatLngs().slice(0).reverse());
  562.     },
  564.     /**
  565.         Returns a sub-part of the polyline, from start to end.
  566.         If start is superior to end, returns extraction from inverted line.
  567.         @param {L.Map} map Leaflet map to be used for this method
  568.         @param {L.PolyLine} polyline Polyline on which will be extracted the sub-part
  569.         @param {Number} start ratio, expressed as a decimal between 0 and 1, inclusive
  570.         @param {Number} end ratio, expressed as a decimal between 0 and 1, inclusive
  571.         @returns {Array<L.LatLng>} new polyline
  572.      */
  573.     extract: function (map, polyline, start, end) {
  574.         if (start > end) {
  575.             return L.GeometryUtil.extract(map, L.GeometryUtil.reverse(polyline), 1.0-start, 1.0-end);
  576.         }
  578.         // Bound start and end to [0-1]
  579.         start = Math.max(Math.min(start, 1), 0);
  580.         end = Math.max(Math.min(end, 1), 0);
  582.         var latlngs = polyline.getLatLngs(),
  583.             startpoint = L.GeometryUtil.interpolateOnLine(map, polyline, start),
  584.             endpoint = L.GeometryUtil.interpolateOnLine(map, polyline, end);
  585.         // Return single point if start == end
  586.         if (start == end) {
  587.             var point = L.GeometryUtil.interpolateOnLine(map, polyline, end);
  588.             return [point.latLng];
  589.         }
  590.         // Array.slice() works indexes at 0
  591.         if (startpoint.predecessor == -1)
  592.             startpoint.predecessor = 0;
  593.         if (endpoint.predecessor == -1)
  594.             endpoint.predecessor = 0;
  595.         var result = latlngs.slice(startpoint.predecessor+1, endpoint.predecessor+1);
  596.         result.unshift(startpoint.latLng);
  597.         result.push(endpoint.latLng);
  598.         return result;
  599.     },
  601.     /**
  602.         Returns true if first polyline ends where other second starts.
  603.         @param {L.PolyLine} polyline First polyline
  604.         @param {L.PolyLine} other Second polyline
  605.         @returns {bool}
  606.     */
  607.     isBefore: function (polyline, other) {
  608.         if (!other) return false;
  609.         var lla = polyline.getLatLngs(),
  610.             llb = other.getLatLngs();
  611.         return (lla[lla.length-1]).equals(llb[0]);
  612.     },
  614.     /**
  615.         Returns true if first polyline starts where second ends.
  616.         @param {L.PolyLine} polyline First polyline
  617.         @param {L.PolyLine} other Second polyline
  618.         @returns {bool}
  619.     */
  620.     isAfter: function (polyline, other) {
  621.         if (!other) return false;
  622.         var lla = polyline.getLatLngs(),
  623.             llb = other.getLatLngs();
  624.         return (lla[0]).equals(llb[llb.length-1]);
  625.     },
  627.     /**
  628.         Returns true if first polyline starts where second ends or start.
  629.         @param {L.PolyLine} polyline First polyline
  630.         @param {L.PolyLine} other Second polyline
  631.         @returns {bool}
  632.     */
  633.     startsAtExtremity: function (polyline, other) {
  634.         if (!other) return false;
  635.         var lla = polyline.getLatLngs(),
  636.             llb = other.getLatLngs(),
  637.             start = lla[0];
  638.         return start.equals(llb[0]) || start.equals(llb[llb.length-1]);
  639.     },
  641.     /**
  642.         Returns horizontal angle in degres between two points.
  643.         @param {L.Point} a Coordinates of point A
  644.         @param {L.Point} b Coordinates of point B
  645.         @returns {Number} horizontal angle
  646.      */
  647.     computeAngle: function(a, b) {
  648.         return (Math.atan2(b.y - a.y, b.x - a.x) * 180 / Math.PI);
  649.     },
  651.     /**
  652.        Returns slope (Ax+B) between two points.
  653.         @param {L.Point} a Coordinates of point A
  654.         @param {L.Point} b Coordinates of point B
  655.         @returns {Object} with ``a`` and ``b`` properties.
  656.      */
  657.     computeSlope: function(a, b) {
  658.         var s = (b.y - a.y) / (b.x - a.x),
  659.             o = a.y - (s * a.x);
  660.         return {'a': s, 'b': o};
  661.     },
  663.     /**
  664.        Returns LatLng of rotated point around specified LatLng center.
  665.         @param {L.LatLng} latlngPoint: point to rotate
  666.         @param {double} angleDeg: angle to rotate in degrees
  667.         @param {L.LatLng} latlngCenter: center of rotation
  668.         @returns {L.LatLng} rotated point
  669.      */
  670.     rotatePoint: function(map, latlngPoint, angleDeg, latlngCenter) {
  671.         var maxzoom = map.getMaxZoom();
  672.         if (maxzoom === Infinity)
  673.             maxzoom = map.getZoom();
  674.         var angleRad = angleDeg*Math.PI/180,
  675.             pPoint = map.project(latlngPoint, maxzoom),
  676.             pCenter = map.project(latlngCenter, maxzoom),
  677.             x2 = Math.cos(angleRad)*(pPoint.x-pCenter.x) - Math.sin(angleRad)*(pPoint.y-pCenter.y) + pCenter.x,
  678.             y2 = Math.sin(angleRad)*(pPoint.x-pCenter.x) + Math.cos(angleRad)*(pPoint.y-pCenter.y) + pCenter.y;
  679.         return map.unproject(new L.Point(x2,y2), maxzoom);
  680.     },
  682.     /**
  683.        Returns the bearing in degrees clockwise from north (0 degrees)
  684.        from the first L.LatLng to the second, at the first LatLng
  685.        @param {L.LatLng} latlng1: origin point of the bearing
  686.        @param {L.LatLng} latlng2: destination point of the bearing
  687.        @returns {float} degrees clockwise from north.
  688.     */
  689.     bearing: function(latlng1, latlng2) {
  690.         var rad = Math.PI / 180,
  691.             lat1 = latlng1.lat * rad,
  692.             lat2 = latlng2.lat * rad,
  693.             lon1 = latlng1.lng * rad,
  694.             lon2 = latlng2.lng * rad,
  695.             y = Math.sin(lon2 - lon1) * Math.cos(lat2),
  696.             x = Math.cos(lat1) * Math.sin(lat2) -
  697.                 Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon2 - lon1);
  699.         var bearing = ((Math.atan2(y, x) * 180 / Math.PI) + 360) % 360;
  700.         return bearing >= 180 ? bearing-360 : bearing;
  701.     },
  703.     /**
  704.        Returns the point that is a distance and heading away from
  705.        the given origin point.
  706.        @param {L.LatLng} latlng: origin point
  707.        @param {float} heading: heading in degrees, clockwise from 0 degrees north.
  708.        @param {float} distance: distance in meters
  709.        @returns {L.latLng} the destination point.
  710.        Many thanks to Chris Veness at http://www.movable-type.co.uk/scripts/latlong.html
  711.        for a great reference and examples.
  712.     */
  713.     destination: function(latlng, heading, distance) {
  714.         heading = (heading + 360) % 360;
  715.         var rad = Math.PI / 180,
  716.             radInv = 180 / Math.PI,
  717.             R = 6378137, // approximation of Earth's radius
  718.             lon1 = latlng.lng * rad,
  719.             lat1 = latlng.lat * rad,
  720.             rheading = heading * rad,
  721.             sinLat1 = Math.sin(lat1),
  722.             cosLat1 = Math.cos(lat1),
  723.             cosDistR = Math.cos(distance / R),
  724.             sinDistR = Math.sin(distance / R),
  725.             lat2 = Math.asin(sinLat1 * cosDistR + cosLat1 *
  726.                 sinDistR * Math.cos(rheading)),
  727.             lon2 = lon1 + Math.atan2(Math.sin(rheading) * sinDistR *
  728.                 cosLat1, cosDistR - sinLat1 * Math.sin(lat2));
  729.         lon2 = lon2 * radInv;
  730.         lon2 = lon2 > 180 ? lon2 - 360 : lon2 < -180 ? lon2 + 360 : lon2;
  731.         return L.latLng([lat2 * radInv, lon2]);
  732.     },
  734.     /**
  735.        Returns the the angle of the given segment and the Equator in degrees,
  736.        clockwise from 0 degrees north.
  737.        @param {L.Map} map: Leaflet map to be used for this method
  738.        @param {L.LatLng} latlngA: geographical point A of the segment
  739.        @param {L.LatLng} latlngB: geographical point B of the segment
  740.        @returns {Float} the angle in degrees.
  741.     */
  742.     angle: function(map, latlngA, latlngB) {
  743.       var pointA = map.latLngToContainerPoint(latlngA),
  744.           pointB = map.latLngToContainerPoint(latlngB),
  745.           angleDeg = Math.atan2(pointB.y - pointA.y, pointB.x - pointA.x) * 180 / Math.PI + 90;
  746.       angleDeg += angleDeg < 0 ? 360 : 0;
  747.       return angleDeg;
  748.     },
  750.     /**
  751.        Returns a point snaps on the segment and heading away from the given origin point a distance.
  752.        @param {L.Map} map: Leaflet map to be used for this method
  753.        @param {L.LatLng} latlngA: geographical point A of the segment
  754.        @param {L.LatLng} latlngB: geographical point B of the segment
  755.        @param {float} distance: distance in meters
  756.        @returns {L.latLng} the destination point.
  757.     */
  758.     destinationOnSegment: function(map, latlngA, latlngB, distance) {
  759.       var angleDeg = L.GeometryUtil.angle(map, latlngA, latlngB),
  760.           latlng = L.GeometryUtil.destination(latlngA, angleDeg, distance);
  761.       return L.GeometryUtil.closestOnSegment(map, latlng, latlngA, latlngB);
  762.     },
  763. });
  765. return L.GeometryUtil;
  767. }));