SMI 2015Large mesh simplification for distributed environments
Graphical Abstract
Introduction
In the last few decades, the evolution of 3D acquisition technologies called for methods to simplify meshes that have become large and larger. Earlier simplification algorithms [1], [2] could focus on efficiency and accuracy only, and today we know that methods based on iterative edge collapses driven by quadric error metrics are both efficient and, under certain conditions, provably optimal [3]. Soon, however, too large meshes appeared that could not fit in main memory, and existing algorithms needed to be redesigned to account for an appropriate out-of-core elaboration. In most of these methods the mesh is partitioned in several sub-meshes, each small enough to be processed with traditional algorithms. In some cases the mesh can be partitioned using an in-core algorithm: this is appropriate when memory is enough to store the mesh, but no further space is available to host all the support data structures necessary for the simplification (e.g. quadric matrices and priority queues) which are often more memory-demanding than the mesh itself. Conversely, when even the plain mesh is too large, out-of-core partitioning is required to produce the sub-meshes.
After having simplified each of the sub-meshes separately, these partial objects can be merged back into a single mesh. If the resulting simplifications are comprehensively small enough to fit in memory, in-core methods can be exploited to merge and polish the final result. Some algorithms, for example, avoid to simplify the sub-mesh boundaries to guarantee an exact match after the simplification. These contact regions are then unified in an in-core merging phase and, if necessary, their neighborhood is simplified using traditional algorithms. When the resulting simplification is still too large for in-core post-processing, contact borders can either be kept unsimplified or treated using a local, though sub-optimal, approach. For example, vertex clustering can be used to simplify sub-meshes so that their eventual boundaries are guaranteed to match, but this has a cost in terms of quality, especially when simplifying meshes with fair morphological variations (i.e. large flat areas mixed with feature-rich areas).
Furthermore, it is important to consider that the most diffused formats employ an indexed mesh representation: a first block in the file represents the vertex coordinates, whereas a second block represents each triangle as a triplet of indexes referred to the first block. Thus, while partitioning the vertices is relatively easy, indexes must be dereferenced to partition triangles, and the latter is not a trivial operation when memory is not sufficient to host all the vertex coordinates. For this reason, most existing methods assume that the input mesh is represented as a list of triangles, each directly encoded by the coordinates of its three vertices. Note that the high redundancy of such “triangle soups” represents a severe limitation when even an indexed mesh requires giga or even terabytes of disk space [4], [5].
A last important aspect that deserves attention is the efficiency. Even if multi-core architectures can be exploited to accelerate the process, the memory available on a single machine has a limit that imposes a sequentialization in any case. Conversely, distributed computer networks give access to virtually infinite resources while still enabling concurrent processing. However, typical multi-core methods communicate based on a fast-access shared memory [6] which is not available in a standard computer network. Hence, these methods are not suitable and innovative solutions are required.
To summarize, the following aspects should be taken into account when designing a large mesh simplification algorithm: (1) Out-of-core initial partitioning; (2) Out-of-core final merging/post-processing; (3) High quality of the simplification/ adaptivity; (4) Treatment of indexed meshes; (5) Efficiency and distributable load.
Herewith, we propose an original algorithm that satisfies all the aforementioned requirements while being comparable with, or even outperforming, less flexible state-of-the-art approaches. To the best of our knowledge, no existing method encapsulates all these characteristics.
Section snippets
Related work
In parallel algorithms [7], [8], [9], [10], [11] a “master” processor partitions the input mesh and distributes the portions across different “slave” processors that perform the partial simplifications simultaneously. When all the portions are ready, the master merges the results together. The many slave processors available in modern GPU-based architectures are exploited in [12]. In these methods the main goal is to speedup the process and, with the exception of [7], the typical approach to
Distributed simplification
In our reference scenario a number of consumer PCs are connected within a standard lab network, and a very large mesh M represented as an OFF file is stored on the local disk of one of these machines. In analogy with previous work on parallel processing, we call this latter machine the “master”, whereas all the other PCs are “slaves”. To simplify M, our method considers a target accuracy, the master׳s available memory, the number Ns of available slaves, and the available memory on each of the
Results and discussion
We performed our tests on a lab network of PCs, each equipped with Windows 7 64bit, an Intel i7 3.5 GHz processor, 4 GB Ram and 1 T hard disk. Connection among machines is provided through a 100 Mbps Ethernet. One machine plays the part of master, while the others are considered as slaves.
Our dataset (Table 1) includes large meshes extracted from the Stanford online repository [24], from the Digital Michelangelo Project [25] and from the IQmulus Project [5]. Some small meshes have been included in
Conclusions
We have demonstrated that the computing power of a network of PCs can be exploited to significantly speedup the simplification of huge triangle meshes. This can be achieved while maintaining a high quality of the simplification, even without a global priority queue or a shared memory. In particular, we have shown that the overhead due to the data transmission is much lower than the gain in speed provided by parallel processing. Even if our experiments were run on a standard 100 Mbps lab network,
Acknowledgment
This work is partly supported by the EU FP7 Project no. ICT-2011-318787 (IQmulus) and by the international joint project on “Mesh Repairing for 3D Printing Applications” funded by Software Architects Inc (WA, USA). The authors are grateful to all the colleagues at IMATI for the helpful discussions.
References (29)
- et al.
Optimal triangulation and quadric-based surface simplification
J Comput GeomTheory Appl
(1999) - Garland M, Heckbert PS. Surface simplification using quadric error metrics. In: Proceedings of SIGGRAPH׳97; 1997. p....
- Heckbert PS, Garland M. Survey of polygonal surface simplification algorithms. Technical report. CS Department,...
- Levoy M, Pulli K, Curless B, Rusinkiewicz S, Koller D, Pereira L, et al. The digital michelangelo project: 3d scanning...
- Iqmulus: A high-volume fusion and analysis platform for geospatial point clouds, coverages and volumetric data sets....
- Yongquan L, Pengdong G, Chu Q, Jintao W, Rui L. Parallel implementation of mesh simplification on a beowulf cluster....
- Brodsky D, Pedersen JB. Parallel model simplification of very large polygonal meshes. In: Proceedings of parallel and...
- Dehne F, Langis C, Roth G. Mesh simplification in parallel. In: Proceedings of algorithms and architectures for...
- Franc M, Skala V. Parallel triangular mesh reduction. In: Proceedings of scientific computing, ALGORITMY 2000; 2000, p....
- Nan L, Pengdong G, Yongquan L, Chu Q, Jintao W, Wenhua Y. Parallel adaptive simplification of massive meshes. In:...
Cited by (14)
Proximity-aware multiple meshes decimation using quadric error metric
2020, Graphical ModelsCitation Excerpt :A shared limitation of the aforementioned algorithms is to rely on sequential processing, which is greedy both in memory and computational power. Very large to huge meshes may thus be processed in parallel [26], out-of-core [27] or by combining the two approaches [28]. While different mesh properties and attributes may be preserved by the simplification, none of the previous methods takes particular care of the proximity between different parts.
Multi-GPU multi-display rendering of extremely large 3D environments
2023, Visual ComputerSemantic segmentation of high-resolution point clouds representing urban contexts
2023, Eurographics Italian Chapter Proceedings - Smart Tools and Applications in Graphics, STAGFast and Robust Parallel Simplification Algorithm for Triangular Mesh
2023, Proceedings of SPIE - The International Society for Optical EngineeringA real 3D scene rendering optimization method based on region of interest and viewing frustum prediction in virtual reality
2022, International Journal of Digital EarthEfficient topology-aware simplification of large triangulated terrains
2021, GIS: Proceedings of the ACM International Symposium on Advances in Geographic Information Systems