/**
* Return the set the unmarked points whose distance to "center" is less
* than search_radius_, and mark these points. By construction, these points
* will be contained by one of the vertex neighbors of "center".
*/
public void Query(S2Point center, System.Collections.Generic.ICollection <S2Point> output)
{
output.Clear();
var neighbors = new List <S2CellId>();
S2CellId.FromPoint(center).GetVertexNeighbors(_level, neighbors);
foreach (var id in neighbors)
{
// Iterate over the points contained by each vertex neighbor.
foreach (var mp in _delegate[id])
{
if (mp.IsMarked)
{
continue;
}
var p = mp.Point;
if (center.Angle(p) <= _searchRadius)
{
output.Add(p);
mp.Mark();
}
}
}
}
/// <summary>
/// Removes all but mentioned items (i.e. determined by Linq expression) from the specified collection.
/// <locDE><para />Entfernt alle außer die angegebenen Elemente (z.B. ermittelt durch Linq Ausdruck) von der angegebenen Collection.</locDE>
/// </summary>
/// <typeparam name="T">The type of the T.<locDE><para />Generischer Datentyp T.</locDE></typeparam>
/// <param name="collection">The collection.<locDE><para />Die Collection.</locDE></param>
/// <param name="condition">The condition.<locDE><para />Die Bedingung.</locDE></param>
/// <example>
/// Removes all elements but those with IsSelected property set to true.
/// <locDE><para />Entfernt alle Elemente außer jenen, deren Eigenschaft IsSelected = true enthält.</locDE>
/// <code>
/// var collection = new ObservableCollection<SelectableItem>();
/// collection.RemoveAllBut(x => x.IsSelected);
/// </code>
/// </example>
/// <returns>Number of removed items.<locDE><para />Anzahl der entfernten Elemente.</locDE></returns>
public static int RemoveAllBut <T>(this System.Collections.Generic.ICollection <T> collection, Func <T, bool> condition)
{
if (null == collection)
{
return(0);
}
// .ToList() saves us from "collection was modified" exception
// .ToList() bewahrt uns vor einer "Collection wurde verändert" Ausnahme.
var itemsToKeep = collection.Where(condition).ToList();
int itemsRemoved = collection.Count - itemsToKeep.Count();
collection.Clear();
foreach (var itemToKeep in itemsToKeep)
{
collection.Add(itemToKeep);
}
return(itemsRemoved);
}
/**
* Return a polygon which is the union of the given polygons; combines
* vertices that form edges that are almost identical, as defined by
* vertexMergeRadius. Note: clears the List!
*/
public static S2Polygon DestructiveUnionSloppy(System.Collections.Generic.ICollection <S2Polygon> polygons, S1Angle vertexMergeRadius)
{
// Effectively create a priority queue of polygons in order of number of
// vertices. Repeatedly union the two smallest polygons and add the result
// to the queue until we have a single polygon to return.
// map: # of vertices -> polygon
//TreeMultimap<Integer, S2Polygon> queue = TreeMultimap.create();
var queue = new MultiMap <int, S2Polygon>();
foreach (var polygon in polygons)
{
queue.Add(polygon.NumVertices, polygon);
}
polygons.Clear();
// Java uses a live-view that maps to the underlying structure
//Set<Map.Entry<Integer, S2Polygon>> queueSet = queue.entries();
var enumer = queue.SortedValues;
while (queue.CountIsAtLeast(2))
{
// Pop two simplest polygons from queue.
// queueSet = queue.entries();
//Iterator<Map.Entry<Integer, S2Polygon>> smallestIter = queueSet.iterator();
var smallestTwo = enumer.Take(2).ToList();
//Map.Entry<Integer, S2Polygon> smallest = smallestIter.next();
//int aSize = smallest.getKey().intValue();
//S2Polygon aPolygon = smallest.getValue();
//smallestIter.remove();
//smallest = smallestIter.next();
//int bSize = smallest.getKey().intValue();
//S2Polygon bPolygon = smallest.getValue();
//smallestIter.remove();
foreach (var item in smallestTwo)
{
queue.Remove(item);
}
// Union and add result back to queue.
var unionPolygon = new S2Polygon();
unionPolygon.InitToUnionSloppy(smallestTwo[0].Value, smallestTwo[1].Value, vertexMergeRadius);
var unionSize = smallestTwo[0].Key + smallestTwo[1].Key;
queue.Add(unionSize, unionPolygon);
// We assume that the number of vertices in the union polygon is the
// sum of the number of vertices in the original polygons, which is not
// always true, but will almost always be a decent approximation, and
// faster than recomputing.
}
if (queue.Count == 0)
{
return(new S2Polygon());
}
else
{
//return queue.get(queue.asMap().firstKey()).first();
return(queue.SortedValues.First().Value);
}
}