OpenGL Implementation Research Articles

Mathematical Model of Forest Fire and Its Relationship with Simulations and Serious Games (SSG)

Forest fires are readily available, but data is not. We present our abstract mathematical model of a forest fire in Bulgaria, without any real-world data. Our main thesis is that it looks realistic. Our calibration techniques are limited to integer values, with a hint of real numbers. Our visualization technique is fixed function pipeline OpenGL implementation, but it does the job. Our programmer staff is limited to two people, both experts in their fields, that managed to make two distinct software products, that have as a base the same solid mathematical algorithm.

OpenCL and OpenGL Implementation of Simultaneous Localization and Mapping Algorithm using High-End GPU

Simultaneous Localization And Mapping (SLAM) algorithms are being used in many robotic applications and autonomous navigation systems. The FastSLAM2.0 addresses an issue of the SLAM problem and allows a robot to navigate in an unknown environment. Several works have presented many algorithmic optimizations to reduce the computational complexity of such algorithm. In this paper, a GPGPU (general-purpose computing on graphics processing units) is exploited to achieve a parallel implementation of the FastSLAM2.0. The GPGPU acceleration is done using two different implementations for parallel programming. The first implementation used OpenGL shading language which is based on the characteristics of graphics hardwares. The second implementation used OpenCL which allows hardware acceleration across heterogeneous architectures. We also explored the impact of the two approaches on the the resulting GPGPU implementation. A comparison related to processing-time and localization accuracy is made using a real indoor dataset. Our results show a significant speedup of the GPGPU implementation over a Quad-Core CPU. We show also that, by adopting the same optimization methodology using the two approachs, the OpenCL implementation is faster and suitable for GPGPU accelerated SLAM algorithms.

Voxelization Parallelism Using CUDA Architecture

The voxelization process is an essential stage in three dimensional (3D) graphics pipeline. Its implementation should precede displaying objects in the pipeline. In this paper, different Voxelization algorithms are modified and parallelized to accelerate the operation of this stage. The 3D Digital Differential Analyzer (DDA) algorithm is used for line voxelization. This algorithm is utilized in triangle filling using the scan-line and the edge-function algorithms. The first one is designed to produce lines in parallel while the second can produce voxels. All these algorithms are parallelized using CUDA architecture and implemented on GPU processor. The actual implementation of these algorithms is examined and optimized according to the occupancy and block size metrics. The experimental results show that the acceleration amount of 3D DDA was about 4352x max compared to the OpenGL implementation, and the edge function implementation has been executed at a higher speed than the scan-line for object triangles voxelization.

On-the-fly Vertex Reuse for Massively-Parallel Software Geometry Processing

Due to its flexibility, compute mode is becoming more and more attractive as a way to implement many of the algorithms part of a state-of-the-art rendering pipeline. A key problem commonly encountered in graphics applications is streaming vertex and geometry processing. In a typical triangle mesh, the same vertex is on average referenced six times. To avoid redundant computation during rendering, a post-transform cache is traditionally employed to reuse vertex processing results. However, such a vertex cache can generally not be implemented efficiently in software and does not scale well as parallelism increases. We explore alternative strategies for reusing per-vertex results on-the-fly during massively-parallel software geometry processing. Given an input stream divided into batches, we analyze the effectiveness of sorting, hashing, and intra-thread-group communication for identifying and exploiting local reuse potential. We design and present four vertex reuse strategies tailored to modern GPU architectures. We demonstrate that, in a variety of applications, these strategies not only achieve effective reuse of vertex processing results, but can boost performance by up to 2-3x compared to a naïve approach. Curiously, our experiments also show that our batch-based approaches exhibit behavior similar to the OpenGL implementation on current graphics hardware.

Fast Generation of Virtual X-ray Images for Reconstruction of 3D Anatomy

We propose a novel GPU-based approach to render virtual X-ray projections of deformable tetrahedral meshes. These meshes represent the shape and the internal density distribution of a particular anatomical structure and are derived from statistical shape and intensity models (SSIMs). We apply our method to improve the geometric reconstruction of 3D anatomy (e.g. pelvic bone) from 2D X-ray images. For that purpose, shape and density of a tetrahedral mesh are varied and virtual X-ray projections are generated within an optimization process until the similarity between the computed virtual X-ray and the respective anatomy depicted in a given clinical X-ray is maximized. The OpenGL implementation presented in this work deforms and projects tetrahedral meshes of high resolution (200.000+ tetrahedra) at interactive rates. It generates virtual X-rays that accurately depict the density distribution of an anatomy of interest. Compared to existing methods that accumulate X-ray attenuation in deformable meshes, our novel approach significantly boosts the deformation/projection performance. The proposed projection algorithm scales better with respect to mesh resolution and complexity of the density distribution, and the combined deformation and projection on the GPU scales better with respect to the number of deformation parameters. The gain in performance allows for a larger number of cycles in the optimization process. Consequently, it reduces the risk of being stuck in a local optimum. We believe that our approach will improve treatments in orthopedics, where 3D anatomical information is essential.

Construction of Virtual CNC Machining System Based on 3DS and Open GL

Virtual CNC machining is test cutting and process optimization of virtual reality before production, which overcomes defects of interferences and collisions while the real workpiece is fabricated. The 3D scenario of Virtual CNC machining system is constructed by 3DS and Open GL on VC++6.0 platform. This system mainly encompasses modules of machine modeling, simulation of virtual cutting and its control panel. Key technologies solve 3DS file reading, simulation control by Open GL back buffer and implementation of control items on control panels respectively, so practicability of CNC system is improved greatly.

Real-time visualisation of fibre networks

Different methods of real-time fibre-network visualisation have been studied. Using an extrusion-based method yields very good results, but for large networks the frame rate becomes unacceptably low. To increase the number of fibres that can be visualised in real time, a textured billboard method has been implemented. With this method, an average performance gain of 60% has been achieved, using an OpenGL implementation.

Hardware-Accelerated Real-Time Rendering of Gaseous Phenomena

In this paper, the problem of rendering a gas in real time is approached by placing specific constraints on the distribution of densities and color inside the gas. A multi-pass algorithm for real-time rendering of a gas defined by a three-dimensional boundary is presented. The density and the color of the gas inside the boundary may be constant, or the color of a dense gas can be defined by a texture. This algorithm is combined with an existing algorithm for rendering layered fog so that the density and color inside the three-dimensional boundary can vary along a single axis. Despite the constraints, the algorithms can be used to render a variety of volumetric phenomena in real time. The OpenGL implementation of the algorithms presented in this paper is used in SGI's Performer, Version 2.4, released in November 2000.