| ');
if(changeClusterIcon)
clusterShape.SetCustomIcon('');
// } else {
// for (var j = 1; j < clusterArray.length; j++) {
// descriptionArray.push(clusterArray[j].GetDescription().split('||')[1]);
// }
// clusterShape.SetDescription(clusterArray[0].GetDescription()+'||'+(descriptionArray.join('||')));
// }
//Stop clusterShape.SetTitle('cluster');
clusterShape.SetTitle(' ' + resourceClusterHeader + ' ');
}
if(debug)console.log("In FormatClusterShapes: ... finished");
}
/**
* Generate the description for popup
*
* @param key - unique ids of clustered pois (\POI\d+||(\d+)+\)
*
* @return the expanded description
*/
this.GenerateDescription = function(key) {
var divHeight = "170px";
var topMargin = "8px";
var keys = key.split('||');
// concat description of each VEShape belonging to cluster as description for that cluster
var descriptionArray = new Array();
var descriptionKey = (keys[0] + '||' + keys[1]);
var descriptionAddressArray = new Array();
var descriptionAddress;
var descriptionImage = InfoBoxManager.GetImage(descriptionKey);
// for each VEShape belonging to cluster
for (var j = 0; j < keys.length - 1; j++) {
//descriptionKey = clusterArray[j].GetDescription().split('')[0].split('>')[1];
// lookup the address for this description
descriptionAddress = InfoBoxManager.GetAddress(descriptionKey);
// remove 'br' tags
descriptionAddressArray = descriptionAddress.split('
');
descriptionAddress = descriptionAddressArray[0];
descriptionArray.push('| ' + descriptionImage + ' | ' + InfoBoxManager.GetName(descriptionKey) + '' + descriptionAddress + ' |
' // Overall
+ '' // top div
+ '' // Bottom div
+ ' '; // overall
return description;
}
/**
* Deletes an array shapes from the cluster layer
*
* @param type - type of shape to delete
*/
this.DeleteShapes = function(type) {
// if type shapes clustered on map
if (this.typeDisplayed(type)) {
var newShapeArrays = new Array();
var shapeArray = new Array();
for (var i = 0; i < this.ShapeArrays.length; i++) {
shapeArray = this.ShapeArrays[i];
if (shapeArray[0] != type) {
newShapeArrays.push(shapeArray);
}
}
var newClusterLayersArray = new Array();
var clusterArray = new Array();
// loop through all clustered layers
for (var i = 0; i < this.ClusterLayersArray.length; i++) {
clusterArray = this.ClusterLayersArray[i];
// keep current cluster layer if it is not of type
if (clusterArray[0] != type) {
newClusterLayersArray.push(clusterArray);
}
// delete current cluster layer and remove it from map if it is of type
else {
this.MapInstance.DeleteShapeLayer(clusterArray[1]);
}
}
// type shapes now deleted
this.ShapeArrays = newShapeArrays;
this.ClusterLayersArray = newClusterLayersArray;
}
HideLoading();
}
/**
* Checks that type is not a shape type already being clustered
* @param type - shape type being checked
*
* returns true if type exists in this.ShapeTypes, false otherwise
*/
this.typeDisplayed = function(type)
{
var shapeArray = new Array();
// checking each shapeArray
for(var i=0; i= 0 && pixel.y >= 0)
{
//calculate the shape's grid location
var gridX = Math.floor(pixel.x / gridSize);
var gridY = Math.floor(pixel.y / gridSize);
//determine the grid index of this shape
var index = gridX + gridY * xCells;
if(index < gridCells.length)
{
if(gridCells[index] == null)
{
gridCells[index] = new Array();
}
gridCells[index].push(shape);
}
}
}
//iterate through the shape grid determine which shapes are clustered, populate shape layer
for(var i = 0; i < gridCells.length; i++)
{
var cell = gridCells[i];
var shape = null;
//multiple points - clustered pin
if(cell != null && cell.length > 1 && zoomLevel < minZoomLimit)
{
//extract the lat/longs for the pins in this pin
var latLongs = '';
//append to the pipe-delimietd list of lat/longs for clustered pins for later use
for(var shapeIndex = 0; shapeIndex < cell.length; shapeIndex++)
{
latLongs += cell[shapeIndex].GetPoints()[0].toString().replace(' ', '');
latLongs += (shapeIndex <= cell.length - 2) ? '|' : '';
}
shape = new VEShape(VEShapeType.Pushpin, cell[0].GetPoints()[0]);
shape.SetTitle('cluster');
shape.SetDescription(latLongs);
shape.SetCustomIcon('');
this.ClusterLayer.AddShape(shape);
}
//multiple unclustered points or single pin
else
{
if(cell != null && cell.length > 0)
{
for(var shapeCount = 0; shapeCount < cell.length; shapeCount++)
{
this.ClusterLayer.AddShape(cell[shapeCount]);
}
}
}
}
}
/**
* Performs the necessary calculations to generate the shape/cluster grid
*/
function GenerateGrid()
{
mapWidth = that.MapInstance.GetWidth();
mapHeight = that.MapInstance.GetHeight();
var xCells = parseInt(Math.ceil(mapWidth / gridSize));
var yCells = parseInt(Math.ceil(mapHeight / gridSize));
gridCells = new Array(xCells * yCells);
}
/**
* Serializes a POI VE pushpin to a string
*/
function ShapeToString(shape)
{
var points = shape.GetPoints()[0];
var result = points.Latitude + '|' + points.Longitude + '|' + shape.GetDescription() + '|' + shape.GetTitle + '|' + shape.GetCustomIcon();
return result;
}
}
/*
* custom clustering algorithm
* msdn documentation:
* http://msdn.microsoft.com/en-us/library/cc966716.aspx
*/
//benchmarking tools
/*
function clusterBenchmark(layer) {
//note: may add overhead
var _id = consoleLog("starting cluster algorithm");
var tmp = customCluster(layer);
consoleLog("done cluster algorithm",_id);
return tmp;
}
var _benchmark = new Array();
var _consoleLastId = 0;
function consoleLog(message, id) {
var now = new Date().getTime();
if (id == undefined) {
console.log(message);
_consoleLastId++;
_benchmark[_consoleLastId] = now;
return _consoleLastId;
} else {
console.log((now - _benchmark[id]) + "ms, " + message);
}
}
*/
//end of benchmarking tools
function deleteFromDist(distArray, allShapes, tmpIndex) {
var tmpx = Math.floor(allShapes[tmpIndex].x / 10);
var tmpy = Math.floor(allShapes[tmpIndex].y / 10);
for (var j = distArray[tmpx][tmpy].length - 1; j >= 0; j--) {
if (distArray[tmpx][tmpy][j] == tmpIndex) {
distArray[tmpx][tmpy].splice(j,1);
j = -1;
}
}
}
//var clusterTurnOff = false;
var totalx = 0;
var totaly = 0;
function customCluster(layer) {
var pins = new Array();
// if (clusterTurnOff)
// return pins;
var total = layer.GetShapeCount();
var allShapes = new Array();
var allShapesIndex = 0;
if(debug)console.log("In customCluster: total Shape in layer: ", total);
totalx = Math.ceil(mapManager.Map.GetWidth() / 10) + 1;
totaly = Math.ceil(mapManager.Map.GetHeight() / 10) + 1;
var distArray = new Array(totalx);
for (var i = totalx - 1; i >= 0; i--) {
distArray[i] = new Array(totaly);
for (var j = totaly - 1; j >= 0; j--)
distArray[i][j] = new Array();
}
//var _benchXY = consoleLog("getting pixel co-ords");
//var returnAfter = false;
for (var i = 0; i < total; i++) {
/* Original code added all pins from layer to allShapes array
allShapes[i] = layer.GetShapeByIndex(i);
var tmp = mapManager.Map.LatLongToPixel(allShapes[i].GetPoints()[0]);
allShapes[i].x = tmp.x;
allShapes[i].y = tmp.y;
*/
var aShape = layer.GetShapeByIndex(i)
var tmp = mapManager.Map.LatLongToPixel(aShape.GetPoints()[0]);
var tmpArrayX = Math.floor(tmp.x / 10);
var tmpArrayY = Math.floor(tmp.y / 10);
if ((tmpArrayX < 0) || (tmpArrayX >= totalx) || (tmpArrayY < 0) || (tmpArrayY >= totaly)) {
/*
var tmpPin = new VEClusterSpecification();
tmpPin.LatLong = new VELatLong(0,0);
tmpPin.Shapes = new Array();
while (total--) {
tmpPin.Shapes[total] = layer.GetShapeByIndex(total);
}
pins.push(tmpPin);
*/
//if(debug)console.log("In customCluster:1st for loop: Discard pin from distArray - grid for visible map: tmpArrayX:%s totalx:%s tmpArrayY:%s totaly:%s ", tmpArrayX, totalx, tmpArrayY, totaly);
//return pins;
} else {
aShape.x = tmp.x;
aShape.y = tmp.y;
allShapes.push(aShape);
//distArray[tmpArrayX][tmpArrayY].push(i);
distArray[tmpArrayX][tmpArrayY].push(allShapesIndex);
allShapesIndex++;
}
//distArray represents a grid
}
//consoleLog("done pixel co-ords",_benchXY);
total = allShapesIndex;
if(debug)console.log("In customCluster: total after building grid is: ", total);
if(debug)console.log("In customCluster: allShapes.length is: ", allShapes.length);
/*if (returnAfter) {
var tmpPin = new VEClusterSpecification();
tmpPin.LatLong = new VELatLong(0,0);
tmpPin.Shapes = allShapes;
pins.push(tmpPin);
return pins;
}*/
var zoomLevel = mapManager.Map.GetZoomLevel();
var zoomLevelClusterCompareDist = zoomLevelClusterCompareDistMap[zoomLevel];
if(debug)console.log("In customCluster: zoomLevel: %s zoomLevelClusterCompareDist: %s", zoomLevel, zoomLevelClusterCompareDist);
var maxValue = 0;
var maxShapes = new Array();
var maxIndex = -1;
var livingIndicesToAllShapes = new Array(total);
var clusterValues = new Array(total);
var tmpResult;
for (var i = allShapes.length - 1; i >= 0; i--) {
livingIndicesToAllShapes[i] = i;
tmpResult = singlePinCluster(i, distArray, allShapes, zoomLevelClusterCompareDist);
//somehow make it not add pins with tmp value of 1
clusterValues[i] = [tmpResult[0], i, tmpResult[1]];
}
if(debug)console.log("In customCluster: clusterValues: ", clusterValues.length);
while (clusterValues.length > 0) {
clusterValues.sort(clusterValueSort);
maxValue = -1;
maxIndex = 0;
var i = 0;
var go = true;
while (go) {
if (i >= clusterValues.length)
go = false;
else {
//var tmp = singlePinValue(clusterValues[i][1], distArray, allShapes);
var tmp = singlePinCache(clusterValues[i][2], livingIndicesToAllShapes);
if (tmp == 1) {
clusterValues.splice(i, 1);
} else {
if (tmp > maxValue) {
maxValue = tmp;
maxIndex = i;
}
if (tmp == clusterValues[i][0]) {
go = false;
}
clusterValues[i][0] = tmp;
i++;
}
}
}
if (maxValue <= 1)
return pins;
//maxShapes = singlePinCluster(clusterValues[maxIndex][1], distArray, allShapes)[1];
//maxShapes = singlePinCacheCluster(clusterValues[maxIndex][2], livingIndicesToAllShapes);
maxShapes = clusterValues[maxIndex][2];
var tmp = new VEClusterSpecification();
tmp.LatLong = allShapes[clusterValues[maxIndex][1]].GetPoints()[0];
//livingIndicesToAllShapes maps allShapes -> clusterValues
//toDelete subset of clusterValues
livingIndicesToAllShapes = [];
var i = clusterValues.length;
while (i--) {
livingIndicesToAllShapes[clusterValues[i][1]] = i;
}
var toDelete = new Array(maxShapes.length);
i = maxShapes.length;
while (i--) {
toDelete[i] = livingIndicesToAllShapes[maxShapes[i]];
}
toDelete.sort(numSort);
i = toDelete.length;
while (i--) {
var tmpIndex = clusterValues[toDelete[i]][1];
deleteFromDist(distArray, allShapes, tmpIndex);
maxShapes[i] = allShapes[tmpIndex];
clusterValues.splice(toDelete[i], 1);
livingIndicesToAllShapes[tmpIndex] = undefined;
}
tmp.Shapes = maxShapes;
pins.push(tmp);
}
if(debug)console.log("In customCluster: End: About to return pins: ", pins.length);
return pins;
}
function clusterValueSort(a,b) { return b[0] - a[0]; }
function numSort(a,b) { return a - b; };
var clusterCompareDist = 1600; //square the distance so Math.sqrt is not necessary in the calculations
function singlePinCluster(index, distArray, allShapes, zoomLevelClusterCompareDist) {
//heart of the algorithm
//we will look 50 pixels away (always 10 more than distance we wish to compare)
//so dist = 5 (5 * 10)
var arrayX = Math.floor(allShapes[index].x / 10);
var arrayY = Math.floor(allShapes[index].y / 10);
//(arrayX > (dist - 1))
var minX = (arrayX > 4) ? arrayX - 4 : 0;
var minY = (arrayY > 4) ? arrayY - 4 : 0;
var maxX = (arrayX < (totalx - 4)) ? arrayX + 4 : totalx - 1;
var maxY = (arrayY < (totaly - 4)) ? arrayY + 4 : totaly - 1;
var shapes = new Array();
var value = 0;
var i = minX - 1;
while (i++ < maxX) {
// for (var i = minX; i <= maxX; i++) {
var j = minY - 1;
while (j++ < maxY) {
// for (var j = minY; j <= maxY; j++) {
//## if (((arrayX - i) * (arrayX - i)) + ((arrayY - j) * (arrayY - j)) <= 8) {
//## value += distArray[i][j].length;
//## Array.prototype.push.apply(shapes, distArray[i][j]);
//## } else {
for (var k = distArray[i][j].length - 1; k >= 0; k--) {
if (distBetween(allShapes[index], allShapes[distArray[i][j][k]]) <= zoomLevelClusterCompareDist) {
//^^ must. increase. speed.
//if (distBetween(allShapes[index], allShapes[distArray[i][j][k]]) <= clusterCompareDist) {
value++;
shapes.push(distArray[i][j][k]);
}
}
//## }
}
}
return [value, shapes];
}
function singlePinCache(cache, livingIndices) {
var value = 0;
for (var i = cache.length - 1; i >= 0; i--) {
if (livingIndices[cache[i]] == undefined) {
cache.splice(i, 1);
} else {
value++;
}
}
return value;
}
function singlePinCacheCluster(cache, livingIndices) {
var shapes = [];
for (var i = cache.length - 1; i >= 0; i--) {
if (livingIndices[cache[i]] != undefined)
shapes.push(cache[i]);
}
return shapes;
}
function singlePinValue(index, distArray, allShapes) {
//singlePinCluster but only returns the value, will be faster in IE because "new Array()" has been removed
var arrayX = Math.floor(allShapes[index].x / 10);
var arrayY = Math.floor(allShapes[index].y / 10);
var minX = (arrayX > 4) ? arrayX - 4 : 0;
var minY = (arrayY > 4) ? arrayY - 4 : 0;
var maxX = (arrayX < (distArray.length - 4)) ? arrayX + 4 : distArray.length - 1;
var maxY = (arrayY < (distArray[arrayX].length - 4)) ? arrayY + 4 : distArray[arrayX].length - 1;
var value = 0;
for (var i = minX; i <= maxX; i++) {
for (var j = minY; j <= maxY; j++) {
for (var k = distArray[i][j].length - 1; k >= 0; k--) {
if (distBetween(allShapes[index], allShapes[distArray[i][j][k]]) <= clusterCompareDist)
value++;
}
}
}
return value;
}
function distBetween(shape1, shape2) {
//does not return true distance, as it does not do the square root (optimization)
var dx = shape1.x - shape2.x;
var dy = shape1.y - shape2.y;
return Math.floor((dx * dx) + (dy * dy));
}
|
'
+ '
'
+ resourceAddToAMap.toUpperCase() + '