Hwanyong Lee

Implementing OpenGL ES on OpenGL

We present an OpenGL ES implementation which utilizes the existing OpenGL library, aiming to support various embedded systems in current consumer markets. Nowadays OpenGL ES becomes an improved version of OpenGL for embedded systems through introducing new features including the fixed-point numeric type. We optimized arithmetic operations on its specific data types such as fixed-point numbers, and achieved totally new optimized implementations of newly introduced features. Efficient ways of parameter conversions between our OpenGL ES implementation and underlying OpenGL are also accomplished even with strictly obeying the standard specifications. Our final implementation result of OpenGL ES 1.1 library completely provides more than 200 API functions in the standard specification and satisfies all the conformance tests. From the efficiency point of view, we compared execution speeds of real world applications to existing commercial implementations to finally show at most 33.147 times speed-ups, which is fastest among the same category implementations.

AlexVG: An OpenVG implementation with SVG-Tiny support

Embedded systems and web browsers have started to provide two-dimensional vector graphics features, to finally support scalability of graphics outputs, while traditional graphics systems have focused on the raster and bitmap operations. Nowadays, SVG and Flash are actively used and OpenVG from Khronos group plays the role of a de facto low-level API standard to support them. In this paper, we represent the design and implementation process and the final results of the first commercial OpenVG implementation, AlexVG. From its design stage, our implementation aims at the cooperation with SVG-Tiny, another de facto standard for embedded systems. Currently, our overall system provides not only the OpenVG core features but also a variety of OpenVG application programs and SVG-Tiny media file playing capabilities. For the conformance with the standard specifications, our system completely passed the whole OpenVG conformance test suites and the graphics output portions of the SVG-Tiny conformance test suites. From the performance point of view, we focused on the efficiency and effectiveness especially on the mobile phones and embedded devices with limited resources. As the result, it showed impressive benchmarks on the small-scale CPUs such as ARMs, even without neither any other libraries nor acceleration hardware. We had started commercial services of our AlexVG products since September 2005, and successfully entered the retail market with a good deal of mobile phones up to the present time.

OpenGL ES 1.1 implementation based on OpenGL

In this paper, we present an efficient way of implementing OpenGL ES 1.1 3D graphics API library for the environments with hardware-supported OpenGL facility, typically as desktop PCs. Although OpenGL ES was started from the existing OpenGL features, it rapidly became the standard 3D graphics library customized for embedded systems through introducing fixed-point arithmetic operations, buffer management with fixed-point data type supports, completely new texture mapping functions and others. Currently, it is the official 3D graphics API for Google Android, Apple iPhone, Sony PlayStation3, etc. In this paper, we achieved improvements on the arithmetic operations for the fixed-point number representation, which is the most characteristic data type for OpenGL ES 1.1. For the conversion of fixed-point data types to the floating-point number representations for the underlying OpenGL, we show the way of efficient conversion processes even with satisfying OpenGL ES standard requirements. We also introduced a specialized memory management scheme to manage the converted data from the buffer containing fixed-point numbers. In the case of texture processing, the requirements in both standards are quite different, and thus we used completely new software-implementations. Our final implementation of OpenGL ES library provides all of more than 200 functions in the standard specification and passed its conformance test, to show its compliance with the standard. From the efficiency point of view, we measured its execution times for several OpenGL ES-specific application programs and achieved remarkable improvements.

Implementation of OpenVG 1.0 using OpenGL ES

OpenVG 1.0 is a 2D vector graphics standard and its API (Application Programming Interface) was released by the Khronos Group. In this paper, we introduce our OpenVG 1.0 implementation, accelerated by OpenGL ES 1.x hardware. Our implementation is an efficient and cost-effective way of accelerating OpenVG, fully utilizing the existing hardware in current embedded systems. Conclusively, our OpenVG implementation shows dramatically outstanding performance with low power consumption.

A cost-effective OpenGL SC solution for the consumer electronics market: An emulation library approach

We present our design and implementation of the OpenGL SC (safety-critical) 3D graphics standard, as a software emulation library over the widely used OpenGL ES 1.1 hardware. It accomplished a remarkable cost-down of the OpenGL SC products, to finally provide highly reliable full 3D graphics features to the safety-critical consumer electronics devices.

A shader language-based design of OpenGL SC

With the shader-language programs on the programmable rendering pipeline, we can reconfigure the internal rendering process. In this paper, we describe the design philosophy of the vertex and fragment shader programs to provide the functionality of the OpenGL SC (safety-critical profile) standard.

Implementing OpenGL SC over OpenGL 1.1

The needs for safety-critical 3D graphics features are rapidly increasing. OpenGL SC is the safety critical profile of the famous OpenGL API. We present a cost-effective way of providing OpenGL SC emulation over the OpenGL 1.1 pipeline with the multi-texture extension.

Research on Implementation of Graphics Standards Using Other Graphics API’s

There are a number of formats and API (Application Program Interface)’s which are used as standard in computer graphics area. Sometimes, format or API is implemented using other format or API’s for hardware acceleration and saving time and cost to implement. In our research, we list major computer graphics API’s and discuss about current status, technical issues, advantages and disadvantages of each cases of implementation on other API’s and dependencies between graphics standards and middleware.

OpenGL ES 1.1 software implementation on mobile phones

OpenGL ES 1.1 is a de facto standard for the 3D graphics API on embedded systems and handheld devices including mobile phones. We present design process and implementation results of our software OpenGL ES 1.1 product. Since the standard document only specifies the API functions and their external actions, the implementer should design all the details of the internal 3D graphics pipeline and exhaustively optimize them. To clearly express the internal pipeline and to explicitly represent related state variables, we introduce some enhancements to UML activity diagrams. Based on these enhanced diagrams, we accomplished the initial draft design and iterative optimizations of the internal pipeline. During the implementation stage, starting from our previous wrapper implementation, we used an iterative block-by-block implementation scheme with immediate verifications. Finally, we achieved a full software implementation of OpenGL ES 1.1, which passes all the official conformance test suites and also satisfies all the requirements in the standard specification. This product is now ready for commercial services.

Implement of Stereo Image Correction for 3D Optical Microscope and Design Hardware System

Recently 3D scenes are used in various industry fields such as medical, game, surface examination, biology and etc. 3D optical microscope can show very tiny details in 3D and it is developed variously. To look 3D images of an optical microscope, two cameras are mounted on an optical microscope. Incoming images through an object lens of an optical microscope are projected on sensors of mounted cameras by using refractive mirrors. Two cameras create left and right of each image and make 3D images. At this time, it can be a problem because of the optical design errors and deformation mechanism of an optical microscope. Then we cannot look 3D images. In this paper, we corrected this error with SURF algorithm and designed the hardware system to correct wrong mirrors position using servo motors.