3 research outputs found
Validation and automatic repair of planar partitions using a constrained triangulation
Planar partitions are frequently used to model, among others, land cover, cadastral parcels and administrative boundaries. In practice, they are often stored as a set of individual polygons to which attributes are attached (e.g. with the Simple Features paradigm), causing different errors and inconsistencies (e.g. gaps, overlaps and disconnected polygons), which are introduced during their creation, manipulation and exchange. These errors severely hamper the use of planar partitions in other software (e.g. due to false assumptions causing erroneous calculations). Existing approaches to validate planar partitions involve first building a planar graph of the polygons and enforcing constraints, then repair is done by snapping vertices and edges of this graph. We argue that these approaches have many shortcomings in terms of complexity, numerical robustness and difficulty of implementation, and do not guarantee valid results. Furthermore, they are semi-automatic, requiring manual user intervention. We propose in this paper a novel method to validate and automatically repair planar partitions. It uses a constrained triangulation of the polygons as a base-which by definition is a planar partition-and only simple operations are needed (i.e. labelling of triangles) to both validate and repair. Perhaps the biggest advantage of our method is that we can guarantee that a planar partition is valid after repair. In the paper we describe the details of our method, our implementation, and the experiments we have done with real-world datasets. We show that our implementation scales to big datasets and that it offers better capabilities and overall performance than existing solutions
On local heuristics to speed up polygon-polygon intersection tests
The polygon-polygon intersection operation is CPU-intensive. Many data structures look into decomposing the polygons into multiple yet simple pieces to speed up the polygon-polygon intersection operation. This paper addresses local heuristics that can be adopted in these data structures by using local information about the simple polygon pieces to decide upon polygon-polygon intersections without having to perform this costly operation. The significance and effectiveness of each of the heuristics is studied. The paper also shows how these heuristics can be put together to perform a polygon join operation. Experiments are given to demonstrate the savings both in CPU and in I/O that result from these local heuristics
Multi-Dimensional Joins
We present three novel algorithms for performing multi-dimensional
joins and an in-depth survey and analysis of a low-dimensional
spatial join. The first algorithm, the Iterative Spatial Join,
performs a spatial join on low-dimensional data and is based
on a plane-sweep technique.
As we show analytically and experimentally,
the Iterative Spatial Join performs well when internal memory is
limited, compared to competing methods. This suggests that
the Iterative Spatial Join would be useful for very large data sets
or in situations where internal memory is a shared resource and
is therefore limited, such as with today's database engines which
share internal memory amongst several queries. Furthermore, the
performance of the Iterative Spatial Join is predictable and has
no parameters which need to be tuned, unlike other algorithms.
The second algorithm, the Quickjoin algorithm,
performs a higher-dimensional
similarity join in which pairs of objects that lie within a
certain distance epsilon of each other are reported.
The Quickjoin algorithm overcomes drawbacks of competing methods,
such as requiring embedding methods on the data first or using
multi-dimensional indices, which limit
the ability to discriminate between objects in each
dimension, thereby degrading performance.
A formal analysis is provided of the Quickjoin method, and
experiments show that the Quickjoin method significantly outperforms
competing methods.
The third algorithm adapts
incremental join techniques to improve the
speed of calculating the Hausdorff distance, which
is used in applications such as image matching, image analysis,
and surface approximations.
The nearest neighbor incremental join technique for indices that
are based on hierarchical containment use a priority queue
of index node pairs and bounds on the distance values between
pairs, both of which need to modified in order to calculate the
Hausdorff distance. Results of experiments are described that
confirm the performance improvement.
Finally, a survey is provided which
instead of just summarizing the literature and presenting each
technique in its entirety, describes distinct components of
the different techniques, and each technique is decomposed into
an overall framework for performing a spatial join