• KSII Transactions on Internet and Information Systems (TIIS)
• /
• v.11 no.8
• /
• pp.4120-4132
• /
• 2017

In this research, we implement a deformable object simulation system using OpenGL's shader language, GLSL4.3. Deformable object simulation is implemented by using volumetric mass-spring system suitable for real-time simulation among the methods of deformable object simulation. The compute shader in GLSL 4.3 which helps to access the GPU resources, is used to parallelize the operations of existing deformable object simulation systems. The proposed system is implemented using a compute shader for parallel processing and it includes a bounding box-based collision detection solution. In general, the collision detection is one of severe computing bottlenecks in simulation of multiple deformable objects. In order to validate an efficiency of the system, we performed the experiments using the 3D volumetric objects. We compared the performance of multiple deformable object simulations between CPU and GPU to analyze the effectiveness of parallel processing using GLSL. Moreover, we measured the computation time of bounding box-based collision detection to show that collision detection can be processed in real-time. The experiments using 3D volumetric models with 10K faces showed the GPU-based parallel simulation improves performance by 98% over the CPU-based simulation, and the overall steps including collision detection and rendering could be processed in real-time frame rate of 218.11 FPS.

• Korean Journal of Computational Design and Engineering
• /
• v.19 no.3
• /
• pp.294-304
• /
• 2014

This 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 buffer object) to be used for up-loading the large-scale point clouds and polygon meshes to a graphic video memory, and describes the shader program composed by a vertex shader and a fragment shader, which manipulates those large-scale data to be rendered by GPU. In addition, we explain the global rendering procedure that creates and runs the shader program with the VAO and VBO. Finally, a rendering performance will be measured with application examples, from which it will be demonstrated that the proposed algorithm enables a real-time rendering of large amount of geometric data, almost impossible to carry out by previous techniques.

• Journal of Broadcast Engineering
• /
• v.19 no.3
• /
• pp.316-328
• /
• 2014

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.

• Journal of Internet Computing and Services
• /
• v.18 no.3
• /
• pp.29-36
• /
• 2017

In these days, 3D dynamic simulation is closely related to many industries. In the past, physically-based 3D simulation was used mainly in the car crash or construction related fields, but it also plays an important role in movies or games today. Many mathematical computations are needed to represent the 3D object realistically, but it is difficult to process a large amount of calculations for simulation of application based on CPU in real-time. Recently, with the advanced graphic hardware and improved architecture, GPU can be utilized for the general purposes of computation function as well as graphic computation. Many approaches using GPU have been applied for various research fields. In this paper, we analyze the performance variation of two cloth simulation algorithms based on GPU according to the change of execution properties of GPU shaders in oder to optimize the performance of GPU-based cloth simulation. Cloth simulation is implemented by the spring centric algorithm and node centric algorithm with GPU parallel computing using compute shader of GLSL 4.3. We compare the performance of between these algorithms according to the change of the size and dimension of work group. The experiment is repeated to 10 times during 5,000 frames for each test and experimental results are provided by averaging of FPS. The experimental result shows that the node centric algorithm is executed in higher speed than the spring centric algorithm.

• Proceedings of the Korea Information Processing Society Conference
• /
• 2016.04a
• /
• pp.189-191
• /
• 2016

실시간 물리 기반 3D 시뮬레이션에서 연산속도는 매우 중요한 요소이다. 객체의 움직임이나 변형과 같은 현상들은 복잡한 연산을 통해서 계산되기 때문에 일반적으로 시뮬레이션의 정확도와 연산속도는 반비례 관계에 있다. 현재 출시되고 있는 대부분의 게임에서는 물체의 움직임을 정확하게 표현하기보다 연산량을 줄이기 위해 물체의 움직임이나 변형을 비슷하게 표현하는데 중점을 두고 있다. 본 논문에서는 이러한 문제를 해결하기 위하여 OpenGL 4.3의 Compute shader를 사용하여 다이내믹 시뮬레이션의 연산 작업을 GPU 병렬처리로 처리하였다. Compute shader에서 파티클의 움직임을 계산하고 Shader storage buffer object에 저장하고 파티클들의 작업량을 적절한 Workgroup의 크기로 나누어 할당하여 최적의 처리속도를 제공하도록 구현하였다. Compute shader에서 파티클의 움직임을 표현하기 위해서 수치해법 중의 하나인 Euler method를 사용하였으며 실험 결과 파티클의 수가 4,194,304개일 때 CPU 방법에 비해 약 182배 빠른 연산속도 결과를 보였다. 추후 Compute shader를 활용하여 연산량이 많은 분야에 적용 가능할 수 있을 것으로 기대한다.

• Journal of the Korea Computer Graphics Society
• /
• v.25 no.3
• /
• pp.55-63
• /
• 2019

Recently, the GPU computing method has been utilized to improve the performance of the physics simulation field. In particular, in the case of a deformed object simulation requiring a large amount of computation, a GPU-based parallel processing algorithm is required to guarantee real-time performance. We have studied the parallel structure design method to improve the performance of the mass spring simulation method which is one of the methods of implementing the deformation object simulation. We used OpenGL's GLSL, a graphics library that allows direct access to the GPU, and implemented the GPGPU environment using an independent pipeline, the compute shader. In order to verify the effectiveness of the parallel structure design method, the mass - spring system was implemented based on CPU and GPU. Experimental results show that the proposed method improves computation speed by about 6,000% compared to the CPU Environment. It is expected that the lightweight simulation technology can be effectively applied to the augmented reality and the virtual reality field by using the design method proposed later in this research.

• The Journal of Korea Institute of Information, Electronics, and Communication Technology
• /
• v.12 no.1
• /
• pp.29-36
• /
• 2019

Unmanned Autonomous Vehicle's driving road in the national defense includes not only paved roads, but also unpaved roads which have rough and unexpected changes. This Unmanned Autonomous Vehicles monitor and recon rugged or remote areas, and defend own position, they frequently encounter environments roads of various and unpredictable. Thus, they need additional learning to drive in this environment, we propose a Additional Learning Nearest Neighbor (ALNN) which is modified from Approximate Nearest Neighbor to allow for quick learning while avoiding the 'Forgetting' problem. In addition, since the Execution speed of the ALNN algorithm decreases as the learning data accumulates, we also propose a solution to this problem using GPU parallel processing based on OpenGL Shader Language. The ALNN based on GPU algorithm can be used in the field of national defense and other similar fields, which require frequent and quick application of additional learning in real-time without affecting the existing learning data.

• Journal of the Korea Institute of Information and Communication Engineering
• /
• v.23 no.4
• /
• pp.416-422
• /
• 2019

This paper proposes a GPU-based modeling and rendering of 3D clouds using procedural functions. The formation of clouds is based on modified noise function made with fbm(Fractional Brownian Motion). Those noise values turn into densities of droplets of liquid water, which is a critical parameter for forming the three different types of clouds. At the rendering stage, the algorithm applies the ray marching technique to decide the colors of cloud using density values obtained from the noise function. In this process, all lighting attenuation and scattering are calculated by physically based manner. Once we have the clouds, they are blended on the sky, which is also rendered physically. We also make the clouds moving in the sky by the wind force. All algorithms are implemented and tested on GPU using GLSL.

• Journal of Advanced Navigation Technology
• /
• v.15 no.6
• /
• pp.1228-1233
• /
• 2011

NPR(Non-Photorealistic rendering) technique is developing by every years. NPR is inspired on artistic styles, which is painting, drawing, technical illustration, animation and cartoon. There have many application programs for NPR, which is popular and useful of animations, even on game industrial. In traditional computer graphics focused on non-photorealism, but this method need much more memory and time. Recent years, Many NPR methods present advanced rendering technique and real time technique using graphic accelerator. This paper propose to explain NPR with GPU programming.

• Journal of KIISE:Computing Practices and Letters
• /
• v.16 no.9
• /
• pp.889-897
• /
• 2010

Recently, a cutting-edge large-scale image database system has demanded these attributes: search with alarming speed, performs with high accuracy, archives efficiently and much more. An image identifier (descriptor) is for measuring the similarity of two images which plays an important role in this system. The extraction method of an image identifier can be roughly classified into two methods: a local and global method. In this paper, the proposed image identifier, LFH(Local Feature's Histogram), is obtained by a histogram of robust and distinctive local descriptors (features) constrained by a district sub-division of a local region. Furthermore, LFH has not only the properties of a local and global descriptor, but also can perform calculations at a magnificent clip to determine distance with pinpoint accuracy. Additionally, we suggested a way to extract LFH via GPU (OpenGL and GLSL). In this experiment, we have compared the LFH with SIFT (local method) and EHD (global method) via storage capacity, extraction and retrieval time along with accuracy.