Elsevier

Computers & Graphics

Volume 51, October 2015, Pages 81-89
Computers & Graphics

SMI 2015
Large mesh simplification for distributed environments

https://doi.org/10.1016/j.cag.2015.05.015Get rights and content

Highlights

  • An algorithm to perform adaptive mesh simplification in distributed environments.

  • An out-of-core technique to partition huge indexed meshes into smaller pieces.

  • Parallel processing of submeshes by concurrent use of several connected PCs.

  • The generation of arbitrary large outputs is supported.

Abstract

An algorithm is described to simplify arbitrarily large triangle meshes while leveraging the computing power of modern distributed environments. Our method combines the flexibility of out-of-core (OOC) techniques with the quality of accurate in-core algorithms, while representing a particularly fast approach thanks to the concurrent use of several computers in a network. When compared with existing parallel algorithms, the simplifications produced by our method exhibit a significantly higher accuracy. Furthermore, when our algorithm is run on a single machine, its speed is comparable with state-of-the-art OOC techniques, whereas the use of more machines enables relevant speedups. Noticeably, we observe that the speedup increases as the size of the input mesh grows.

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)

  • P.S. Heckbert 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:...
  • Tang X, Jia S, Li B. Simplification algorithm for large polygonal model in distributed environment. In: Advanced...
  • Shontz SM, Nistor DM. CPU-GPU algorithms for triangular surface mesh simplification. In: Proceedings of international...
  • Lindstrom P. Out-of-core simplification of large polygonal models. In: Proceedings of SIGGRAPH ׳00; 2000. p....
  • Lindstrom P, Silva CT. A memory insensitive technique for large model simplification. In: Proceedings of IEEE...
  • Cited by (14)

    View all citing articles on Scopus
    View full text