no-heatmap.js 2.0.8

package/plugins/leaflet-heatmap/leaflet-heatmap.js

@@ -0,0 +1,246 @@
+/*
+* Leaflet Heatmap Overlay
+*
+* Copyright (c) 2008-2016, Patrick Wied (https://www.patrick-wied.at)
+* Dual-licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
+* and the Beerware (http://en.wikipedia.org/wiki/Beerware) license.
+*/
+;(function (name, context, factory) {
+  // Supports UMD. AMD, CommonJS/Node.js and browser context
+  if (typeof module !== "undefined" && module.exports) {
+    module.exports = factory(
+      require('heatmap.js'),
+      require('leaflet')
+    );
+  } else if (typeof define === "function" && define.amd) {
+    define(['heatmap.js', 'leaflet'], factory);
+  } else {
+    // browser globals
+    if (typeof window.h337 === 'undefined') {
+      throw new Error('heatmap.js must be loaded before the leaflet heatmap plugin');
+    }
+    if (typeof window.L === 'undefined') {
+      throw new Error('Leaflet must be loaded before the leaflet heatmap plugin');
+    }
+    context[name] = factory(window.h337, window.L);
+  }
+
+})("HeatmapOverlay", this, function (h337, L) {
+  'use strict';
+
+  // Leaflet < 0.8 compatibility
+  if (typeof L.Layer === 'undefined') {
+    L.Layer = L.Class;
+  }
+
+  var HeatmapOverlay = L.Layer.extend({
+
+    initialize: function (config) {
+      this.cfg = config;
+      this._el = L.DomUtil.create('div', 'leaflet-zoom-hide');
+      this._data = [];
+      this._max = 1;
+      this._min = 0;
+      this.cfg.container = this._el;
+    },
+
+    onAdd: function (map) {
+      var size = map.getSize();
+
+      this._map = map;
+
+      this._width = size.x;
+      this._height = size.y;
+
+      this._el.style.width = size.x + 'px';
+      this._el.style.height = size.y + 'px';
+      this._el.style.position = 'absolute';
+
+      this._origin = this._map.layerPointToLatLng(new L.Point(0, 0));
+
+      map.getPanes().overlayPane.appendChild(this._el);
+
+      if (!this._heatmap) {
+        this._heatmap = h337.create(this.cfg);
+      } 
+
+      // this resets the origin and redraws whenever
+      // the zoom changed or the map has been moved
+      map.on('moveend', this._reset, this);
+      this._draw();
+    },
+
+    addTo: function (map) {
+      map.addLayer(this);
+      return this;
+    },
+
+    onRemove: function (map) {
+      // remove layer's DOM elements and listeners
+      map.getPanes().overlayPane.removeChild(this._el);
+
+      map.off('moveend', this._reset, this);
+    },
+    _draw: function() {
+      if (!this._map) { return; }
+      
+      var mapPane = this._map.getPanes().mapPane;
+      var point = mapPane._leaflet_pos;      
+
+      // reposition the layer
+      this._el.style[HeatmapOverlay.CSS_TRANSFORM] = 'translate(' +
+        -Math.round(point.x) + 'px,' +
+        -Math.round(point.y) + 'px)';
+
+      this._update();
+    },
+    _update: function() {
+      var bounds, zoom, scale;
+      var generatedData = { max: this._max, min: this._min, data: [] };
+
+      bounds = this._map.getBounds();
+      zoom = this._map.getZoom();
+      scale = Math.pow(2, zoom);
+
+      if (this._data.length == 0) {
+        if (this._heatmap) {
+          this._heatmap.setData(generatedData);
+        }
+        return;
+      }
+
+
+      var latLngPoints = [];
+      var radiusMultiplier = this.cfg.scaleRadius ? scale : 1;
+      var localMax = 0;
+      var localMin = 0;
+      var valueField = this.cfg.valueField;
+      var len = this._data.length;
+    
+      while (len--) {
+        var entry = this._data[len];
+        var value = entry[valueField];
+        var latlng = entry.latlng;
+
+
+        // we don't wanna render points that are not even on the map ;-)
+        if (!bounds.contains(latlng)) {
+          continue;
+        }
+        // local max is the maximum within current bounds
+        localMax = Math.max(value, localMax);
+        localMin = Math.min(value, localMin);
+
+        var point = this._map.latLngToContainerPoint(latlng);
+        var latlngPoint = { x: Math.round(point.x), y: Math.round(point.y) };
+        latlngPoint[valueField] = value;
+
+        var radius;
+
+        if (entry.radius) {
+          radius = entry.radius * radiusMultiplier;
+        } else {
+          radius = (this.cfg.radius || 2) * radiusMultiplier;
+        }
+        latlngPoint.radius = radius;
+        latLngPoints.push(latlngPoint);
+      }
+      if (this.cfg.useLocalExtrema) {
+        generatedData.max = localMax;
+        generatedData.min = localMin;
+      }
+
+      generatedData.data = latLngPoints;
+
+      this._heatmap.setData(generatedData);
+    },
+    setData: function(data) {
+      this._max = data.max || this._max;
+      this._min = data.min || this._min;
+      var latField = this.cfg.latField || 'lat';
+      var lngField = this.cfg.lngField || 'lng';
+      var valueField = this.cfg.valueField || 'value';
+    
+      // transform data to latlngs
+      var data = data.data;
+      var len = data.length;
+      var d = [];
+    
+      while (len--) {
+        var entry = data[len];
+        var latlng = new L.LatLng(entry[latField], entry[lngField]);
+        var dataObj = { latlng: latlng };
+        dataObj[valueField] = entry[valueField];
+        if (entry.radius) {
+          dataObj.radius = entry.radius;
+        }
+        d.push(dataObj);
+      }
+      this._data = d;
+    
+      this._draw();
+    },
+    // experimential... not ready.
+    addData: function(pointOrArray) {
+      if (pointOrArray.length > 0) {
+        var len = pointOrArray.length;
+        while(len--) {
+          this.addData(pointOrArray[len]);
+        }
+      } else {
+        var latField = this.cfg.latField || 'lat';
+        var lngField = this.cfg.lngField || 'lng';
+        var valueField = this.cfg.valueField || 'value';
+        var entry = pointOrArray;
+        var latlng = new L.LatLng(entry[latField], entry[lngField]);
+        var dataObj = { latlng: latlng };
+        
+        dataObj[valueField] = entry[valueField];
+        this._max = Math.max(this._max, dataObj[valueField]);
+        this._min = Math.min(this._min, dataObj[valueField]);
+
+        if (entry.radius) {
+          dataObj.radius = entry.radius;
+        }
+        this._data.push(dataObj);
+        this._draw();
+      }
+    },
+    _reset: function () {
+      this._origin = this._map.layerPointToLatLng(new L.Point(0, 0));
+      
+      var size = this._map.getSize();
+      if (this._width !== size.x || this._height !== size.y) {
+        this._width  = size.x;
+        this._height = size.y;
+
+        this._el.style.width = this._width + 'px';
+        this._el.style.height = this._height + 'px';
+
+        this._heatmap._renderer.setDimensions(this._width, this._height);
+      }
+      this._draw();
+    } 
+  });
+
+  HeatmapOverlay.CSS_TRANSFORM = (function() {
+    var div = document.createElement('div');
+    var props = [
+      'transform',
+      'WebkitTransform',
+      'MozTransform',
+      'OTransform',
+      'msTransform'
+    ];
+
+    for (var i = 0; i < props.length; i++) {
+      var prop = props[i];
+      if (div.style[prop] !== undefined) {
+        return prop;
+      }
+    }
+    return props[0];
+  })();
+
+  return HeatmapOverlay;
+});

package/plugins/leaflet-heatmap/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "leaflet-heatmap",
+  "version": "1.0.0",
+  "description": "heatmap.js Leaflet Overlay",
+  "homepage": "https://www.patrick-wied.at/static/heatmapjs/",
+  "main": "leaflet-heatmap.js",
+  "dependencies": {
+    "heatmap.js": "*",
+    "leaflet": "*"
+  },
+  "keywords": [
+    "heatmap",
+    "leaflet",
+    "heat",
+    "heat map",
+    "heatmaps",
+    "heat maps",
+    "map",
+    "maps"
+  ]
+}

package/plugins/segment-heatmap.js

@@ -0,0 +1,71 @@
+(function() {
+  'use strict';
+
+  var segmentHeatmapPlugin = (function SegmentHeatmapPluginClosure() {
+
+    var defaultSegmentsX = 10;
+    var defaultSegmentsY = 5;
+
+    function SegmentStore(config) {
+      this._coordinator = {};
+      this._data = [];
+      this._max = 1;
+      this._min = 0;
+      this._initSegments();
+    };
+
+    SegmentStore.prototype = {
+      _initSegments: function() {
+
+      },
+      setCoordinator: function(coordinator) {
+
+      },
+      setData: function(data) {
+        var max = data.max;
+        var min = data.min;
+        var data = data.data;
+
+        this._coordinator.emit('renderall', {
+          min: min,
+          max: max,
+          data: data
+        });
+      },
+      addData: function(data) {
+
+      },
+      removeData: function(data) {
+
+      },
+      getData: function() {
+        return this._data;
+      }
+    };
+
+
+
+    function SegmentRenderer(config) {
+
+    };
+    SegmentRenderer.prototype = {
+      renderAll: function(data) {
+        
+      },
+      renderPartial: function(data) {
+
+      },
+      getDataURL: function() {
+
+      }
+    };  
+
+    return {
+      store: SegmentStore,
+      renderer: SegmentRenderer
+    }
+  }());
+
+  h337.register('segment-heatmap', segmentHeatmapPlugin);
+
+}());

package/plugins/svg-area-heatmap.js

@@ -0,0 +1,195 @@
+/*
+* SVG Area Heatmap Plugin
+*
+* Copyright (c) 2014, Patrick Wied (http://www.patrick-wied.at)
+* Dual-licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
+* and the Beerware (http://en.wikipedia.org/wiki/Beerware) license.
+*/
+(function() {
+  'use strict';
+
+  var SvgAreaHeatmap = (function SvgAreaHeatmapClosure() {
+
+    var _getColorPalette = function(config) {
+      var gradientConfig = config.gradient || config.defaultGradient;
+      var paletteCanvas = document.createElement('canvas');
+      var paletteCtx = paletteCanvas.getContext('2d');
+
+      paletteCanvas.width = 256;
+      paletteCanvas.height = 1;
+
+      var gradient = paletteCtx.createLinearGradient(0, 0, 256, 1);
+      for (var key in gradientConfig) {
+        gradient.addColorStop(key, gradientConfig[key]);
+      }
+
+      paletteCtx.fillStyle = gradient;
+      paletteCtx.fillRect(0, 0, 256, 1);
+
+      return paletteCtx.getImageData(0, 0, 256, 1).data;
+    };
+
+
+    function SvgAreaHeatmapStore(config) {
+      this._coordinator = {};
+      this._data = {};
+      this._max = 1;
+      this._min = 0;
+    };
+
+    SvgAreaHeatmapStore.prototype = {
+      setCoordinator: function(coordinator) {
+        this._coordinator = coordinator;
+      },
+      setData: function(data) {
+        this._max = data.max || this._max;
+        this._min = data.min || this._min;
+        this._data = {};
+
+        var d =  data.data;
+        var dataLen = d.length;
+
+        while (dataLen--) {
+          this._organiseData(d[dataLen]);
+        }
+
+        this._coordinator.emit('renderall', this._getInternalData());
+      },
+      addData: function(data) {
+        var organisedEntry = this._organiseData(data);
+        if (organisedEntry) {
+          this._coordinator.emit('renderpartial', {
+            min: this._min,
+            max: this._max,
+            data: [organisedEntry]
+          });
+        }
+      },
+      updateData: function(data) {
+
+      },
+      removeData: function(data) {
+
+      },
+      getData: function() {
+
+      },
+      setDataMax: function(max) {
+        this._max = max;
+        //this._onExtremaChange();
+        this._coordinator.emit('renderall', this._getInternalData());
+        return this;
+      },
+      setDataMin: function(min) {
+        this._min = min;
+        //this._onExtremaChange();
+        this._coordinator.emit('renderall', this._getInternalData());
+        return this;
+      },
+      _organiseData: function(point) {
+        if (this._data[point.id]) {
+          this._data[point.id] += point.value;
+
+        } else {
+          this._data[point.id] = point.value;
+        }
+
+        if (this._data[point.id] > this._max) {
+          this.setDataMax(this._data[point.id]);
+        }
+        if (this._data[point.id] < this._min) {
+          this.setDataMin(this._data[point.id]);
+        }
+        return point;
+      },
+      _getInternalData: function() {
+        return { 
+          max: this._max,
+          min: this._min, 
+          data: this._data,
+        };
+      }
+    };
+
+
+    function SvgAreaHeatmapRenderer(config) {
+      // initialization
+      var container = config.container;
+      var svgUrl = config.svgUrl;
+      this.renderQueue = [];
+
+
+      var svgObj = document.createElement('object');
+      svgObj.type = 'image/svg+xml';
+      svgObj.id = 'svgHeatmap';
+      svgObj.data = svgUrl;
+
+      var that = this;
+
+      svgObj.onload = function() {
+        that.svgDoc = this.getSVGDocument();
+        that.$ = function(selector) {
+          return that.svgDoc.querySelector(selector);
+        };
+
+        that._processQueue();
+      }
+
+      container.appendChild(svgObj);
+
+      this._palette = _getColorPalette(config);
+
+    };
+
+    SvgAreaHeatmapRenderer.prototype = {
+      renderPartial: function(data) {
+        var point = data.data[0];
+        this.max = data.max;
+        this.min = data.min;
+        this._colorize(point.id, point.value);
+      },
+      renderAll: function(data) {
+        var points = data.data;
+        this.max = data.max;
+        this.min = data.min;
+        for (var key in points) {
+          this._colorize(key, points[key]);
+        }
+      },
+      _colorize: function(key, value) {
+        
+        if (!this.svgDoc) {
+          this.renderQueue.push([key, value]);
+        } else {
+          var node = this.$('#' + key);
+          var color;
+          var max = this.max;
+          var min = this.min;
+          var colorIndex = (((value/(Math.abs(max-min)) * 255) >> 0) * 4);
+
+          var r = this._palette[colorIndex];
+          var g = this._palette[colorIndex + 1];
+          var b = this._palette[colorIndex + 2];
+
+          node.style.fill = ['rgb(', r, ',', g, ',', b,')'].join('');
+        }
+      },
+      _processQueue: function() {
+        var renderElement = this.renderQueue.pop();
+        if (!renderElement) {
+          return;
+        }
+        this._colorize.apply(this, renderElement);
+        this._processQueue();
+      }
+    };
+
+    return {
+      store: SvgAreaHeatmapStore,
+      renderer: SvgAreaHeatmapRenderer
+    }
+  }());
+
+  h337.register('SvgAreaHeatmap', SvgAreaHeatmap);
+
+}());