extend addData method NOT WORK

Author: stefanocudini

README.md

@@ -10,6 +10,7 @@ The algorithm is documented in [Google Maps API Docs](https://developers.google.
 - [pip](https://pip.pypa.io/en/latest/installing.html)
 - [flask](http://flask.pocoo.org/)
 - [flask-cors](http://flask-cors.readthedocs.org/en/latest/)
+- [watchdog](https://pypi.python.org/pypi/watchdog)
 
 
 ### Installation

examples/index.html

@@ -33,9 +33,9 @@ <h4>Simple Example</h4>
 	<div class="maps" id="map1"></div>
 	<div class="maps" id="map2"></div>
 </div>
-<script src="../node_modules/leaflet/dist/leaflet.js"></script>
-<script src="../node_modules/polyline-encoded/Polyline.encoded.js"></script>
 <script src="../node_modules/jquery/dist/jquery.min.js"></script>
+<script src="../node_modules/leaflet/dist/leaflet-src.js"></script>
+<script src="../node_modules/polyline-encoded/Polyline.encoded.js"></script>
 <script src="../src/leaflet.geojson.encoded.js"></script>
 <script>
 
@@ -53,8 +53,8 @@ <h4>Simple Example</h4>
 	});
 
 	$.getJSON('http://localhost:8000/encode/geojson_test.json', function(data) {
-		
-		var geoEnc = L.GeoJSON.Encoded(data);
+
+		var geoEnc = new L.GeoJSON.Encoded(data);
 
 		map2.addLayer(geoEnc).fitBounds( geoEnc.getBounds() );
 	});	

requirements.txt

@@ -1,2 +1,3 @@
 flask
-flask-cors
+flask-cors
+watchdog

src/leaflet.geojson.encoded.js

@@ -1,74 +1,103 @@
 (function() {
 
-function _build_linestrings(geom) {
+L.GeoJSON.Encoded = L.GeoJSON.extend({
 
-    var paths = [];
-    for (var j = 0; j < geom.length; j++) {
-        paths.push(L.PolylineUtil.decode(geom[j]));
-    }
-    return paths;
-}
+	_decodeFeature: function(feature) {
 
-function _build_polygons(geom) {
-    var polygons = [];
-    for (var i = 0; i < geom.length; i++) {
-        polygons.push(_build_linestrings(geom[i]));
-    }
-    return polygons;
-}
+		var resp;
 
-function decodeToLayer(featureCollection, targetLayer, style, onEachFeature) {
-    var geom,bb,
-    	features = featureCollection["features"],
-    	popupOpts = {closeButton: false};
+		function _build_linestrings(geom) {
+		    var paths = [];
+		    for (var j = 0; j < geom.length; j++)
+		        paths.push( L.PolylineUtil.decode(geom[j]) );
+		    return paths;
+		}
 
-    for (var i = 0; i < features.length; i++) {
-        var feature = features[i];
+		function _build_polygons(geom) {
+		    var polygons = [];
+		    for (var i = 0; i < geom.length; i++)
+		        polygons.push( _build_linestrings(geom[i]) );
+		    return polygons;
+		}
 
-        geom = feature["geometry"]["coordinates"];
+        var geom = feature["geometry"]["coordinates"];
 
         switch(feature["geometry"]["type"]) {
             case "Point":
-                L.marker([geom[1], geom[0]]).addTo(targetLayer);
+                
+                resp = L.marker([geom[1], geom[0]]);
+
                 break;
             case "LineString":
                 var coords = L.Util.isArray(geom[0]) ? L.GeoJSON.coordsToLatLngs(geom, 0) : L.PolylineUtil.decode(geom);
 
-                var poly = L.polyline(coords, style).addTo(targetLayer);
-                onEachFeature(feature, poly);
+                resp = L.polyline(coords);
 
                 break;
             case "MultiLineString":
-                var ls = L.Util.isArray(geom[0][0]) ? L.GeoJSON.coordsToLatLngs(geom, 1) : _build_linestrings(geom);
+                var coords = L.Util.isArray(geom[0][0]) ? L.GeoJSON.coordsToLatLngs(geom, 1) : _build_linestrings(geom);
 
-                var poly = L.multiPolyline(ls, style).addTo(targetLayer);
-                onEachFeature(feature, poly);
+                resp = L.multiPolyline(coords);
 
                 break;
             case "Polygon":
                 var rings = L.Util.isArray(geom[0][0]) ? L.GeoJSON.coordsToLatLngs(geom, 1) : _build_linestrings(geom);
 
-                var poly = L.polygon(rings, style).addTo(targetLayer);
-                onEachFeature(feature, poly);
+                resp = L.polygon(rings);
 
                 break;
             case "MultiPolygon":
                 var polygons = L.Util.isArray(geom[0][0]) ? L.GeoJSON.coordsToLatLngs(geom, 2) : _build_polygons(geom);
 
-                var poly = L.multiPolygon(polygons, style).addTo(targetLayer);
-                onEachFeature(feature, poly);
+                resp = L.multiPolygon(polygons);
 
                 break;
-            default:
-                console.error(feature.geometry.type + ' not implemented.');
         }
-    }
-    return targetLayer;
-}
 
-L.GeoJSON.Encoded = L.GeoJSON.extend({
+        return resp.toGeoJSON();
+	},
+
+	addData: function (geojsonEnc) {
 
-/*	addData: function (geojson) {
+		var features = L.Util.isArray(geojsonEnc) ? geojsonEnc : geojsonEnc.features,
+		    i, len, feature;
+
+		if (features) {
+			for (i = 0, len = features.length; i < len; i++) {
+				// only add this if geometry or geometries are set and not null
+
+				feature = this._decodeFeature(features[i]);
+				//feature = features[i];
+
+				console.log(features[i], feature);
+
+				if (feature.geometries || feature.geometry || feature.features || feature.coordinates) {
+					this.addData(feature);
+				}
+			}
+			return this;
+		}
+
+		var options = this.options;
+
+		if (options.filter && !options.filter(geojsonEnc)) { return this; }
+
+		var layer = L.GeoJSON.geometryToLayer(geojsonEnc, options);
+		layer.feature = L.GeoJSON.asFeature(geojsonEnc);
+
+		layer.defaultOptions = layer.options;
+		this.resetStyle(layer);
+
+		if (options.onEachFeature) {
+			options.onEachFeature(geojsonEnc, layer);
+		}
+
+		return this.addLayer(layer);
+		//return L.GeoJSON.prototype.addData.call(this, geojsonEnc);
+	}
+// */
+/*	DEFAULT GeoJSON METHOD
+	addData: function (geojson) {
 		var features = L.Util.isArray(geojson) ? geojson : geojson.features,
 		    i, len, feature;
 
@@ -100,9 +129,59 @@ L.GeoJSON.Encoded = L.GeoJSON.extend({
 		return this.addLayer(layer);
 	}*/
 });
+/*
+
+L.extend(L.GeoJSON.Encoded, {
+	geometryToLayer: function (geojson, options) {
+
+		var geometry = geojson.type === 'Feature' ? geojson.geometry : geojson,
+		    coords = geometry.coordinates,
+		    layers = [],
+		    pointToLayer = options && options.pointToLayer,
+		    coordsToLatLng = options && options.coordsToLatLng || this.coordsToLatLng,
+		    latlng, latlngs, i, len;
+
+		switch (geometry.type) {
+		case 'Point':
+			latlng = coordsToLatLng(coords);
+			return pointToLayer ? pointToLayer(geojson, latlng) : new L.Marker(latlng);
+
+		case 'MultiPoint':
+			for (i = 0, len = coords.length; i < len; i++) {
+				latlng = coordsToLatLng(coords[i]);
+				layers.push(pointToLayer ? pointToLayer(geojson, latlng) : new L.Marker(latlng));
+			}
+			return new L.FeatureGroup(layers);
+
+		case 'LineString':
+		case 'MultiLineString':
+			latlngs = this.coordsToLatLngs(coords, geometry.type === 'LineString' ? 0 : 1, coordsToLatLng);
+			return new L.Polyline(latlngs, options);
+
+		case 'Polygon':
+		case 'MultiPolygon':
+			latlngs = this.coordsToLatLngs(coords, geometry.type === 'Polygon' ? 1 : 2, coordsToLatLng);
+			return new L.Polygon(latlngs, options);
+
+		case 'GeometryCollection':
+			for (i = 0, len = geometry.geometries.length; i < len; i++) {
+
+				layers.push(this.geometryToLayer({
+					geometry: geometry.geometries[i],
+					type: 'Feature',
+					properties: geojson.properties
+				}, options));
+			}
+			return new L.FeatureGroup(layers);
+
+		default:
+			throw new Error('Invalid GeoJSON object.');
+		}
+	}
+});*/
 
-L.geoJson.encoded = function (options) {
-    return new L.GeoJSON.Encoded(options);
+L.geoJson.encoded = function (geojson, options) {
+    return new L.GeoJSON.Encoded(geojson, options);
 };
 
 }).call(this);