The HOOPS/OOC module is provided in this release as a technical preview. It is currently under development and for use as a technical demonstration of out of core processing and rendering of very large datasets.
The HOOPS/OOC module is an out-of-core system that processes and renders large amounts of data. This system is designed take as its input an ASCII point cloud file. In a multi-stage process, HOOPS/OOC transforms the raw point cloud data into a compressed format and renders it with high visual quality without sacrificing performance.
To begin, a prepocessor loads raw input data. It restructures and compresses the data. The preprocessor creates an OOC file, a special purpose HSF file, as well as a directory of data node files. This processed data can be as small as a third of the size of the original raw input. The resultant OOC file can be loaded and rendered in the HOOPS graphics system.
HOOPS/OOC provides a simple command line executable for processing your data. It is called ooc.exe and can be found in the bin directory of the HOOPS installation.
When the preprocessor receives a point cloud file, it performs three passes of the data. In each pass, every single data point is examined. As a result, this stage can take a significant amount of time. We suggest that you allow for sufficient preprocessing time prior to loading and rendering your model.
The following is a description of the three phases of preprocessing input data goes through:
HOOPS/OOC uses a version of the binary space partition algorithm to sort the data. For each partition, it creates a node that stores a user-specifiable number of points. This number will be the size of the shell that later is loaded into the HOOPS database. If the number of data points exceeds the limit, then HOOPS/OOC subdivides the node further until the threshold is not surpassed.
While sorting the points, HOOPS/OOC adheres to a memory limit. If the memory usage reaches the limit, HOOPS/OOC writes the least recently used nodes out to disk to free up memory so that it can continue processing the remaining data.
To preprocess a point cloud file, run the MS Windows command prompt, cmd.exe. Navigate to the HOOPS bin directory. Now you can run the ooc.exe utility. This program takes a number of options but the most important is the input file name which is passed with the -f option. The following example show how you might preprocess a the MyPointCloud.ptx ASCII point cloud file:
> ooc -f ../data/MyPointCloud.ptx -l ../data/MyPointCloudLog.txt
The above command line entry tells ooc.exe to process the ../data/MyPointCloud.ptx file. In the data directory, it creates a MyPointCloudLog_ptx.ooc file along with a MyPointCloudLog_ptx_nodes directory that contains a series of *.node data files. Additionally, it will also create a MyPointCloudLog.txt log file. The preprocessor takes a number of options that lets you control how your data is analyzed and organized. They are as follows:
Once an OOC file and its associated directory of node files have been generated, the OOC file can be passed as input file to the HIOManager in HOOPS/MVO. The HIOManager uses the HOOPS/OOC HIO plug-in to load data into the HOOPS database.
The following is the workflow describing what happens when an OOC file is loaded into HOOPS:
Because the loading and storing of data in memory can be a higly intensive process, HOOPS implements several mechanisms to balance the throughput of data with system performance. HOOPS/3dGS and HOOPS/OOC work in concert to control the amount of data loaded at any given time. Additionally, HOOPS/3dGS also carefully manages the amount of memory used. As parts of the model move out of the view frustrum or are extent culled, HOOPS/3dGS depopulates the data from the associated segments. Geometry is flushed from memory. As areas become visible again, data is reloaded. Note that HOOPS/3dGS does use caching logic such that in situations of quickly panning back and forth or zooming in and out, data is not disposed of prematurely.
The HOOPS/OOC HIO plug-in lets you import OOC files into HOOPS. It is part of the HIO Plug-in architecture. To use this integration, you must be running the HOOPS/MVO module.
To use the HOOPS/OOC HIO plug-in, please follow the steps below:
During start-up, when HOOPS/MVO finds the HOOPS/OOC HIO plug-in in your application's path, it will perform the following steps:
The input handler that is registered with the HIOManager is HIOUtilityOOC. You can load files directly with this input handler as shown in the sample code below:
HIOUtilityOOC ooc_reader; HInputHandlerOptions ooc_opt; ooc_opt.m_pHBaseView = view; HFileInputResult result = ooc_reader.FileInputByKey("c:\\temp\\mypointcloud.ooc", &ooc_opt);
In addition to the intensive memory and data management HOOPS performs to ensure visual quality and performance for point cloud rendering, there are additional options developers can set that further assist in the optimization of point cloud visualization.
Within HOOPS/MVO, you can use HBaseView::SetFramerateMode passing FrameRateMode::FramerateFixed indicating a frame rate as well as a culling threshold. Setting the framerate lets HOOPS understand how best to balance performance with visual acuity.
By default, the data points will be rendered as vertex markers but you can enable point splatting so that the points give an appearance of a smooth surface. To enable this feature, use the function HBaseView::SetSplatRendering. With HBaseView::SetSplatSize and HBaseView::SetSplatSymbol, you can determine the size and symbol of your splats respectively. If hardware acceleration is available, you can allow HOOPS to leverage it if you call HBaseView::SetFastMarkerDrawing.
Within HOOPS/3dGS, you set several options that will improve rendering performance. We recommend that for point cloud data, shadows should be disabled. In HOOPS, there are two kinds of shadows: Simple shadows and shadow maps. These are both rendering options and can be disabled by calling Set_Rendering_Options. The following code snippets shows how you can turn these options off:
HC_Set_Rendering_Options("no simple shadow, shadow map = off");
There also is another rendering option you can use to improve performance: vertex decimation. Although HOOPS does use culling logic in the fixed frame rate mode, vertex decimation is a quick and direct way to tell HOOPS to only draw a percentage of the vertices in the scene. If you are decimated vertices, the randomize vertices rendering option will cause vertices that are compiled into display lists to be inserted in random order. This option is intended for a more uniform point distribution when applying vertex decimation to non-randomized data.
HOOPS/OOC is supported on the Windows platform for Visual Studio 2005 and 2008.