2,068 research outputs found
GPU-based Image Analysis on Mobile Devices
With the rapid advances in mobile technology many mobile devices are capable
of capturing high quality images and video with their embedded camera. This
paper investigates techniques for real-time processing of the resulting images,
particularly on-device utilizing a graphical processing unit. Issues and
limitations of image processing on mobile devices are discussed, and the
performance of graphical processing units on a range of devices measured
through a programmable shader implementation of Canny edge detection.Comment: Proceedings of Image and Vision Computing New Zealand 201
High-level programming of stencil computations on multi-GPU systems using the SkelCL library
The implementation of stencil computations on modern, massively parallel systems with GPUs and other accelerators currently relies on manually-tuned coding using low-level approaches like OpenCL and CUDA. This makes development of stencil applications a complex, time-consuming, and error-prone task. We describe how stencil computations can be programmed in our SkelCL approach that combines high-level programming abstractions with competitive performance on multi-GPU systems. SkelCL extends the OpenCL standard by three high-level features: 1) pre-implemented parallel patterns (a.k.a. skeletons); 2) container data types for vectors and matrices; 3) automatic data (re)distribution mechanism. We introduce two new SkelCL skeletons which specifically target stencil computations – MapOverlap and Stencil – and we describe their use for particular application examples, discuss their efficient parallel implementation, and report experimental results on systems with multiple GPUs. Our evaluation of three real-world applications shows that stencil code written with SkelCL is considerably shorter and offers competitive performance to hand-tuned OpenCL code
Lightweight Real-time Detection of Components via a Micro Aerial Vehicle with Domain Randomization Towards Structural Health Monitoring
Civil structural component detection plays an integral role in Structural Health Monitoring (SHM) pre and post-construction. Challenges including but not limited to labor-intensiveness, cost, and time constraints associated with traditional methods make it a less opti-mal approach in SHM. Despite the success of deep convolutional neural networks in diverse detection problems, the required computational resources are a challenge. This has led to rendering a chunk of resource-constrained edge nodes less applicable with deep convolutional neural networks. In this paper, a computational-efficient deep convolutional neural network is presented based on Gabor filters and a color Canny edge detector. Generic Gabor filters are generated and used as initializers in the computational-efficient deep convolutional neural network presented, afterward trained on building components data. Next, extensive offline and online experimentation with a resource-constrained edge node is conducted and evaluated using diverse metrics. The computational-efficient detection model demonstrates to be effective in detection and via NVIDIA GPU profiler, we observe conservation of around 30% of computational resources during training. The computational-efficient detection model adduces almost a 3% mean average precision higher than two state-of-the-art detectors and records a promising frame processing rate during the online experimentation
Binary Adaptive Semi-Global Matching Based on Image Edges
Image-based modeling and rendering is currently one of the most challenging topics in Computer Vision and Photogrammetry. The key issue here is building a set of dense correspondence points between two images, namely dense matching or stereo matching. Among all dense matching algorithms, Semi-Global Matching (SGM) is arguably one of the most promising algorithms for real-time stereo vision. Compared with global matching algorithms, SGM aggregates matching cost from several (eight or sixteen) directions rather than only the epipolar line using Dynamic Programming (DP). Thus, SGM eliminates the classical “streaking problem” and greatly improves its accuracy and efficiency. In this paper, we aim at further improvement of SGM accuracy without increasing the computational cost. We propose setting the penalty parameters adaptively according to image edges extracted by edge detectors. We have carried out experiments on the standard Middlebury stereo dataset and evaluated the performance of our modified method with the ground truth. The results have shown a noticeable accuracy improvement compared with the results using fixed penalty parameters while the runtime computational cost was not increased
Generic Techniques in General Purpose GPU Programming with Applications to Ant Colony and Image Processing Algorithms
In 2006 NVIDIA introduced a new unified GPU architecture facilitating general-purpose computation on the GPU. The following year NVIDIA introduced CUDA, a parallel programming architecture for developing general purpose applications for direct execution on the new unified GPU. CUDA exposes the GPU's massively parallel architecture of the GPU so that parallel code can be written to execute much faster than its sequential counterpart. Although CUDA abstracts the underlying architecture, fully utilising and scheduling the GPU is non-trivial and has given rise to a new active area of research. Due to the inherent complexities pertaining to GPU development, in this thesis we explore and find efficient parallel mappings of existing and new parallel algorithms on the GPU using NVIDIA CUDA. We place particular emphasis on metaheuristics, image processing and designing reusable techniques and mappings that can be applied to other problems and domains.
We begin by focusing on Ant Colony Optimisation (ACO), a nature inspired heuristic approach for solving optimisation problems. We present a versatile improved data-parallel approach for solving the Travelling Salesman Problem using ACO resulting in significant speedups. By extending our initial work, we show how existing mappings of ACO on the GPU are unable to compete against their sequential counterpart when common CPU optimisation strategies are employed and detail three distinct candidate set parallelisation strategies for execution on the GPU. By further extending our data-parallel approach we present the first implementation of an ACO-based edge detection algorithm on the GPU to reduce the execution time and improve the viability of ACO-based edge detection. We finish by presenting a new color edge detection technique using the volume of a pixel in the HSI color space along with a parallel GPU implementation that is able to withstand greater levels of noise than existing algorithms
Image Processing on the GPU: Implementing the Canny Edge Detection Algorithm
Abstract: In this paper we present a detailed Graphics Processing Unit (GPU)-based implementation of the well known Canny edge detection algorithm. The aim of the paper is to provide an overview on our approach to implement the Canny edge detection algorithm, as it encompasses a set of image processing techniques. The result is an algorithm that can be applied in real-time applications..
Evaluating Rapid Application Development with Python for Heterogeneous Processor-based FPGAs
As modern FPGAs evolve to include more het- erogeneous processing elements,
such as ARM cores, it makes sense to consider these devices as processors first
and FPGA accelerators second. As such, the conventional FPGA develop- ment
environment must also adapt to support more software- like programming
functionality. While high-level synthesis tools can help reduce FPGA
development time, there still remains a large expertise gap in order to realize
highly performing implementations. At a system-level the skill set necessary to
integrate multiple custom IP hardware cores, interconnects, memory interfaces,
and now heterogeneous processing elements is complex. Rather than drive FPGA
development from the hardware up, we consider the impact of leveraging Python
to ac- celerate application development. Python offers highly optimized
libraries from an incredibly large developer community, yet is limited to the
performance of the hardware system. In this work we evaluate the impact of
using PYNQ, a Python development environment for application development on the
Xilinx Zynq devices, the performance implications, and bottlenecks associated
with it. We compare our results against existing C-based and hand-coded
implementations to better understand if Python can be the glue that binds
together software and hardware developers.Comment: To appear in 2017 IEEE 25th Annual International Symposium on
Field-Programmable Custom Computing Machines (FCCM'17
Fast Detection of Curved Edges at Low SNR
Detecting edges is a fundamental problem in computer vision with many
applications, some involving very noisy images. While most edge detection
methods are fast, they perform well only on relatively clean images. Indeed,
edges in such images can be reliably detected using only local filters.
Detecting faint edges under high levels of noise cannot be done locally at the
individual pixel level, and requires more sophisticated global processing.
Unfortunately, existing methods that achieve this goal are quite slow. In this
paper we develop a novel multiscale method to detect curved edges in noisy
images. While our algorithm searches for edges over a huge set of candidate
curves, it does so in a practical runtime, nearly linear in the total number of
image pixels. As we demonstrate experimentally, our algorithm is orders of
magnitude faster than previous methods designed to deal with high noise levels.
Nevertheless, it obtains comparable, if not better, edge detection quality on a
variety of challenging noisy images.Comment: 9 pages, 11 figure
Fast Graph-Based Object Segmentation for RGB-D Images
Object segmentation is an important capability for robotic systems, in
particular for grasping. We present a graph- based approach for the
segmentation of simple objects from RGB-D images. We are interested in
segmenting objects with large variety in appearance, from lack of texture to
strong textures, for the task of robotic grasping. The algorithm does not rely
on image features or machine learning. We propose a modified Canny edge
detector for extracting robust edges by using depth information and two simple
cost functions for combining color and depth cues. The cost functions are used
to build an undirected graph, which is partitioned using the concept of
internal and external differences between graph regions. The partitioning is
fast with O(NlogN) complexity. We also discuss ways to deal with missing depth
information. We test the approach on different publicly available RGB-D object
datasets, such as the Rutgers APC RGB-D dataset and the RGB-D Object Dataset,
and compare the results with other existing methods
- …