278 lines
8.7 KiB
JavaScript
278 lines
8.7 KiB
JavaScript
/* Copyright (c) 2006-2012 by OpenLayers Contributors (see authors.txt for
|
|
* full list of contributors). Published under the 2-clause BSD license.
|
|
* See license.txt in the OpenLayers distribution or repository for the
|
|
* full text of the license. */
|
|
|
|
/**
|
|
* @requires OpenLayers/Strategy.js
|
|
*/
|
|
|
|
/**
|
|
* Class: OpenLayers.Strategy.Cluster
|
|
* Strategy for vector feature clustering.
|
|
*
|
|
* Inherits from:
|
|
* - <OpenLayers.Strategy>
|
|
*/
|
|
OpenLayers.Strategy.Cluster = OpenLayers.Class(OpenLayers.Strategy, {
|
|
|
|
/**
|
|
* APIProperty: distance
|
|
* {Integer} Pixel distance between features that should be considered a
|
|
* single cluster. Default is 20 pixels.
|
|
*/
|
|
distance: 20,
|
|
|
|
/**
|
|
* APIProperty: threshold
|
|
* {Integer} Optional threshold below which original features will be
|
|
* added to the layer instead of clusters. For example, a threshold
|
|
* of 3 would mean that any time there are 2 or fewer features in
|
|
* a cluster, those features will be added directly to the layer instead
|
|
* of a cluster representing those features. Default is null (which is
|
|
* equivalent to 1 - meaning that clusters may contain just one feature).
|
|
*/
|
|
threshold: null,
|
|
|
|
/**
|
|
* Property: features
|
|
* {Array(<OpenLayers.Feature.Vector>)} Cached features.
|
|
*/
|
|
features: null,
|
|
|
|
/**
|
|
* Property: clusters
|
|
* {Array(<OpenLayers.Feature.Vector>)} Calculated clusters.
|
|
*/
|
|
clusters: null,
|
|
|
|
/**
|
|
* Property: clustering
|
|
* {Boolean} The strategy is currently clustering features.
|
|
*/
|
|
clustering: false,
|
|
|
|
/**
|
|
* Property: resolution
|
|
* {Float} The resolution (map units per pixel) of the current cluster set.
|
|
*/
|
|
resolution: null,
|
|
|
|
/**
|
|
* Constructor: OpenLayers.Strategy.Cluster
|
|
* Create a new clustering strategy.
|
|
*
|
|
* Parameters:
|
|
* options - {Object} Optional object whose properties will be set on the
|
|
* instance.
|
|
*/
|
|
|
|
/**
|
|
* APIMethod: activate
|
|
* Activate the strategy. Register any listeners, do appropriate setup.
|
|
*
|
|
* Returns:
|
|
* {Boolean} The strategy was successfully activated.
|
|
*/
|
|
activate: function() {
|
|
var activated = OpenLayers.Strategy.prototype.activate.call(this);
|
|
if(activated) {
|
|
this.layer.events.on({
|
|
"beforefeaturesadded": this.cacheFeatures,
|
|
"moveend": this.cluster,
|
|
scope: this
|
|
});
|
|
}
|
|
return activated;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: deactivate
|
|
* Deactivate the strategy. Unregister any listeners, do appropriate
|
|
* tear-down.
|
|
*
|
|
* Returns:
|
|
* {Boolean} The strategy was successfully deactivated.
|
|
*/
|
|
deactivate: function() {
|
|
var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
|
|
if(deactivated) {
|
|
this.clearCache();
|
|
this.layer.events.un({
|
|
"beforefeaturesadded": this.cacheFeatures,
|
|
"moveend": this.cluster,
|
|
scope: this
|
|
});
|
|
}
|
|
return deactivated;
|
|
},
|
|
|
|
/**
|
|
* Method: cacheFeatures
|
|
* Cache features before they are added to the layer.
|
|
*
|
|
* Parameters:
|
|
* event - {Object} The event that this was listening for. This will come
|
|
* with a batch of features to be clustered.
|
|
*
|
|
* Returns:
|
|
* {Boolean} False to stop features from being added to the layer.
|
|
*/
|
|
cacheFeatures: function(event) {
|
|
var propagate = true;
|
|
if(!this.clustering) {
|
|
this.clearCache();
|
|
this.features = event.features;
|
|
this.cluster();
|
|
propagate = false;
|
|
}
|
|
return propagate;
|
|
},
|
|
|
|
/**
|
|
* Method: clearCache
|
|
* Clear out the cached features.
|
|
*/
|
|
clearCache: function() {
|
|
this.features = null;
|
|
},
|
|
|
|
/**
|
|
* Method: cluster
|
|
* Cluster features based on some threshold distance.
|
|
*
|
|
* Parameters:
|
|
* event - {Object} The event received when cluster is called as a
|
|
* result of a moveend event.
|
|
*/
|
|
cluster: function(event) {
|
|
if((!event || event.zoomChanged) && this.features) {
|
|
var resolution = this.layer.map.getResolution();
|
|
if(resolution != this.resolution || !this.clustersExist()) {
|
|
this.resolution = resolution;
|
|
var clusters = [];
|
|
var feature, clustered, cluster;
|
|
for(var i=0; i<this.features.length; ++i) {
|
|
feature = this.features[i];
|
|
if(feature.geometry) {
|
|
clustered = false;
|
|
for(var j=clusters.length-1; j>=0; --j) {
|
|
cluster = clusters[j];
|
|
if(this.shouldCluster(cluster, feature)) {
|
|
this.addToCluster(cluster, feature);
|
|
clustered = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!clustered) {
|
|
clusters.push(this.createCluster(this.features[i]));
|
|
}
|
|
}
|
|
}
|
|
this.layer.removeAllFeatures();
|
|
if(clusters.length > 0) {
|
|
if(this.threshold > 1) {
|
|
var clone = clusters.slice();
|
|
clusters = [];
|
|
var candidate;
|
|
for(var i=0, len=clone.length; i<len; ++i) {
|
|
candidate = clone[i];
|
|
if(candidate.attributes.count < this.threshold) {
|
|
Array.prototype.push.apply(clusters, candidate.cluster);
|
|
} else {
|
|
clusters.push(candidate);
|
|
}
|
|
}
|
|
}
|
|
this.clustering = true;
|
|
// A legitimate feature addition could occur during this
|
|
// addFeatures call. For clustering to behave well, features
|
|
// should be removed from a layer before requesting a new batch.
|
|
this.layer.addFeatures(clusters);
|
|
this.clustering = false;
|
|
}
|
|
this.clusters = clusters;
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Method: clustersExist
|
|
* Determine whether calculated clusters are already on the layer.
|
|
*
|
|
* Returns:
|
|
* {Boolean} The calculated clusters are already on the layer.
|
|
*/
|
|
clustersExist: function() {
|
|
var exist = false;
|
|
if(this.clusters && this.clusters.length > 0 &&
|
|
this.clusters.length == this.layer.features.length) {
|
|
exist = true;
|
|
for(var i=0; i<this.clusters.length; ++i) {
|
|
if(this.clusters[i] != this.layer.features[i]) {
|
|
exist = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return exist;
|
|
},
|
|
|
|
/**
|
|
* Method: shouldCluster
|
|
* Determine whether to include a feature in a given cluster.
|
|
*
|
|
* Parameters:
|
|
* cluster - {<OpenLayers.Feature.Vector>} A cluster.
|
|
* feature - {<OpenLayers.Feature.Vector>} A feature.
|
|
*
|
|
* Returns:
|
|
* {Boolean} The feature should be included in the cluster.
|
|
*/
|
|
shouldCluster: function(cluster, feature) {
|
|
var cc = cluster.geometry.getBounds().getCenterLonLat();
|
|
var fc = feature.geometry.getBounds().getCenterLonLat();
|
|
var distance = (
|
|
Math.sqrt(
|
|
Math.pow((cc.lon - fc.lon), 2) + Math.pow((cc.lat - fc.lat), 2)
|
|
) / this.resolution
|
|
);
|
|
return (distance <= this.distance);
|
|
},
|
|
|
|
/**
|
|
* Method: addToCluster
|
|
* Add a feature to a cluster.
|
|
*
|
|
* Parameters:
|
|
* cluster - {<OpenLayers.Feature.Vector>} A cluster.
|
|
* feature - {<OpenLayers.Feature.Vector>} A feature.
|
|
*/
|
|
addToCluster: function(cluster, feature) {
|
|
cluster.cluster.push(feature);
|
|
cluster.attributes.count += 1;
|
|
},
|
|
|
|
/**
|
|
* Method: createCluster
|
|
* Given a feature, create a cluster.
|
|
*
|
|
* Parameters:
|
|
* feature - {<OpenLayers.Feature.Vector>}
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Feature.Vector>} A cluster.
|
|
*/
|
|
createCluster: function(feature) {
|
|
var center = feature.geometry.getBounds().getCenterLonLat();
|
|
var cluster = new OpenLayers.Feature.Vector(
|
|
new OpenLayers.Geometry.Point(center.lon, center.lat),
|
|
{count: 1}
|
|
);
|
|
cluster.cluster = [feature];
|
|
return cluster;
|
|
},
|
|
|
|
CLASS_NAME: "OpenLayers.Strategy.Cluster"
|
|
});
|