Table 1: Timings for experiments with ONGs for point
sets of different size. The timings in ms are averaged over
10 000 iterations.
Point set 1 000 10 000 100 000
Incremental build 0.031 s 0.367 s 6.141 s
Remove all points 0.027 s 0.309 s 5.694 s
Point movement 0.055 ms 0.059 ms 0.058 ms
Range searching 0.109 ms 0.111 ms 0.110 ms
Using this algorithm, we can also provide prox-
imity queries for other metrics. For example, the
Euclidean nearest neighbor to p can be found by
searching all vertices nearer than the nearest neigh-
bor n
M
based on the Manhattan metric. We do this
by performing a range search around p with radius
d
M
(p, n
M
) and comparing the distances of the result
points according to the Euclidean metric.
5 DISCUSSION
In the following we give preliminary results for our
approach. We have implemented all presented algo-
rithms and data structures in C++. Figure 1 shows a
complex ONG generated with our system.
Table 1 gives timings of some experiments on
a 3GHz PC using our prototypical implementation,
where the code was not optimized for speed. First,
we inserted a large number of points with random
distribution in arbitrary order. The table shows that
these can be quickly incrementally inserted into an
ONG. The incremental removal of all points is even
faster, because no localization step (as explained in
section 4.4) is needed. In the next experiment we
compare the cost of locally moving a point in small
and large point sets consisting of 1 000, 10 000, and
100 000 points. The timings for all three cases are
nearly equal. Finally, we do a range search in small
and large point sets. We adapt the radius, so that 100
points are found each time. Again, the timings are
nearly equal. Therefore, the total number of points in
the ONG does not inﬂuence the cost of local opera-
tions like local movements or range searching. This
conﬁrms the scalability of ONGs.
5.1 Conclusion
We have introduced ONGs, a new spatial data struc-
ture that supports proximity queries in dynamic point
sets. The basis for ONGs are weak spanners, which
ensure that storing the nearest neighbor for each quad-
rant results in a strongly connected graph. ONGs
are decentralized in that all information is distributed
on the whole point set. We presented different algo-
rithms that work on the local neighborhood of given
points. This allows dynamic insertions, deletions and
movements of points as well as range queries inde-
pendent of the size of the point set. Our algorithms are
input and output sensitive: The cost of moving a point
is low for small movements, but grows as it moves
farther. Also, the cost of range queries depends of
the number and the neighborhood of the result points.
These properties make ONGs applicable to systems
consisting of a large number of points, like particle or
agent systems.
5.2 Future Work
There are many areas of future work and open ques-
tions for ONGs. The approach and the presented algo-
rithms have to be analyzed and evaluated in more de-
tail. A comparison with other techniques (like quad-
or kd-trees) will show the usability of ONGs.
We want to adopt ONGs to 3D and higher dimen-
sions. In principle, the presented algorithms and data
structures also work in higher dimensions. However,
the number of orthants grows exponentially with the
number of dimensions, resulting in drawdowns in per-
formance. The lowest known bound of the number
of neighbors required for weak spanners in 3D is 8.
However, this bound is not tight (Fischer et al., 1999).
ONGs would beneﬁt from a scheme that requires less
cones and still produces weak spanners.
Another direction of future work is the kinetiza-
tion of ONGs. Kinetic data structures store dynamic
objects and explicitly model their motion (Basch
et al., 1997). The idea is to only change the underly-
ing structure if certain predicates change. This could
save unnecessary updates of ONGs for small motions
which do not change the graph topology.
Finally, we want to apply ONGs to different prob-
lems in computer graphics. For example, higher di-
mensional ONGs could be used for the broad phase
of collision detection.
REFERENCES
Arya, S., Das, G., Mount, D. M., Salowe, J. S., and Smid,
M. (1995). Euclidean spanners: short, thin, and lanky.
In STOC ’95: Proc. 27th annual ACM symposium on
Theory of computing, pages 489–498.
Basch, J., Guibas, L. J., and Hershberger, J. (1997). Data
structures for mobile data. In SODA ’97: Proc. 8th an-
nual ACM-SIAM symposium on Discrete algorithms,
pages 747–756.
Bentley, J. L. (1990). K-d trees for semidynamic point sets.
In SCG ’90: Proc. 6th annual symp. on Computa-
tional geometry, pages 187–197.
GRAPP 2007 - International Conference on Computer Graphics Theory and Applications
92