=Paper=
{{Paper
|id=Vol-1543/p8
|storemode=property
|title=Performance Analysis of Roberts Edge Detection Using CUDA and OpenGL
|pdfUrl=https://ceur-ws.org/Vol-1543/p8.pdf
|volume=Vol-1543
|authors=Marco Calì,Valeria Di Mauro
|dblpUrl=https://dblp.org/rec/conf/system/CaliM15
}}
==Performance Analysis of Roberts Edge Detection Using CUDA and OpenGL==
https://ceur-ws.org/Vol-1543/p8.pdf
Performance Analysis of Roberts Edge Detection
Using CUDA and OpenGL
Marco Calı̀ and Valeria Di Mauro
University of Catania, Catania, Italy
Abstract—The evolution of high-performance and pro- without the developer. In this paper we have also measured
grammable graphics processing units (GPUs) has generated the execution times and compared them to heterogeneous code
considerable advancements in graphics and parallel computing. execution on CPU, then we have observed the speedup advan-
In this paper we present a Roberts filter based on edge detection
algorithm using CUDA and OpenGL architectures. The basic tages. The experiments were performed taking into account
idea is to use the Pixel Buffer Object (PBO) to create images different image sizes and numbers.
with CUDA on a pixel-by-pixel basis and display them using In Section II the edge recognition operators basis will be
OpenGL. The images can then be processed applying a Roberts introduced with particular attention to the Roberts operator
filter for edge detection. Finally, it describes the results of an and the respective Kernel. In Section III an introduction to
extensive measurement campaign as well as several comparisons
among the code performance on CPUs and GPUs. The results GPU programming is presented as well as the multihreading
are very promising since the GPU parallel version offers much logic used in CUDA, moreover the use of OpenGL libraries for
higher performances than the CPU sequential version. The processing image are explained relatively to the Pixel Buffer
execution time of the GPU parallel version is much lower than Object. Portions of the developed algorithm and the related
the sequential equivalent execution time. comments are devised in Section IV. Finally, in Section V
Index Terms—CUDA, GPU, Image Processing, OpenGL, PBO,
Roberts Edge Detection. a performance analysis is presented as well as a comparison
between the sequential and the parallel algorithm.
I. I NTRODUCTION
II. I MAGE P ROCESSING
The technological development has increased computer
performances and applications can perform more complex The digital filters used in image pre-processing can be rep-
tasks [1], [2]. Recently the field of information retrieval has resented as mathematical operators. Such digital filters may be
encountered a tremendous growth due to the newly available used to reduce noise, improve contrast, separate objects from
computational power and developed architectural supports. A the background, etc. [3], [4], [5], [6]. It is possible to obtain
large variety of scientific and industrial applications requires substantial image improvement using parallel processing also
to analyze 2D images. In order to extract information from for real time solutions [7]. Among the different types of image
images it is often possible to apply specific filters to perform enhancement algorithms, spatial convolution kernel filtering
segmentation, edge identification, sharpening, etc. The most produces the worst scenario.
commonly used edge detection system is based on Roberts A convolution kernel replaces every pixel with a new one
method. so that its value is based on the relationship between the old
In this paper we present a GPU parallel algorithm elabo- pixel value and the values of pixels that surround it. In such a
rating a great number of images in a short time. The solution convolution procedure, two functions are overlaid: pixel values
can then be readily used for the realization of real-time devices of the original image are stored in memory, and it is applied
and systems for industrial applications. A real-time execution the mask of the convolution kernel. The kernels can vary in
requires to optimize the processing time for image elaboration dimension, determining a different number of neighbouring
and analysis. In this work we use the Common Unified pixels involved in the convolution. The kernel operates on the
Device Architecture (CUDA): an NVIDIA architecture which image by replacing the original pixels one by one, therefore
provides support to interact with the Graphic Processing Unit the operation must be performed by applying the convolution
(GPU) for general-purpose computing. The solution presented operator to each pixel in the image. A typical convolution
is used to work with pgm grayscale images by OpenGL kernel mask operation is represented in Fig. 1.
libraries implementing functions. An example of the features The field of image processing and computer vision often
enabled by such functions are: make use of procedures like edge detection. Such a procedure
• loading an image in RAM;
is particularly useful for features extraction. The edge detec-
• mapping an image to a Pixel Buffer Object (PBO);
tion eliminates the informations in order to focus only on a
• fast transferring the PBO data to GPU memory.
specific variations set on the image based on the geometric
and structural characteristics of the examined objects in order
OpenGL libraries provide a direct control on image as
to recognize the borders. An example of such a variation is
well as making it possible to track the changes of the image
constituted by the region of pixels where the light intensity
Copyright c 2016 held by the authors. undergoes abrupt changes. Those rapidly variating regions can
55
as the registers and shared memory usage. We will use the
adjective active for the executed blocks on one SM at a certain
moment. One block typically is executed on several warps and
the number of warps consists of the total number of GPU cores
divided by the number of cores contained in one warp. The
latter on Nvidia GPU cards has generally been 32, but could
change in the future for new card models.
CUDA architecture makes it possible to have direct access
to the GPU instruction set enabling us to use such GPU
card for general purpose parallel computing. The management
and programming is supported by the CUDA APIs [10].
Each CUDA thread is mapped to a GPU core. The GPU
card can execute one or more kernel grids, as well as the
streaming multiprocessors (SM) which execute one or more
blocks. CUDA architecture provides APIs and directives in
order to be compatible with different standard programming
languages such as C, C++, Fortran, etc. The main advantages
Fig. 1. Convolution kernel mask operation
is then the easy implementation possibilities offered to the
developers which have experience in the said standard pro-
be identified as the edges of a certain object on the image. The gramming languages, and the possibility to achieve highly
edge detection method is based on digital Roberts filter. The modular software systems [11], [12], [13]. Moreover, CUDA
Roberts filter operator approximates the intensity gradient of architecture has been proven a more efficient method to
the brightness using two different kernels: port developed software systems with respect to other GPU
oriented technologies such as Direct3D and OpenGL.
1 0 0 1 Nevertheless, the OpenGL (Open Graphics Library) [14],
Gx = Gy = (1)
0 −1 −1 0 [15], [16] offers a great number of software tools for the
Gx , also called horizontal kernel, is able to enhance the development of GPU oriented code. OpenGL offers cross-
horizontal component of the intensity gradient, the Gy , also language and multi-platform application programming inter-
called vertical kernel, at each point, enhances the vertical faces (API) generally used in rendering applications. These
component. When combined Gx and Gy give the Roberts APIs are used to interact with a GPU to achieve hardware-
kernel q accelerated rendering, therefore OpenGL allows applications
|G| = G2x + G2y (2) to use advanced graphics on relatively small systems. It is
possible to mix OpenGL and CUDA technology in order to
When G is applied to an image, a threshold is used to enhance the performances of an application. An example is
determine which values indicate a boundary and which do given by the use of PBO (Pixel Buffer Object) which makes
not. By increasing the pixels gradient value the lines tend to it possible to import multidimensional structures on a pixel-
white. by-pixel basis and display them using the related OpenGL
APIs. The advantage in such an approach is to directly obtain
III. GPU COMPUTING
an efficient mapping of pixels directly into threads [17]. In
The GPU architecture consists of a scalable number facts, PBO is a specific portion of the video memory in which
of streaming multiprocessors (SMs), each containing eight it is possible to render images that can be transformed into
streaming processor (SP) cores, two special function units textures. Another important advantage of the approach is the
(SFUs), a multithreaded instruction fetch and issue unit, a speed of pixel data transfer through DMA (Direct Memory
read-only constant cache, and a 16KB read/write shared mem- Access) channel [18]. The OpenGL PBO mechanism also
ory [8]. The SM executes a batch of 32 threads together called permits asynchronous data transfers between the host and the
a warp [9], unlike SIMD instructions the concept of warp device [19]. It is therefore important to correctly schedule
is not exposed to programmers, rather programmers write a the workload between different memory transfers in order to
program for one thread and then specify the number of parallel maximise the performance obtainable with the asynchronous
threads in a block, and the number of blocks in a kernel grid. approach.
In an SM all threads block should be executed all together. The texture data are loaded from an image source (image
On the other hand, a SM can manage multiple concurrently file or video stream) that can be directly loaded into a PBO,
running blocks. The number of blocks running on a SM is which is controlled by OpenGL. Fig. 2 gives a simplified
determined by the resource requirements of each block as well schema of the texture transfer using the Pixel Buffer Object. Of
course, while the transfer is asynchronous, it is anyway needed
SIMD and MIMD are types of parallel architectures identified in Flynn’s
taxonomy, which basically says that computers have Single or Multiple a certain amount of CPU workload in order to transfer data
streams of Instructions processing single or Multiple Data from the host memory to the PBO. Then, after such transfers,
56
Fig. 2. Texture loading with PBO.
the GPU controllers (driven by the OpenGL drivers) manage Fig. 4. Upload Application Layout.
to copy data from a PBO to a texture object. This means that
OpenGL performs a DMA transfer operation without wasting
CPU cycles, so the CPU benefits from a lower workload and 1) Creating a PBO on the GPU using glGenBuffers
can perform other operations without waiting such a transfer 2) Binding PBO to unpack the buffer target
to be completed. 3) Allocating buffer space on GPU with glBufferData
Since in this work we make use of both OpenGL and CUDA 4) Mapping PBO to CPU memory denying GPU access
directives, in order to correctly map the pixels using the PBO, for now, glMapBuffer returns a pointer to a place in
it is firstly needed to create a GL context (which is OS specific) GPU memory where the PBO resides
and a CUDA buffer registration. After that it is necessary to set 5) Copying data from CPU to GPU using pointer from
up the GL view port and coordinate system [20], generate one glMapBuffer
or more GL buffers to be shared with the CUDA application 6) Unmapping PBO (glUnmapBuffer) to allow GPU
and, subsequently, register these buffers within the application full access of the PBO again
itself (see Fig. 3). 7) Transfering data from buffer to a texture target
8) Unbinding the PBO to allow for normal operation again
Steps one to three are only necessary during initialization,
while steps four to eight have to be performed every time the
texture needs to be updated.
Fig. 4 shows a generic upload application layout.
B. Download
PBOs can also be used to download data back to the CPU.
There is one problem which must be addressed though; as
the download is an asynchronous operation (using DMA) one
must make sure that the GPU does not clear the render buffer
before the transfer is complete.
The following is a description of how to download data
using PBOs.
1) Generating a PBO on the GPU using glGenBuffers
2) Binding PBO to unpack buffer target
3) Allocating buffer space on GPU according to data size
using glBufferData
4) Deciding what framebuffer to read using glReadBuffer.
One can also read directly from a texture using glGet-
TexImage, then skipping the next step
5) Using glReadPixels to read pixel data from the targeted
framebuffer to the bound PBO. This call does not block
as it is asynchronous when reading to a PBO as opposed
Fig. 3. CUDA Buffer Registration. to CPU controlled memory. Map PBO to CPU memory
denying GPU access for now. glMapBuffer returns a
pointer to a place in GPU memory where the PBO
A. Upload resides
The algorithm used to upload data using PBOs [21] is as 6) Copying data from GPU to CPU using pointer from
follows. glMapBuffer
57
// Boundary control Median range control
if Median lower inf then
return inf
else
if Median higher sup then
return sup
end
end
return (unsigned char) Median
// because the PBO works using data char
// Definition space memory to be used in GPU
*pointer new array = pointer original array
+ blockIdx.x*Dimension z
cycle (start to threadIdx.x; stop to widht;
increase of blockDim.x)
Then, perform a texture lookup in a given 2D sampler with
Fig. 5. Roberts Edge Detection procedure. the function tex2D and associate it to pointer of new array
in the position (step cycle).
The elaboration of image is performed by means of the
7) Unmaping PBO (glUnmapBuffer) to allow GPU full following steps: initializing an array in CUDA for the elaborate
access of the PBO again image, inserting Original data.
8) Unbinding the PBO to allow for normal operation again // Definition space memory to be used in GPU
Steps one to three are only necessary during initialization,
*pointer new array = pointer original array
while steps four to nine need to be performed every time + blockIdx.x*Dimension z
new data have to be downloaded. However, downloads and cycle (start to threadIdx.x; stop to Dimension z;
uploads still involve GPU context switch and cannot be done in increase of blockDim.x)
parallel with the GPU processing or drawing. Multiple PBOs
can potentially speed up the transfers. Then, performing a texture lookup in a given 2D sampler with
the function tex2D and insert it in the matrix of Roberts.
IV. ROBERTS ALGORITHM upper_left = tex2D(lookup, coordinate_to_perform_lookup -1,
dimension_x-1)
Roberts edge detection filter can be broken down in different
upper_right = tex2D(lookup, coordinate_to_perform_lookup,
steps. First we need to set up the image data objects which dimension_x-1)
will store the intermediate and final results, obtaining the size
lower_left = tex2D(lookup, coordinate_to_perform_lookup -1,
of the input image with the OpenGL libraries. Next, we have dimension_x)
to do the computation using Roberts operators and the sum of
lower_right = tex2D(lookup, coordinate_to_perform_lookup,
the Roberts operators to create and edge image on the CUDA. dimension_x)
Roberts Edge Detection procedure is displayed in Fig. 5.
The algorithm using the features provided by OpenGL and Finally, the matrix of Roberts is associated to the pointer of a
CUDA will be described below [22]. new array.
We now describe how to create a convolution kernel of Then, it is necessary to define the setup of the texture in an
Roberts and apply it for an image processing in CUDA. The external C function, according to the following steps.
following code is for Roberts Edge Detection. • Describe the format of the value that is
returned when fetching the texture through the
// Roberts Edge Detection
Matrix2x2_original_image(upper_left, upper_right, "cudaChannelFormatDesc" function
lower_left, lower_right)
if the image is ”pgm” then
// Horizontal kernel
principal_diagonal = lower_right - upper_left;
assigned format unsigned char
else
// Vertical kernel assigned format uchar4
secondary_diagonal = lower_left - upper_right;
end
// Module of gradient
Median = square(abs(principal_diagonal)+abs(secondary_diagonal))
• Allocate a CUDA array using cudaMallocArray()
The following code is for copying the original image. The function that is included in checkCudaErrors, used
main operations are: copy of image, insert original data. to correct the string in case of errors.
58
• Copy from the memory area pointed to by src to • Specify a two-dimensional texture subimage, with target,
the CUDA array dst using cudaMemcpyToArray() texture, level, xoffset, yoffset, width, height, format, type,
function, and specifying the direction of the copy with pixels, using glTexSubImage2D() function.
cudaMemcpyHostToDevice. • Disable server-side GL_DEPTH_TEST by
For deleting the texture with an external C function, the glDisable(), or enable server-side GL_TEXTURE_2D
following steps are needed. by glEnable().
• Release the CUDA array using cudaFreeArray() • Set texture parameters by means of
function, which must have been returned by a previous glTexParameterf(), with target GL_TEXTURE_2D,
call. which specifies the target texture of the active
• Wrap for the global call that sets up the texture and texture unit, and pname GL_TEXTURE_MIN_FILTER,
threads in an external void C function. GL_TEXTURE_MAG_FILTER, GL_TEXTURE_WRAP_S,
• Bind the CUDA array to the texture reference tex through GL_TEXTURE_WRAP_T, which specifies the symbolic
cudaBindTextureToArray() function. name of a single-valued texture parameter, and finally
param GL_LINEAR, GL_REPEAT, which specifies the
switch for different cases do value of pname.
case original image • Specify the primitive or primitives that will be cre-
sets up the texture and threads break ated from vertices presented between glBegin and
case elaborate image with ROBERTS the subsequent glEnd (the primitives are specified by
sets up the texture and threads break glVertex2f and glTexCoord2f)
end • Perform a buffer swap on the layer in use for the current
endsw window through glutSwapBuffers
Function reshape() consists of the following main steps.
• Unbind the texture bound to tex.
For elaborating an image with OpenGL the code below • Specify the affine transformation of x and y from nor-
is used. Such a graphic library is designed to aid in ren- malized device coordinates to window coordinates using
dering computer graphics. This typically involves providing glViewport.
• Specify GL_PROJECTION is the target for subsequent
optimized versions of functions that handle common rendering
tasks. It can be realized purely by code running on the CPU, matrix operations by means of glMatrixMode.
• Replace the current matrix with the identity matrix
common in embedded systems, or code running on hardware
accelerated by a GPU, more common in PCs. By employing through glLoadIdentity, and describe a transforma-
these functions, a program can prepare an image to be output tion that produces a parallel projection using glOrtho.
• Specify GL_MODELVIEW is the target for subsequent ma-
to a monitor. These libraries load the image data into memory,
map between screen and world-coordinates, generate of texture trix operations by means of glMatrixMode.
• Replace the current matrix with the identity matrix using
mipmaps and also ensure interoperability with other third party
libraries and SDK. glLoadIdentity.
More specifically, for function display() the following For function cleanup() the following steps are per-
steps have to be performed. formed.
• Map the graphics resources (PBO) in resources for access • Unregister a graphics resource for access by CUDA
by CUDA using cudaGraphicsMapResources() using cudaGraphicsUnregisterResource, with
function. resource cuda pbo.
• Return a pointer through which the mapped • Bind a named buffer object using glBindBuffer tak-
graphics resource may be accessed using ing it from GL_PIXEL_UNPACK_BUFFER.
cudaGraphicsResourceGetMappedPointer() • Delete a buffer object named by the elements of
function. pbo buffer by means of glDeleteBuffers, and
• Unmap the graphics resources in PBO (and once delete a texture named by the elements of texid using
unmapped, the resources can not be accessed glDeleteTextures.
by CUDA until they are mapped again) using In addition to the above functions, a main() function has
cudaGraphicsUnmapResources(). been implemented in order to initialize data, load a default
• Use function glClear() for the bitwise of masks
image, run the processing functions, and save results.
that indicate the buffers to be cleared; using the mask
GL_COLOR_BUFFER_BIT, indicating the buffers currently
V. P ERFORMANCE A NALYSIS
are enabled for color writing.
• Bind a named texture to a texturing target using The performance analysis has been done by comparing
glBindTexture() function; then bind a named buffer execution time of parallel computing with its sequential coun-
object using glBindBuffer() function, and taking it terpart. Intel i7 processor and NVIDIA GEFORCE 845m
from PBO buffer. devices have been used. Detailed technical specifications are
59
TABLE I TABLE III
GPU TECHNICAL SPECIFICATION AVERAGE EXECUTION TIME
Memory Bandwidth 16 GB/s
Pixel Rate 13.8 GPixel/s CPU GPU
Texture Rate 27.6 GTexel/s Image Size Average Average Average
Floating Point Performance 883.7 GFLOPS (Pixel) Processing Processing Processing
Shading Units 512 Time Time Time Ratio
Texture Mapping Units 32
128 x 128 0,000488625 0,000114875 4,2535365
TABLE II
CPU TECHNICAL SPECIFICATION
256 x 256 0,001517857 0,000360125 4,2148064
Processor Number i7-4710HQ
Intel R Smart Cache 6 MB
DMI2 5 GT/s 512 x 512 0,005681625 0,001378625 4,1212259
# of Cores 4
# of Threads 8
Processor Base Frequency 2.5 GHz 1024 x 1024 0,0205595 0,00464925 4,4221111
Max Turbo Frequency 3.5 GHz
Processor Graphics Intel R HD Graphics 4600
Graphics Base Frequency 400 MHz
Graphics Max Dynamic Frequency 1.2 GHz
given in TABLE I and TABLE II. The code has been compiled
using CUDA runtime v.7 and CUDA compute capability 5.
The tests were carried out using the same grayscale image
in four different sizes, in order to evaluate temporal variations
for different sizes.
The image size has been varied from 128x128 pixels to
1024x1024 pixels. For each of them the algorithm works so
that, after loading the image, it is possible to select the original
image or the one processed (through the use of Roberts edge
detection) by using a selection menu, as shown in Fig. 6
Roberts operator provides the edge detection of the image
at small scales. If an object with a jagged boundary is present,
as it is shown in Fig. 6 (left), Roberts operator will find the
edges at each spike and twist of the perimeter as in Fig. 6 Fig. 7. Average Processing Times.
(right). The operator is sensitive to high frequency noise in
the image and will generate only local edge data instead of
recovering the global structure of a boundary.
For each image, multiple runs were carried out and the
greatest amounts of processing time were recorded, by using
CudaEventElapsedTime() function for the GPU version
and SDK Timer function for the CPU version. Then it was
calculated the average for different image sizes, as shown in
TABLE III.
The execution times for the sequential and parallel versions
on CPU and GPU are plotted in Fig. 7. Looking at the data
in Fig. 7, we can state that the average processing CPU time
is greater than the average processing GPU time, particularly
when the image size increses then the sequential version of
the program has a considerable loger execution time. For each
image size, it has been computed the average processing time
ratio between CPU and GPU, which is in the range between
4.1 and 4.4, and it is shown in Fig. 8.
Fig. 9 shows the comparison between the average processing Fig. 8. Average Processing Times Ratio.
time on the GPU and CPU for a number of images equal to
50. It illustrates that the time of the CPU is higher than the
60
Fig. 6. Original image (left) and Processed image (right).
the code the steps for loading the file, storing it in memory, the
data transport on CPU to GPU and back, and the visualization
on a window screen, without direct control of images by
OpenGL libraries.
Shah [20] has proposed the implementation of the Sobel
filter on a GeForce GT 130. Image processing is performed
in CUDA environment with the GPU computing; OpenGL
libraries provide a control of frame and the insertion into the
memory. In the end, the execution times were compared with
each other taking into account a heterogeneous code on CPU
and observing the improvements of speedup on GPU.
VII. C ONCLUSIONS
As shown by the performance between execution time of
parallel computing with its sequential counterpart, the perfor-
Fig. 9. Average Processing Times to 50 Image. mance GPU results indicate that significant speedup can be
achieved. In fact, Roberts edge detection can get a substantial
speedup, compared to the CPU based implementations, ob-
time of the GPU. Moreover, if we process a greater number taining an average processing time CPU over GPU ratio in
of images, the time difference is considerable. the range 4.1 to 4.4.
The time reduction is significant in a great number of
VI. R ELATED W ORKS processing tasks, allowing the detection of images in high
The edge detection can be carried out by different types quality and in real time. This is due to GPUs, which pro-
of operators such as Roberts, Canny, Deriche, Differential, vide a novel and efficient acceleration technique for image
Prewitt, Sobel. An example regarding how to use Sobel Edge processing, cheaper than hardware implementation.
Detection can be seen in the following articles. In the future work, we plan to implement a code which al-
In [23], authors have used the Sobel kernel for edge lows independent and parallel execution cores, so as to further
detection. The processing times were compared using code reduce the execution times. The unstructured programming
developed for CPU and GPU, in order to observe the im- logic provides freedom of architecture and an implementation
provements reported by the GPU computing. Furthermore, a of algorithms able to execute more articulated functions. The
study has been performed about the timing given by the use of capacity to achieve high speeds depends on the core number
field-programmable gate array (FPGA), noting that the running and the program architecture using the parallelism in the best
times are comparable to GPU. The authors have included in way, to reduce the execution times.
61
R EFERENCES [21] J. Sandgren, “Transfer time reduction of data transfers between cpu
and gpu,” Teknisk-naturvetenskaplig fakultet UTH-enheten, July 2013.
[1] C. Napoli, G. Pappalardo, and E. Tramontana, “An agent-driven se- [Online]. Available: http://www.teknat.uu.se/student
mantical identifier using radial basis neural networks and reinforcement [22] Nvidia cuda library documentation 4.1. NVIDIA Corporation. [Online].
learning,” in XV Workshop ”From Objects to Agents” (WOA), vol. 1260. Available: http://developer.download.nvidia.com/compute/cuda/4 1/rel/
Catania, Italy: CEUR-WS, September 2014. toolkit/docs/online/modules.html
[2] C. Napoli, G. Pappalardo, E. Tramontana, R. Nowicki, J. Starczewski, [23] M. Chouchene, F. E. Sayadi, Y. Said, M. Atri, and R. Tourki, “Efficient
and M. Woźniak, “Toward work groups classification based on prob- implementation of sobel edge detection algorithm on cpu, gpu and fpga,”
abilistic neural network approach,” in Proceedings of International International Journal of Advanced Media and Communication, vol. 5,
Conference on Artificial Intelligence and Soft Computing (ICAISC), ser. pp. 105 – 117, April 2014.
Springer LNCS, Zakopane, Poland, June 2015, vol. 9119, pp. 79–89.
[3] C. Napoli, G. Pappalardo, E. Tramontana, Z. Marszałek, D. Połap,
and M. Woźniak, “Simplified firefly algorithm for 2d image key-points
search,” in Symposium on Computational Intelligence for Human-
like Intelligence (CHILI), ser. Symposium Series on Computational
Intelligence (SSCI). IEEE, 2014, pp. 118–125. [Online]. Available:
http://dx.doi.org/10.1109/CIHLI.2014.7013395
[4] M. Woźniak, C. Napoli, E. Tramontana, G. Capizzi, G. Lo Sciuto,
R. Nowicki, and J. Starczewski, “A multiscale image compressor with
rbfnn and discrete wavelet decomposition,” in Proceedings of IEEE
International Joint Conference on Neural Networks (IJCNN), Killarney,
Ireland, July 2015, pp. 1–7, DOI: 10.1109/IJCNN.2015.7280461.
[5] M. Woźniak, D. Połap, M. Gabryel, R. Nowicki, C. Napoli, and
E. Tramontana, “Can we process 2d images using artificial bee colony?”
in Proceedings of International Conference on Artificial Intelligence and
Soft Computing (ICAISC), ser. Springer LNCS, Zakopane, Poland, June
2015, vol. 9119, pp. 660–671.
[6] G. Capizzi, G. Lo Sciuto, C. Napoli, E. Tramontana, and M. Woźniak,
“Automatic classification of fruit defects based on co-occurrence matrix
and neural networks,” in Proceedings of IEEE Federated Conference on
Computer Science and Information Systems (FedCSIS), Lodz, Poland,
September 2015, pp. 873–879.
[7] J. Wade and R. Millar, “Fpga-powered display controllers enhance isr
video in real time,” Z Microsystems, May 2012. [Online]. Available:
http://mil-embedded.com/articles/fpga-powered-isr-video-real-time/
[8] E. Lindholm, J. Nickolls, S. Oberman, and J. Montrym, “Nvidia tesla:
A unified graphics and computing architecture,” IEEE Micro, vol. 28,
no. 2, pp. 39 – 55, March 2008.
[9] (2009) Nvidias next generation cudaTM compute architecture: FermiTM .
NVIDIA Corporation. [Online]. Available: http://www.nvidia.it/page/
home.html
[10] A. Lal, Shimpi, Derek, and Wilson, “Nvidia’s geforce 8800 (g80): Gpus
re-architected for directx 10,” AnandTech, November 2006. [Online].
Available: http://www.anandtech.com/show/2116
[11] R. Giunta, G. Pappalardo, and E. Tramontana, “AODP: refactoring code
to provide advanced aspect-oriented modularization of design patterns,”
in Proceedings of ACM Symposium on Applied Computing (SAC), Riva
del Garda, Italy, March 2012, pp. 1243–1250.
[12] G. Pappalardo and E. Tramontana, “Suggesting extract class refactoring
opportunities by measuring strength of method interactions,” in Pro-
ceedings of Asia Pacific Software Engineering Conference (APSEC).
Bangkok, Thailand: IEEE, December 2013, pp. 105–110.
[13] E. Tramontana, “Automatically characterising components with concerns
and reducing tangling,” in Proceedings of IEEE Computer Software and
Applications Conference (COMPSAC) Workshop QUORS, Kyoto, Japan,
July 2013, pp. 499–504.
[14] “Opengl wiki,” OpenGL.org. [Online]. Available: https://www.opengl.
org/wiki/Main Page
[15] M. Segal and K. Akeley, The OpenGL Graphics System: A Specification
(Version 4.0). OpenGL.org, March 2010. [Online]. Available:
https://www.opengl.org/registry/doc/glspec40.core.20100311.pdf
[16] D. Shreiner, G. Sellers, J. Kessenich, and B. Licea-Kane, OpenGL
Programming Guide Eighth Edition. Addison-Wesley, March 2013.
[17] S. A. MahMoudi and P. Manneback, “Parallel image processing on gpu
with cuda and opengl.”
[18] S. H. Ahn. Opengl pixel buffer object (pbo). [Online]. Available:
http://www.songho.ca/opengl/gl pbo.html
[19] K. Group. Arb pixel buffer object, architecture review board (arb).
[Online]. Available: http://www.opengl.org/registry/specs/ARB/pixel
buffer object.txt
[20] K. Shah, “Performance analysis of sobel edge detection filter on gpu
using cuda & opengl,” International Journal for Research in Applied
Science and Engineering Technology (IJRASET), vol. 1 Issue III ISSN:
2321-9653, October 2013. [Online]. Available: http://www.ijraset.com/
62