public List <long> CollectNIDsPlus(IEnvelope envelope)
{
// envelope fully contains bounds -> all nodes -> return Zero!
if (envelope == null || envelope.Contains(_bounds))
{
return(null);
}
List <long> ids = new List <long>();
NodeNumbers nn = new NodeNumbers(_nodeNumbers);
// Query Envelope is outside bounds
if (!envelope.Intersects(_bounds))
{
if (nn.Contains(0)) // if features outside bounds exists -> add zero node
{
ids.Add(0);
}
return(ids);
}
CollectPlus(0, 0, envelope, _bounds, nn, ids);
return(ids);
}
public long ContainerNodeNumber(IEnvelope FeatureEnvelope)
{
NodeNumbers nn = new NodeNumbers(_nodeNumbers);
long containerNode = 0;
ContainerNodeNumber(FeatureEnvelope, nn, ref containerNode);
return(containerNode);
}
private void ContainerNodeNumber(IEnvelope FeatureEnvelope, NodeNumbers nn, ref long containerNode)
{
//if (nn.Cancel) return;
//int level = NodeLevel(nn.Value);
//long reachable = (long)(nn.Value + (long)Math.Pow(2, _maxLevels - level + 1) - 2);
//if (nn.Value > reachable) return;
//IEnvelope env = this[nn.Value];
//if (env.Contains(FeatureEnvelope))
//{
// containerNode = nn.Value;
// nn.Inc();
// ContainerNodeNumber(FeatureEnvelope, nn, ref containerNode);
//}
//else
//{
// while (nn.Value <= reachable)
// {
// nn.Inc();
// if (nn.Cancel) return;
// }
// ContainerNodeNumber(FeatureEnvelope, nn, ref containerNode);
//}
long reachable = ReachableNodes(0, 0); //(long)(Math.Pow(2, _maxLevels + 1) - 2);
while (!nn.Cancel)
{
if (nn.Value > reachable)
{
return;
}
int level = NodeLevel(nn.Value);
long r = ReachableNodes(nn.Value, level); //(long)(nn.Value + (long)Math.Pow(2, _maxLevels - level + 1) - 2);
IEnvelope env = this[nn.Value];
if (env.Contains(FeatureEnvelope))
{
reachable = r;
containerNode = nn.Value;
}
else
{
while (nn.Value <= r)
{
nn.Inc();
if (nn.Cancel)
{
return;
}
}
}
nn.Inc();
}
}
public List <long> CollectNIDs(IGeometry geometry)
{
if (geometry is IEnvelope)
{
// Schnelle Suche für Envelope (GetMap)
return(CollectNIDs(geometry as IEnvelope));
}
// sonst ausführliche Suche
//
// Envelopes der Geometrie Teile bestimmen
//
List <IEnvelope> envelops = gView.Framework.SpatialAlgorithms.Algorithm.PartEnvelops(geometry);
List <long> ids = new List <long>();
//if (_nodeNumbers.BinarySearch(0) > -1) ids.Add(0);
//
// IDs für die Envelopes suchen
//
foreach (IEnvelope envelope in envelops)
{
if (envelops == null)
{
continue;
}
NodeNumbers nn = new NodeNumbers(_nodeNumbers);
Collect(0, 0, envelope, _bounds, nn, ids, true);
ids.Sort();
}
//
// IDs wieder entfernen, die sich nicht mit der Geometrie schneiden
//
foreach (long id in ListOperations <long> .Clone(ids))
{
IEnvelope bound = this[id];
if (!SpatialAlgorithms.Algorithm.IntersectBox(geometry, bound))
{
ids.Remove(id);
}
}
if (ids.Count == 0)
{
ids.Add(0);
}
else if (ids.IndexOf(0) == -1 && _nodeNumbers.BinarySearch(0) > -1)
{
ids.Add(0);
}
return(ids);
}
private List <long> CollectNIDs(IEnvelope bounds)
{
List <long> ids = new List <long>();
//if (_nodeNumbers.BinarySearch(0) > -1) ids.Add(0);
NodeNumbers nn = new NodeNumbers(_nodeNumbers);
//history = new List<long>();
Collect(0, 0, bounds, _bounds, nn, ids, false);
if (ids.Count == 0)
{
ids.Add(0);
}
else if (ids.IndexOf(0) == -1 && _nodeNumbers.BinarySearch(0) > -1)
{
ids.Add(0);
}
return(ids);
}
private void Collect(long FromNodeNumber, long ToNodeNumber, NodeNumbers nn, List <long> ids, bool checkDuplicates)
{
//if (actIndex >= _nodeNumbers.Count) return _nodeNumbers.Count;
//long number = _nodeNumbers[actIndex];
if (nn.Cancel)
{
return;
}
long number = nn.Value;
while (number <= ToNodeNumber)
{
if (number >= FromNodeNumber && number <= ToNodeNumber)
{
if (checkDuplicates)
{
if (ids.BinarySearch(number) < 0)
{
ids.Add(number);
}
}
else
{
ids.Add(number);
}
}
//actIndex++;
//if (actIndex >= _nodeNumbers.Count) return _nodeNumbers.Count;
//number = _nodeNumbers[actIndex];
nn.Inc();
if (nn.Cancel)
{
return;
}
number = nn.Value;
}
//return actIndex;
}
private void CollectPlus(long number, int level, IEnvelope rect, IEnvelope NodeEnvelope, NodeNumbers nn, List <long> ids)
{
long reachable = ReachableNodes(number, level); //(long)(number + (long)Math.Pow(2, _maxLevels - level + 1) - 2);
if (nn.Cancel || nn.Value > reachable)
{
return; // ???
}
if (!rect.Intersects(NodeEnvelope))
{
return;
}
if (!nn.Contains(number, reachable))
{
return;
}
if (number > 0 && rect.Contains(NodeEnvelope))
{
int index = ids.IndexOf(number - 1);
if (index > 0 && ids[index - 1] < 0)
{
// Optimierung:
// voriger knoten schon mit Between abgefragt wird ->
// Vorigen Between gleich mit neuem Reachable Wert versehen -> weniger Statements!!
ids[index] = reachable;
}
else
{
ids.Add(-number);
ids.Add(reachable);
}
return;
}
if (nn.SetTo(number))
{
ids.Add(number);
}
if (level < _maxLevels)
{
long c1, c2;
ChildNodeNumbers(number, level, out c1, out c2);
CollectPlus(c1, level + 1, rect, this.SplitEnvelope(NodeEnvelope, true), nn, ids);
CollectPlus(c2, level + 1, rect, this.SplitEnvelope(NodeEnvelope, false), nn, ids);
}
}
//private List<long> history;
private void Collect(long number, int level, IEnvelope rect, IEnvelope NodeEnvelope, NodeNumbers nn, List <long> ids, bool checkDuplicates)
{
//history.Add(number);
long reachable = ReachableNodes(number, level); //(long)(number + (long)Math.Pow(2, _maxLevels - level + 1) - 2);
if (nn.Cancel || nn.Value > reachable)
{
return;
}
if (!rect.Intersects(NodeEnvelope))
{
return;
}
//int nodeIndex = _nodeNumbers.BinarySearch(number);
//if (nodeIndex > -1 && ids.BinarySearch(number) < 0) ids.Add(number);
int added = 0;
if (nn.SetTo(number))
{
if (checkDuplicates)
{
if (ids.BinarySearch(number) < 0)
{
ids.Add(number);
}
}
else
{
ids.Add(number);
added = 1;
}
}
if (rect.Contains(NodeEnvelope))
{
if (level <= _maxLevels)
{
Collect(number + added, reachable, nn, ids, checkDuplicates);
return;
}
}
if (level < _maxLevels)
{
long c1, c2;
ChildNodeNumbers(number, level, out c1, out c2);
Collect(c1, level + 1, rect, this.SplitEnvelope(NodeEnvelope, true), nn, ids, checkDuplicates);
Collect(c2, level + 1, rect, this.SplitEnvelope(NodeEnvelope, false), nn, ids, checkDuplicates);
}
}
