").append(n.parseHTML(a)).find(d):a)}).complete(c&&function(a,b){g.each(c,e||[a.responseText,b,a])}),this},n.expr.filters.animated=function(a){return n.grep(n.timers,function(b){return a===b.elem}).length};var dd=a.document.documentElement;function ed(a){return n.isWindow(a)?a:9===a.nodeType?a.defaultView||a.parentWindow:!1}n.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=n.css(a,"position"),l=n(a),m={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=n.css(a,"top"),i=n.css(a,"left"),j=("absolute"===k||"fixed"===k)&&n.inArray("auto",[f,i])>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),n.isFunction(b)&&(b=b.call(a,c,h)),null!=b.top&&(m.top=b.top-h.top+g),null!=b.left&&(m.left=b.left-h.left+e),"using"in b?b.using.call(a,m):l.css(m)}},n.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){n.offset.setOffset(this,a,b)});var b,c,d={top:0,left:0},e=this[0],f=e&&e.ownerDocument;if(f)return b=f.documentElement,n.contains(b,e)?(typeof e.getBoundingClientRect!==L&&(d=e.getBoundingClientRect()),c=ed(f),{top:d.top+(c.pageYOffset||b.scrollTop)-(b.clientTop||0),left:d.left+(c.pageXOffset||b.scrollLeft)-(b.clientLeft||0)}):d},position:function(){if(this[0]){var a,b,c={top:0,left:0},d=this[0];return"fixed"===n.css(d,"position")?b=d.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),n.nodeName(a[0],"html")||(c=a.offset()),c.top+=n.css(a[0],"borderTopWidth",!0),c.left+=n.css(a[0],"borderLeftWidth",!0)),{top:b.top-c.top-n.css(d,"marginTop",!0),left:b.left-c.left-n.css(d,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||dd;while(a&&!n.nodeName(a,"html")&&"static"===n.css(a,"position"))a=a.offsetParent;return a||dd})}}),n.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c=/Y/.test(b);n.fn[a]=function(d){return W(this,function(a,d,e){var f=ed(a);return void 0===e?f?b in f?f[b]:f.document.documentElement[d]:a[d]:void(f?f.scrollTo(c?n(f).scrollLeft():e,c?e:n(f).scrollTop()):a[d]=e)},a,d,arguments.length,null)}}),n.each(["top","left"],function(a,b){n.cssHooks[b]=Mb(l.pixelPosition,function(a,c){return c?(c=Kb(a,b),Ib.test(c)?n(a).position()[b]+"px":c):void 0})}),n.each({Height:"height",Width:"width"},function(a,b){n.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){n.fn[d]=function(d,e){var f=arguments.length&&(c||"boolean"!=typeof d),g=c||(d===!0||e===!0?"margin":"border");return W(this,function(b,c,d){var e;return n.isWindow(b)?b.document.documentElement["client"+a]:9===b.nodeType?(e=b.documentElement,Math.max(b.body["scroll"+a],e["scroll"+a],b.body["offset"+a],e["offset"+a],e["client"+a])):void 0===d?n.css(b,c,g):n.style(b,c,d,g)},b,f?d:void 0,f,null)}})}),n.fn.size=function(){return this.length},n.fn.andSelf=n.fn.addBack,"function"==typeof define&&define.amd&&define("jquery",[],function(){return n});var fd=a.jQuery,gd=a.$;return n.noConflict=function(b){return a.$===n&&(a.$=gd),b&&a.jQuery===n&&(a.jQuery=fd),n},typeof b===L&&(a.jQuery=a.$=n),n});
diff --git a/app/static/js/leaflet-knn.min.js b/app/static/js/leaflet-knn.min.js
new file mode 100644
index 0000000..a6143c9
--- /dev/null
+++ b/app/static/js/leaflet-knn.min.js
@@ -0,0 +1 @@
+!function(e){if("function"==typeof bootstrap)bootstrap("leafletknn",e);else if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else if("undefined"!=typeof ses){if(!ses.ok())return;ses.makeLeafletKnn=e}else"undefined"!=typeof window?window.leafletKnn=e():global.leafletKnn=e()}(function(){return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a="function"==typeof require&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}for(var i="function"==typeof require&&require,o=0;o
=low;)if(mid=low+high>>>1,comp=comparator(array[mid],item),0>comp)low=mid+1;else{if(!(comp>0))return mid;high=mid-1}return-(low+1)},exports.insert=function(item,array,comparator){var i=exports.search(item,array,comparator);0>i&&(i=-(i+1)),array.splice(i,0,item)}},{}],4:[function(require,module,exports){function Node(axis,split,left,right){this.axis=axis,this.split=split,this.left=left,this.right=right}function distance(a,b){for(var k,i=Math.min(a.length,b.length),d=0;i--;)k=b[i]-a[i],d+=k*k;return d}function byDistance(a,b){return a.dist-b.dist}function buildrec(array,depth){if(0===array.length)return null;if(1===array.length)return array[0];var axis=depth%array[0].position.length;array.sort(function(a,b){return a.position[axis]-b.position[axis]});var i=Math.floor(.5*array.length);return++depth,new Node(axis,array[i].position[axis],buildrec(array.slice(0,i),depth),buildrec(array.slice(i),depth))}function build(array){return buildrec(array,0)}function lookup(position,node,n,max){max>0||(max=Number.POSITIVE_INFINITY);var array=[];if(null===node||0>=n)return array;for(var dist,i,stack=[node,0];stack.length;)if(dist=stack.pop(),node=stack.pop(),!(dist>max||array.length===n&&array[array.length-1].dist=dist&&binary.insert({object:node,dist:dist},array,byDistance),array.length>n&&array.pop()}for(i=array.length;i--;)array[i]=array[i].object;return array}var binary=require("./binary");exports.build=build,exports.lookup=lookup},{"./binary":3}],5:[function(require,module,exports){function spherical2cartesian(lat,lon){lat*=rad,lon*=rad;var cos=Math.cos(lat);return[cos*Math.cos(lon),Math.sin(lat),cos*Math.sin(lon)]}function Position(object){var lat,lon;object.hasOwnProperty("lat")?lat=object.lat:object.hasOwnProperty("latitude")?lat=object.latitude:object.hasOwnProperty("location")&&Array.isArray(object.location)&&2===object.location.length&&(lat=object.location[0]),object.hasOwnProperty("lon")?lon=object.lon:object.hasOwnProperty("longitude")?lon=object.longitude:object.hasOwnProperty("lng")?lon=object.lng:object.hasOwnProperty("long")?lon=object.long:object.hasOwnProperty("location")&&Array.isArray(object.location)&&2===object.location.length&&(lon=object.location[1]),this.object=object,this.position=spherical2cartesian(lat,lon)}function build(array){for(var i=array.length,out=new Array(i);i--;)out[i]=new Position(array[i]);return kd.build(out)}function lookup(lat,lon,node,n,max){for(var array=kd.lookup(spherical2cartesian(lat,lon),node,n,max>0?2*Math.sin(max*invEarthDiameter):void 0),i=array.length;i--;)array[i]=array[i].object;return array}var kd=require("./kd"),rad=Math.PI/180,invEarthDiameter=1/12742018;exports.build=build,exports.lookup=lookup},{"./kd":4}]},{},[1])(1)});
\ No newline at end of file
diff --git a/app/static/js/leaflet.css b/app/static/js/leaflet.css
new file mode 100644
index 0000000..ddf5d41
--- /dev/null
+++ b/app/static/js/leaflet.css
@@ -0,0 +1,658 @@
+/* required styles */
+
+.leaflet-pane,
+.leaflet-tile,
+.leaflet-marker-icon,
+.leaflet-marker-shadow,
+.leaflet-tile-container,
+.leaflet-pane > svg,
+.leaflet-pane > canvas,
+.leaflet-zoom-box,
+.leaflet-image-layer,
+.leaflet-layer {
+ position: absolute;
+ left: 0;
+ top: 0;
+ }
+.leaflet-container {
+ overflow: hidden;
+ }
+.leaflet-tile,
+.leaflet-marker-icon,
+.leaflet-marker-shadow {
+ -webkit-user-select: none;
+ -moz-user-select: none;
+ user-select: none;
+ -webkit-user-drag: none;
+ }
+/* Prevents IE11 from highlighting tiles in blue */
+.leaflet-tile::selection {
+ background: transparent;
+}
+/* Safari renders non-retina tile on retina better with this, but Chrome is worse */
+.leaflet-safari .leaflet-tile {
+ image-rendering: -webkit-optimize-contrast;
+ }
+/* hack that prevents hw layers "stretching" when loading new tiles */
+.leaflet-safari .leaflet-tile-container {
+ width: 1600px;
+ height: 1600px;
+ -webkit-transform-origin: 0 0;
+ }
+.leaflet-marker-icon,
+.leaflet-marker-shadow {
+ display: block;
+ }
+/* .leaflet-container svg: reset svg max-width decleration shipped in Joomla! (joomla.org) 3.x */
+/* .leaflet-container img: map is broken in FF if you have max-width: 100% on tiles */
+.leaflet-container .leaflet-overlay-pane svg {
+ max-width: none !important;
+ max-height: none !important;
+ }
+.leaflet-container .leaflet-marker-pane img,
+.leaflet-container .leaflet-shadow-pane img,
+.leaflet-container .leaflet-tile-pane img,
+.leaflet-container img.leaflet-image-layer,
+.leaflet-container .leaflet-tile {
+ max-width: none !important;
+ max-height: none !important;
+ width: auto;
+ padding: 0;
+ }
+
+.leaflet-container.leaflet-touch-zoom {
+ -ms-touch-action: pan-x pan-y;
+ touch-action: pan-x pan-y;
+ }
+.leaflet-container.leaflet-touch-drag {
+ -ms-touch-action: pinch-zoom;
+ /* Fallback for FF which doesn't support pinch-zoom */
+ touch-action: none;
+ touch-action: pinch-zoom;
+}
+.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom {
+ -ms-touch-action: none;
+ touch-action: none;
+}
+.leaflet-container {
+ -webkit-tap-highlight-color: transparent;
+}
+.leaflet-container a {
+ -webkit-tap-highlight-color: rgba(51, 181, 229, 0.4);
+}
+.leaflet-tile {
+ filter: inherit;
+ visibility: hidden;
+ }
+.leaflet-tile-loaded {
+ visibility: inherit;
+ }
+.leaflet-zoom-box {
+ width: 0;
+ height: 0;
+ -moz-box-sizing: border-box;
+ box-sizing: border-box;
+ z-index: 800;
+ }
+/* workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=888319 */
+.leaflet-overlay-pane svg {
+ -moz-user-select: none;
+ }
+
+.leaflet-pane { z-index: 400; }
+
+.leaflet-tile-pane { z-index: 200; }
+.leaflet-overlay-pane { z-index: 400; }
+.leaflet-shadow-pane { z-index: 500; }
+.leaflet-marker-pane { z-index: 600; }
+.leaflet-tooltip-pane { z-index: 650; }
+.leaflet-popup-pane { z-index: 700; }
+
+.leaflet-map-pane canvas { z-index: 100; }
+.leaflet-map-pane svg { z-index: 200; }
+
+.leaflet-vml-shape {
+ width: 1px;
+ height: 1px;
+ }
+.lvml {
+ behavior: url(#default#VML);
+ display: inline-block;
+ position: absolute;
+ }
+
+
+/* control positioning */
+
+.leaflet-control {
+ position: relative;
+ z-index: 800;
+ pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */
+ pointer-events: auto;
+ }
+.leaflet-top,
+.leaflet-bottom {
+ position: absolute;
+ z-index: 1000;
+ pointer-events: none;
+ }
+.leaflet-top {
+ top: 0;
+ }
+.leaflet-right {
+ right: 0;
+ }
+.leaflet-bottom {
+ bottom: 0;
+ }
+.leaflet-left {
+ left: 0;
+ }
+.leaflet-control {
+ float: left;
+ clear: both;
+ }
+.leaflet-right .leaflet-control {
+ float: right;
+ }
+.leaflet-top .leaflet-control {
+ margin-top: 10px;
+ }
+.leaflet-bottom .leaflet-control {
+ margin-bottom: 10px;
+ }
+.leaflet-left .leaflet-control {
+ margin-left: 10px;
+ }
+.leaflet-right .leaflet-control {
+ margin-right: 10px;
+ }
+
+
+/* zoom and fade animations */
+
+.leaflet-fade-anim .leaflet-popup {
+ opacity: 0;
+ -webkit-transition: opacity 0.2s linear;
+ -moz-transition: opacity 0.2s linear;
+ transition: opacity 0.2s linear;
+ }
+.leaflet-fade-anim .leaflet-map-pane .leaflet-popup {
+ opacity: 1;
+ }
+.leaflet-zoom-animated {
+ -webkit-transform-origin: 0 0;
+ -ms-transform-origin: 0 0;
+ transform-origin: 0 0;
+ }
+svg.leaflet-zoom-animated {
+ will-change: transform;
+}
+
+.leaflet-zoom-anim .leaflet-zoom-animated {
+ -webkit-transition: -webkit-transform 0.25s cubic-bezier(0,0,0.25,1);
+ -moz-transition: -moz-transform 0.25s cubic-bezier(0,0,0.25,1);
+ transition: transform 0.25s cubic-bezier(0,0,0.25,1);
+ }
+.leaflet-zoom-anim .leaflet-tile,
+.leaflet-pan-anim .leaflet-tile {
+ -webkit-transition: none;
+ -moz-transition: none;
+ transition: none;
+ }
+
+.leaflet-zoom-anim .leaflet-zoom-hide {
+ visibility: hidden;
+ }
+
+
+/* cursors */
+
+.leaflet-interactive {
+ cursor: pointer;
+ }
+.leaflet-grab {
+ cursor: -webkit-grab;
+ cursor: -moz-grab;
+ cursor: grab;
+ }
+.leaflet-crosshair,
+.leaflet-crosshair .leaflet-interactive {
+ cursor: crosshair;
+ }
+.leaflet-popup-pane,
+.leaflet-control {
+ cursor: auto;
+ }
+.leaflet-dragging .leaflet-grab,
+.leaflet-dragging .leaflet-grab .leaflet-interactive,
+.leaflet-dragging .leaflet-marker-draggable {
+ cursor: move;
+ cursor: -webkit-grabbing;
+ cursor: -moz-grabbing;
+ cursor: grabbing;
+ }
+
+/* marker & overlays interactivity */
+.leaflet-marker-icon,
+.leaflet-marker-shadow,
+.leaflet-image-layer,
+.leaflet-pane > svg path,
+.leaflet-tile-container {
+ pointer-events: none;
+ }
+
+.leaflet-marker-icon.leaflet-interactive,
+.leaflet-image-layer.leaflet-interactive,
+.leaflet-pane > svg path.leaflet-interactive,
+svg.leaflet-image-layer.leaflet-interactive path {
+ pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */
+ pointer-events: auto;
+ }
+
+/* visual tweaks */
+
+.leaflet-container {
+ background: #ddd;
+ outline-offset: 1px;
+ }
+.leaflet-container a {
+ color: #0078A8;
+ }
+.leaflet-zoom-box {
+ border: 2px dotted #38f;
+ background: rgba(255,255,255,0.5);
+ }
+
+
+/* general typography */
+.leaflet-container {
+ font-family: "Helvetica Neue", Arial, Helvetica, sans-serif;
+ font-size: 12px;
+ font-size: 0.75rem;
+ line-height: 1.5;
+ }
+
+
+/* general toolbar styles */
+
+.leaflet-bar {
+ box-shadow: 0 1px 5px rgba(0,0,0,0.65);
+ border-radius: 4px;
+ }
+.leaflet-bar a {
+ background-color: #fff;
+ border-bottom: 1px solid #ccc;
+ width: 26px;
+ height: 26px;
+ line-height: 26px;
+ display: block;
+ text-align: center;
+ text-decoration: none;
+ color: black;
+ }
+.leaflet-bar a,
+.leaflet-control-layers-toggle {
+ background-position: 50% 50%;
+ background-repeat: no-repeat;
+ display: block;
+ }
+.leaflet-bar a:hover,
+.leaflet-bar a:focus {
+ background-color: #f4f4f4;
+ }
+.leaflet-bar a:first-child {
+ border-top-left-radius: 4px;
+ border-top-right-radius: 4px;
+ }
+.leaflet-bar a:last-child {
+ border-bottom-left-radius: 4px;
+ border-bottom-right-radius: 4px;
+ border-bottom: none;
+ }
+.leaflet-bar a.leaflet-disabled {
+ cursor: default;
+ background-color: #f4f4f4;
+ color: #bbb;
+ }
+
+.leaflet-touch .leaflet-bar a {
+ width: 30px;
+ height: 30px;
+ line-height: 30px;
+ }
+.leaflet-touch .leaflet-bar a:first-child {
+ border-top-left-radius: 2px;
+ border-top-right-radius: 2px;
+ }
+.leaflet-touch .leaflet-bar a:last-child {
+ border-bottom-left-radius: 2px;
+ border-bottom-right-radius: 2px;
+ }
+
+/* zoom control */
+
+.leaflet-control-zoom-in,
+.leaflet-control-zoom-out {
+ font: bold 18px 'Lucida Console', Monaco, monospace;
+ text-indent: 1px;
+ }
+
+.leaflet-touch .leaflet-control-zoom-in, .leaflet-touch .leaflet-control-zoom-out {
+ font-size: 22px;
+ }
+
+
+/* layers control */
+
+.leaflet-control-layers {
+ box-shadow: 0 1px 5px rgba(0,0,0,0.4);
+ background: #fff;
+ border-radius: 5px;
+ }
+.leaflet-control-layers-toggle {
+ background-image: url(images/layers.png);
+ width: 36px;
+ height: 36px;
+ }
+.leaflet-retina .leaflet-control-layers-toggle {
+ background-image: url(images/layers-2x.png);
+ background-size: 26px 26px;
+ }
+.leaflet-touch .leaflet-control-layers-toggle {
+ width: 44px;
+ height: 44px;
+ }
+.leaflet-control-layers .leaflet-control-layers-list,
+.leaflet-control-layers-expanded .leaflet-control-layers-toggle {
+ display: none;
+ }
+.leaflet-control-layers-expanded .leaflet-control-layers-list {
+ display: block;
+ position: relative;
+ }
+.leaflet-control-layers-expanded {
+ padding: 6px 10px 6px 6px;
+ color: #333;
+ background: #fff;
+ }
+.leaflet-control-layers-scrollbar {
+ overflow-y: scroll;
+ overflow-x: hidden;
+ padding-right: 5px;
+ }
+.leaflet-control-layers-selector {
+ margin-top: 2px;
+ position: relative;
+ top: 1px;
+ }
+.leaflet-control-layers label {
+ display: block;
+ font-size: 13px;
+ font-size: 1.08333em;
+ }
+.leaflet-control-layers-separator {
+ height: 0;
+ border-top: 1px solid #ddd;
+ margin: 5px -10px 5px -6px;
+ }
+
+/* Default icon URLs */
+.leaflet-default-icon-path { /* used only in path-guessing heuristic, see L.Icon.Default */
+ background-image: url(images/marker-icon.png);
+ }
+
+
+/* attribution and scale controls */
+
+.leaflet-container .leaflet-control-attribution {
+ background: #fff;
+ background: rgba(255, 255, 255, 0.8);
+ margin: 0;
+ }
+.leaflet-control-attribution,
+.leaflet-control-scale-line {
+ padding: 0 5px;
+ color: #333;
+ line-height: 1.4;
+ }
+.leaflet-control-attribution a {
+ text-decoration: none;
+ }
+.leaflet-control-attribution a:hover,
+.leaflet-control-attribution a:focus {
+ text-decoration: underline;
+ }
+.leaflet-attribution-flag {
+ display: inline !important;
+ vertical-align: baseline !important;
+ width: 1em;
+ height: 0.6669em;
+ }
+.leaflet-left .leaflet-control-scale {
+ margin-left: 5px;
+ }
+.leaflet-bottom .leaflet-control-scale {
+ margin-bottom: 5px;
+ }
+.leaflet-control-scale-line {
+ border: 2px solid #777;
+ border-top: none;
+ line-height: 1.1;
+ padding: 2px 5px 1px;
+ white-space: nowrap;
+ overflow: hidden;
+ -moz-box-sizing: border-box;
+ box-sizing: border-box;
+
+ background: #fff;
+ background: rgba(255, 255, 255, 0.5);
+ }
+.leaflet-control-scale-line:not(:first-child) {
+ border-top: 2px solid #777;
+ border-bottom: none;
+ margin-top: -2px;
+ }
+.leaflet-control-scale-line:not(:first-child):not(:last-child) {
+ border-bottom: 2px solid #777;
+ }
+
+.leaflet-touch .leaflet-control-attribution,
+.leaflet-touch .leaflet-control-layers,
+.leaflet-touch .leaflet-bar {
+ box-shadow: none;
+ }
+.leaflet-touch .leaflet-control-layers,
+.leaflet-touch .leaflet-bar {
+ border: 2px solid rgba(0,0,0,0.2);
+ background-clip: padding-box;
+ }
+
+
+/* popup */
+
+.leaflet-popup {
+ position: absolute;
+ text-align: center;
+ margin-bottom: 20px;
+ }
+.leaflet-popup-content-wrapper {
+ padding: 1px;
+ text-align: left;
+ border-radius: 12px;
+ }
+.leaflet-popup-content {
+ margin: 13px 24px 13px 20px;
+ line-height: 1.3;
+ font-size: 13px;
+ font-size: 1.08333em;
+ min-height: 1px;
+ }
+.leaflet-popup-content p {
+ margin: 17px 0;
+ margin: 1.3em 0;
+ }
+.leaflet-popup-tip-container {
+ width: 40px;
+ height: 20px;
+ position: absolute;
+ left: 50%;
+ margin-top: -1px;
+ margin-left: -20px;
+ overflow: hidden;
+ pointer-events: none;
+ }
+.leaflet-popup-tip {
+ width: 17px;
+ height: 17px;
+ padding: 1px;
+
+ margin: -10px auto 0;
+ pointer-events: auto;
+
+ -webkit-transform: rotate(45deg);
+ -moz-transform: rotate(45deg);
+ -ms-transform: rotate(45deg);
+ transform: rotate(45deg);
+ }
+.leaflet-popup-content-wrapper,
+.leaflet-popup-tip {
+ background: white;
+ color: #333;
+ box-shadow: 0 3px 14px rgba(0,0,0,0.4);
+ }
+.leaflet-container a.leaflet-popup-close-button {
+ position: absolute;
+ top: 0;
+ right: 0;
+ border: none;
+ text-align: center;
+ width: 24px;
+ height: 24px;
+ font: 16px/24px Tahoma, Verdana, sans-serif;
+ color: #757575;
+ text-decoration: none;
+ background: transparent;
+ }
+.leaflet-container a.leaflet-popup-close-button:hover,
+.leaflet-container a.leaflet-popup-close-button:focus {
+ color: #585858;
+ }
+.leaflet-popup-scrolled {
+ overflow: auto;
+ }
+
+.leaflet-oldie .leaflet-popup-content-wrapper {
+ -ms-zoom: 1;
+ }
+.leaflet-oldie .leaflet-popup-tip {
+ width: 24px;
+ margin: 0 auto;
+
+ -ms-filter: "progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)";
+ filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678);
+ }
+
+.leaflet-oldie .leaflet-control-zoom,
+.leaflet-oldie .leaflet-control-layers,
+.leaflet-oldie .leaflet-popup-content-wrapper,
+.leaflet-oldie .leaflet-popup-tip {
+ border: 1px solid #999;
+ }
+
+
+/* div icon */
+
+.leaflet-div-icon {
+ background: #fff;
+ border: 1px solid #666;
+ }
+
+
+/* Tooltip */
+/* Base styles for the element that has a tooltip */
+.leaflet-tooltip {
+ position: absolute;
+ padding: 6px;
+ background-color: #fff;
+ border: 1px solid #fff;
+ border-radius: 3px;
+ color: #222;
+ white-space: nowrap;
+ -webkit-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+ pointer-events: none;
+ box-shadow: 0 1px 3px rgba(0,0,0,0.4);
+ }
+.leaflet-tooltip.leaflet-interactive {
+ cursor: pointer;
+ pointer-events: auto;
+ }
+.leaflet-tooltip-top:before,
+.leaflet-tooltip-bottom:before,
+.leaflet-tooltip-left:before,
+.leaflet-tooltip-right:before {
+ position: absolute;
+ pointer-events: none;
+ border: 6px solid transparent;
+ background: transparent;
+ content: "";
+ }
+
+/* Directions */
+
+.leaflet-tooltip-bottom {
+ margin-top: 6px;
+}
+.leaflet-tooltip-top {
+ margin-top: -6px;
+}
+.leaflet-tooltip-bottom:before,
+.leaflet-tooltip-top:before {
+ left: 50%;
+ margin-left: -6px;
+ }
+.leaflet-tooltip-top:before {
+ bottom: 0;
+ margin-bottom: -12px;
+ border-top-color: #fff;
+ }
+.leaflet-tooltip-bottom:before {
+ top: 0;
+ margin-top: -12px;
+ margin-left: -6px;
+ border-bottom-color: #fff;
+ }
+.leaflet-tooltip-left {
+ margin-left: -6px;
+}
+.leaflet-tooltip-right {
+ margin-left: 6px;
+}
+.leaflet-tooltip-left:before,
+.leaflet-tooltip-right:before {
+ top: 50%;
+ margin-top: -6px;
+ }
+.leaflet-tooltip-left:before {
+ right: 0;
+ margin-right: -12px;
+ border-left-color: #fff;
+ }
+.leaflet-tooltip-right:before {
+ left: 0;
+ margin-left: -12px;
+ border-right-color: #fff;
+ }
+
+/* Printing */
+
+@media print {
+ /* Prevent printers from removing background-images of controls. */
+ .leaflet-control {
+ -webkit-print-color-adjust: exact;
+ print-color-adjust: exact;
+ }
+ }
diff --git a/app/static/js/leaflet.geometryutil.js b/app/static/js/leaflet.geometryutil.js
new file mode 100644
index 0000000..9bb53b3
--- /dev/null
+++ b/app/static/js/leaflet.geometryutil.js
@@ -0,0 +1,767 @@
+// Packaging/modules magic dance.
+(function (factory) {
+ var L;
+ if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(['leaflet'], factory);
+ } else if (typeof module !== 'undefined') {
+ // Node/CommonJS
+ L = require('leaflet');
+ module.exports = factory(L);
+ } else {
+ // Browser globals
+ if (typeof window.L === 'undefined')
+ throw 'Leaflet must be loaded first';
+ factory(window.L);
+ }
+}(function (L) {
+"use strict";
+
+L.Polyline._flat = L.LineUtil.isFlat || L.Polyline._flat || function (latlngs) {
+ // true if it's a flat array of latlngs; false if nested
+ return !L.Util.isArray(latlngs[0]) || (typeof latlngs[0][0] !== 'object' && typeof latlngs[0][0] !== 'undefined');
+};
+
+/**
+ * @fileOverview Leaflet Geometry utilities for distances and linear referencing.
+ * @name L.GeometryUtil
+ */
+
+L.GeometryUtil = L.extend(L.GeometryUtil || {}, {
+
+ /**
+ Shortcut function for planar distance between two {L.LatLng} at current zoom.
+
+ @tutorial distance-length
+
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {L.LatLng} latlngA geographical point A
+ @param {L.LatLng} latlngB geographical point B
+ @returns {Number} planar distance
+ */
+ distance: function (map, latlngA, latlngB) {
+ return map.latLngToLayerPoint(latlngA).distanceTo(map.latLngToLayerPoint(latlngB));
+ },
+
+ /**
+ Shortcut function for planar distance between a {L.LatLng} and a segment (A-B).
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {L.LatLng} latlng - The position to search
+ @param {L.LatLng} latlngA geographical point A of the segment
+ @param {L.LatLng} latlngB geographical point B of the segment
+ @returns {Number} planar distance
+ */
+ distanceSegment: function (map, latlng, latlngA, latlngB) {
+ var p = map.latLngToLayerPoint(latlng),
+ p1 = map.latLngToLayerPoint(latlngA),
+ p2 = map.latLngToLayerPoint(latlngB);
+ return L.LineUtil.pointToSegmentDistance(p, p1, p2);
+ },
+
+ /**
+ Shortcut function for converting distance to readable distance.
+ @param {Number} distance distance to be converted
+ @param {String} unit 'metric' or 'imperial'
+ @returns {String} in yard or miles
+ */
+ readableDistance: function (distance, unit) {
+ var isMetric = (unit !== 'imperial'),
+ distanceStr;
+ if (isMetric) {
+ // show metres when distance is < 1km, then show km
+ if (distance > 1000) {
+ distanceStr = (distance / 1000).toFixed(2) + ' km';
+ }
+ else {
+ distanceStr = distance.toFixed(1) + ' m';
+ }
+ }
+ else {
+ distance *= 1.09361;
+ if (distance > 1760) {
+ distanceStr = (distance / 1760).toFixed(2) + ' miles';
+ }
+ else {
+ distanceStr = distance.toFixed(1) + ' yd';
+ }
+ }
+ return distanceStr;
+ },
+
+ /**
+ Returns true if the latlng belongs to segment A-B
+ @param {L.LatLng} latlng - The position to search
+ @param {L.LatLng} latlngA geographical point A of the segment
+ @param {L.LatLng} latlngB geographical point B of the segment
+ @param {?Number} [tolerance=0.2] tolerance to accept if latlng belongs really
+ @returns {boolean}
+ */
+ belongsSegment: function(latlng, latlngA, latlngB, tolerance) {
+ tolerance = tolerance === undefined ? 0.2 : tolerance;
+ var hypotenuse = latlngA.distanceTo(latlngB),
+ delta = latlngA.distanceTo(latlng) + latlng.distanceTo(latlngB) - hypotenuse;
+ return delta/hypotenuse < tolerance;
+ },
+
+ /**
+ * Returns total length of line
+ * @tutorial distance-length
+ *
+ * @param {L.Polyline|Array|Array} coords Set of coordinates
+ * @returns {Number} Total length (pixels for Point, meters for LatLng)
+ */
+ length: function (coords) {
+ var accumulated = L.GeometryUtil.accumulatedLengths(coords);
+ return accumulated.length > 0 ? accumulated[accumulated.length-1] : 0;
+ },
+
+ /**
+ * Returns a list of accumulated length along a line.
+ * @param {L.Polyline|Array|Array} coords Set of coordinates
+ * @returns {Array} Array of accumulated lengths (pixels for Point, meters for LatLng)
+ */
+ accumulatedLengths: function (coords) {
+ if (typeof coords.getLatLngs == 'function') {
+ coords = coords.getLatLngs();
+ }
+ if (coords.length === 0)
+ return [];
+ var total = 0,
+ lengths = [0];
+ for (var i = 0, n = coords.length - 1; i< n; i++) {
+ total += coords[i].distanceTo(coords[i+1]);
+ lengths.push(total);
+ }
+ return lengths;
+ },
+
+ /**
+ Returns the closest point of a {L.LatLng} on the segment (A-B)
+
+ @tutorial closest
+
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {L.LatLng} latlng - The position to search
+ @param {L.LatLng} latlngA geographical point A of the segment
+ @param {L.LatLng} latlngB geographical point B of the segment
+ @returns {L.LatLng} Closest geographical point
+ */
+ closestOnSegment: function (map, latlng, latlngA, latlngB) {
+ var maxzoom = map.getMaxZoom();
+ if (maxzoom === Infinity)
+ maxzoom = map.getZoom();
+ var p = map.project(latlng, maxzoom),
+ p1 = map.project(latlngA, maxzoom),
+ p2 = map.project(latlngB, maxzoom),
+ closest = L.LineUtil.closestPointOnSegment(p, p1, p2);
+ return map.unproject(closest, maxzoom);
+ },
+
+ /**
+ Returns the closest latlng on layer.
+
+ Accept nested arrays
+
+ @tutorial closest
+
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {Array|Array>|L.PolyLine|L.Polygon} layer - Layer that contains the result
+ @param {L.LatLng} latlng - The position to search
+ @param {?boolean} [vertices=false] - Whether to restrict to path vertices.
+ @returns {L.LatLng} Closest geographical point or null if layer param is incorrect
+ */
+ closest: function (map, layer, latlng, vertices) {
+
+ var latlngs,
+ mindist = Infinity,
+ result = null,
+ i, n, distance, subResult;
+
+ if (layer instanceof Array) {
+ // if layer is Array>
+ if (layer[0] instanceof Array && typeof layer[0][0] !== 'number') {
+ // if we have nested arrays, we calc the closest for each array
+ // recursive
+ for (i = 0; i < layer.length; i++) {
+ subResult = L.GeometryUtil.closest(map, layer[i], latlng, vertices);
+ if (subResult && subResult.distance < mindist) {
+ mindist = subResult.distance;
+ result = subResult;
+ }
+ }
+ return result;
+ } else if (layer[0] instanceof L.LatLng
+ || typeof layer[0][0] === 'number'
+ || typeof layer[0].lat === 'number') { // we could have a latlng as [x,y] with x & y numbers or {lat, lng}
+ layer = L.polyline(layer);
+ } else {
+ return result;
+ }
+ }
+
+ // if we don't have here a Polyline, that means layer is incorrect
+ // see https://github.com/makinacorpus/Leaflet.GeometryUtil/issues/23
+ if (! ( layer instanceof L.Polyline ) )
+ return result;
+
+ // deep copy of latlngs
+ latlngs = JSON.parse(JSON.stringify(layer.getLatLngs().slice(0)));
+
+ // add the last segment for L.Polygon
+ if (layer instanceof L.Polygon) {
+ // add the last segment for each child that is a nested array
+ var addLastSegment = function(latlngs) {
+ if (L.Polyline._flat(latlngs)) {
+ latlngs.push(latlngs[0]);
+ } else {
+ for (var i = 0; i < latlngs.length; i++) {
+ addLastSegment(latlngs[i]);
+ }
+ }
+ };
+ addLastSegment(latlngs);
+ }
+
+ // we have a multi polygon / multi polyline / polygon with holes
+ // use recursive to explore and return the good result
+ if ( ! L.Polyline._flat(latlngs) ) {
+ for (i = 0; i < latlngs.length; i++) {
+ // if we are at the lower level, and if we have a L.Polygon, we add the last segment
+ subResult = L.GeometryUtil.closest(map, latlngs[i], latlng, vertices);
+ if (subResult.distance < mindist) {
+ mindist = subResult.distance;
+ result = subResult;
+ }
+ }
+ return result;
+
+ } else {
+
+ // Lookup vertices
+ if (vertices) {
+ for(i = 0, n = latlngs.length; i < n; i++) {
+ var ll = latlngs[i];
+ distance = L.GeometryUtil.distance(map, latlng, ll);
+ if (distance < mindist) {
+ mindist = distance;
+ result = ll;
+ result.distance = distance;
+ }
+ }
+ return result;
+ }
+
+ // Keep the closest point of all segments
+ for (i = 0, n = latlngs.length; i < n-1; i++) {
+ var latlngA = latlngs[i],
+ latlngB = latlngs[i+1];
+ distance = L.GeometryUtil.distanceSegment(map, latlng, latlngA, latlngB);
+ if (distance <= mindist) {
+ mindist = distance;
+ result = L.GeometryUtil.closestOnSegment(map, latlng, latlngA, latlngB);
+ result.distance = distance;
+ }
+ }
+ return result;
+ }
+
+ },
+
+ /**
+ Returns the closest layer to latlng among a list of layers.
+
+ @tutorial closest
+
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {Array} layers Set of layers
+ @param {L.LatLng} latlng - The position to search
+ @returns {object} ``{layer, latlng, distance}`` or ``null`` if list is empty;
+ */
+ closestLayer: function (map, layers, latlng) {
+ var mindist = Infinity,
+ result = null,
+ ll = null,
+ distance = Infinity;
+
+ for (var i = 0, n = layers.length; i < n; i++) {
+ var layer = layers[i];
+ if (layer instanceof L.LayerGroup) {
+ // recursive
+ var subResult = L.GeometryUtil.closestLayer(map, layer.getLayers(), latlng);
+ if (subResult.distance < mindist) {
+ mindist = subResult.distance;
+ result = subResult;
+ }
+ } else {
+ // Single dimension, snap on points, else snap on closest
+ if (typeof layer.getLatLng == 'function') {
+ ll = layer.getLatLng();
+ distance = L.GeometryUtil.distance(map, latlng, ll);
+ }
+ else {
+ ll = L.GeometryUtil.closest(map, layer, latlng);
+ if (ll) distance = ll.distance; // Can return null if layer has no points.
+ }
+ if (distance < mindist) {
+ mindist = distance;
+ result = {layer: layer, latlng: ll, distance: distance};
+ }
+ }
+ }
+ return result;
+ },
+
+ /**
+ Returns the n closest layers to latlng among a list of input layers.
+
+ @param {L.Map} map - Leaflet map to be used for this method
+ @param {Array} layers - Set of layers
+ @param {L.LatLng} latlng - The position to search
+ @param {?Number} [n=layers.length] - the expected number of output layers.
+ @returns {Array