public void updateConnections(List <GridCluster> clusters)
{
for (int p = 0; p < this.getNumPoints(); p++)
{
MapPoint auxPoint = this.getPoint(p);
for (int connect = 0; connect < auxPoint.getRelations().Count; connect++)
{
for (int clusterConnected = 0; clusterConnected < auxPoint.getRelations()[connect].getTo().getRelatedClusters().Count; clusterConnected++)
{
GridCluster auxCluster = auxPoint.getRelations()[connect].getTo().getRelatedClusters()[clusterConnected];
if (auxCluster.getLevel() == 0 && auxCluster != this)
{
int levelCluster = 0;
bool clusterLevelFound = false;
while (!clusterLevelFound && levelCluster < clusters.Count)
{
clusterLevelFound = (clusters[levelCluster] == auxCluster);
levelCluster++;
}
if (clusterLevelFound)
{
connectionsList[levelCluster - 1]++;
//Debug.Log("Hay conexión con cluster " + (levelCluster - 1));
}
}
}
}
}
}
static void PMapTest()
{
var b = new Boundary {
Minx = -180, Maxx = 180, Miny = -90, Maxy = 90
};
const int dx = 20;
const int dy = 20;
var xy = GridCluster.GetPointMappedIds(new P {
X = 175, Y = 35
}, b, dx, dy);
CWF("x: {0} y: {1}", xy[0], xy[1]);
xy = GridCluster.GetPointMappedIds(new P {
X = 175, Y = 35
}, b, dx, dy);
CWF("x: {0} y: {1}", xy[0], xy[1]);
xy = GridCluster.GetPointMappedIds(new P {
X = 180, Y = 35
}, b, dx, dy);
CWF("x: {0} y: {1}", xy[0], xy[1]);
xy = GridCluster.GetPointMappedIds((new P {
X = 181, Y = 35
}).Normalize(), b, dx, dy);
CWF("x: {0} y: {1}", xy[0], xy[1]);
xy = GridCluster.GetPointMappedIds((new P {
X = -181, Y = 35
}).Normalize(), b, dx, dy);
CWF("x: {0} y: {1}", xy[0], xy[1]);
}
protected void arrangeRelatives(MapLevel level, MapLevel lastLevel)
{
List <GridCluster> levelClusterList = level.getGridClusters();
foreach (GridCluster clusterChild in levelClusterList)
{
MapPoint childPoint = clusterChild.getPoint(0);
//Debug.Log("Se llama desde cluster con h=" + clusterChild.hQuad + " y v=" + clusterChild.vQuad);
int h = lastLevel.getHGrid(clusterChild.hQuad);
int v = lastLevel.getVGrid(clusterChild.vQuad);
//List<GridCluster> parentCandidates = lastLevel.getGridClustersPerQuad(h, v);
GridCluster clusterParent = lastLevel.getClusterWithPoint(childPoint);
//GridCluster clusterParent = lastLevel.getClusterWithPointInQuad(childPoint);
if (clusterParent != null)
{
clusterChild.setParent(clusterParent);
clusterParent.addChild(clusterChild);
}
}
}
public int scaleCorrection(GridCluster cluster, int numPoints, float zoom)
{
int scale = getScale(cluster, this.points.Count);
// Debug.Log(zoom);
float corrector = 1.0f;
//int level = clusterManager.getLevel(zoom);
/*
* switch (level)
* {
* //zoom > 4 && zoom <= 6)
* case 1:
* corrector = 2.0f;
* break;
* //zoom > 6 && zoom <= 8)
* case 2:
* corrector = 2.5f;
* break;
* //zoom > 8)
* case 3:
* corrector = 3.0f;
* break;
* }
*/
//scale = (int)(scale * corrector);
//if (!cluster.getCategory().Equals("silknow.org/#pthing"))
// scale = scale * 2;
return(scale);
}
private OnlineMapsDrawingLine addConnection(GridCluster clusterFrom, GridCluster clusterTo, int numConnections)
{
MapPoint from = clusterFrom.getCenter();
MapPoint to = clusterTo.getCenter();
List <Vector2> points = new List <Vector2>();
points.Add(from.getVector2());
points.Add(to.getVector2());
OnlineMapsDrawingLine oLine = new OnlineMapsDrawingLine(points, Color.blue);
oLine.width = 1.0f;
oLine.visible = true;
OnlineMapsDrawingElementManager.AddItem(oLine);
oLine.visible = false;
oLine.name = "connection";
return(oLine);
}
public void addChild(GridCluster child)
{
if (!this.childs.Contains(child))
{
this.childs.Add(child);
}
}
public void managePoints(GridCluster cluster)
{
int i = 0;
int h, v;
int auxLevel;
bool found;
List <MapPoint> points = cluster.getPoints();
//Debug.Log("Managin cluster with " + points.Count);
int numPoints = points.Count;
for (i = 0; i < numPoints; i++)
{
//h = getHGrid(points[i].getMarker().position.y);
//v = getVGrid(points[i].getMarker().position.x);
//h = getHGrid(points[i].getY());
//v = getVGrid(points[i].getX());
auxLevel = 0;
found = false;
int numClusters = this.clusters.Count;
while (!found && auxLevel < numClusters)
{
found = this.clusters[auxLevel].checkPoint(points[i].getX(), points[i].getY());// h, v);//,points[i].getCategory());
auxLevel++;
}
if (found)
{
this.clusters[auxLevel - 1].addPoint(points[i]);
points[i].addCluster(this.clusters[auxLevel - 1]);
}
else
{
h = getHGrid(points[i].getX());
v = getVGrid(points[i].getY());
GridCluster newGridCluster = new GridCluster(h, v, points[i], this);
newGridCluster.setLevel(this.level);
points[i].addCluster(newGridCluster);
newGridCluster.setParent(cluster);
cluster.addChild(newGridCluster);
this.clusters.Add(newGridCluster);
//QuadCluster quadC = this.getQuadCluster(h, v);
//quadC.addCluster(newGridCluster);
//if (level==0 || level== 1)
//{
// Debug.Log("Se crea quad en nivel " + level + " con h= " + h + " , v=" + v);
// }
}
}
}
public GridCluster(GridCluster a)
{
this.numFilteredPoints = 0;
this.points.AddRange(a.getPoints());
a.setParent(this);
this.addChild(a);
this.center = new MapPoint(a.getCenter().getX(), a.getCenter().getY());
}
public void addCluster(GridCluster cluster)
{
this.clusterList.Add(cluster);
if (cluster.getLevel() == 1)
{
Debug.Log("Se ha añadido un cluster de nivel 1");
}
}
public GridCluster(GridCluster a, GridCluster b)
{
this.numFilteredPoints = 0;
this.points.AddRange(a.getPoints());
this.points.AddRange(b.getPoints());
a.setParent(this);
b.setParent(this);
this.addChild(a);
this.addChild(b);
this.setAverageCenter(a.getCenter(), b.getCenter());
}
/**
* Distribute the points that are located in the same longitud,latitud in a circle
* arround the original location.
* */
public void distributeGroupsOnCircle()
{
float incR = 0.1f;
double incAng = 6.28f;
int level;
double pointsPerLevel;
int pointAtLevel;
foreach (Vector2 v in positionsGroup.Keys)
{
List <MapPoint> pointList = positionsGroup[v];
if (pointList.Count <= MAX_POINTS_PER_GROUP)
{
level = 0;
pointAtLevel = 1;
pointsPerLevel = Math.Pow(2, level);
for (int i = 0; i < pointList.Count; i++)
{
if (pointAtLevel > pointsPerLevel)
{
pointAtLevel = 1;
level++;
pointsPerLevel = Math.Pow(2, level);
incAng = 6.28f / pointsPerLevel;
}
double x = v.x + Math.Cos(pointAtLevel * incAng) * incR * level;
double y = v.y + Math.Sin(pointAtLevel * incAng) * incR * level;
pointList[i].setXY(Convert.ToSingle(x), Convert.ToSingle(y));
pointAtLevel++;
}
}
else
{
GridCluster gCluster = new GridCluster(pointList);
gCluster.setCenter(pointList[0]);
gCluster.groupPoints = true;
clusterManager.addPointGroup(gCluster);
foreach (MapPointMarker m in pointList)
{
m.clusteredLevel = true; // xxx
m.addCluster(gCluster); //xxx
m.isInGroupPoint = gCluster;
}
}
}
}
public GridCluster getClusterByName(String name)
{
GridCluster cluster = null;
int numCluster = Int32.Parse(name);
int level = (int)(numCluster / 1000);
int position = numCluster % 1000;
List <GridCluster> clusters = clusterManager.getGridClustersAtLevel(level);
cluster = clusters[position];
return(cluster);
}
protected List <GridCluster> clustersOfPoints(List <MapPoint> pointListToCheck)
{
List <GridCluster> clustersRelated = new List <GridCluster>();
foreach (MapPoint p in pointListToCheck)
{
GridCluster directCluster = p.getDirectCluster();
if (!clustersRelated.Contains(directCluster))
{
clustersRelated.Add(directCluster);
}
}
return(clustersRelated);
}
public int getScale(GridCluster cluster, int totalNumPoints)
{
int scaleMin = 5;
int scaleMax = 40;
int scale;
int clusterPoints = cluster.getNumPoints();
scale = scaleMin + (int)((3 * scaleMax * clusterPoints) / totalNumPoints);
if (!cluster.isGroupPoints())
{
scale = scale / 4;
}
return(20); // scale;
}
/// <summary>
/// Read Through Cache
/// </summary>
/// <param name="getParams"></param>
/// <returns></returns>
private ClusterMarkersResponse GetMarkersHelper(GetMarkersParams getParams)
{
try
{
var neLat = getParams.NorthEastLatitude;
var neLong = getParams.NorthEastLongitude;
var swLat = getParams.SouthWestLatitude;
var swLong = getParams.SouthWestLongitude;
var zoomLevel = getParams.ZoomLevel;
var filter = getParams.Filter ?? "";
// values are validated there
var markersInput = new MarkersInput(neLat, neLong, swLat, swLong, zoomLevel, filter);
var grid = GridCluster.GetBoundaryExtended(markersInput);
var cacheKeyHelper = string.Format("{0}_{1}_{2}", markersInput.Zoomlevel, markersInput.FilterHashCode(), grid.GetHashCode());
var cacheKey = CacheKeys.GetMarkers(cacheKeyHelper.GetHashCode());
var response = new ClusterMarkersResponse();
markersInput.Viewport.ValidateLatLon(); // Validate google map viewport input (should be always valid)
markersInput.Viewport.Normalize();
// Get all points from memory
IList <MapPoint> points = _pointCollection.Get(getParams.PointType); // _pointsDatabase.GetPoints();
// Filter points
points = FilterUtil.FilterByType(
points,
new FilterData {
TypeFilterExclude = markersInput.TypeFilterExclude
}
);
// Create new instance for every ajax request with input all points and json data
var clusterAlgo = new GridCluster(points, markersInput);
var clusteringEnabled = markersInput.IsClusteringEnabled ||
GmcConfiguration.Get.AlwaysClusteringEnabledWhenZoomLevelLess > markersInput.Zoomlevel;
// Clustering
if (clusteringEnabled && markersInput.Zoomlevel < GmcConfiguration.Get.ZoomlevelClusterStop)
{
IList <MapPoint> markers = clusterAlgo.RunCluster();
response = new ClusterMarkersResponse
{
Markers = markers,
Polylines = clusterAlgo.GetPolyLines()
};
}
else
{
// If we are here then there are no clustering
// The number of items returned is restricted to avoid json data overflow
IList <MapPoint> filteredDataset = FilterUtil.FilterDataByViewport(points, markersInput.Viewport);
IList <MapPoint> filteredDatasetMaxPoints = filteredDataset.Take(GmcConfiguration.Get.MaxMarkersReturned).ToList();
response = new ClusterMarkersResponse
{
Markers = filteredDatasetMaxPoints,
Polylines = clusterAlgo.GetPolyLines(),
Mia = filteredDataset.Count - filteredDatasetMaxPoints.Count,
};
}
// if client ne and sw is inside a specific grid box then cache the grid box and the result
// next time test if ne and sw is inside the grid box and return the cached result
if (GmcConfiguration.Get.CacheServices)
{
_memCache.Set(cacheKey, response, TimeSpan.FromMinutes(10)); // cache data
}
return(response);
}
catch (Exception ex)
{
return(new ClusterMarkersResponse
{
OperationResult = "0",
ErrorMessage = string.Format("MapService says: exception {0}", ex.Message)
});
}
}
public void addPointGroup(GridCluster gCluster)
{
pointGroups.Add(gCluster);
}
protected MapPointMarker getClusterMarker(GridCluster gCluster, int id)
{
MapPointMarker mapPoint = new MapPointMarker(gCluster.getCenter().getX(), gCluster.getCenter().getY(), clusterPrefab, true);
mapPoint.setGridCluster(gCluster);
mapPoint.setLabel("Cluster " + id);
//if(mapPoint.getMarker3D()!= null)
// mapPoint.getMarker3D().instance.name = id.ToString();
mapPoint.setClusteredPoints(gCluster.getPoints());
mapPoint.setCluster(true);
if (mapPoint.getMarker3D() != null)
{
mapPoint.getMarker3D().altitude = 30.0f;
mapPoint.getMarker3D().altitudeType = OnlineMapsAltitudeType.absolute;
mapPoint.getMarker3D().scale = getScale(gCluster, this.points.Count);
}
mapPoint.setMap(this);
addMarkerInstance(mapPoint);
if (mapPoint.isGroupPoint())
{
var img = mapPoint.markerInstance.gameObject.GetComponentInChildren <Image>();
if (img != null)
{
img.sprite = customGroupPointMarker;
foreach (var imgchild in img.GetComponentsInChildren <Image>())
{
if (imgchild != img)
{
imgchild.sprite = customGroupPointMarker;
}
}
}
}
gCluster.setCenter(mapPoint);
//if (gCluster.isGroupPoints())
// Debug.Log("AQUI");
/*
*
* if (gCluster.getCategory().Equals("silknow.org/#pthing"))
* {
* SphereCollider sphereCollider = mapPoint.getMarker3D().instance.GetComponent<SphereCollider>();
* sphereCollider.radius = 1;
* //mapPoint.getMarker3D().scale = mapPoint.getMarker3D().scale * 100.0f;
* }
* else
* {
* CapsuleCollider capsuleCollider = mapPoint.getMarker3D().instance.GetComponent<CapsuleCollider>();
* capsuleCollider.radius = 0.5f;
* capsuleCollider.height = 1.5f;
* capsuleCollider.direction = 1;
* mapPoint.getMarker3D().altitude = 70.0f;
* //mapPoint.getMarker3D().transform.position = mapPoint.getMarker3D().transform.position + new Vector3(0.0f, 60.0f, 0.0f);
* //mapPoint.getMarker3D().al
*
* }*/
mapPoint.hide();
return(mapPoint);
}
/// <summary>
/// Read Through Cache
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public JsonMarkersReply GetMarkersHelper(JsonGetMarkersInput input)
{
try
{
var nelat = Math.Round(input.nelat.ToDouble(), Numbers.Round);
var nelon = Math.Round(input.nelon.ToDouble(), Numbers.Round);
var swlat = Math.Round(input.swlat.ToDouble(), Numbers.Round);
var swlon = Math.Round(input.swlon.ToDouble(), Numbers.Round);
var zoomLevel = int.Parse(input.zoomLevel);
var filter = input.filter ?? "";
// values are validated there
var inputValidated = new JsonGetMarkersReceive(nelat, nelon, swlat, swlon, zoomLevel, filter);
var grid = GridCluster.GetBoundaryExtended(inputValidated);
var cacheKeyHelper = string.Format("{0}_{1}_{2}", inputValidated.Zoomlevel, inputValidated.FilterHashCode(), grid.GetHashCode());
var cacheKey = CacheKeys.GetMarkers(cacheKeyHelper.GetHashCode());
var reply = _memCache.Get <JsonMarkersReply>(cacheKey);
if (reply != null)
{
// return cached data
reply.Cache = true;
return(reply);
}
inputValidated.Viewport.ValidateLatLon(); // Validate google map viewport input (should be always valid)
inputValidated.Viewport.Normalize();
// Get all points from memory
IList <P> points = _pointsDatabase.GetPoints();
#region fiter
// Filter points
points = FilterUtil.FilterByType(
points,
new FilterData {
TypeFilterExclude = inputValidated.TypeFilterExclude
}
);
#endregion filter
// Create new instance for every ajax request with input all points and json data
ICluster clusterAlgo = new GridCluster(points, inputValidated);
var clusteringEnabled = inputValidated.IsClusteringEnabled ||
GmcSettings.Get.AlwaysClusteringEnabledWhenZoomLevelLess > inputValidated.Zoomlevel;
// Clustering
if (clusteringEnabled && inputValidated.Zoomlevel < GmcSettings.Get.ZoomlevelClusterStop)
{
#region cluster
IList <P> markers = clusterAlgo.RunCluster();
#endregion cluster
reply = new JsonMarkersReply
{
Markers = markers,
Polylines = clusterAlgo.GetPolyLines(),
};
}
else
{
// If we are here then there are no clustering
// The number of items returned is restricted to avoid json data overflow
IList <P> filteredDataset = FilterUtil.FilterDataByViewport(points, inputValidated.Viewport);
IList <P> filteredDatasetMaxPoints = filteredDataset.Take(GmcSettings.Get.MaxMarkersReturned).ToList();
reply = new JsonMarkersReply
{
Markers = filteredDatasetMaxPoints,
Polylines = clusterAlgo.GetPolyLines(),
Mia = filteredDataset.Count - filteredDatasetMaxPoints.Count,
};
}
// if client ne and sw is inside a specific grid box then cache the grid box and the result
// next time test if ne and sw is inside the grid box and return the cached result
if (GmcSettings.Get.CacheServices)
{
_memCache.Set(reply, cacheKey, TimeSpan.FromMinutes(10)); // cache data
}
return(reply);
}
catch (Exception ex)
{
return(new JsonMarkersReply
{
Ok = "0",
EMsg = string.Format("MapService says: exception {0}", ex.Message)
});
}
}
public void addCluster(GridCluster cluster)
{
this.clusters.Add(cluster);
cluster.setLevel(this.getLevel());
}
public void managePoints(List <MapPoint> points, float radius)
{
int numPoints = points.Count;
bool pointKey = false;
radius = radius * radius;
int baseLevel = -100;
//Debug.Log("el radio sin raiz es " + radius);
for (int i = 0; i < numPoints; i++)
{
//Debug.Log("Analizando punto " + i + " = " + points[i].getX() + "," + points[i].getY());
if (!points[i].clusteredLevel)
{
GridCluster radialCluster = points[i].isInGroupPoint;
if (radialCluster == null)
{
radialCluster = new GridCluster(0, 0, points[i], this);
//radialCluster.addPoint(points[i]);
//points[i].setGridCluster(radialCluster);
points[i].addCluster(radialCluster);
points[i].clusteredLevel = true;
}
else
{
/*
* for (int gP = 0; gP < radialCluster.getNumPoints(); gP++)
* {
* radialCluster.setLevel(this);
* points[gP].addCluster(radialCluster);
* points[gP].clusteredLevel = true;
* }*/
}
//Debug.Log("Se crea el cluster con punto "+i);
for (int j = 0; j < numPoints; j++)
{
//Debug.Log("Analizando emparejamiento con punto " + j + " = " + points[j].getX() + "," + points[j].getY());
if (!points[j].clusteredLevel && j != i)
{
//Debug.Log("Distancia con punto " + j + " es de " + getDistance(points[i], points[j]));
if (getDistance(points[i], points[j]) <= radius)
{
radialCluster.addPoint(points[j]);
points[j].addCluster(radialCluster);
points[j].clusteredLevel = true;
}
}
}
if (pointKey)
{
Debug.Log("El cluster radial tiene " + radialCluster.getNumPoints());
pointKey = false;
}
if (radialCluster.getNumPoints() > 0)
{
radialCluster.update();
this.addCluster(radialCluster);
}
else
{
// points[i].removeCluster(radialCluster);
//points[i].clusteredLevel = false;
//for (int auxC=0;auxC<auxList.Count;auxC++)
//{
// auxList[auxC].removeCluster(radialCluster);
// auxList[auxC].clusteredLevel = false;
// }
}
//auxList.Clear();
}
}
//Debug.Log("En el nivel base hay " + this.clusters.Count + " clusters mayores de 1 punto");
int punto1 = 0;
for (int i = 0; i < numPoints; i++)
{
if (!points[i].clusteredLevel)
{
GridCluster radialCluster = new GridCluster(0, 0, points[i], this);
//radialCluster.addPoint(points[i]);
//points[i].setGridCluster(radialCluster);
points[i].clusteredLevel = true;
points[i].addCluster(radialCluster);
this.addCluster(radialCluster);
punto1++;
}
}
//Debug.Log("En el nivel base hay " + punto1 + " clusters de 1 punto");
}
public void setGridCluster(GridCluster gCluster)
{
this.gridCluster = gCluster;
setCluster(true);
}
public void removeCluster(GridCluster cluster)
{
this.clusterList.Remove(cluster);
}
public void managePointsNew(GridCluster cluster)
{
int i = 0;
List <MapPoint> points = cluster.getPoints();
//Debug.Log("Managin cluster with " + points.Count);
int numPoints = points.Count;
List <GridCluster> newClusters = new List <GridCluster>();
float width = (cluster.maxX - cluster.minX) / 2.5f;
float heigth = cluster.maxY - cluster.minY;
Vector2 size = new Vector2(width, heigth);
if (size.x != 0.0f)
{
Rect area1 = new Rect(new Vector2(cluster.minX, cluster.minY), size);
//Rect area2 = new Rect(new Vector2(cluster.minX + (cluster.maxX - cluster.minX) / 3.0f, cluster.minY), size);
Rect area3 = new Rect(new Vector2(cluster.maxX - (cluster.maxX - cluster.minX) / 3.0f, cluster.minY), size);
Vector2 center1 = getRectCenter(area1);
//Vector2 center2 = getRectCenter(area2);
Vector2 center3 = getRectCenter(area3);
GridCluster cluster1 = new GridCluster(0, 0); // this.getHGrid(center1.x), this.getVGrid(center1.y));
// GridCluster cluster2 = new GridCluster(0,0); //;this.getHGrid(center2.x), this.getVGrid(center2.y));
GridCluster cluster3 = new GridCluster(0, 0); // this.getHGrid(center3.x), this.getVGrid(center3.y));
for (i = 0; i < numPoints; i++)
{
MapPoint p = cluster.getPoints()[i];
if (isInRect(p.getX(), p.getY(), area1))
{
p.addCluster(cluster1);
cluster1.addPoint(p);
}
else
{
/*
* if (isInRect(p.getX(), p.getY(), area2))
* {
* p.addCluster(cluster2);
* cluster2.addPoint(p);
* }
* else
* {*/
p.addCluster(cluster3);
cluster3.addPoint(p);
//}
}
}
int numclusters = 0;
if (cluster1.getNumPoints() > 0)
{
cluster1.setParent(cluster);
cluster1.setLevel(this.level);
cluster.addChild(cluster1);
this.clusters.Add(cluster1);
numclusters++;
}
/*
* if (cluster2.getNumPoints() > 0)
* {
* cluster2.setParent(cluster);
* cluster.addChild(cluster2);
* cluster2.setLevel(this.level);
* this.clusters.Add(cluster2);
* numclusters++;
* }*/
if (cluster3.getNumPoints() > 0)
{
cluster3.setParent(cluster);
cluster.addChild(cluster3);
cluster3.setLevel(this.level);
this.clusters.Add(cluster3);
numclusters++;
}
//Debug.Log("Se crean "+ numclusters+ " clusters normales en nivel " + this.level);
}
else // grouppoint o clusters de 1 punto
{
//Debug.Log("Se crea un cluster de grouppoint/1 punto en nivel " + this.level);
GridCluster cluster1 = new GridCluster(0, 0, cluster.getPoints()[0]);
cluster1.setLevel(this.level);
cluster1.setParent(cluster);
cluster.addChild(cluster1);
this.clusters.Add(cluster1);
}
}
public void setParent(GridCluster cluster)
{
this.parent = cluster;
}
public void update()
{
int i = 0;
MapLevel lastLevel = null;
//List<MapPoint> levelPoints = this.points;
//Debug.Log("Actualizando para " + points.Count + "");
for (i = 0; i < zoomIntervals; i++)
{
this.levels.Add(new MapLevel(this.zone, this.numQuadsHoriz, this.numQuadsVert, i));
}
for (i = zoomIntervals - 2; i >= 0; i--)
{
int numClos = 0;
int punto1 = 0;
//MapLevel level = new MapLevel(this.zone, this.numQuadsHoriz, this.numQuadsVert, i);
MapLevel level = this.levels[i];
if (lastLevel == null)
{
//Debug.Log("Hay "+ this.pointGroups.Count+" gouppoints");
for (int pG = 0; pG < this.pointGroups.Count; pG++)
{
this.pointGroups[pG].setLevel(level);
level.addCluster(this.pointGroups[pG]);
//this.pointGroups[pG].processed = true;
}
level.managePoints(this.points, 0.5f);
}
else
{
List <GridCluster> clusterList = lastLevel.getGridClusters();// this.getGridClustersAtLevel(i+1);
//Debug.Log("EN ZOOM INTERVAL " + i + "y nivel " + lastLevel.getLevel() + " hay ....");
//Debug.Log("EN nivel " + lastLevel.getLevel() + " hay " + clusterList.Count + " clusters");
//Debug.Log("El minimio del nivel " + lastLevel.getLevel() + " es " + level.getMinimum());
if (clusterList != null)
{
if (clusterList.Count == 1)
{
//Debug.Log("UNO Y SALE");
GridCluster newGridCluster = new GridCluster(clusterList[0]);
newGridCluster.associatePoints();
//newGridCluster.update();
level.addCluster(newGridCluster);
}
else
{
float minimum = level.getMinimum();
if (level.getLevel() <= 1)
{
minimum = minimum * 100.0f;
}
//for (int o = 0;o<clusterList.Count;o++)
// clusterList[o].closest = getClosestTo(clusterList[o], clusterList, 0, minimum, false);
int aux = 0;
while (aux < clusterList.Count)
{
GridCluster currentCluster = clusterList[aux];
if (!clusterList[aux].processed)
{
if (clusterList[aux].getPoints()[0].getURI().Equals(("http://data.silknow.org/object/5f7a48fe-d8ac-37d8-90e3-f4448e665a9b")))
{
Debug.Log("Procesando");
}
GridCluster closest = getClosestTo(clusterList[aux], clusterList, aux, minimum, false);
if (closest != null)
{
GridCluster newGridCluster = new GridCluster(currentCluster, closest);
newGridCluster.associatePoints();
newGridCluster.update();
level.addCluster(newGridCluster);
currentCluster.processed = true;
closest.processed = true;
numClos++;
}
else
{
GridCluster newGridCluster = new GridCluster(currentCluster);
newGridCluster.associatePoints();
//newGridCluster.update();
level.addCluster(newGridCluster);
currentCluster.processed = true;
punto1++;
}
/*
* }
* else
* {
* GridCluster newGridCluster = new GridCluster(currentCluster);
* newGridCluster.associatePoints();
* //newGridCluster.update();
* level.addCluster(newGridCluster);
* currentCluster.processed = true;
* punto1++;
* //closest.processed = true;
* }*/
}
aux++;
}
}
}
//Debug.Log("EN el nivel " + i + " hay " + level.getGridClusters().Count);
//Debug.Log("De los cuales " + punto1 + " son de 1 punto");
}
//Debug.Log(numClos + " clusters cercanos");
lastLevel = level;
//this.levels.Add(level);
}
for (int p = 0; p < points.Count; p++)
{
if (points[p].getURI().Equals("http://data.silknow.org/object/54e7582f-d37e-3e85-9cac-c26b52a7711b"))
{
MapPoint pn = points[p];
}
if (points[p].getURI().Equals("http://data.silknow.org/object/12eed6aa-578c-39c0-b0d8-ecf3cdfd68c8"))
{
MapPoint pn = points[p];
}
if (points[p].getURI().Equals("http://data.silknow.org/object/db5ed89d-fac0-3cf1-81ec-fc55a66b8252"))
{
MapPoint pn = points[p];
}
}
}
public void associateTo(GridCluster gridCluster)
{
this.associatedTo = gridCluster;
}
// Post
public JsonMarkersReply Markers(
double nelat, double nelon, double swlat, double swlon,
int zoomlevel, string filter, int sendid
)
{
var sw = new Stopwatch();
sw.Start();
var jsonReceive = new JsonGetMarkersReceive(nelat, nelon, swlat, swlon, zoomlevel, filter, sendid);
var clusteringEnabled = jsonReceive.IsClusteringEnabled || AlgoConfig.AlwaysClusteringEnabledWhenZoomLevelLess > jsonReceive.Zoomlevel;
JsonMarkersReply reply;
jsonReceive.Viewport.ValidateLatLon(); // Validate google map viewport input (is always valid)
jsonReceive.Viewport.Normalize();
// Get all points from memory
IPoints points = MemoryDatabase.GetPoints();
if (jsonReceive.TypeFilterExclude.Count == AlgoConfig.MarkerTypes.Count)
{
// Filter all
points = new Points(); // empty
}
else if (jsonReceive.TypeFilterExclude.Count > 0)
{
// Filter data by typeFilter value
// Make new obj, don't overwrite obj data
points = new Points
{
Data = points.Data
.Where(p => jsonReceive.TypeFilterExclude.Contains(p.T) == false)
.ToList()
};
}
// Create new instance for every ajax request with input all points and json data
var clusterAlgo = new GridCluster(points, jsonReceive); // create polylines
// Clustering
if (clusteringEnabled && jsonReceive.Zoomlevel < AlgoConfig.ZoomlevelClusterStop)
{
// Calculate data to be displayed
var clusterPoints = clusterAlgo.GetCluster(new ClusterInfo
{
ZoomLevel = jsonReceive.Zoomlevel,
});
var converted = DataConvert(clusterPoints);
// Prepare data to the client
reply = new JsonMarkersReply
{
Markers = converted,
Rid = sendid,
Polylines = clusterAlgo.Lines,
Msec = Sw(sw),
};
// Return client data
return(reply);
}
// If we are here then there are no clustering
// The number of items returned is restricted to avoid json data overflow
IPoints filteredDataset = ClusterAlgorithmBase.FilterDataset(points, jsonReceive.Viewport);
IPoints filteredDatasetMaxPoints = new Points
{
Data = filteredDataset.Data
.Take(AlgoConfig.MaxMarkersReturned)
.ToList()
};
reply = new JsonMarkersReply
{
Markers = DataConvert(filteredDatasetMaxPoints),
Rid = sendid,
Polylines = clusterAlgo.Lines,
Mia = filteredDataset.Count - filteredDatasetMaxPoints.Count,
Msec = Sw(sw),
};
return(reply);
}
protected GridCluster getClosestTo(GridCluster from, List <GridCluster> clusterList, int since, float minimum, bool check)
{
GridCluster closest = null;
GridCluster closest1 = null;
string fromURI = from.getPoints()[0].getURI();
float minDistance = 1000000.0f;
float minDistance1 = 1000000.0f;
//float minimum = 5.0f;
int i = since;
//i = 0;
while (i < clusterList.Count)
{
if (!clusterList[i].processed && from != clusterList[i]) //&& clusterList[i].getNumPoints()>1)
{
float currentDistance = getDistance(from.getCenter(), clusterList[i].getCenter());
if (currentDistance <= minimum)
{
if (check)
{
//GridCluster closest2 = getClosestTo(clusterList[i], clusterList, since, minimum, false);
GridCluster closest2 = clusterList[i].closest;
if (closest2 != null)
{
if (closest2.getPoints()[0].getURI().Equals(fromURI))
{
if (currentDistance < minDistance && clusterList[i].getNumPoints() >= 1)
{
minDistance = currentDistance;
closest = clusterList[i];
}
/*
* if (currentDistance < minDistance1 && clusterList[i].getNumPoints() == 1)
* {
* minDistance1 = currentDistance;
* closest1 = clusterList[i];
* }*/
}
}
}
else
{
if (currentDistance < minDistance && clusterList[i].getNumPoints() >= 1)
{
minDistance = currentDistance;
closest = clusterList[i];
}
/*
* if (currentDistance < minDistance1 && clusterList[i].getNumPoints() == 1)
* {
* minDistance1 = currentDistance;
* closest1 = clusterList[i];
* }*/
}
}
}
i++;
}
//if (minDistance1 < minDistance / 1.25f)
// closest = closest1;
return(closest);
}
