MinGPU: a minimum GPU library for computer vision

In the field of computer vision, it is becoming increasingly popular to implement algorithms, in sections or in their entirety, on a graphics processing unit (GPU). This is due to the superior speed GPUs offer compared to CPUs. In this paper, we present a GPU library, MinGPU, which contains all of the necessary functions to convert an existing CPU code to GPU. We have created GPU implementations of several well known computer vision algorithms, including the homography transformation between two 3D views. We provide timing charts and show that our MinGPU implementation of homography transformations performs approximately 600 times faster than its C++ CPU implementation.

Stereo vision for planetary rovers: Stochastic modeling to near real-time implementation

NASA scenarios for lunar and planetary missions include robotic vehicles that function in both teleoperated and semi-autonomous modes. Under teleoperation, on-board stereo cameras may provide 3-D scene information to human operators via stereographic displays; likewise, under semi-autonomy, machine stereo vision may provide 3-D information for obstacle avoidance. In the past, the slow speed of machine stereo vision systems has posed a hurdle to the semi-autonomous scenario; however, recent work at JPL and other laboratories has produced stereo systems with high reliability and near real-time performance for low-resolution image pairs. In particular, JPL has taken a significant step by achieving the first autonomous, cross-country robotic traverses (of up to 100 meters) to use stereo vision, with all computing on-board the vehicle. Here, we describe the stereo vision system, including the underlying statistical model and the details of the implementation. The statistical and algorithmic aspects employ random field models of the disparity map, Bayesian formulations of single-scale matching, and area-based image comparisons. The implementation builds bandpass image pyramids and produces disparity maps from the 60×64 level of the pyramids at rates of up to two seconds per image pair. All vision processing is done in one 68020 augmented with Datacube image processing boards. We argue that the overall approach provides a unifying paradigm for practical, domain-independent stereo ranging. We close with a discussion of practical and theoretical issues involved in evaluating and extending the performance of the stereo system.     

A new neural real-time implementation for obstacle detection using linear stereo vision

This paper presents a neural vision system for real-time obstacle detection in front of a moving vehicle using linear stereo vision. The key problem is the correspondence task which consists of matching features in two stereo images that are projections of the same physical entity in the three-dimensional world. The linear stereo correspondence problem is formulated as an optimization task. An energy function, which represents the constraints on the solution, is mapped onto a Hopfield neural network for minimization. The system has been evaluated with experimental results on real stereo images.     

A generic and scalable pipeline for GPU tetrahedral grid rendering

Recent advances in algorithms and graphics hardware have opened the possibility to render tetrahedral grids at interactive rates on commodity PCs. This paper extends on this work in that it presents a direct volume rendering method for such grids which supports both current and upcoming graphics hardware architectures, large and deformable grids, as well as different rendering options. At the core of our method is the idea to perform the sampling of tetrahedral elements along the view rays entirely in local barycentric coordinates. Then, sampling requires minimum GPU memory and texture access operations, and it maps efficiently onto a feed-forward pipeline of multiple stages performing computation and geometry construction. We propose to spawn rendered elements from one single vertex. This makes the method amenable to upcoming Direct3D 10 graphics hardware which allows to create geometry on the GPU. By only modifying the algorithm slightly it can be used to render per-pixel iso-surfaces and to perform tetrahedral cell projection. As our method neither requires any pre-processing nor an intermediate grid representation it can efficiently deal with dynamic and large 3D meshes.     

A GPU implementation for LBG and SOM training

Vector quantization (VQ) is an effective technique applicable in a wide range of areas, such as image compression and pattern recognition. The most time-consuming procedure of VQ is codebook training, and two of the frequently used training algorithms are LBG and self-organizing map (SOM). Nowadays, desktop computers are usually equipped with programmable graphics processing units (GPUs), whose parallel data-processing ability is ideal for codebook training acceleration. Although there are some GPU algorithms for LBG training, their implementations suffer from a large amount of data transfer between CPU and GPU and a large number of rendering passes within a training iteration. This paper presents a novel GPU-based training implementation for LBG and SOM training. More specifically, we utilize the random write ability of vertex shader to reduce the overheads mentioned above. Our experimental results show that our approach can run four times faster than the previous approach.     

HRT-HOOD: A structured design method for hard real-time systems

Most structured design methods claim to address the needs of hard real-time systems. However, few contain abstractions which directly relate to common hard real-time activities, such as periodic or sporadic processes. Furthermore, the methods do not constrain the designer to produce systems which can be analyzed for their timing properties. In this article we present a structured design method called HRT-HOOD (Hard Real-Time Hierarchical Object Oriented Design). HRT-HOOD is an extension of HOOD, and includes object types which enable common hard real-time abstractions to be represented. The method is presented in the context of a hard real-time system life cycle, which enables issues of timeliness and dependability to be addressed much earlier on in the development process. We argue that this will enable dependable real-time systems to be engineered in a more cost effective manner than the current practice, which in effect treats these topics as performance issues. To illustrate our approach we present a simple case study of a Mine Drainage Control System, and show how it can be designed using the abstractions presented in the article.HOOD is a trademark of the HOOD User Group.The work has been supported, in part, by the European Space Agency (ESTEC Contract 9198/90/NL/SF) and by the UK Defence Research Agency (Contract Number 2191/023).     

gpuRIR: A python library for room impulse response simulation with GPU acceleration

Multimedia Tools and Applications - The Image Source Method (ISM) is one of the most employed techniques to calculate acoustic Room Impulse Responses (RIRs), however, its computational complexity...     

CAESAR_SOLVE: A generic library for on-the-fly resolution of alternation-free Boolean equation systems

Boolean equation systems (Bess) provide a useful framework for modeling various verification problems on finite-state concurrent systems, such as equivalence checking and model checking. These problems can be solved on the fly (i.e., without constructing explicitly the state space of the system under analysis) by using a demand-driven construction and resolution of the corresponding Bes. In this article, we present a generic software library dedicated to on-the-fly resolution of alternation-free Bess. Four resolution algorithms are currently provided by the library: algorithms A1 and A2 are general, the latter being optimized to produce small-depth diagnostics, whereas algorithms A3 and A4 are specialized for handling acyclic and disjunctive/conjunctive Bess in a memory-efficient way. The library has been developed within the Cadp verification toolbox using the generic Open/Caesar environment and is currently used for three purposes: on-the-fly equivalence checking modulo five widely used equivalence relations, on-the-fly model checking of regular alternation-free modal μ-calculus, and on-the-fly reduction of state spaces based on τ-confluence .     

A bright side of NP-hardness of interval computations: interval heuristics applied to NP-problems

It is known that interval computations are NP-hard. In other words, the solution of many important problems can be reduced to interval computations. The immediate conclusion is negative: in the general case, one cannot expect an algorithm to do all the interval computations in less than exponential running time. We show that this result also has a bright side: since there are many heuristics, for interval computations, we can solve other problems by reducing them to interval computations and applying these heuristics.     

A generic approach for the solution of nonlinear residual equations. Part III: Sensitivity computations

Sensitivity analysis provides qualitative and quantitative information on the behaviour of the model under study, and offers an access to gradients that may be used for identification purposes. Such precious information may be obtained at a low development cost applying a generic automatic differentiation (AD) tool to the computer code implementing this model. Nonlinear residual problems solved through a path following method may be addressed too. In this paper, AD techniques are adapted to the Taylor-based asymptotic numerical method. A sensitivity study of a laminated glass beam to the perturbation of some material and geometric parameters, and the perturbation of elementary stiffness matrices illustrates the method.     

A flexible real-time scheduling abstraction: design and implementation

An evolution is happening in the way that operating systems support the real-time requirements of their applications. The need to run real-time applications such as multimedia in the same environment as complex non-real-time servers and applications has motivated much interest in restructuring existing operating systems. Many issues related to thread scheduling and synchronization have been investigated. However, little consideration has been given to the flexibility and modularity required in the support of application-level scheduling needs, although it is well known that application requirements are diverse. In this paper, we describe a real-time scheduling abstraction which provides modularity and flexibility to the scheduling support of operating systems. Our design has been implemented using the Mach 3.0 kernel and a locally developed multiprocessor kernel (the r-kernel) as development platforms. © 1997 John Wiley & Sons, Ltd.     

A greedy algorithm for combined scheduling of computations and data exchanges in real-time systems

A mathematical statement of the problem of building consistent schedules for executing application programs and exchanging messages for preliminary given sets of applications and messages is described. This problem arises in the design of real-time management information systems (MISs). Various approaches to the design of algorithms for solving this problem are analyzed, a greedy algorithm is proposed and described, and experimental results concerning this algorithm is presented.     

A review on vision techniques applied to Human Behaviour Analysis for Ambient-Assisted Living

Human Behaviour Analysis (HBA) is more and more being of interest for computer vision and artificial intelligence researchers. Its main application areas, like Video Surveillance and Ambient-Assisted Living (AAL), have been in great demand in recent years. This paper provides a review on HBA for AAL and ageing in place purposes focusing specially on vision techniques. First, a clearly defined taxonomy is presented in order to classify the reviewed works, which are consequently presented following a bottom-up abstraction and complexity order. At the motion level, pose and gaze estimation as well as basic human movement recognition are covered. Next, the mainly used action and activity recognition approaches are presented with examples of recent research works. Increasing the degree of semantics and the time interval involved in the HBA, finally the behaviour level is reached. Furthermore, useful tools and datasets are analysed in order to provide help for initiating projects.     

The density matrix renormalization group for strongly correlated electron systems: A generic implementation

The purpose of this paper is (i) to present a generic and fully functional implementation of the density-matrix renormalization group (DMRG) algorithm, and (ii) to describe how to write additional strongly-correlated electron models and geometries by using templated classes. Besides considering general models and geometries, the code implements Hamiltonian symmetries in a generic way and parallelization over symmetry-related matrix blocks.

Program summary

Program title: DMRG++Catalogue identifier: AEDJ_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEDJ_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: See file LICENSENo. of lines in distributed program, including test data, etc.: 15 795No. of bytes in distributed program, including test data, etc.: 83 454Distribution format: tar.gzProgramming language: C++, MPIComputer: PC, HP clusterOperating system: Any, tested on LinuxHas the code been vectorized or parallelized?: YesRAM: 1 GB (256 MB is enough to run included test)Classification: 23External routines: BLAS and LAPACKNature of problem: Strongly correlated electrons systems, display a broad range of important phenomena, and their study is a major area of research in condensed matter physics. In this context, model Hamiltonians are used to simulate the relevant interactions of a given compound, and the relevant degrees of freedom. These studies rely on the use of tight-binding lattice models that consider electron localization, where states on one site can be labeled by spin and orbital degrees of freedom. The calculation of properties from these Hamiltonians is a computational intensive problem, since the Hilbert space over which these Hamiltonians act grows exponentially with the number of sites on the lattice.Solution method: The DMRG is a numerical variational technique to study quantum many body Hamiltonians. For one-dimensional and quasi one-dimensional systems, the DMRG is able to truncate, with bounded errors and in a general and efficient way, the underlying Hilbert space to a constant size, making the problem tractable.Running time: The test program runs in 15 seconds.     

A novel hardware plane fitting implementation and applications for bionic vision

This paper presents a high-speed real-time plane fitting implementation on a field-programmable gate array (FPGA) platform. A novel hardware-based least squares algorithm fits planes to patches of points within a depth image captured using a Microsoft Kinect v2 sensor. The validity of a plane fit and the plane parameters are reported for each patch of 11 by 11 depth pixels. The high level of parallelism of operations in the algorithm has allowed for a fast, low-latency hardware implementation on an FPGA that is capable of processing depth data at a rate of 480 frames per second. A hybrid hardware–software end-to-end system integrates the hardware solution with the Kinect v2 sensor via a computer and PCI express communication link to a Terasic TR4 FPGA development board. We have also implemented two proof-of-concept object detection applications as future candidates for bionic vision systems. We show that our complete end-to-end system is capable of running at 60 frames per second. An analysis and characterisation of the Kinect v2 sensor errors has been performed in order to specify logic precision requirements, statistical testing of the validity of a plane fit, and achievable plane fitting angle resolution.     

Modular architecture for custom-built systems oriented to real-time computer vision: Application to color recognition

This paper presents a modular architecture called DIPSA, which is intended to be used for building custom-made real-time Computer-Vision systems. It consists of four module types and each of them represents a family of circuits that perform specific visual tasks. Our architectural model proposes an algorithm-dependent methodology and makes good results possible using problem oriented solutions. The desired performance is achieved choosing the appropriate modules and connecting them by means of heterogeneous pipeline and concurrence. Additionally, two DIPSA-based hardware systems for real-time Color Recognition are described here.     

DTL: A language for the design and implementation of concurrent programs as structured networks

DTL is an experimental programming language which has developed from an investigation of data structured design methods and data driven programming techniques. A DTL program is derived from a specification of the structure of its valid input and output languages. The program function is defined as a translation between these languages. A complex translation can be hierarchically structured into a network of simpler translations by stepwise refinement.     

CL_ARRAY: A new generic library of multidimensional containers for c++ compilers with extension for OpenCL framework

This paper presents a new metaprogramming library, CL_ARRAY, that offers multiplatform and generic multidimensional data containers for C++ specifically adapted for parallel programming. The CL_ARRAY containers are built around a new formalism for representing the multidimensional nature of data as well as the semantics of multidimensional pointers and contiguous data structures. We also present OCL_ARRAY_VIEW, a concept based on metaprogrammed enveloped objects that supports multidimensional transformations and multidimensional iterators designed to simplify and formalize the interfacing process between OpenCL APIs, standard template library (STL) algorithms and CL_ARRAY containers. Our results demonstrate improved performance and energy savings over the three most popular container libraries available to the developer community for use in the context of multi-linear algebraic applications.     

A template for real-time image processing development: Windows-based PCs and webcams for computer vision research and education

A free and open-source software package called TRIPOD: Template for Real-time Image Processing Development, is described. TRIPOD was designed for classroom implementation or self-instruction. USB Logitech, Windows PC, Microsoft Visual C++ 6.0 compiler, and ANSI C/C++ are used in TRIPOD. The motivation for TRIPOD stemmed from observations that affordable, widely available, and portable components have made a strong impact on robotics. The article showcased applications like laser rangefinding and visual servoing.