OpenGL Shading Language Research Articles

Understanding 3D seismic data visualization with C++, OpenGL and GLSL

Seismic data visualization in 3D space is a valuable interpretation tool. Several open-source visualization tools are available. However, little explanation is provided about the inner working of visualization process. The current work discusses a “hello world” equivalent source code for 3D seismic data visualization using Graphical Processing Units (GPUs) with OpenGL and the OpenGL Shading Language (GLSL) programming languages. Rendering is the core process generating 2D image that we see on the screen from the 3D data structures being visualized. Texture mapping-based rendering commonly applied to seismic data starts with creating an OpenGL object called texture. The texture is then mapped over a rectangular object to display a seismic line. The work presented here is performed using OpenGL, GLSL, C++ and Qt toolkit. Here Qt provides the application GUI framework, C++ is used for data I/O, filtering, and sorting, and OpenGL and GLSL are used for 3D rendering. This paper describes the data flow through the application, and two implementations of vertex and fragment GLSL shaders. Visualization is critical for seismic data processing and interpretation. The low-level details of the process presented here will hopefully help readers in obtaining better understanding of the visualization concept and inner working principle and facilitate further development.

Program Reconditioning: Avoiding Undefined Behaviour When Finding and Reducing Compiler Bugs

We introduce program reconditioning, a method for allowing program generation and differential testing to be used to find miscompilation bugs, and test-case reduction to be used to simplify bug-triggering programs, even when (a) the programming language of interest features undefined behaviour (UB) and (b) no tools exist to detect and avoid this UB. We present two program generation tools based on our reconditioning idea: GLSLsmith for the OpenGL Shading Language (GLSL), a widely-used language for graphics programming, and WGSLsmith for the WebGPU Shading Language (WGSL), a new language for web-based graphics rendering. GLSL features many UBs, but unlike for languages such as C and C++ no tools exist to detect them automatically. While the WGSL language specification features very limited UB, early WGSL implementations do exhibit UB, for reasons of initial implementation simplicity, making it challenging to test them to quickly detect and eliminate unrelated miscompilation bugs. Thanks to reconditioning, we show that GLSLsmith and WGSLsmith allow differential testing and test-case reduction to be applied to compilers for GLSL and WGSL for the first time, despite the unavailability of UB detection techniques for these languages. Through a large testing campaign, we have found 24 and 33 bugs in GLSL and WGSL compilers, respectively. We present experiments showing that when reconditioning is disabled, compiler testing leads to a high rate of test programs that appear to trigger miscompilation bugs, but actually just feature UB. We also present a novel approach to managing floating-point roundoff error using reconditioning, implemented for both GLSL and WGSL.

Parallel Cloth Simulation Using OpenGL Shading Language

The primary goal of cloth simulation is to express object behavior in a realistic manner and achieve real-time performance by following the fundamental concept of physic. In general, the mass–spring system is applied to real-time cloth simulation with three types of springs. However, hard spring cloth simulation using the mass–spring system requires a small integration time-step in order to use a large stiffness coefficient. Furthermore, to obtain stable behavior, constraint enforcement is used instead of maintenance of the force of each spring. Constraint force computation involves a large sparse linear solving operation. Due to the large computation, we implement a cloth simulation using adaptive constraint activation and deactivation techniques that involve the mass–spring system and constraint enforcement method to prevent excessive elongation of cloth. At the same time, when the length of the spring is stretched or compressed over a defined threshold, adaptive constraint activation and deactivation method deactivates the spring and generate the implicit constraint. Traditional method that uses a serial process of the Central Processing Unit (CPU) to solve the system in every frame cannot handle the complex structure of clothmodel in real-time. Our simulation utilizes the Graphic Processing Unit (GPU) parallel processing with compute shader in OpenGL Shading Language (GLSL) to solve the system effectively. In this paper, we design and implement parallel method for cloth simulation, and experiment on the performance and behavior comparison of the mass–spring system, constraint enforcement, and adaptive constraint activation and deactivation techniques the using GPU-based parallel method.

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.

Real-time Volume Preserving Constraints for Volumetric Model on GPU

This paper presents a parallel method for simulating real-time 3D deformable objects using the volume preservation mass-spring system method on tetrahedron meshes. In general, the conventional mass-spring system is manipulated as a force-driven method because it is fast, simple to implement, and the parameters can be controlled. However, the springs in traditional mass-spring system can be excessively elongated which cause severe stability and robustness issues that lead to shape restoring, simulation blow-up, and huge volume loss of the deformable object. In addition, traditional method that uses a serial process of the central processing unit (CPU) to solve the system in every frame cannot handle the complex structure of deformable object in real-time. Therefore, the first order implicit constraint enforcement for a mass-spring model is utilized to achieve accurate visual realism of deformable objects with tough constraint error. In this paper, we applied the distance constraint and volume conservation constraints for each tetrahedron element to improve the stability of deformable object simulation using the mass-spring system and behave the same as its real-world counterparts. To reduce the computational complexity while ensuring stable simulation, we applied a method that utilizes OpenGL compute shader, a part of OpenGL Shading Language (GLSL) that executes on the graphic processing unit (GPU) to solve the numerical problems effectively. We applied the proposed methods to experimental volumetric models, and volume percentages of all objects are compared. The average volume percentages of all models during the simulation using the mass-spring system, distance constraint, and the volume constraint method were 68.21%, 89.64%, and 98.70%, respectively. The proposed approaches are successfully applied to improve the stability of mass-spring system and the performance comparison from our experimental tests also shows that the GPU-based method is faster than CPU-based implementation for all cases.

Geometry types for graphics programming

In domains that deal with physical space and geometry, programmers need to track the coordinate systems that underpin a computation. We identify a class of geometry bugs that arise from confusing which coordinate system a vector belongs to. These bugs are not ruled out by current languages for vector-oriented computing, are difficult to check for at run time, and can generate subtly incorrect output that can be hard to test for. We introduce a type system and language that prevents geometry bugs by reflecting the coordinate system for each geometric object. A value's geometry type encodes its reference frame, the kind of geometric object (such as a point or a direction), and the coordinate representation (such as Cartesian or spherical coordinates). We show how these types can rule out geometrically incorrect operations, and we show how to use them to automatically generate correct-by-construction code to transform vectors between coordinate systems. We implement a language for graphics programming, Gator, that checks geometry types and compiles to OpenGL's shading language, GLSL. Using case studies, we demonstrate that Gator can raise the level of abstraction for shader programming and prevent common errors without inducing significant annotation overhead or performance cost.

Automatic sound synthesis using the fly algorithm

Our study is demonstrated a new type of evolutionary sound synthesis method. This work based on the fly algorithm, a cooperative co-evolution algorithm; it is derived from the Parisian evolution approach. The algorithm has relatively amended the position of individuals (the Flies) represented by 3-D points. The fly algorithm has successfully investigated in different applications, starting with a real-time stereo vision for robotics. Also, the algorithm shows promising results in tomography to reconstruct 3-D images. The final application of the fly algorithm was generating artistic images, such as digital mosaics. In all these applications, the flies’representation started for simple, 3-D points, to complex one, the structure of 9-elements. Our method follows evolutionary digital art with the fly algorithm in representing the pattern of the flies. They represented in a way of having their structure. This structure includes position, colour, rotation angle, and size. Our algorithm has the benefit of graphics processing units (GPUs) to generate the sound waveform using the modern OpenGL shading language.

On pixel-exact rendering for high-order mesh and solution

With the increasing use of high-order methods and high-order meshes, scientific visualization software need to adapt themselves to reliably render the associated meshes and numerical solutions. In this paper, a novel approach, based on OpenGL 4 framework, enables a GPU-based rendering of high-order meshes as well as an almost pixel-exact rendering of high-order solutions. Several aspects of the OpenGL Shading Language and in particular the use of dedicated shaders (GPU programs) allows to answer this visualization challenge. Fragment shaders are used to compute the exact solution for each pixel, made possible by the transfer of degrees of freedom and shape functions to the GPU with textures. Tessellation shaders, combined with geometric error estimates, allow us to render high-order curved meshes by providing an adaptive subdivision of elements on the GPU directly. A convenient way to compute bounds for high-order solutions is described. The interest of using Bézier basis instead of Lagrange functions lies in the existence of fast and robust evaluation of polynomial functions with de Casteljau algorithm. A technique to plot highly nonlinear isolines and wire frames with a desired thickness is derived. It is based on a finite difference scheme performed on GPU. In comparison with standard techniques, we remove the use of any linear interpolation step and the need to generate a priori a fixed subdivided mesh. This reduces the memory footprint, improves the accuracy and the speed of the rendering. Finally, the method is illustrated with various 3D examples.

Free viewpoint image generation system using fisheye cameras and a laser rangefinder for indoor robot teleoperation

In robot teleoperation, a lack of depth information often results in collisions between the robots and obstacles in its path or surroundings. To address this issue, free viewpoint images can greatly benefit the operators in terms of collision avoidance as the operators are able to view the robot’s surrounding from the images at arbitrary points, giving them a better depth information. In this paper, a novel free viewpoint image generation system is proposed. One approach to generate free viewpoint images is to use multiple cameras and Light Detection and Ranging (LiDAR). Instead of using the expensive LiDAR, this study utilizes a cost-effective laser rangefinder (LRF) and a characteristic of man-made environments. In other words, we install multiple fisheye cameras and an LRF on a robot. Free viewpoint images are generated under the assumption that walls are perpendicular to the floor. Furthermore, an easy calibration for estimating the poses of the multiple fisheye cameras, the LRF, and the robot model is proposed. Experimental results show that the proposed method can generate free viewpoint images using cameras and an LRF. Finally, the proposed method is primarily implemented using OpenGL Shading Language to utilize a graphics processing unit computation to achieve a real-time processing of the multiple high-resolution images. Supplementary videos and our source code are available at our project page (https://matsuren.github.io/fvp).

Automated testing of graphics shader compilers

We present an automated technique for finding defects in compilers for graphics shading languages. key challenge in compiler testing is the lack of an oracle that classifies an output as correct or incorrect; this is particularly pertinent in graphics shader compilers where the output is a rendered image that is typically under-specified. Our method builds on recent successful techniques for compiler validation based on metamorphic testing, and leverages existing high-value graphics shaders to create sets of transformed shaders that should be semantically equivalent. Rendering mismatches are then indicative of shader compilation bugs. Deviant shaders are automatically minimized to identify, in each case, a minimal change to an original high-value shader that induces a shader compiler bug. We have implemented the approach as a tool, GLFuzz, targeting the OpenGL shading language, GLSL. Our experiments over a set of 17 GPU and driver configurations, spanning the main 7 GPU designers, have led to us finding and reporting more than 60 distinct bugs, covering all tested configurations. As well as defective rendering, these issues identify security-critical vulnerabilities that affect WebGL, including a significant remote information leak security bug where a malicious web page can capture the contents of other browser tabs, and a bug whereby visiting a malicious web page can lead to a ``blue screen of death'' under Windows 10. Our findings show that shader compiler defects are prevalent, and that metamorphic testing provides an effective means for detecting them automatically.

Fly4Arts : Art numérique évolutionnaire avec l’Algorithme des mouches

The aim of this study is to generate artistic images, such as digital mosaics, as an optimisation problem without the introduction of any a priori knowledge or constraint other than an input image. The usual practice to produce digital mosaic images heavily relies on Centroidal Voronoi diagrams. We demonstrate here that it can be modelled as an optimisation problem solved using a cooperative co-evolution strategy based on the Parisian evolution approach, the Fly algorithm. An individual is called a fly. Its aim of the algorithm is to optimise the position of infinitely small 3-D points (the flies). The Fly algorithm has been initially used in real-time stereo vision for robotics. It has also demonstrated promising results in image reconstruction for tomography. In this new application, a much more complex representation has been study. A y is a tile. It has its own position, size, colour, and rotation angle. Our method takes advantage of graphics processing units (GPUs) to generate the images using the modern OpenGL Shading Language (GLSL) and Open Computing Language (OpenCL) to compute the difference between the input image and simulated image. Different types of tiles are implemented, some with transparency, to generate different visual effects, such as digital mosaic and spray paint. An online study with 41 participants has been conducted to compare some of our results with those generated using an open source software for image manipulation. It demonstrates that our method leads to more visually appealing images.

Prototype implementation of the OpenGL ES 2.0 shading language offline compiler

Latest 3D graphics libraries, including OpenGL and OpenGL ES, provide programmable rendering pipelines. These programmable pipelines naturally requires special-purpose programming languages. It is so called OpenGL Shading Language in the case of OpenGL. In this paper, we show a new compact design scheme for the implementation of OpenGL SL offline compilers. This scheme is used for our OpenGL SL offline compiler prototype implementation. Our implementation shows feasibility and correctness with respect to the standard specification.

A novel GPU-based sonar simulator for real-time applications

Mainly when applied in the underwater environment, sonar simulation requires great computational effort due to the complexity of acoustic physics. Simulation of sonar operation allows evaluating algorithms and control systems without going to the real underwater environment; that reduces the costs and risks of in-field experiments. This paper tackles with the problem of real-time underwater imaging sonar simulation by using the OpenGL shading language chain on GPU. Our proposed system is able to simulate two main types of acoustic devices: mechanical scanning imaging sonars and forward-looking sonars. The underwater scenario simulation is performed based on three frameworks: (i) OpenSceneGraph reproduces the ocean visual effects, (ii) Gazebo deals with physical forces, and (iii) the Robot Construction Kit controls the sonar in underwater environments. Our system exploits the rasterization pipeline in order to simulate the sonar devices, which are simulated by means of three parameters: the pulse distance, the echo intensity and the sonar field-of-view, being all calculated over observable objects shapes in the 3D rendered scene. Sonar-intrinsic operational parameters, speckle noise and object material properties are also considered as part of the acoustic image. Our evaluation demonstrated that the proposed system is able to operate close to or faster than the real-world devices. Also, our method generates visually realistic sonar images when compared with real-world sonar images of the same scenes.

A method of Earth terrain tessellation on the GPU for space simulators

This paper presents a new distributed method for virtual Earth terrain tessellation on a graphics processing unit (GPU) for space simulator complexes. The method operates in real time in multi-object virtual scenes comprising up to two million polygons. A polygonal terrain model is constructed using triangle patches of different levels of detail on graphics cards with programmable tessellation. Patches of the same level of detail are calculated entirely on the GPU, in parallel and independently, by using a developed shader program written in the OpenGL Shading Language (GLSL). This paper also describes a patch extraction algorithm for visible Earth surface rendering and an algorithm for correcting the barycentric coordinates of tessellated patch vertices that allows triangles in the terrain model to be docked without geometric discontinuities. Based on the distributed methods and algorithms developed, a program complex for virtual Earth surface visualization was created and successfully tested. The proposed solution can also be employed in virtual environment systems, virtual labs, educational geo-applications, etc.

A fluid simulation method based on two-dimensional smoothed particle hydrodynamics

Smoothed particle hydrodynamics (SPH) method is a kind of meshless method, which is used to solve the problem of fluid simulation without complex operations of the grids. To reduce the computational complexity, SPH method based on the two-dimensional shallow water equations is employed to establish a fluid model. In large scale scenes, taking into account the high computational complexity and the serious distortion problems, in this paper we introduce an improved two-dimensional SPH algorithm according to the shallow water equations. The proposed method with two-dimensional complexity is obtained by discretizing the two-dimensional shallow water equations with SPH, and the depth of water is introduced as the particle's property. The problem of increased amount of calculation cannot be well solved by using traditional neighboring particle search method based on tree structure. To improve the efficiency of search and simplify the search operation of neighborhood particles, in this paper we introduce a point-in-box search algorithm and put forward a neighboring particles searching method on the basis of dynamic grid. Besides, for large scale scenes, by considering that the virtual particle method provides slow computation speed with complex boundary condition, the type-one virtual particles are utilized to ensure that the borders can be calculated precisely by combining the punish force to prevent the phenomenon of particle boundary penetrating. Therefore, a method is further obtained to handle boundary condition efficiently by combining the virtual particles with punish force in this paper. In the process of rendering, the fluid surface is first determined by mapping and interpolating particles into regular grids without the complex reconstruction of surface in three-dimensional. Then, we utilize the bilinear interpolation method to deal with the problem of missing values, and the surface grids are further densified. With OpenSceneGraph three-dimensional render engine, OpenGL Shading Language is adopted to speed up the rendering speed, and in this way, the real-time fluid simulation of large scale scenes can be further achieved. With the basic KD tree searching method employed in the simulations, the comparative experiments are provided to verify effectiveness of the proposed searching method based on dynamic grid. Given the data set obtained from random points, experimental results demonstrate that the method in this paper can be used to solve the problem of neighboring particles searching in large scale scenes. To show the effectiveness of the proposed method on the basis of the virtual particles and the punish force, another experiment based on the collapsing of a water column is further provided. Besides, in this paper we conduct an experiment on a certain actual reservoir terrain to prove that the proposed method can be applied to fluid simulation of large scale scenes.

대규모 점군 및 폴리곤 모델의 GLSL 기반 실시간 렌더링 알고리즘

Received 2 July 2014; received in revised form 27 July 2014; accepted 29 July 2014ABSTRACTThis paper presents a real-time rendering algorithm of large-scale geometric data using GLSL(OpenGL shading language). It details the VAO (vertex array object) and VBO(vertex bufferobject) to be used for up-loading the large-scale point clouds and polygon meshes to a graphicvideo memory, and describes the shader program composed by a vertex shader and a fragmentshader, which manipulates those large-scale data to be rendered by GPU. In addition, weexplain the global rendering procedure that creates and runs the shader program with the VAOand VBO. Finally, a rendering performance will be measured with application examples, fromwhich it will be demonstrated that the proposed algorithm enables a real-time rendering of largeamount of geometric data, almost impossible to carry out by previous techniques.Key Words: Fragment shader, GLSL, Large-scale point cloud, Real-time rendering, Shaderprogram, Vertex shader, Video memory

OpenCL 및 Embedded GPU를 이용한 영상 특징 추출 및 파노라마 영상 생성의 병렬화

본 논문에서는 최신 embedded GPU를 사용하여 영상의 특징 추출 알고리즘(SIFT, SURF)을 병렬화하고, 특징 추출 및 정합 결과를 이용하여 파노라마 영상을 GPU에서 고속으로 생성하는 방법을 제안한다. 병렬화 된 알고리즘의 GPGPU(general purpose computation on GPU) 구현은 최신 스마트폰의 embedded GPU에서 지원하기 시작한 OpenCL을 이용하였다. 본 논문에서는 GPU에서 OpenGL Shading Language(GLSL)를 이용한 기존의 병렬화와 OpenCL을 이용한 새로운 병렬화 구현 결과를 효과적인 코드 구현 방법과 수행속도 관점에서 비교하였다. 실험결과, OpenCL은 GLSL과 유사한 수행 속도를 보였으며 embedded CPU와 비교하여 약 3~4배 빠른 수행속도를 보였다. 구현한 특징 추출 결과의 응용 사례로써, 특징 정합을 통한 영상 정합을 GPU상에서 병렬 수행하여 여러 장의 영상으로부터 파노라마 영상을 고속으로 생성하는 사례를 보인다. In this paper, we parallelize the popular feature detection algorithms, i.e. SIFT and SURF, and its application to fast panoramic image generation on the latest embedded GPU. Parallelized algorithms are implemented using recently developed OpenCL as the embedded GPGPU software platform. We compare the implementation efficiency and speed performance of conventional OpenGL Shading Language and OpenCL. Experimental result shows that implementation on OpenCL has comparable performance with GLSL. Compared with the performance on the embedded CPU in the same application processor, the embedded GPU runs 3~4 times faster. As an example of using feature extraction, panorama image synthesis is performed on embedded GPU by applying image matching using detected features.

Fast 3D Graphics Rendering Technique with CUDA Parallel Processing

D Graphic Rendering has been used to express realistic, 3-dimensional, and emphasized effects in the graphics. As 3D Graphic Rendering developed and became more prevalent, the need for acceleration in data processing grew as well, leading to a development of GPU (Graphic Processing Unit) and shading language used for GPU such as GLSL (OpenGL Shading Language) and HLSL (Higher Language Shading Language). 3D Graphic Rendering based on GPU, however, clearly has its limitation in processing complicated calculations such as calculating curvatures of the surface or ray tracing method, especially as the greater magnitude of the 3D polygonal model data is being used. The following paper will discuss the new method of 3D graphic rendering that is based on faster GPU parallel processing system called CUDA (Compute Unified Device Architecture) to administer 3D polygonal model data and process calculations. In the paper, we will discuss about the characteristics of CUDA and test for graphic rendering of 3D polygonal model according to those characteristics. We will also examine whether it is possible to accelerate the graphic rendering process using CUDA for 3D graphic rendering.

Photographic Volume Visualization with LH Histogram and Color Distance Gradient

Volume rendering is an important issue in the field of images visualization, which can display the details of the volume data intuitively. In this paper, we provide an new transfer function for volume visualization of photographic data set. LH histogram and color gradient are used for opacity design. And special organ can be enhanced in 3D view for special mission. We use GLSL (OpenGL Shading Language) for the GPUs accelerate. VHP data set is used for test and the result confirms that our method is effective.

Parallel tsunami simulation and visualization on tiled display wall using OpenGL Shading Language

Tsunami simulation consists of fluid dynamics, numerical computations, and visualization techniques. Nonlinear shallow water equations are often used to model the tsunami propagation. Tsunami inundation is modeled by adding the friction slope to the conservation of momentum. The two-step second-order finite difference MacCormack numerical method can solve these equations. It is well suited for nonlinear equations and simpler for related application development. In addition, the finite difference method can be computed in parallel. The programmable graphics hardware allows general-purpose computing on graphics processing units (GPUs) to solve the MacCormack method in parallel to speed up the simulation. Tsunami simulation data can be loaded as textures data in graphics memory, the computation processes can be written as shader programs using OpenGL Shading Language so that the operations can be computed by graphics processors in parallel. We developed different versions of the tsunami simulation and visualization programs: (i) CPU-based, and (ii) CPU–GPU collaboration to implement the MacCormack numerical method. The performance results showed that graphics hardware accelerated simulation had a significant improvement in the execution time of each computation step. Real-time simulation and visualization are made possible by the programmable shaders. Furthermore, we achieved high-performance parallel visualization on a tiled display wall with a cluster of computers.