The purpose of this study was to investigate the suitability of using the OpenGL and OpenCL graphics
application programming interfaces (APIs), to increase the speed at which 2D vector geographic information
could be rendered. The research focused on rendering APIs available to the Windows operating system.
In order to determine the suitability of OpenGL for efficiently rendering geographic data, this dissertation
looked at how software and hardware based rendering performed. The results were then compared to that of
the different rendering APIs. In order to collect the data necessary to achieve this; an in-depth study of
geographic information systems (GIS), geographic coordinate systems, OpenGL and OpenCL was conducted.
A simplistic 2D geographic rendering engine was then constructed using a number of graphic APIs which
included GDI, GDI+, DirectX, OpenGL and the Direct2D API. The purpose of the developed rendering engine
was to provide a tool on which to perform a number of rendering experiments. A large dataset was then
rendered via each of the implementations. The processing times as well as image quality were recorded and
analysed. This research investigated the potential issues such as acquiring data to be rendered for the API as
fast as possible. This was needed to ensure saturation at the API level. Other aspects such as difficulty of
implementation as well as implementation differences were examined.
Additionally, leveraging the OpenCL API in conjunction with the TopoJSON storage format as a means of data
compression was investigated. Compression is beneficial in that to get optimal rendering performance from
OpenGL, the graphic data to be rendered needs to reside in the graphics processing unit (GPU) memory bank.
More data in GPU memory in turn theoretically provides faster rendering times. The aim was to utilise the
extra processing power of the GPU to decode the data and then pass it to the OpenGL API for rendering and
display. This was achievable via OpenGL/OpenCL context sharing.
The results of the research showed that on average, the OpenGL API provided a significant speedup of between
nine and fifteen times that of GDI and GDI+. This means a faster and more performant rendering engine could
be built with OpenGL at its core. Additional experiments show that the OpenGL API performed faster than
GDI and GDI+ even when a dedicated graphics device is not present. A challenge early in the experiments was
related to the supply of data to the graphic API. Disk access is orders of magnitude slower than the rest of the
computer system. As such, in order to saturate the different graphics APIs, data had to be loaded into main
Using the TopoJSON storage format yielded decent data compression allowing a larger amount of data to be
stored on the GPU. However, in an initial experiment, it took longer to process the TopoJSON file into a flat
structure that could be utilised by OpenGL than to simply use the actual created objects, process them on the
central processing unit (CPU) and then upload them directly to OpenGL. It is left as future work to develop a
more efficient algorithm for converting from TopoJSON format to a format that OpenCL can utilise.