An Easy Viewer for Out-of-core Visualization of Huge Point-sampled Models

Transcription

1 An Easy Viewer for Out-of-core Visualization of Huge Point-sampled Models Fang Meng, Hongbin Zha National Laboratory on Machine Perception, Peking University Beijing , P. R. China {mengfang, Abstract In this paper, we propose a viewer for huge point-sampled models by combining out-of-core technologies with view-dependent level-of-detail (LOD) control. This viewer is designed on the basis of a multiresolution data structure we have developed for gaze-guided visualization and transmission of 3D point sets. In order to reduce memory loads for huge point sets on general PC platforms, we introduce a partition-based out-of-core strategy to balance usage of main and external memories. At first, the data surface is partitioned into small blocks and points in each block are reorganized into error-controlled LODs by hierarchical clustering and LOD organization. In the interactive rendering process, a data block scheduling algorithm is used to realize the view-dependent paging. Experimental results show that the viewer can perform interactive visualization of huge point models on commodity graphics platforms with ease. 1. Introduction With advancements in 3D scanning and modeling technologies [1, 2], we can obtain high-quality geometrical models much more quickly and conveniently than before. Based on current commodity graphics platforms, however, real-time visualization of large scale models is still a challenge due to the huge sizes of these models. Since interactive visualization of 3D models is important for many applications, such as architectural walkthrough, games, and so on, some effective visualization techniques have been proposed to solve this problem. Level of Detail (LOD) methods can provide a powerful way to manage scene complexity [3], which are used for graphics developers to control rendering speed. However, LOD organization on 3D models will make the storage problem much more critical for large models because of the additional storage for multiresolutional data structures. To alleviate the storage problem, out-of-core techniques [4] are proposed to extend the main memories to the sizes of the external hard drivers, which enables us to make the LOD methods work smoothly on very large data sets. For environment walkthrough applications, in addition to view-dependent LOD, special techniques like indexing, caching and prefetching are also developed [5] to avoid latencies in the transmission of high-resolution data when users move to a new site in the environment. Until now, most attention of those techniques is focused on mesh models. As compared with mesh model processing, however, point-based methods needn t care about the connective relationship among points. To make good use of these properties, we propose an easy viewer for out-of-core visualization of huge point-sampled models with the following characteristics: Huge models are partitioned into small blocks in preprocessing, and the system can set different parameters for data reorganization on each block respectively. Error-controlled LODs are generated directly on point sets for managing gaze-guided LOD distributions on the model surfaces in interactive visualization. A view-dependent paging algorithm and indexed data structures are developed to improve the efficiency of the out-of-core visualization on users demands. The remainder of the paper is organized as follows: After a brief review on related work in Section 2, we introduce the conceptual overview for our viewer in Section 3. Section 4 describes our methods in detail, including space partition on model surfaces, data reorganization on each block, view-dependent LOD selection, data structures and paging algorithms. Experimental results and analysis are shown in Section 5, and Section 6 concludes the paper. 2. Related work 2.1. View-dependent LODs In interactive visualization of large models, view-dependent LODs provide effective techniques to

2 reduce the amount of needed data by using selective LODs [3]. [6] proposed a view-dependent meshing algorithm for interactive LOD generation and rendering of large triangle meshes. Isosurfaces were used for view-dependent rendering of large volume data sets [7], and [8] guaranteed interactive frame rates on standard PC hardware by proposing a compressed hierarchical wavelet representation and using hardware texture mapping. Moreover, to accelerate the selection for appropriate LODs within very large datasets, only active nodes that do contribute to the next frame were searched in [9], and smooth view-dependent LOD control were realized in [10] by smoothly interpolating geometry to eliminate popping artifacts. In addition, gaze-driven approaches were also integrated in the view-dependent LODs to update the resolution distribution on model surfaces dynamically [11, 12]. Furthermore, [13] analyzed perceptual models to remove nonperceptible components of 3D computer graphics scenes and optimize the system performance, and some perceptually-driven techniques were employed for interactive rendering in [14, 15] Out-of-core techniques Out-of-core techniques are proposed for managing datasets larger than main memory in computer graphics [4] and have been used widely in many applications. [16] proposed a fast view-dependent meshing algorithm for very large meshes at interactive frame rates by a novel disk-based multiresolution data structure. Some other techniques were incorporated to improve the performance in applications concerned with architectural walkthrough. [17] defined a randomized sample tree for interactive walkthrough in external memory, while [18] used cached geometry to obtain fast view-dependent LOD rendering. With management of large textured landscapes, [19] can realize the visualization of very large models on commodity graphics platforms. Moreover, out-of-core algorithms were also employed in other fields, such as mesh simplification for large complex models [20] Point-based methods The concept of using points in computer graphics was first proposed in 1983 [21], and was intensively discussed in [22]. For huge point-sampled models, some techniques have been developed for efficient simplification [23], rendering [24, 25, 26, 27, 28], transmission [29, 30], and so on. For very large volumetric datasets, in particular, [31] proposed an out-of-core feature-based approach to visualization of iso-value structures at full resolution and interactive frame rates. However, the feature-based interactive rendering has limited its applicability to specific fields, such as medical visualization. For interactive visualization of large-scale models or scenes, our viewer is designed based on the combination of gaze-guided LODs and out-of-core techniques. To our knowledge, this is the first example to realize the visualization of large point-sampled models by combining those two techniques. 3. Overview of our approach Our approach is based on the assumption that input 3D points are dense and even-sampled, and the goal is to enable users to realize the interactive visualization conveniently at commodity PC systems. Para. I Viewers Para. II Block 1 3D Points Data partition Block N Hierarchical clustering & LOD organization Error-controlled LODs Main External Paging algorithm Selective LODs Error-controlled LODs Main External Figure 1. Data flow in our algorithm. Fig.1 shows the data flow in our algorithm. At first, input 3D points are partitioned into small blocks with almost the same size. Secondly, hierarchical clustering and LOD organization are performed respectively on each block to generate error-controlled LODs. After that, the system can set parameters (Para. I in Fig.1) for dividing those LODs into two parts: one part will be kept in main memory during the out-of-core visualization, and the other should be stored in external memory with file format. Parts in main memory play important roles in the visualization: (1) to convey models rough shape; (2) to be used as index data to make sure that later searching for specific data is performed only in a very small portion within external data. While in interactive visualization, users can set view parameters for current viewpoint (Para. II in Fig.1). With a paging algorithm, selective LODs taken from main and external memories will control resolution distribution of points on the whole model surfaces, and the distribution will vary dynamically while users move their gazes. Though the paging algorithm employed in our approach is very simple, experiments show it is efficient for our purpose.

3 4. Main processes in our approach 4.1. Data partition Partition techniques enable us to manage the size and accuracy problems related to large models by taking input models as some small ones in data processing. In this paper, huge or large has several meanings: (1) Though LOD data of input models can be controlled in main memory, the process is time-consuming; (2) The main memory can support input models, but it can not include its LODs completely; (3) The sizes of input models are larger than the size of main memory. The principle of data partition here is to keep almost the same number of points in each block for system load balance, and a major characteristic is that we need not perform any sort process here. The involved processes are discussed as follows: Segmentation boundary. We perform the data partition of an unorganized point set mainly according to its coordinate values in object space. At first, we define a size bound for blocks based on current system configurations, and then we split the point cloud P at its centroid along the longest axis in the 3D coordinate system. The splitting process will go on till the size of each block is smaller than the size bound. A 2D case is illustrated in Fig.2(a) to show the process, and Fig.2(b) shows eight blocks with different colors after the data partition. Y X block (a) space dichotomy (b) blocks on model surfaces Figure 2. Data partition. Size of each block. Considering that computational time and storage space for point-based processes increase nonlinearly with the sizes of models, each block should not keep too many points to obtain good performance. On the other hand, fewer points in one block will bring frequent paging between main and external memories. Therefore, special care has to be paid to the determination of the size bounds. More analysis will be shown in experimental results Data reorganization for each block We perform data reorganization on each block to generate error-control LODs respectively. Since main processes of this step are extended from our former work [30], we only give a brief introduction and point out differences. Hierarchical clustering. For later LOD organization of input blocks, we perform the clustering to obtain hierarchical data structures based on top-down data splitting. The basic operation in this step is similar to Fig.2(a) with each block representing a cluster here. The difference is that the space partition should go on till there exists only one point in each cluster. Moreover, a local fitting with error-estimation is performed on each cluster for point simplification based on geometrical properties over model surfaces. After the hierarchical clustering, a binary tree is built with each node representing a fitting primitive (Fig.3(a)). Here, we use a linear approximation scheme to fit the points with a planar square as the fitting primitive. Fig.3(b) illustrates the local fitting in a 2D case. The line L is defined by the point P (the centroid of the point set { P i }), and the normal V (the average normal of all points in { P i } ). The line with a finite length is used as the fitting primitive for the point set { } P i. The error-estimation of { P i } the local fitting is given both by the distance from to L and the difference between the normal of L and those of the points. It is defined by N N 1 1 _ 1 D1( Pi, L) + α 2 D2 Vi, V N N i= 1 i= 1 E = α, D1 P i, L is the distance between Pi and L, where ( ) and ( V V ) D2 i, the normal difference. The coefficients α are used to balance the weights of the two α 1 and 2 factors, and currently, we assigned 0.5 to both in our experiments. LOD data organization. We perform LOD data organization on each binary tree to obtain error-controlled LODs according to the error-estimation of nodes. After that, we divide these LOD data into three parts according to its error-estimation (Fig.4). For a specified error tolerance, such as (a) a binary tree E i { P i } (b) local fitting, we can find a cut through the tree, and nodes at this cut belong to Part II. These nodes will form a simplified version of this block for original points, _ P Figure 3. Hierarchical clustering. _ V L

4 Part II Part I E1 Binary Tree Ei Ej topological problems should be considered. Fig.5 shows an example for a simplified version of a scene model with four blocks, and the middle figure shows the original model without partition. In order to demonstrate the resolution distribution of points clearly, here, we substitute small points of a constant size for planar squares as the rendering primitives in all experimental figures. Part III and are remained in main memory for conveying the rough model surfaces. Nodes on the upper level of this cut (Part I in Fig.4) are omitted in our approach, and nodes on the lower level (Part III in Fig.4) with higher resolutions are stored as a segment file for this block in external memory. The cutting curve on the binary tree can be determined and adjusted by the system to balance visual effects and storage requirements in main memory. Parameters in this process can be adjusted respectively for each block according to geometrical properties over its surfaces. After the process for all blocks, a simplified version of the whole input model will be visualized by a simple combination of all Part II. Operations of partition and integration for point sets are very simple since no En Figure 4. Organization on LODs for main and external memories View-dependent LOD selection. We define parameters of fovea regions on 2D screen for current frame. It consists of three parts (Fig.6(a)): (1) a gaze point ; (2) its extension, a circle area within a G 0 certain distance from G 0 ; (3) a resolution degradation function used to control the continuous variation of the data LODs. With the highest resolution at its center, the LOD reduces in peripheral regions continuously as the human visual system shows in the visual acuity degradation. Based on these parameters for current fovea region, blank nodes are selected from Part III to add details for the visualization for current frame (Fig.6(b)). More detail about mapping fovea regions onto object surfaces are introduced in [30]. This selection operation will be difficult for performing LOD selection within several blocks simultaneously at one frame. We use a lookup table to combine different blocks together, and use another index table to accelerate Screen space Part II (a) (b) (c) (d) Fovea region G 0 Part III (a) (b) Figure 6. Gaze-controlled LOD selection. a b c d (e) Figure 5. Integration of all Part II ((a), (b), (c), (d)) for a simplified whole model (e). Figure 7. LOD selection over the blocks.

5 the selection. Fig.7 demonstrates the visual effects after a view-dependent LOD selection within four blocks Data structures In order to balance the usage of main and external memories, appropriate data structures are designed to improve the performance of the out-of-core LOD selection. Basic primitive. Nodes generated from the process of hierarchical clustering are used as the basic primitives in our algorithm. They are defined as follows: { Block_no; // index of blocks Attribute; // active or de-active Position; // position in 3D coordinate system Norm; // its normal Radius; // overlapping area of this primitive Num_nodes; // number of original points Fitting_error; // used for LOD selection Child_offset; //offset of its children in segment files } Data structures in external memory. External memory is a backup storage for LODs. In our approach, nodes within Part III in Fig.4 of each block are recorded by breadth-first search at first, and then be saved in external memory with file format. Each record in segment files consists of two items: node information and the offset of its children in this file. Fig.8 shows a segment file for block N. Node Info. Node Info. Node Info. Child_offset Child_offset Child_offset Figure 8. Records in segment file N. Data structures in main memory. We have three types of data structures in main memory: (1) data for current frame rendering; (2) current available blocks scheduled from external memory; (3) a look-up table for paging blocks from external to main memories, and an index table to accelerate the mapping process from pixels on 2D screen to 3D points in object space. Fig.9 shows these data structures and the mapping process for fovea regions. Segment Info. is a look-up table to record information of all blocks. The entry Addr. of each item is associated with the address of Current Available Blocks in main memory. Selective LODs and Part II in all blocks are used for current frame rendering. Selective LODs stores Segment Info. Status Prop. Addr. A D A Selective LODs Part II in all blocks Current View Parameters 2D Index Table Fovea region in 2D screen space MAIN MEMORY Current Avaiable Blocks NULL from block I from block J view-dependent LODs from all block determined by the current fovea region; Part II in all blocks is created by integrating all Part II from the error-controlled LODs. 2D Index Table is created for Part II in all blocks, which is used to relate the selected pixels in screen space to the 3D points. The 2D and 3D mapping process is performed based on current view parameters. We can update this index table dynamically with the user s gaze varying in the interactive visualization View-dependent paging algorithm We update Current Available Blocks according to Current View Parameters. The number of Current Available Blocks in main memory depends on the performance of current graphics platform and it is fixed during the visualization. Considering that no heuristic information can be used before the visualization, and parameters for viewers gaze may change at any time, we define a view-dependent paging algorithm based on two factors: (1) distance from current gaze to all boundary of available blocks; (2) Least Recently Used (LRU) strategy, which is usually used for page scheduling in computer operation systems. These factors are integrated for a better scheduling performance. Pi G 0 Figure 9. Data structures in main memory and the mapping process from 2D screen to 3D space.

6 In order to implement the paging algorithm, Properties of Segment Info. (Fig.9) should include three items: centroid_value computed from all points in this block, bounding_box used to define its boundary, and call_times recording times for the calling of this block while being used. 5. Results of experiments All the test cases were run on an Intel Pentium 4 processor running at 2.4 GHz, and the graphics processor in our platform is configured of NVIDIA Geforce4 MX400 with AGP8X. We apply our approach to two kinds of point-sampled models. The first is one that is impossible for users to observe directly on general platforms. The second is a model that can be visualized on general platforms but with difficulty, and our out-of-core method will improve the visualization performance. Experiment 1: Too big models. Table 1. Statistics of two models. Model Huabiao Yungang Grotto Points 714K 1303K Number of blocks Size of blocks 30K ~ 50K 70K ~ 101K Base storage 53M 111M Out-of-core visualization For huge point sets visualization, rates is mainly determined by current used point Used Point Aver. Rates < 10K < 15 ms < 20K < 31 ms < 30K < 47 ms < 50K < 100 ms Among the models in Table 1, Huabiao is a kind of symbolic sculptured columns that can be seen in many heritage sites in China. The model used in our experiment is one located in the campus of Peking University. Yungang Grotto is one of China's three largest grottos, which was built in 453 and had been listed as one of World Heritages in In our research work, it s hard to render those huge models on advanced platforms, not to mention commodity PCs. In our experiments, the number of points in each block is kept between 30K and 50K for Huabiao model, and 70K and 110K for Yungang Grotto model. The number of memory-resident blocks is set to 8. Fig.10 and Fig.11 show visualization effects for different parts of those two models according to simulated gazes. In Table 1, Base storage means the least memory requirements determined by Part II in all blocks in main memory and other parameters for the visualization. The number of used points in current frame with its corresponding rates shows that our viewer is effective in reducing on-line storage loads. Experiment 2: General large models. In Table 2, the Scene model has been used early in Fig.2, 5, and 7 in this paper, and the Wall model is a partial wall of Yungang Grotto with details everywhere. Rows with Scene and Wall show the performance for the whole models without any partition, *_4 means to partition the models into four blocks and *_8 means eight blocks. We only list running times in the process of data reorganization here since the running time recorded in interactive visualization is almost equal. Value of the last column Storage indicates the sizes of the used storage in main memory for equal visual effects in rendering. As compared with the main memory-based visualization, out-of-core techniques only keep parts of points used in current frame in main memory. Therefore, we can decrease the storage requirements greatly. Table 2. Comparisons of running times and storage requirements. Model Points Running time (secs.) Storage Reading Clustering LODs Scene 103K M Scene_ M Scene_ M Wall 327K M Wall_ M Wall_ M 6. Conclusions In this paper, we proposed an easy viewer for out-of-core visualization of huge point-sampled models. With a partition-based multiresolution data structure and a view-dependent paging algorithm, we can implement the interactive visualization for very large point sets. Experiments show that our approach can not only realize the visualization for huge models, but also improve the usage of main memory for general models. Though our approach is designed for out-of-core visualization process, it is easy to extend to streaming schemes for point-sampled models. In future work, we consider integrating some other techniques for improving the performance: 3D data compression to decrease storage space in main and external memories. More natural perceptually-driven techniques to enhance visualization effects. Acknowledgments We would like to acknowledge the helpful discussions with Dr. Hong Liu. The work was supported in part by the NSFC grant (No ).

7 References [1] Levoy, M., Pulli, K., Curless, B., etc., The Digital Michelangelo Project: 3D Scanning of Large Statues, Proc. SIGGRAPH 2000, pp [2] Hu, J., You, S. and Neumann, U., Approaches to Large-Scale Urban Modeling, IEEE Computer Graphics and Applications, Vol. 23, Issue 6, 2003, pp [3] Luebke, D., Cohen, J., Heubner, R., etc., Advanced Issues In Level Of Detail, Course Notes, SIGGRAPH [4] Chiang, Y.-J., El-Sana, J., Lindstorm, P. and Silva, C.T., Out-Of-Core Algorithms for Scientific Visualization and Computer Graphics, Course Notes, IEEE Visualization [5] Shou, L., Chionh, J., Huang, Z., etc., Walking through a very large virtual environment in real-time, Proc. the Intl. Conf. on Very Large Data Bases, 2001, pp [6] Pajarola, R. and Decoro, C., Efficient Implement of Real-Time view-dependent Multiresolution Meshing, IEEE Transaction on Visualization and Computer Graphics, Vol. 10, No. 3, 2004, pp [7] Gregorski, B., Duchaineau, M., Lindstorm, P. and Pascucci, V., Interactive View-Dependent Rendering Of Large Isosurfaces, Proc. IEEE Visualization 2002, pp [8] Guthe, S., Wand, M., Gonser, J. and Straßer, W., Interactive Rendering of Large Volume Data Sets, Proc. IEEE Visualization 2002, pp [9] El-Sana, J. and Bachmat, E., Optimized View-Dependent Rendering for Large Polygonal Datasets, Proc. IEEE Visualization 2002, pp [10] Hoppe, H., Smooth View-Dependent Level-of-Detail Control and its Application to Terrain Rendering, Proc. IEEE Visualization 1998, pp [11] Zha, H., Makimoto, Y. and Hasegawa, T., Dynamic Gaze-Controlled Levels of Detail of Polygonal Objects in 3-D Environment Modeling, Proc. Second Intl. Conf. on 3DIM 1999, pp [12] Murphy, H. and Duchowski, A.T., Gaze-Contingent Level Of Detail Rendering, Proc. EuroGraphics (Short Presentations), pp [13] Reddy, M., Perceptually Optimized 3D Graphics, IEEE Computer Graphics and Applications, Vol. 21, Issue 5, 2001, pp [14] Luebke, D. and Hallen, B., Perceptually Driven Interactive Rendering, Tech Report #CS , University of Virginia, [15] Dumont, R., Pellacini, F. and Ferwerda, J.A., Perceptually-Driven Decision Theory for Interactive Realistic Rendering, ACM Transaction on Graphics, Vol. 22, No. 2, 2003, pp [16] Decoro, C. and Pajarola, R., XFastMesh: Fast View-dependent Meshing from External Memory, Proc. IEEE Visualization 2002, pp [17] Klein, J., Krokowski, J., Fischer, M., etc., The Randomized Sampled Tree: A Data Structure for Interactive Walkthroughs in Externally Stored Virtual Environments, Proc. the ACM symposium on Virtual reality software and technology, 2002, pp [18] Levenberg, J., Fast View-Dependent Level-of-Detail Rendering Using Cached Geometry, Proc. IEEE Visualization 2002, pp [19] Cignoni, P. Ganovelli, F., Gobbetti, E., etc., Interactive Out-of-core Visualisation of Very Large Landscapes on Commodity Graphics Platform, Proc. Intl. Conf. on Virtual Storytelling 2003, pp [20] Isenburg, M., Lindstorm, P., Gumhold, S. and Snoeyink, J., Large Mesh Simplification using Processing Sequences, Proc. IEEE Visualization 2003, pp [21] Reeves, W. T., Particle System -- A Technique for Modeling a Class of Fuzzy Objects, Computer Graphics, Vol. 19, No. 3, 1983, pp [22] Gross, M., Pfister, H., Alexa, M., etc., Point-Based Computer Graphics, Eurographics 2003 Tutorial T1. [23] Pauly, M., Gross, M., and Kobbelt, L., Efficient Simplification of Point-Sampled Surfaces, Proc. IEEE Visualization 2002, pp [24] Botsch, M., Wiratanaya, A., and Kobbelt, L., Efficient High Quality Rendering of Point Sampled Geometry, Proc. 13th workshop on Rendering, 2002, pp [25] Fleishman, S. and Cohen-Or, D., Progressive Point Set Surfaces, ACM Transaction on Graphics, Vol. 22, Issue 4, 2003, pp [26] Coconu, L. and Hege, H., Hardware-Oriented Point-Based Rendering of Complex Scenes, Proc. Eurographics Workshop on Rendering, 2002, pp [27] Pajarola, R., Efficient Level-of-Detail for Point Based Rendering, Proc. IASTED Computer Graphics and Imaging, [28] Dachsbacher, C., Vogelgsang, C. and Stamminger, M., Sequential Point Trees, ACM Transaction on Graphics, Vol. 22, Issue 3, 2003, pp [29] Rusinkiewicz, S., and Levoy, M., Streaming QSplat: A Viewer for Networked Visualization of Large, Dense Models, Proc Symposium on Interactive 3D Graphics, 2001, pp [30] Meng, F. and Zha, H., Streaming Transmission of Point-Sampled Geometry Based on View-Dependent Level-of-Detail, Proc. Fourth Intl. Conf. on 3DIM 2003, pp [31] Nuber, C., Bruckschen, R.W., Hamann, B. and Joy, K.I., Interactive Visualization of Very Large Datasets Using an Out-of-Core Point-based Approach, Proc. the High Performance Computing Symposium 2003, pp

8 (a) (f) (b) (e) (c) (d) Figure 10. Different parts of the Huabiao model are visualized at different frames based on (a). Numbers of points in the frames are: (b) 25,212 points, (c) 49,746 points, (d) 22,344 points, (e) 75,021 points, (f) 17,873 points. (a) (c) (b) (d) Figure 11. Different parts of the Yungang Grotto model are visualized at different frames based on (a). Numbers of points in the frames are: (b) 54,442 points, (c) 104,441 points, (d) 62,564 points.