Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

source: extensions/piwigo-openstreetmap/leaflet/leaflet.markercluster-src.js @ 31680

Last change on this file since 31680 was 24677, checked in by ddtddt, 11 years ago
[extensions] - piwigo-openstreetmap - add file for translate
File size: 53.6 KB

Rev	Line
[24677]	1	/*
	2	Leaflet.markercluster, Provides Beautiful Animated Marker Clustering functionality for Leaflet, a JS library for interactive maps.
	3	https://github.com/Leaflet/Leaflet.markercluster
	4	(c) 2012-2013, Dave Leaver, smartrak
	5	*/
	6	(function (window, document, undefined) {
	7	/*
	8	* L.MarkerClusterGroup extends L.FeatureGroup by clustering the markers contained within
	9	*/
	10
	11	L.MarkerClusterGroup = L.FeatureGroup.extend({
	12
	13	options: {
	14	maxClusterRadius: 80, //A cluster will cover at most this many pixels from its center
	15	iconCreateFunction: null,
	16
	17	spiderfyOnMaxZoom: true,
	18	showCoverageOnHover: true,
	19	zoomToBoundsOnClick: true,
	20	singleMarkerMode: false,
	21
	22	disableClusteringAtZoom: null,
	23
	24	// Setting this to false prevents the removal of any clusters outside of the viewpoint, which
	25	// is the default behaviour for performance reasons.
	26	removeOutsideVisibleBounds: true,
	27
	28	//Whether to animate adding markers after adding the MarkerClusterGroup to the map
	29	// If you are adding individual markers set to true, if adding bulk markers leave false for massive performance gains.
	30	animateAddingMarkers: false,
	31
	32	//Increase to increase the distance away that spiderfied markers appear from the center
	33	spiderfyDistanceMultiplier: 1,
	34
	35	//Options to pass to the L.Polygon constructor
	36	polygonOptions: {}
	37	},
	38
	39	initialize: function (options) {
	40	L.Util.setOptions(this, options);
	41	if (!this.options.iconCreateFunction) {
	42	this.options.iconCreateFunction = this._defaultIconCreateFunction;
	43	}
	44
	45	this._featureGroup = L.featureGroup();
	46	this._featureGroup.on(L.FeatureGroup.EVENTS, this._propagateEvent, this);
	47
	48	this._nonPointGroup = L.featureGroup();
	49	this._nonPointGroup.on(L.FeatureGroup.EVENTS, this._propagateEvent, this);
	50
	51	this._inZoomAnimation = 0;
	52	this._needsClustering = [];
	53	this._needsRemoving = []; //Markers removed while we aren't on the map need to be kept track of
	54	//The bounds of the currently shown area (from _getExpandedVisibleBounds) Updated on zoom/move
	55	this._currentShownBounds = null;
	56	},
	57
	58	addLayer: function (layer) {
	59
	60	if (layer instanceof L.LayerGroup) {
	61	var array = [];
	62	for (var i in layer._layers) {
	63	array.push(layer._layers[i]);
	64	}
	65	return this.addLayers(array);
	66	}
	67
	68	//Don't cluster non point data
	69	if (!layer.getLatLng) {
	70	this._nonPointGroup.addLayer(layer);
	71	return this;
	72	}
	73
	74	if (!this._map) {
	75	this._needsClustering.push(layer);
	76	return this;
	77	}
	78
	79	if (this.hasLayer(layer)) {
	80	return this;
	81	}
	82
	83
	84	//If we have already clustered we'll need to add this one to a cluster
	85
	86	if (this._unspiderfy) {
	87	this._unspiderfy();
	88	}
	89
	90	this._addLayer(layer, this._maxZoom);
	91
	92	//Work out what is visible
	93	var visibleLayer = layer,
	94	currentZoom = this._map.getZoom();
	95	if (layer.__parent) {
	96	while (visibleLayer.__parent._zoom >= currentZoom) {
	97	visibleLayer = visibleLayer.__parent;
	98	}
	99	}
	100
	101	if (this._currentShownBounds.contains(visibleLayer.getLatLng())) {
	102	if (this.options.animateAddingMarkers) {
	103	this._animationAddLayer(layer, visibleLayer);
	104	} else {
	105	this._animationAddLayerNonAnimated(layer, visibleLayer);
	106	}
	107	}
	108	return this;
	109	},
	110
	111	removeLayer: function (layer) {
	112
	113	//Non point layers
	114	if (!layer.getLatLng) {
	115	this._nonPointGroup.removeLayer(layer);
	116	return this;
	117	}
	118
	119	if (!this._map) {
	120	if (!this._arraySplice(this._needsClustering, layer) && this.hasLayer(layer)) {
	121	this._needsRemoving.push(layer);
	122	}
	123	return this;
	124	}
	125
	126	if (!layer.__parent) {
	127	return this;
	128	}
	129
	130	if (this._unspiderfy) {
	131	this._unspiderfy();
	132	this._unspiderfyLayer(layer);
	133	}
	134
	135	//Remove the marker from clusters
	136	this._removeLayer(layer, true);
	137
	138	if (this._featureGroup.hasLayer(layer)) {
	139	this._featureGroup.removeLayer(layer);
	140	if (layer.setOpacity) {
	141	layer.setOpacity(1);
	142	}
	143	}
	144
	145	return this;
	146	},
	147
	148	//Takes an array of markers and adds them in bulk
	149	addLayers: function (layersArray) {
	150	var i, l, m,
	151	onMap = this._map,
	152	fg = this._featureGroup,
	153	npg = this._nonPointGroup;
	154
	155	for (i = 0, l = layersArray.length; i < l; i++) {
	156	m = layersArray[i];
	157
	158	//Not point data, can't be clustered
	159	if (!m.getLatLng) {
	160	npg.addLayer(m);
	161	continue;
	162	}
	163
	164	if (this.hasLayer(m)) {
	165	continue;
	166	}
	167
	168	if (!onMap) {
	169	this._needsClustering.push(m);
	170	continue;
	171	}
	172
	173	this._addLayer(m, this._maxZoom);
	174
	175	//If we just made a cluster of size 2 then we need to remove the other marker from the map (if it is) or we never will
	176	if (m.__parent) {
	177	if (m.__parent.getChildCount() === 2) {
	178	var markers = m.__parent.getAllChildMarkers(),
	179	otherMarker = markers[0] === m ? markers[1] : markers[0];
	180	fg.removeLayer(otherMarker);
	181	}
	182	}
	183	}
	184
	185	if (onMap) {
	186	//Update the icons of all those visible clusters that were affected
	187	fg.eachLayer(function (c) {
	188	if (c instanceof L.MarkerCluster && c._iconNeedsUpdate) {
	189	c._updateIcon();
	190	}
	191	});
	192
	193	this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
	194	}
	195
	196	return this;
	197	},
	198
	199	//Takes an array of markers and removes them in bulk
	200	removeLayers: function (layersArray) {
	201	var i, l, m,
	202	fg = this._featureGroup,
	203	npg = this._nonPointGroup;
	204
	205	if (!this._map) {
	206	for (i = 0, l = layersArray.length; i < l; i++) {
	207	m = layersArray[i];
	208	this._arraySplice(this._needsClustering, m);
	209	npg.removeLayer(m);
	210	}
	211	return this;
	212	}
	213
	214	for (i = 0, l = layersArray.length; i < l; i++) {
	215	m = layersArray[i];
	216
	217	if (!m.__parent) {
	218	npg.removeLayer(m);
	219	continue;
	220	}
	221
	222	this._removeLayer(m, true, true);
	223
	224	if (fg.hasLayer(m)) {
	225	fg.removeLayer(m);
	226	if (m.setOpacity) {
	227	m.setOpacity(1);
	228	}
	229	}
	230	}
	231
	232	//Fix up the clusters and markers on the map
	233	this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
	234
	235	fg.eachLayer(function (c) {
	236	if (c instanceof L.MarkerCluster) {
	237	c._updateIcon();
	238	}
	239	});
	240
	241	return this;
	242	},
	243
	244	//Removes all layers from the MarkerClusterGroup
	245	clearLayers: function () {
	246	//Need our own special implementation as the LayerGroup one doesn't work for us
	247
	248	//If we aren't on the map (yet), blow away the markers we know of
	249	if (!this._map) {
	250	this._needsClustering = [];
	251	delete this._gridClusters;
	252	delete this._gridUnclustered;
	253	}
	254
	255	if (this._noanimationUnspiderfy) {
	256	this._noanimationUnspiderfy();
	257	}
	258
	259	//Remove all the visible layers
	260	this._featureGroup.clearLayers();
	261	this._nonPointGroup.clearLayers();
	262
	263	this.eachLayer(function (marker) {
	264	delete marker.__parent;
	265	});
	266
	267	if (this._map) {
	268	//Reset _topClusterLevel and the DistanceGrids
	269	this._generateInitialClusters();
	270	}
	271
	272	return this;
	273	},
	274
	275	//Override FeatureGroup.getBounds as it doesn't work
	276	getBounds: function () {
	277	var bounds = new L.LatLngBounds();
	278	if (this._topClusterLevel) {
	279	bounds.extend(this._topClusterLevel._bounds);
	280	} else {
	281	for (var i = this._needsClustering.length - 1; i >= 0; i--) {
	282	bounds.extend(this._needsClustering[i].getLatLng());
	283	}
	284	}
	285
	286	//TODO: Can remove this isValid test when leaflet 0.6 is released
	287	var nonPointBounds = this._nonPointGroup.getBounds();
	288	if (nonPointBounds.isValid()) {
	289	bounds.extend(nonPointBounds);
	290	}
	291
	292	return bounds;
	293	},
	294
	295	//Overrides LayerGroup.eachLayer
	296	eachLayer: function (method, context) {
	297	var markers = this._needsClustering.slice(),
	298	i;
	299
	300	if (this._topClusterLevel) {
	301	this._topClusterLevel.getAllChildMarkers(markers);
	302	}
	303
	304	for (i = markers.length - 1; i >= 0; i--) {
	305	method.call(context, markers[i]);
	306	}
	307
	308	this._nonPointGroup.eachLayer(method, context);
	309	},
	310
	311	//Returns true if the given layer is in this MarkerClusterGroup
	312	hasLayer: function (layer) {
	313	if (!layer) {
	314	return false;
	315	}
	316
	317	var i, anArray = this._needsClustering;
	318
	319	for (i = anArray.length - 1; i >= 0; i--) {
	320	if (anArray[i] === layer) {
	321	return true;
	322	}
	323	}
	324
	325	anArray = this._needsRemoving;
	326	for (i = anArray.length - 1; i >= 0; i--) {
	327	if (anArray[i] === layer) {
	328	return false;
	329	}
	330	}
	331
	332	return !!(layer.__parent && layer.__parent._group === this) \|\| this._nonPointGroup.hasLayer(layer);
	333	},
	334
	335	//Zoom down to show the given layer (spiderfying if necessary) then calls the callback
	336	zoomToShowLayer: function (layer, callback) {
	337
	338	var showMarker = function () {
	339	if ((layer._icon \|\| layer.__parent._icon) && !this._inZoomAnimation) {
	340	this._map.off('moveend', showMarker, this);
	341	this.off('animationend', showMarker, this);
	342
	343	if (layer._icon) {
	344	callback();
	345	} else if (layer.__parent._icon) {
	346	var afterSpiderfy = function () {
	347	this.off('spiderfied', afterSpiderfy, this);
	348	callback();
	349	};
	350
	351	this.on('spiderfied', afterSpiderfy, this);
	352	layer.__parent.spiderfy();
	353	}
	354	}
	355	};
	356
	357	if (layer._icon) {
	358	callback();
	359	} else if (layer.__parent._zoom < this._map.getZoom()) {
	360	//Layer should be visible now but isn't on screen, just pan over to it
	361	this._map.on('moveend', showMarker, this);
	362	if (!layer._icon) {
	363	this._map.panTo(layer.getLatLng());
	364	}
	365	} else {
	366	this._map.on('moveend', showMarker, this);
	367	this.on('animationend', showMarker, this);
	368	this._map.setView(layer.getLatLng(), layer.__parent._zoom + 1);
	369	layer.__parent.zoomToBounds();
	370	}
	371	},
	372
	373	//Overrides FeatureGroup.onAdd
	374	onAdd: function (map) {
	375	this._map = map;
	376	var i, l, layer;
	377
	378	this._featureGroup.onAdd(map);
	379	this._nonPointGroup.onAdd(map);
	380
	381	if (!this._gridClusters) {
	382	this._generateInitialClusters();
	383	}
	384
	385	for (i = 0, l = this._needsRemoving.length; i < l; i++) {
	386	layer = this._needsRemoving[i];
	387	this._removeLayer(layer);
	388	}
	389	this._needsRemoving = [];
	390
	391	for (i = 0, l = this._needsClustering.length; i < l; i++) {
	392	layer = this._needsClustering[i];
	393
	394	//If the layer doesn't have a getLatLng then we can't cluster it, so add it to our child featureGroup
	395	if (!layer.getLatLng) {
	396	this._featureGroup.addLayer(layer);
	397	continue;
	398	}
	399
	400
	401	if (layer.__parent) {
	402	continue;
	403	}
	404	this._addLayer(layer, this._maxZoom);
	405	}
	406	this._needsClustering = [];
	407
	408
	409	this._map.on('zoomend', this._zoomEnd, this);
	410	this._map.on('moveend', this._moveEnd, this);
	411
	412	if (this._spiderfierOnAdd) { //TODO FIXME: Not sure how to have spiderfier add something on here nicely
	413	this._spiderfierOnAdd();
	414	}
	415
	416	this._bindEvents();
	417
	418
	419	//Actually add our markers to the map:
	420
	421	//Remember the current zoom level and bounds
	422	this._zoom = this._map.getZoom();
	423	this._currentShownBounds = this._getExpandedVisibleBounds();
	424
	425	//Make things appear on the map
	426	this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
	427	},
	428
	429	//Overrides FeatureGroup.onRemove
	430	onRemove: function (map) {
	431	map.off('zoomend', this._zoomEnd, this);
	432	map.off('moveend', this._moveEnd, this);
	433
	434	this._unbindEvents();
	435
	436	//In case we are in a cluster animation
	437	this._map._mapPane.className = this._map._mapPane.className.replace(' leaflet-cluster-anim', '');
	438
	439	if (this._spiderfierOnRemove) { //TODO FIXME: Not sure how to have spiderfier add something on here nicely
	440	this._spiderfierOnRemove();
	441	}
	442
	443	//Clean up all the layers we added to the map
	444	this._featureGroup.onRemove(map);
	445	this._nonPointGroup.onRemove(map);
	446
	447	this._map = null;
	448	},
	449
	450	getVisibleParent: function (marker) {
	451	var vMarker = marker;
	452	while (vMarker !== null && !vMarker._icon) {
	453	vMarker = vMarker.__parent;
	454	}
	455	return vMarker;
	456	},
	457
	458	//Remove the given object from the given array
	459	_arraySplice: function (anArray, obj) {
	460	for (var i = anArray.length - 1; i >= 0; i--) {
	461	if (anArray[i] === obj) {
	462	anArray.splice(i, 1);
	463	return true;
	464	}
	465	}
	466	},
	467
	468	//Internal function for removing a marker from everything.
	469	//dontUpdateMap: set to true if you will handle updating the map manually (for bulk functions)
	470	_removeLayer: function (marker, removeFromDistanceGrid, dontUpdateMap) {
	471	var gridClusters = this._gridClusters,
	472	gridUnclustered = this._gridUnclustered,
	473	fg = this._featureGroup,
	474	map = this._map;
	475
	476	//Remove the marker from distance clusters it might be in
	477	if (removeFromDistanceGrid) {
	478	for (var z = this._maxZoom; z >= 0; z--) {
	479	if (!gridUnclustered[z].removeObject(marker, map.project(marker.getLatLng(), z))) {
	480	break;
	481	}
	482	}
	483	}
	484
	485	//Work our way up the clusters removing them as we go if required
	486	var cluster = marker.__parent,
	487	markers = cluster._markers,
	488	otherMarker;
	489
	490	//Remove the marker from the immediate parents marker list
	491	this._arraySplice(markers, marker);
	492
	493	while (cluster) {
	494	cluster._childCount--;
	495
	496	if (cluster._zoom < 0) {
	497	//Top level, do nothing
	498	break;
	499	} else if (removeFromDistanceGrid && cluster._childCount <= 1) { //Cluster no longer required
	500	//We need to push the other marker up to the parent
	501	otherMarker = cluster._markers[0] === marker ? cluster._markers[1] : cluster._markers[0];
	502
	503	//Update distance grid
	504	gridClusters[cluster._zoom].removeObject(cluster, map.project(cluster._cLatLng, cluster._zoom));
	505	gridUnclustered[cluster._zoom].addObject(otherMarker, map.project(otherMarker.getLatLng(), cluster._zoom));
	506
	507	//Move otherMarker up to parent
	508	this._arraySplice(cluster.__parent._childClusters, cluster);
	509	cluster.__parent._markers.push(otherMarker);
	510	otherMarker.__parent = cluster.__parent;
	511
	512	if (cluster._icon) {
	513	//Cluster is currently on the map, need to put the marker on the map instead
	514	fg.removeLayer(cluster);
	515	if (!dontUpdateMap) {
	516	fg.addLayer(otherMarker);
	517	}
	518	}
	519	} else {
	520	cluster._recalculateBounds();
	521	if (!dontUpdateMap \|\| !cluster._icon) {
	522	cluster._updateIcon();
	523	}
	524	}
	525
	526	cluster = cluster.__parent;
	527	}
	528
	529	delete marker.__parent;
	530	},
	531
	532	_propagateEvent: function (e) {
	533	if (e.layer instanceof L.MarkerCluster) {
	534	e.type = 'cluster' + e.type;
	535	}
	536
	537	this.fire(e.type, e);
	538	},
	539
	540	//Default functionality
	541	_defaultIconCreateFunction: function (cluster) {
	542	var childCount = cluster.getChildCount();
	543
	544	var c = ' marker-cluster-';
	545	if (childCount < 10) {
	546	c += 'small';
	547	} else if (childCount < 100) {
	548	c += 'medium';
	549	} else {
	550	c += 'large';
	551	}
	552
	553	return new L.DivIcon({ html: '<div><span>' + childCount + '</span></div>', className: 'marker-cluster' + c, iconSize: new L.Point(40, 40) });
	554	},
	555
	556	_bindEvents: function () {
	557	var map = this._map,
	558	spiderfyOnMaxZoom = this.options.spiderfyOnMaxZoom,
	559	showCoverageOnHover = this.options.showCoverageOnHover,
	560	zoomToBoundsOnClick = this.options.zoomToBoundsOnClick;
	561
	562	//Zoom on cluster click or spiderfy if we are at the lowest level
	563	if (spiderfyOnMaxZoom \|\| zoomToBoundsOnClick) {
	564	this.on('clusterclick', this._zoomOrSpiderfy, this);
	565	}
	566
	567	//Show convex hull (boundary) polygon on mouse over
	568	if (showCoverageOnHover) {
	569	this.on('clustermouseover', this._showCoverage, this);
	570	this.on('clustermouseout', this._hideCoverage, this);
	571	map.on('zoomend', this._hideCoverage, this);
	572	map.on('layerremove', this._hideCoverageOnRemove, this);
	573	}
	574	},
	575
	576	_zoomOrSpiderfy: function (e) {
	577	var map = this._map;
	578	if (map.getMaxZoom() === map.getZoom()) {
	579	if (this.options.spiderfyOnMaxZoom) {
	580	e.layer.spiderfy();
	581	}
	582	} else if (this.options.zoomToBoundsOnClick) {
	583	e.layer.zoomToBounds();
	584	}
	585	},
	586
	587	_showCoverage: function (e) {
	588	var map = this._map;
	589	if (this._inZoomAnimation) {
	590	return;
	591	}
	592	if (this._shownPolygon) {
	593	map.removeLayer(this._shownPolygon);
	594	}
	595	if (e.layer.getChildCount() > 2 && e.layer !== this._spiderfied) {
	596	this._shownPolygon = new L.Polygon(e.layer.getConvexHull(), this.options.polygonOptions);
	597	map.addLayer(this._shownPolygon);
	598	}
	599	},
	600
	601	_hideCoverage: function () {
	602	if (this._shownPolygon) {
	603	this._map.removeLayer(this._shownPolygon);
	604	this._shownPolygon = null;
	605	}
	606	},
	607
	608	_hideCoverageOnRemove: function (e) {
	609	if (e.layer === this) {
	610	this._hideCoverage();
	611	}
	612	},
	613
	614	_unbindEvents: function () {
	615	var spiderfyOnMaxZoom = this.options.spiderfyOnMaxZoom,
	616	showCoverageOnHover = this.options.showCoverageOnHover,
	617	zoomToBoundsOnClick = this.options.zoomToBoundsOnClick,
	618	map = this._map;
	619
	620	if (spiderfyOnMaxZoom \|\| zoomToBoundsOnClick) {
	621	this.off('clusterclick', this._zoomOrSpiderfy, this);
	622	}
	623	if (showCoverageOnHover) {
	624	this.off('clustermouseover', this._showCoverage, this);
	625	this.off('clustermouseout', this._hideCoverage, this);
	626	map.off('zoomend', this._hideCoverage, this);
	627	map.off('layerremove', this._hideCoverageOnRemove, this);
	628	}
	629	},
	630
	631	_zoomEnd: function () {
	632	if (!this._map) { //May have been removed from the map by a zoomEnd handler
	633	return;
	634	}
	635	this._mergeSplitClusters();
	636
	637	this._zoom = this._map._zoom;
	638	this._currentShownBounds = this._getExpandedVisibleBounds();
	639	},
	640
	641	_moveEnd: function () {
	642	if (this._inZoomAnimation) {
	643	return;
	644	}
	645
	646	var newBounds = this._getExpandedVisibleBounds();
	647
	648	this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._zoom, newBounds);
	649	this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, newBounds);
	650
	651	this._currentShownBounds = newBounds;
	652	return;
	653	},
	654
	655	_generateInitialClusters: function () {
	656	var maxZoom = this._map.getMaxZoom(),
	657	radius = this.options.maxClusterRadius;
	658
	659	if (this.options.disableClusteringAtZoom) {
	660	maxZoom = this.options.disableClusteringAtZoom - 1;
	661	}
	662	this._maxZoom = maxZoom;
	663	this._gridClusters = {};
	664	this._gridUnclustered = {};
	665
	666	//Set up DistanceGrids for each zoom
	667	for (var zoom = maxZoom; zoom >= 0; zoom--) {
	668	this._gridClusters[zoom] = new L.DistanceGrid(radius);
	669	this._gridUnclustered[zoom] = new L.DistanceGrid(radius);
	670	}
	671
	672	this._topClusterLevel = new L.MarkerCluster(this, -1);
	673	},
	674
	675	//Zoom: Zoom to start adding at (Pass this._maxZoom to start at the bottom)
	676	_addLayer: function (layer, zoom) {
	677	var gridClusters = this._gridClusters,
	678	gridUnclustered = this._gridUnclustered,
	679	markerPoint, z;
	680
	681	if (this.options.singleMarkerMode) {
	682	layer.options.icon = this.options.iconCreateFunction({
	683	getChildCount: function () {
	684	return 1;
	685	},
	686	getAllChildMarkers: function () {
	687	return [layer];
	688	}
	689	});
	690	}
	691
	692	//Find the lowest zoom level to slot this one in
	693	for (; zoom >= 0; zoom--) {
	694	markerPoint = this._map.project(layer.getLatLng(), zoom); // calculate pixel position
	695
	696	//Try find a cluster close by
	697	var closest = gridClusters[zoom].getNearObject(markerPoint);
	698	if (closest) {
	699	closest._addChild(layer);
	700	layer.__parent = closest;
	701	return;
	702	}
	703
	704	//Try find a marker close by to form a new cluster with
	705	closest = gridUnclustered[zoom].getNearObject(markerPoint);
	706	if (closest) {
	707	var parent = closest.__parent;
	708	if (parent) {
	709	this._removeLayer(closest, false);
	710	}
	711
	712	//Create new cluster with these 2 in it
	713
	714	var newCluster = new L.MarkerCluster(this, zoom, closest, layer);
	715	gridClusters[zoom].addObject(newCluster, this._map.project(newCluster._cLatLng, zoom));
	716	closest.__parent = newCluster;
	717	layer.__parent = newCluster;
	718
	719	//First create any new intermediate parent clusters that don't exist
	720	var lastParent = newCluster;
	721	for (z = zoom - 1; z > parent._zoom; z--) {
	722	lastParent = new L.MarkerCluster(this, z, lastParent);
	723	gridClusters[z].addObject(lastParent, this._map.project(closest.getLatLng(), z));
	724	}
	725	parent._addChild(lastParent);
	726
	727	//Remove closest from this zoom level and any above that it is in, replace with newCluster
	728	for (z = zoom; z >= 0; z--) {
	729	if (!gridUnclustered[z].removeObject(closest, this._map.project(closest.getLatLng(), z))) {
	730	break;
	731	}
	732	}
	733
	734	return;
	735	}
	736
	737	//Didn't manage to cluster in at this zoom, record us as a marker here and continue upwards
	738	gridUnclustered[zoom].addObject(layer, markerPoint);
	739	}
	740
	741	//Didn't get in anything, add us to the top
	742	this._topClusterLevel._addChild(layer);
	743	layer.__parent = this._topClusterLevel;
	744	return;
	745	},
	746
	747	//Merge and split any existing clusters that are too big or small
	748	_mergeSplitClusters: function () {
	749	if (this._zoom < this._map._zoom) { //Zoom in, split
	750	this._animationStart();
	751	//Remove clusters now off screen
	752	this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, this._zoom, this._getExpandedVisibleBounds());
	753
	754	this._animationZoomIn(this._zoom, this._map._zoom);
	755
	756	} else if (this._zoom > this._map._zoom) { //Zoom out, merge
	757	this._animationStart();
	758
	759	this._animationZoomOut(this._zoom, this._map._zoom);
	760	} else {
	761	this._moveEnd();
	762	}
	763	},
	764
	765	//Gets the maps visible bounds expanded in each direction by the size of the screen (so the user cannot see an area we do not cover in one pan)
	766	_getExpandedVisibleBounds: function () {
	767	if (!this.options.removeOutsideVisibleBounds) {
	768	return this.getBounds();
	769	}
	770
	771	var map = this._map,
	772	bounds = map.getBounds(),
	773	sw = bounds._southWest,
	774	ne = bounds._northEast,
	775	latDiff = L.Browser.mobile ? 0 : Math.abs(sw.lat - ne.lat),
	776	lngDiff = L.Browser.mobile ? 0 : Math.abs(sw.lng - ne.lng);
	777
	778	return new L.LatLngBounds(
	779	new L.LatLng(sw.lat - latDiff, sw.lng - lngDiff, true),
	780	new L.LatLng(ne.lat + latDiff, ne.lng + lngDiff, true));
	781	},
	782
	783	//Shared animation code
	784	_animationAddLayerNonAnimated: function (layer, newCluster) {
	785	if (newCluster === layer) {
	786	this._featureGroup.addLayer(layer);
	787	} else if (newCluster._childCount === 2) {
	788	newCluster._addToMap();
	789
	790	var markers = newCluster.getAllChildMarkers();
	791	this._featureGroup.removeLayer(markers[0]);
	792	this._featureGroup.removeLayer(markers[1]);
	793	} else {
	794	newCluster._updateIcon();
	795	}
	796	}
	797	});
	798
	799	L.MarkerClusterGroup.include(!L.DomUtil.TRANSITION ? {
	800
	801	//Non Animated versions of everything
	802	_animationStart: function () {
	803	//Do nothing...
	804	},
	805	_animationZoomIn: function (previousZoomLevel, newZoomLevel) {
	806	this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel);
	807	this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
	808	},
	809	_animationZoomOut: function (previousZoomLevel, newZoomLevel) {
	810	this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel);
	811	this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
	812	},
	813	_animationAddLayer: function (layer, newCluster) {
	814	this._animationAddLayerNonAnimated(layer, newCluster);
	815	}
	816	} : {
	817
	818	//Animated versions here
	819	_animationStart: function () {
	820	this._map._mapPane.className += ' leaflet-cluster-anim';
	821	this._inZoomAnimation++;
	822	},
	823	_animationEnd: function () {
	824	if (this._map) {
	825	this._map._mapPane.className = this._map._mapPane.className.replace(' leaflet-cluster-anim', '');
	826	}
	827	this._inZoomAnimation--;
	828	this.fire('animationend');
	829	},
	830	_animationZoomIn: function (previousZoomLevel, newZoomLevel) {
	831	var me = this,
	832	bounds = this._getExpandedVisibleBounds(),
	833	fg = this._featureGroup,
	834	i;
	835
	836	//Add all children of current clusters to map and remove those clusters from map
	837	this._topClusterLevel._recursively(bounds, previousZoomLevel, 0, function (c) {
	838	var startPos = c._latlng,
	839	markers = c._markers,
	840	m;
	841
	842	if (c._isSingleParent() && previousZoomLevel + 1 === newZoomLevel) { //Immediately add the new child and remove us
	843	fg.removeLayer(c);
	844	c._recursivelyAddChildrenToMap(null, newZoomLevel, bounds);
	845	} else {
	846	//Fade out old cluster
	847	c.setOpacity(0);
	848	c._recursivelyAddChildrenToMap(startPos, newZoomLevel, bounds);
	849	}
	850
	851	//Remove all markers that aren't visible any more
	852	//TODO: Do we actually need to do this on the higher levels too?
	853	for (i = markers.length - 1; i >= 0; i--) {
	854	m = markers[i];
	855	if (!bounds.contains(m._latlng)) {
	856	fg.removeLayer(m);
	857	}
	858	}
	859
	860	});
	861
	862	this._forceLayout();
	863
	864	//Update opacities
	865	me._topClusterLevel._recursivelyBecomeVisible(bounds, newZoomLevel);
	866	//TODO Maybe? Update markers in _recursivelyBecomeVisible
	867	fg.eachLayer(function (n) {
	868	if (!(n instanceof L.MarkerCluster) && n._icon) {
	869	n.setOpacity(1);
	870	}
	871	});
	872
	873	//update the positions of the just added clusters/markers
	874	me._topClusterLevel._recursively(bounds, previousZoomLevel, newZoomLevel, function (c) {
	875	c._recursivelyRestoreChildPositions(newZoomLevel);
	876	});
	877
	878	//Remove the old clusters and close the zoom animation
	879
	880	setTimeout(function () {
	881	//update the positions of the just added clusters/markers
	882	me._topClusterLevel._recursively(bounds, previousZoomLevel, 0, function (c) {
	883	fg.removeLayer(c);
	884	c.setOpacity(1);
	885	});
	886
	887	me._animationEnd();
	888	}, 200);
	889	},
	890
	891	_animationZoomOut: function (previousZoomLevel, newZoomLevel) {
	892	this._animationZoomOutSingle(this._topClusterLevel, previousZoomLevel - 1, newZoomLevel);
	893
	894	//Need to add markers for those that weren't on the map before but are now
	895	this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
	896	//Remove markers that were on the map before but won't be now
	897	this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, previousZoomLevel, this._getExpandedVisibleBounds());
	898	},
	899	_animationZoomOutSingle: function (cluster, previousZoomLevel, newZoomLevel) {
	900	var bounds = this._getExpandedVisibleBounds();
	901
	902	//Animate all of the markers in the clusters to move to their cluster center point
	903	cluster._recursivelyAnimateChildrenInAndAddSelfToMap(bounds, previousZoomLevel + 1, newZoomLevel);
	904
	905	var me = this;
	906
	907	//Update the opacity (If we immediately set it they won't animate)
	908	this._forceLayout();
	909	cluster._recursivelyBecomeVisible(bounds, newZoomLevel);
	910
	911	//TODO: Maybe use the transition timing stuff to make this more reliable
	912	//When the animations are done, tidy up
	913	setTimeout(function () {
	914
	915	//This cluster stopped being a cluster before the timeout fired
	916	if (cluster._childCount === 1) {
	917	var m = cluster._markers[0];
	918	//If we were in a cluster animation at the time then the opacity and position of our child could be wrong now, so fix it
	919	m.setLatLng(m.getLatLng());
	920	m.setOpacity(1);
	921	} else {
	922	cluster._recursively(bounds, newZoomLevel, 0, function (c) {
	923	c._recursivelyRemoveChildrenFromMap(bounds, previousZoomLevel + 1);
	924	});
	925	}
	926	me._animationEnd();
	927	}, 200);
	928	},
	929	_animationAddLayer: function (layer, newCluster) {
	930	var me = this,
	931	fg = this._featureGroup;
	932
	933	fg.addLayer(layer);
	934	if (newCluster !== layer) {
	935	if (newCluster._childCount > 2) { //Was already a cluster
	936
	937	newCluster._updateIcon();
	938	this._forceLayout();
	939	this._animationStart();
	940
	941	layer._setPos(this._map.latLngToLayerPoint(newCluster.getLatLng()));
	942	layer.setOpacity(0);
	943
	944	setTimeout(function () {
	945	fg.removeLayer(layer);
	946	layer.setOpacity(1);
	947
	948	me._animationEnd();
	949	}, 200);
	950
	951	} else { //Just became a cluster
	952	this._forceLayout();
	953
	954	me._animationStart();
	955	me._animationZoomOutSingle(newCluster, this._map.getMaxZoom(), this._map.getZoom());
	956	}
	957	}
	958	},
	959
	960	//Force a browser layout of stuff in the map
	961	// Should apply the current opacity and location to all elements so we can update them again for an animation
	962	_forceLayout: function () {
	963	//In my testing this works, infact offsetWidth of any element seems to work.
	964	//Could loop all this._layers and do this for each _icon if it stops working
	965
	966	L.Util.falseFn(document.body.offsetWidth);
	967	}
	968	});
	969
	970	L.markerClusterGroup = function (options) {
	971	return new L.MarkerClusterGroup(options);
	972	};
	973
	974
	975	L.MarkerCluster = L.Marker.extend({
	976	initialize: function (group, zoom, a, b) {
	977
	978	L.Marker.prototype.initialize.call(this, a ? (a._cLatLng \|\| a.getLatLng()) : new L.LatLng(0, 0), { icon: this });
	979
	980
	981	this._group = group;
	982	this._zoom = zoom;
	983
	984	this._markers = [];
	985	this._childClusters = [];
	986	this._childCount = 0;
	987	this._iconNeedsUpdate = true;
	988
	989	this._bounds = new L.LatLngBounds();
	990
	991	if (a) {
	992	this._addChild(a);
	993	}
	994	if (b) {
	995	this._addChild(b);
	996	}
	997	},
	998
	999	//Recursively retrieve all child markers of this cluster
	1000	getAllChildMarkers: function (storageArray) {
	1001	storageArray = storageArray \|\| [];
	1002
	1003	for (var i = this._childClusters.length - 1; i >= 0; i--) {
	1004	this._childClusters[i].getAllChildMarkers(storageArray);
	1005	}
	1006
	1007	for (var j = this._markers.length - 1; j >= 0; j--) {
	1008	storageArray.push(this._markers[j]);
	1009	}
	1010
	1011	return storageArray;
	1012	},
	1013
	1014	//Returns the count of how many child markers we have
	1015	getChildCount: function () {
	1016	return this._childCount;
	1017	},
	1018
	1019	//Zoom to the extents of this cluster
	1020	zoomToBounds: function () {
	1021	this._group._map.fitBounds(this._bounds);
	1022	},
	1023
	1024	getBounds: function () {
	1025	var bounds = new L.LatLngBounds();
	1026	bounds.extend(this._bounds);
	1027	return bounds;
	1028	},
	1029
	1030	_updateIcon: function () {
	1031	this._iconNeedsUpdate = true;
	1032	if (this._icon) {
	1033	this.setIcon(this);
	1034	}
	1035	},
	1036
	1037	//Cludge for Icon, we pretend to be an icon for performance
	1038	createIcon: function () {
	1039	if (this._iconNeedsUpdate) {
	1040	this._iconObj = this._group.options.iconCreateFunction(this);
	1041	this._iconNeedsUpdate = false;
	1042	}
	1043	return this._iconObj.createIcon();
	1044	},
	1045	createShadow: function () {
	1046	return this._iconObj.createShadow();
	1047	},
	1048
	1049
	1050	_addChild: function (new1, isNotificationFromChild) {
	1051
	1052	this._iconNeedsUpdate = true;
	1053	this._expandBounds(new1);
	1054
	1055	if (new1 instanceof L.MarkerCluster) {
	1056	if (!isNotificationFromChild) {
	1057	this._childClusters.push(new1);
	1058	new1.__parent = this;
	1059	}
	1060	this._childCount += new1._childCount;
	1061	} else {
	1062	if (!isNotificationFromChild) {
	1063	this._markers.push(new1);
	1064	}
	1065	this._childCount++;
	1066	}
	1067
	1068	if (this.__parent) {
	1069	this.__parent._addChild(new1, true);
	1070	}
	1071	},
	1072
	1073	//Expand our bounds and tell our parent to
	1074	_expandBounds: function (marker) {
	1075	var addedCount,
	1076	addedLatLng = marker._wLatLng \|\| marker._latlng;
	1077
	1078	if (marker instanceof L.MarkerCluster) {
	1079	this._bounds.extend(marker._bounds);
	1080	addedCount = marker._childCount;
	1081	} else {
	1082	this._bounds.extend(addedLatLng);
	1083	addedCount = 1;
	1084	}
	1085
	1086	if (!this._cLatLng) {
	1087	// when clustering, take position of the first point as the cluster center
	1088	this._cLatLng = marker._cLatLng \|\| addedLatLng;
	1089	}
	1090
	1091	// when showing clusters, take weighted average of all points as cluster center
	1092	var totalCount = this._childCount + addedCount;
	1093
	1094	//Calculate weighted latlng for display
	1095	if (!this._wLatLng) {
	1096	this._latlng = this._wLatLng = new L.LatLng(addedLatLng.lat, addedLatLng.lng);
	1097	} else {
	1098	this._wLatLng.lat = (addedLatLng.lat * addedCount + this._wLatLng.lat * this._childCount) / totalCount;
	1099	this._wLatLng.lng = (addedLatLng.lng * addedCount + this._wLatLng.lng * this._childCount) / totalCount;
	1100	}
	1101	},
	1102
	1103	//Set our markers position as given and add it to the map
	1104	_addToMap: function (startPos) {
	1105	if (startPos) {
	1106	this._backupLatlng = this._latlng;
	1107	this.setLatLng(startPos);
	1108	}
	1109	this._group._featureGroup.addLayer(this);
	1110	},
	1111
	1112	_recursivelyAnimateChildrenIn: function (bounds, center, maxZoom) {
	1113	this._recursively(bounds, 0, maxZoom - 1,
	1114	function (c) {
	1115	var markers = c._markers,
	1116	i, m;
	1117	for (i = markers.length - 1; i >= 0; i--) {
	1118	m = markers[i];
	1119
	1120	//Only do it if the icon is still on the map
	1121	if (m._icon) {
	1122	m._setPos(center);
	1123	m.setOpacity(0);
	1124	}
	1125	}
	1126	},
	1127	function (c) {
	1128	var childClusters = c._childClusters,
	1129	j, cm;
	1130	for (j = childClusters.length - 1; j >= 0; j--) {
	1131	cm = childClusters[j];
	1132	if (cm._icon) {
	1133	cm._setPos(center);
	1134	cm.setOpacity(0);
	1135	}
	1136	}
	1137	}
	1138	);
	1139	},
	1140
	1141	_recursivelyAnimateChildrenInAndAddSelfToMap: function (bounds, previousZoomLevel, newZoomLevel) {
	1142	this._recursively(bounds, newZoomLevel, 0,
	1143	function (c) {
	1144	c._recursivelyAnimateChildrenIn(bounds, c._group._map.latLngToLayerPoint(c.getLatLng()).round(), previousZoomLevel);
	1145
	1146	//TODO: depthToAnimateIn affects _isSingleParent, if there is a multizoom we may/may not be.
	1147	//As a hack we only do a animation free zoom on a single level zoom, if someone does multiple levels then we always animate
	1148	if (c._isSingleParent() && previousZoomLevel - 1 === newZoomLevel) {
	1149	c.setOpacity(1);
	1150	c._recursivelyRemoveChildrenFromMap(bounds, previousZoomLevel); //Immediately remove our children as we are replacing them. TODO previousBounds not bounds
	1151	} else {
	1152	c.setOpacity(0);
	1153	}
	1154
	1155	c._addToMap();
	1156	}
	1157	);
	1158	},
	1159
	1160	_recursivelyBecomeVisible: function (bounds, zoomLevel) {
	1161	this._recursively(bounds, 0, zoomLevel, null, function (c) {
	1162	c.setOpacity(1);
	1163	});
	1164	},
	1165
	1166	_recursivelyAddChildrenToMap: function (startPos, zoomLevel, bounds) {
	1167	this._recursively(bounds, -1, zoomLevel,
	1168	function (c) {
	1169	if (zoomLevel === c._zoom) {
	1170	return;
	1171	}
	1172
	1173	//Add our child markers at startPos (so they can be animated out)
	1174	for (var i = c._markers.length - 1; i >= 0; i--) {
	1175	var nm = c._markers[i];
	1176
	1177	if (!bounds.contains(nm._latlng)) {
	1178	continue;
	1179	}
	1180
	1181	if (startPos) {
	1182	nm._backupLatlng = nm.getLatLng();
	1183
	1184	nm.setLatLng(startPos);
	1185	if (nm.setOpacity) {
	1186	nm.setOpacity(0);
	1187	}
	1188	}
	1189
	1190	c._group._featureGroup.addLayer(nm);
	1191	}
	1192	},
	1193	function (c) {
	1194	c._addToMap(startPos);
	1195	}
	1196	);
	1197	},
	1198
	1199	_recursivelyRestoreChildPositions: function (zoomLevel) {
	1200	//Fix positions of child markers
	1201	for (var i = this._markers.length - 1; i >= 0; i--) {
	1202	var nm = this._markers[i];
	1203	if (nm._backupLatlng) {
	1204	nm.setLatLng(nm._backupLatlng);
	1205	delete nm._backupLatlng;
	1206	}
	1207	}
	1208
	1209	if (zoomLevel - 1 === this._zoom) {
	1210	//Reposition child clusters
	1211	for (var j = this._childClusters.length - 1; j >= 0; j--) {
	1212	this._childClusters[j]._restorePosition();
	1213	}
	1214	} else {
	1215	for (var k = this._childClusters.length - 1; k >= 0; k--) {
	1216	this._childClusters[k]._recursivelyRestoreChildPositions(zoomLevel);
	1217	}
	1218	}
	1219	},
	1220
	1221	_restorePosition: function () {
	1222	if (this._backupLatlng) {
	1223	this.setLatLng(this._backupLatlng);
	1224	delete this._backupLatlng;
	1225	}
	1226	},
	1227
	1228	//exceptBounds: If set, don't remove any markers/clusters in it
	1229	_recursivelyRemoveChildrenFromMap: function (previousBounds, zoomLevel, exceptBounds) {
	1230	var m, i;
	1231	this._recursively(previousBounds, -1, zoomLevel - 1,
	1232	function (c) {
	1233	//Remove markers at every level
	1234	for (i = c._markers.length - 1; i >= 0; i--) {
	1235	m = c._markers[i];
	1236	if (!exceptBounds \|\| !exceptBounds.contains(m._latlng)) {
	1237	c._group._featureGroup.removeLayer(m);
	1238	if (m.setOpacity) {
	1239	m.setOpacity(1);
	1240	}
	1241	}
	1242	}
	1243	},
	1244	function (c) {
	1245	//Remove child clusters at just the bottom level
	1246	for (i = c._childClusters.length - 1; i >= 0; i--) {
	1247	m = c._childClusters[i];
	1248	if (!exceptBounds \|\| !exceptBounds.contains(m._latlng)) {
	1249	c._group._featureGroup.removeLayer(m);
	1250	if (m.setOpacity) {
	1251	m.setOpacity(1);
	1252	}
	1253	}
	1254	}
	1255	}
	1256	);
	1257	},
	1258
	1259	//Run the given functions recursively to this and child clusters
	1260	// boundsToApplyTo: a L.LatLngBounds representing the bounds of what clusters to recurse in to
	1261	// zoomLevelToStart: zoom level to start running functions (inclusive)
	1262	// zoomLevelToStop: zoom level to stop running functions (inclusive)
	1263	// runAtEveryLevel: function that takes an L.MarkerCluster as an argument that should be applied on every level
	1264	// runAtBottomLevel: function that takes an L.MarkerCluster as an argument that should be applied at only the bottom level
	1265	_recursively: function (boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel) {
	1266	var childClusters = this._childClusters,
	1267	zoom = this._zoom,
	1268	i, c;
	1269
	1270	if (zoomLevelToStart > zoom) { //Still going down to required depth, just recurse to child clusters
	1271	for (i = childClusters.length - 1; i >= 0; i--) {
	1272	c = childClusters[i];
	1273	if (boundsToApplyTo.intersects(c._bounds)) {
	1274	c._recursively(boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel);
	1275	}
	1276	}
	1277	} else { //In required depth
	1278
	1279	if (runAtEveryLevel) {
	1280	runAtEveryLevel(this);
	1281	}
	1282	if (runAtBottomLevel && this._zoom === zoomLevelToStop) {
	1283	runAtBottomLevel(this);
	1284	}
	1285
	1286	//TODO: This loop is almost the same as above
	1287	if (zoomLevelToStop > zoom) {
	1288	for (i = childClusters.length - 1; i >= 0; i--) {
	1289	c = childClusters[i];
	1290	if (boundsToApplyTo.intersects(c._bounds)) {
	1291	c._recursively(boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel);
	1292	}
	1293	}
	1294	}
	1295	}
	1296	},
	1297
	1298	_recalculateBounds: function () {
	1299	var markers = this._markers,
	1300	childClusters = this._childClusters,
	1301	i;
	1302
	1303	this._bounds = new L.LatLngBounds();
	1304	delete this._wLatLng;
	1305
	1306	for (i = markers.length - 1; i >= 0; i--) {
	1307	this._expandBounds(markers[i]);
	1308	}
	1309	for (i = childClusters.length - 1; i >= 0; i--) {
	1310	this._expandBounds(childClusters[i]);
	1311	}
	1312	},
	1313
	1314
	1315	//Returns true if we are the parent of only one cluster and that cluster is the same as us
	1316	_isSingleParent: function () {
	1317	//Don't need to check this._markers as the rest won't work if there are any
	1318	return this._childClusters.length > 0 && this._childClusters[0]._childCount === this._childCount;
	1319	}
	1320	});
	1321
	1322
	1323
	1324	L.DistanceGrid = function (cellSize) {
	1325	this._cellSize = cellSize;
	1326	this._sqCellSize = cellSize * cellSize;
	1327	this._grid = {};
	1328	this._objectPoint = { };
	1329	};
	1330
	1331	L.DistanceGrid.prototype = {
	1332
	1333	addObject: function (obj, point) {
	1334	var x = this._getCoord(point.x),
	1335	y = this._getCoord(point.y),
	1336	grid = this._grid,
	1337	row = grid[y] = grid[y] \|\| {},
	1338	cell = row[x] = row[x] \|\| [],
	1339	stamp = L.Util.stamp(obj);
	1340
	1341	this._objectPoint[stamp] = point;
	1342
	1343	cell.push(obj);
	1344	},
	1345
	1346	updateObject: function (obj, point) {
	1347	this.removeObject(obj);
	1348	this.addObject(obj, point);
	1349	},
	1350
	1351	//Returns true if the object was found
	1352	removeObject: function (obj, point) {
	1353	var x = this._getCoord(point.x),
	1354	y = this._getCoord(point.y),
	1355	grid = this._grid,
	1356	row = grid[y] = grid[y] \|\| {},
	1357	cell = row[x] = row[x] \|\| [],
	1358	i, len;
	1359
	1360	delete this._objectPoint[L.Util.stamp(obj)];
	1361
	1362	for (i = 0, len = cell.length; i < len; i++) {
	1363	if (cell[i] === obj) {
	1364
	1365	cell.splice(i, 1);
	1366
	1367	if (len === 1) {
	1368	delete row[x];
	1369	}
	1370
	1371	return true;
	1372	}
	1373	}
	1374
	1375	},
	1376
	1377	eachObject: function (fn, context) {
	1378	var i, j, k, len, row, cell, removed,
	1379	grid = this._grid;
	1380
	1381	for (i in grid) {
	1382	row = grid[i];
	1383
	1384	for (j in row) {
	1385	cell = row[j];
	1386
	1387	for (k = 0, len = cell.length; k < len; k++) {
	1388	removed = fn.call(context, cell[k]);
	1389	if (removed) {
	1390	k--;
	1391	len--;
	1392	}
	1393	}
	1394	}
	1395	}
	1396	},
	1397
	1398	getNearObject: function (point) {
	1399	var x = this._getCoord(point.x),
	1400	y = this._getCoord(point.y),
	1401	i, j, k, row, cell, len, obj, dist,
	1402	objectPoint = this._objectPoint,
	1403	closestDistSq = this._sqCellSize,
	1404	closest = null;
	1405
	1406	for (i = y - 1; i <= y + 1; i++) {
	1407	row = this._grid[i];
	1408	if (row) {
	1409
	1410	for (j = x - 1; j <= x + 1; j++) {
	1411	cell = row[j];
	1412	if (cell) {
	1413
	1414	for (k = 0, len = cell.length; k < len; k++) {
	1415	obj = cell[k];
	1416	dist = this._sqDist(objectPoint[L.Util.stamp(obj)], point);
	1417	if (dist < closestDistSq) {
	1418	closestDistSq = dist;
	1419	closest = obj;
	1420	}
	1421	}
	1422	}
	1423	}
	1424	}
	1425	}
	1426	return closest;
	1427	},
	1428
	1429	_getCoord: function (x) {
	1430	return Math.floor(x / this._cellSize);
	1431	},
	1432
	1433	_sqDist: function (p, p2) {
	1434	var dx = p2.x - p.x,
	1435	dy = p2.y - p.y;
	1436	return dx * dx + dy * dy;
	1437	}
	1438	};
	1439
	1440
	1441	/* Copyright (c) 2012 the authors listed at the following URL, and/or
	1442	the authors of referenced articles or incorporated external code:
	1443	http://en.literateprograms.org/Quickhull_(Javascript)?action=history&offset=20120410175256
	1444
	1445	Permission is hereby granted, free of charge, to any person obtaining
	1446	a copy of this software and associated documentation files (the
	1447	"Software"), to deal in the Software without restriction, including
	1448	without limitation the rights to use, copy, modify, merge, publish,
	1449	distribute, sublicense, and/or sell copies of the Software, and to
	1450	permit persons to whom the Software is furnished to do so, subject to
	1451	the following conditions:
	1452
	1453	The above copyright notice and this permission notice shall be
	1454	included in all copies or substantial portions of the Software.
	1455
	1456	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	1457	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	1458	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	1459	IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	1460	CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	1461	TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	1462	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	1463
	1464	Retrieved from: http://en.literateprograms.org/Quickhull_(Javascript)?oldid=18434
	1465	*/
	1466
	1467	(function () {
	1468	L.QuickHull = {
	1469	getDistant: function (cpt, bl) {
	1470	var vY = bl[1].lat - bl[0].lat,
	1471	vX = bl[0].lng - bl[1].lng;
	1472	return (vX * (cpt.lat - bl[0].lat) + vY * (cpt.lng - bl[0].lng));
	1473	},
	1474
	1475
	1476	findMostDistantPointFromBaseLine: function (baseLine, latLngs) {
	1477	var maxD = 0,
	1478	maxPt = null,
	1479	newPoints = [],
	1480	i, pt, d;
	1481
	1482	for (i = latLngs.length - 1; i >= 0; i--) {
	1483	pt = latLngs[i];
	1484	d = this.getDistant(pt, baseLine);
	1485
	1486	if (d > 0) {
	1487	newPoints.push(pt);
	1488	} else {
	1489	continue;
	1490	}
	1491
	1492	if (d > maxD) {
	1493	maxD = d;
	1494	maxPt = pt;
	1495	}
	1496
	1497	}
	1498	return { 'maxPoint': maxPt, 'newPoints': newPoints };
	1499	},
	1500
	1501	buildConvexHull: function (baseLine, latLngs) {
	1502	var convexHullBaseLines = [],
	1503	t = this.findMostDistantPointFromBaseLine(baseLine, latLngs);
	1504
	1505	if (t.maxPoint) { // if there is still a point "outside" the base line
	1506	convexHullBaseLines =
	1507	convexHullBaseLines.concat(
	1508	this.buildConvexHull([baseLine[0], t.maxPoint], t.newPoints)
	1509	);
	1510	convexHullBaseLines =
	1511	convexHullBaseLines.concat(
	1512	this.buildConvexHull([t.maxPoint, baseLine[1]], t.newPoints)
	1513	);
	1514	return convexHullBaseLines;
	1515	} else { // if there is no more point "outside" the base line, the current base line is part of the convex hull
	1516	return [baseLine];
	1517	}
	1518	},
	1519
	1520	getConvexHull: function (latLngs) {
	1521	//find first baseline
	1522	var maxLat = false, minLat = false,
	1523	maxPt = null, minPt = null,
	1524	i;
	1525
	1526	for (i = latLngs.length - 1; i >= 0; i--) {
	1527	var pt = latLngs[i];
	1528	if (maxLat === false \|\| pt.lat > maxLat) {
	1529	maxPt = pt;
	1530	maxLat = pt.lat;
	1531	}
	1532	if (minLat === false \|\| pt.lat < minLat) {
	1533	minPt = pt;
	1534	minLat = pt.lat;
	1535	}
	1536	}
	1537	var ch = [].concat(this.buildConvexHull([minPt, maxPt], latLngs),
	1538	this.buildConvexHull([maxPt, minPt], latLngs));
	1539	return ch;
	1540	}
	1541	};
	1542	}());
	1543
	1544	L.MarkerCluster.include({
	1545	getConvexHull: function () {
	1546	var childMarkers = this.getAllChildMarkers(),
	1547	points = [],
	1548	hullLatLng = [],
	1549	hull, p, i;
	1550
	1551	for (i = childMarkers.length - 1; i >= 0; i--) {
	1552	p = childMarkers[i].getLatLng();
	1553	points.push(p);
	1554	}
	1555
	1556	hull = L.QuickHull.getConvexHull(points);
	1557
	1558	for (i = hull.length - 1; i >= 0; i--) {
	1559	hullLatLng.push(hull[i][0]);
	1560	}
	1561
	1562	return hullLatLng;
	1563	}
	1564	});
	1565
	1566	//This code is 100% based on https://github.com/jawj/OverlappingMarkerSpiderfier-Leaflet
	1567	//Huge thanks to jawj for implementing it first to make my job easy :-)
	1568
	1569	L.MarkerCluster.include({
	1570
	1571	_2PI: Math.PI * 2,
	1572	_circleFootSeparation: 25, //related to circumference of circle
	1573	_circleStartAngle: Math.PI / 6,
	1574
	1575	_spiralFootSeparation: 28, //related to size of spiral (experiment!)
	1576	_spiralLengthStart: 11,
	1577	_spiralLengthFactor: 5,
	1578
	1579	_circleSpiralSwitchover: 9, //show spiral instead of circle from this marker count upwards.
	1580	// 0 -> always spiral; Infinity -> always circle
	1581
	1582	spiderfy: function () {
	1583	if (this._group._spiderfied === this \|\| this._group._inZoomAnimation) {
	1584	return;
	1585	}
	1586
	1587	var childMarkers = this.getAllChildMarkers(),
	1588	group = this._group,
	1589	map = group._map,
	1590	center = map.latLngToLayerPoint(this._latlng),
	1591	positions;
	1592
	1593	this._group._unspiderfy();
	1594	this._group._spiderfied = this;
	1595
	1596	//TODO Maybe: childMarkers order by distance to center
	1597
	1598	if (childMarkers.length >= this._circleSpiralSwitchover) {
	1599	positions = this._generatePointsSpiral(childMarkers.length, center);
	1600	} else {
	1601	center.y += 10; //Otherwise circles look wrong
	1602	positions = this._generatePointsCircle(childMarkers.length, center);
	1603	}
	1604
	1605	this._animationSpiderfy(childMarkers, positions);
	1606	},
	1607
	1608	unspiderfy: function (zoomDetails) {
	1609	/// <param Name="zoomDetails">Argument from zoomanim if being called in a zoom animation or null otherwise</param>
	1610	if (this._group._inZoomAnimation) {
	1611	return;
	1612	}
	1613	this._animationUnspiderfy(zoomDetails);
	1614
	1615	this._group._spiderfied = null;
	1616	},
	1617
	1618	_generatePointsCircle: function (count, centerPt) {
	1619	var circumference = this._group.options.spiderfyDistanceMultiplier * this._circleFootSeparation * (2 + count),
	1620	legLength = circumference / this._2PI, //radius from circumference
	1621	angleStep = this._2PI / count,
	1622	res = [],
	1623	i, angle;
	1624
	1625	res.length = count;
	1626
	1627	for (i = count - 1; i >= 0; i--) {
	1628	angle = this._circleStartAngle + i * angleStep;
	1629	res[i] = new L.Point(centerPt.x + legLength * Math.cos(angle), centerPt.y + legLength * Math.sin(angle))._round();
	1630	}
	1631
	1632	return res;
	1633	},
	1634
	1635	_generatePointsSpiral: function (count, centerPt) {
	1636	var legLength = this._group.options.spiderfyDistanceMultiplier * this._spiralLengthStart,
	1637	separation = this._group.options.spiderfyDistanceMultiplier * this._spiralFootSeparation,
	1638	lengthFactor = this._group.options.spiderfyDistanceMultiplier * this._spiralLengthFactor,
	1639	angle = 0,
	1640	res = [],
	1641	i;
	1642
	1643	res.length = count;
	1644
	1645	for (i = count - 1; i >= 0; i--) {
	1646	angle += separation / legLength + i * 0.0005;
	1647	res[i] = new L.Point(centerPt.x + legLength * Math.cos(angle), centerPt.y + legLength * Math.sin(angle))._round();
	1648	legLength += this._2PI * lengthFactor / angle;
	1649	}
	1650	return res;
	1651	},
	1652
	1653	_noanimationUnspiderfy: function () {
	1654	var group = this._group,
	1655	map = group._map,
	1656	fg = group._featureGroup,
	1657	childMarkers = this.getAllChildMarkers(),
	1658	m, i;
	1659
	1660	this.setOpacity(1);
	1661	for (i = childMarkers.length - 1; i >= 0; i--) {
	1662	m = childMarkers[i];
	1663
	1664	fg.removeLayer(m);
	1665
	1666	if (m._preSpiderfyLatlng) {
	1667	m.setLatLng(m._preSpiderfyLatlng);
	1668	delete m._preSpiderfyLatlng;
	1669	}
	1670	m.setZIndexOffset(0);
	1671
	1672	if (m._spiderLeg) {
	1673	map.removeLayer(m._spiderLeg);
	1674	delete m._spiderLeg;
	1675	}
	1676	}
	1677	}
	1678	});
	1679
	1680	L.MarkerCluster.include(!L.DomUtil.TRANSITION ? {
	1681	//Non Animated versions of everything
	1682	_animationSpiderfy: function (childMarkers, positions) {
	1683	var group = this._group,
	1684	map = group._map,
	1685	fg = group._featureGroup,
	1686	i, m, leg, newPos;
	1687
	1688	for (i = childMarkers.length - 1; i >= 0; i--) {
	1689	newPos = map.layerPointToLatLng(positions[i]);
	1690	m = childMarkers[i];
	1691
	1692	m._preSpiderfyLatlng = m._latlng;
	1693	m.setLatLng(newPos);
	1694	m.setZIndexOffset(1000000); //Make these appear on top of EVERYTHING
	1695
	1696	fg.addLayer(m);
	1697
	1698
	1699	leg = new L.Polyline([this._latlng, newPos], { weight: 1.5, color: '#222' });
	1700	map.addLayer(leg);
	1701	m._spiderLeg = leg;
	1702	}
	1703	this.setOpacity(0.3);
	1704	group.fire('spiderfied');
	1705	},
	1706
	1707	_animationUnspiderfy: function () {
	1708	this._noanimationUnspiderfy();
	1709	}
	1710	} : {
	1711	//Animated versions here
	1712	SVG_ANIMATION: (function () {
	1713	return document.createElementNS('http://www.w3.org/2000/svg', 'animate').toString().indexOf('SVGAnimate') > -1;
	1714	}()),
	1715
	1716	_animationSpiderfy: function (childMarkers, positions) {
	1717	var me = this,
	1718	group = this._group,
	1719	map = group._map,
	1720	fg = group._featureGroup,
	1721	thisLayerPos = map.latLngToLayerPoint(this._latlng),
	1722	i, m, leg, newPos;
	1723
	1724	//Add markers to map hidden at our center point
	1725	for (i = childMarkers.length - 1; i >= 0; i--) {
	1726	m = childMarkers[i];
	1727
	1728	m.setZIndexOffset(1000000); //Make these appear on top of EVERYTHING
	1729	m.setOpacity(0);
	1730
	1731	fg.addLayer(m);
	1732
	1733	m._setPos(thisLayerPos);
	1734	}
	1735
	1736	group._forceLayout();
	1737	group._animationStart();
	1738
	1739	var initialLegOpacity = L.Path.SVG ? 0 : 0.3,
	1740	xmlns = L.Path.SVG_NS;
	1741
	1742
	1743	for (i = childMarkers.length - 1; i >= 0; i--) {
	1744	newPos = map.layerPointToLatLng(positions[i]);
	1745	m = childMarkers[i];
	1746
	1747	//Move marker to new position
	1748	m._preSpiderfyLatlng = m._latlng;
	1749	m.setLatLng(newPos);
	1750	m.setOpacity(1);
	1751
	1752
	1753	//Add Legs.
	1754	leg = new L.Polyline([me._latlng, newPos], { weight: 1.5, color: '#222', opacity: initialLegOpacity });
	1755	map.addLayer(leg);
	1756	m._spiderLeg = leg;
	1757
	1758	//Following animations don't work for canvas
	1759	if (!L.Path.SVG \|\| !this.SVG_ANIMATION) {
	1760	continue;
	1761	}
	1762
	1763	//How this works:
	1764	//http://stackoverflow.com/questions/5924238/how-do-you-animate-an-svg-path-in-ios
	1765	//http://dev.opera.com/articles/view/advanced-svg-animation-techniques/
	1766
	1767	//Animate length
	1768	var length = leg._path.getTotalLength();
	1769	leg._path.setAttribute("stroke-dasharray", length + "," + length);
	1770
	1771	var anim = document.createElementNS(xmlns, "animate");
	1772	anim.setAttribute("attributeName", "stroke-dashoffset");
	1773	anim.setAttribute("begin", "indefinite");
	1774	anim.setAttribute("from", length);
	1775	anim.setAttribute("to", 0);
	1776	anim.setAttribute("dur", 0.25);
	1777	leg._path.appendChild(anim);
	1778	anim.beginElement();
	1779
	1780	//Animate opacity
	1781	anim = document.createElementNS(xmlns, "animate");
	1782	anim.setAttribute("attributeName", "stroke-opacity");
	1783	anim.setAttribute("attributeName", "stroke-opacity");
	1784	anim.setAttribute("begin", "indefinite");
	1785	anim.setAttribute("from", 0);
	1786	anim.setAttribute("to", 0.5);
	1787	anim.setAttribute("dur", 0.25);
	1788	leg._path.appendChild(anim);
	1789	anim.beginElement();
	1790	}
	1791	me.setOpacity(0.3);
	1792
	1793	//Set the opacity of the spiderLegs back to their correct value
	1794	// The animations above override this until they complete.
	1795	// If the initial opacity of the spiderlegs isn't 0 then they appear before the animation starts.
	1796	if (L.Path.SVG) {
	1797	this._group._forceLayout();
	1798
	1799	for (i = childMarkers.length - 1; i >= 0; i--) {
	1800	m = childMarkers[i]._spiderLeg;
	1801
	1802	m.options.opacity = 0.5;
	1803	m._path.setAttribute('stroke-opacity', 0.5);
	1804	}
	1805	}
	1806
	1807	setTimeout(function () {
	1808	group._animationEnd();
	1809	group.fire('spiderfied');
	1810	}, 200);
	1811	},
	1812
	1813	_animationUnspiderfy: function (zoomDetails) {
	1814	var group = this._group,
	1815	map = group._map,
	1816	fg = group._featureGroup,
	1817	thisLayerPos = zoomDetails ? map._latLngToNewLayerPoint(this._latlng, zoomDetails.zoom, zoomDetails.center) : map.latLngToLayerPoint(this._latlng),
	1818	childMarkers = this.getAllChildMarkers(),
	1819	svg = L.Path.SVG && this.SVG_ANIMATION,
	1820	m, i, a;
	1821
	1822	group._animationStart();
	1823
	1824	//Make us visible and bring the child markers back in
	1825	this.setOpacity(1);
	1826	for (i = childMarkers.length - 1; i >= 0; i--) {
	1827	m = childMarkers[i];
	1828
	1829	//Marker was added to us after we were spidified
	1830	if (!m._preSpiderfyLatlng) {
	1831	continue;
	1832	}
	1833
	1834	//Fix up the location to the real one
	1835	m.setLatLng(m._preSpiderfyLatlng);
	1836	delete m._preSpiderfyLatlng;
	1837	//Hack override the location to be our center
	1838	m._setPos(thisLayerPos);
	1839
	1840	m.setOpacity(0);
	1841
	1842	//Animate the spider legs back in
	1843	if (svg) {
	1844	a = m._spiderLeg._path.childNodes[0];
	1845	a.setAttribute('to', a.getAttribute('from'));
	1846	a.setAttribute('from', 0);
	1847	a.beginElement();
	1848
	1849	a = m._spiderLeg._path.childNodes[1];
	1850	a.setAttribute('from', 0.5);
	1851	a.setAttribute('to', 0);
	1852	a.setAttribute('stroke-opacity', 0);
	1853	a.beginElement();
	1854
	1855	m._spiderLeg._path.setAttribute('stroke-opacity', 0);
	1856	}
	1857	}
	1858
	1859	setTimeout(function () {
	1860	//If we have only <= one child left then that marker will be shown on the map so don't remove it!
	1861	var stillThereChildCount = 0;
	1862	for (i = childMarkers.length - 1; i >= 0; i--) {
	1863	m = childMarkers[i];
	1864	if (m._spiderLeg) {
	1865	stillThereChildCount++;
	1866	}
	1867	}
	1868
	1869
	1870	for (i = childMarkers.length - 1; i >= 0; i--) {
	1871	m = childMarkers[i];
	1872
	1873	if (!m._spiderLeg) { //Has already been unspiderfied
	1874	continue;
	1875	}
	1876
	1877
	1878	m.setOpacity(1);
	1879	m.setZIndexOffset(0);
	1880
	1881	if (stillThereChildCount > 1) {
	1882	fg.removeLayer(m);
	1883	}
	1884
	1885	map.removeLayer(m._spiderLeg);
	1886	delete m._spiderLeg;
	1887	}
	1888	group._animationEnd();
	1889	}, 200);
	1890	}
	1891	});
	1892
	1893
	1894	L.MarkerClusterGroup.include({
	1895	//The MarkerCluster currently spiderfied (if any)
	1896	_spiderfied: null,
	1897
	1898	_spiderfierOnAdd: function () {
	1899	this._map.on('click', this._unspiderfyWrapper, this);
	1900
	1901	if (this._map.options.zoomAnimation) {
	1902	this._map.on('zoomstart', this._unspiderfyZoomStart, this);
	1903	} else {
	1904	//Browsers without zoomAnimation don't fire zoomstart
	1905	this._map.on('zoomend', this._unspiderfyWrapper, this);
	1906	}
	1907
	1908	if (L.Path.SVG && !L.Browser.touch) {
	1909	this._map._initPathRoot();
	1910	//Needs to happen in the pageload, not after, or animations don't work in webkit
	1911	// http://stackoverflow.com/questions/8455200/svg-animate-with-dynamically-added-elements
	1912	//Disable on touch browsers as the animation messes up on a touch zoom and isn't very noticable
	1913	}
	1914	},
	1915
	1916	_spiderfierOnRemove: function () {
	1917	this._map.off('click', this._unspiderfyWrapper, this);
	1918	this._map.off('zoomstart', this._unspiderfyZoomStart, this);
	1919	this._map.off('zoomanim', this._unspiderfyZoomAnim, this);
	1920
	1921	this._unspiderfy(); //Ensure that markers are back where they should be
	1922	},
	1923
	1924
	1925	//On zoom start we add a zoomanim handler so that we are guaranteed to be last (after markers are animated)
	1926	//This means we can define the animation they do rather than Markers doing an animation to their actual location
	1927	_unspiderfyZoomStart: function () {
	1928	if (!this._map) { //May have been removed from the map by a zoomEnd handler
	1929	return;
	1930	}
	1931
	1932	this._map.on('zoomanim', this._unspiderfyZoomAnim, this);
	1933	},
	1934	_unspiderfyZoomAnim: function (zoomDetails) {
	1935	//Wait until the first zoomanim after the user has finished touch-zooming before running the animation
	1936	if (L.DomUtil.hasClass(this._map._mapPane, 'leaflet-touching')) {
	1937	return;
	1938	}
	1939
	1940	this._map.off('zoomanim', this._unspiderfyZoomAnim, this);
	1941	this._unspiderfy(zoomDetails);
	1942	},
	1943
	1944
	1945	_unspiderfyWrapper: function () {
	1946	/// <summary>_unspiderfy but passes no arguments</summary>
	1947	this._unspiderfy();
	1948	},
	1949
	1950	_unspiderfy: function (zoomDetails) {
	1951	if (this._spiderfied) {
	1952	this._spiderfied.unspiderfy(zoomDetails);
	1953	}
	1954	},
	1955
	1956	_noanimationUnspiderfy: function () {
	1957	if (this._spiderfied) {
	1958	this._spiderfied._noanimationUnspiderfy();
	1959	}
	1960	},
	1961
	1962	//If the given layer is currently being spiderfied then we unspiderfy it so it isn't on the map anymore etc
	1963	_unspiderfyLayer: function (layer) {
	1964	if (layer._spiderLeg) {
	1965	this._featureGroup.removeLayer(layer);
	1966
	1967	layer.setOpacity(1);
	1968	//Position will be fixed up immediately in _animationUnspiderfy
	1969	layer.setZIndexOffset(0);
	1970
	1971	this._map.removeLayer(layer._spiderLeg);
	1972	delete layer._spiderLeg;
	1973	}
	1974	}
	1975	});
	1976
	1977
	1978	}(window, document));

Note: See TracBrowser for help on using the repository browser.

Download in other formats: