Marcus Komann

Comparison of evolving uniform, non-uniform cellular automaton, and genetic programming for centroid detection with hardware agents

Current industrial applications require fast and robust image processing in systems with low size and power dissipation. One of the main tasks in industrial vision is fast detection of centroids of objects. This paper compares three different approaches for finding geometric algorithms for centroid detection which are appropriate for a fine-grained parallel hardware architecture in an embedded vision chip. The algorithms shall comprise emergent capabilities and high problem-specific functionality without requiring large amounts of states or memory. For that problem, we consider uniform and non-uniform cellular automata (CA) as well as Genetic Programming. Due to the inherent complexity of the problem, an evolutionary approach is applied. The appropriateness of these approaches for centroid detection is discussed.

An Organic Computing architecture for visual microprocessors based on Marching Pixels

The paper presents architecture and synthesis results for an organic computing hardware for smart CMOS camera chips. The organic behavior in the chip hardware is based on distributed and emergent functionality exploited for detection of objects and their center points given in binary images. Future real-time embedded systems used in industrial image processing have to provide reply times in the range of milliseconds. It is impossible to meet such strict requirements for megapixel resolutions with serial processing schemes in particular if multiple given objects have to be detected. Even classical parallel techniques like SIMD or MIMD approaches are not sufficient due to their dependency on more or less central control structures. To achieve more flexibility, unlimited scalability and higher performance parallel emergent architectures are necessary. We present such an approach, denoted as marching pixels, for future digital visual microprocessors. Marching pixels work similar to artificial ants. They are crawling as hardware agents within a pixel field, e.g. to identify and to detect center points of an arbitrary number of objects given in an image. We present an emergent marching pixel algorithm for the processing of arbitrary concave objects and its mapping onto real hardware. Based on synthesis results for FPGAs and ASICs we discuss the possibilities of digital organic computing approaches for visual microprocessors for future smart high-speed camera systems.

Realising emergent image preprocessing tasks in cellular-automaton-alike massively parallel hardware

In this paper, we present an emergent computing architecture scheme, denoted as marching pixels (MPs), which is well-suited for massively-parallel embedded systems based realising smart optical sensors. Smart in this context refers to sensors in which signal capturing and signal processing is combined either in one chip or in a compact 3D chip stack. MPs are life-like agents, which are crawling within a pixel field in such a chip in order to find centre points and other attributes of objects in binary images. MPs fulfill these tasks only by utilising local interaction and stigmertic communication. Principal ideas, the architecture and first results are described in this paper along with a comparison to both conventional and other unconventional computing approaches.

Emergent algorithms for centroid and orientation detection in high-performance embedded cameras

Due to increasing speed and capabilities of production machines, the need for extremely fast and robust observation, classification, and error handling is vital to industrial image processing. We present an emergent algorithmic computing scheme and a corresponding embedded massively-parallel hardware architecture for these problems. They offer the potential to turn CMOS-camera-chips into intelligent vision devices which carry out tasks without help of a central processor, only based on local interaction of agents crawling on a large field of processing elements. It also constitutes a breakthrough for understanding sensor devices as a decentralized concept, resulting in much faster computation evading communication bottlenecks of classic approaches that become an ever-growing impediment to scalability. Here, in contrast, the number of agents and the field size and thus the computable image resolution is extremely scalable and therefore promises even more benefit with future hardware development. The results are based on novel algorithmic solutions allowing processor elements to compute center points, moments, and orientation of multiple image objects in parallel, which is of central importance to e.g. robotics. We finally present the algorithms capabilities if realized in state-of-the-art FPGAs and ASICs.

Marching Pixels - Using Organic Computing Principles in Embedded Parallel Hardware

We present an organic computing approach for very fast image processing, which we call marching pixels (MPs). Using an embedded massively-parallel array of processor elements (PEs) MPs exploit emergent algorithms in order to solve difficult tasks. They are data packets residing in specific PEs and can be seen as virtual organisms, which are born, move, unite, are mutated, leave signatures on the ground, and die on the processor field. MPs algorithms feature the desired self-x attributes and have the abilities to make image processing in a smart CMOS camera robust and fast enough. An example algorithm for object detection is outlined and evaluated concerning complexity and effectiveness

On the Effectiveness of Evolution Compared to Time-Consuming Full Search of Optimal 6-State Automata

The Creatures Exploration Problem is defined for an independent agent on regular grids. This agent shall visit all non-blocked cells in the grid autonomously in shortest time. Such a creature is defined by a specific finite state machine. Literature shows that the optimal 6-state automaton has already been found by simulating all possible automata. This paper tries to answer the question if it is possible to find good or optimal automata by using evolution instead of time-consuming full simulation. We show that it is possible to achieve 80% to 90% of the quality of the best automata with evolution in much shorter time.

Realizing Real-Time Centroid Detection of Multiple Objects with Marching Pixels Algorithms

In this paper we present a class of emergent algorithms called Marching Pixels which can be used for real time image processing in smart camera chips. Marching Pixels are based on hardware agents which are virtually crawling in a pixel grid image to find attributes like centroid, rotation and size of an arbitrary number of objects given in an image. Due to the distributed and local processing scheme of MPs reply times in milliseconds can be fulfilled. This means in that time is determined where pre-known objects are located and how they are oriented to the main axes of the image. We present an example Marching Pixels algorithm and corresponding application-specific and programmable architectures designedf or the use in embedded systems. The strengths and weaknesses of those architectures concerning the realization as FPGAs and ASICs are discussed by means of hardware synthesis results.

Bioinspired architecture approach for a one-billion transistor smart CMOS camera chip

In the paper we present a massively parallel VLSI architecture for future smart CMOS camera chips with up to one billion transistors. To exploit efficiently the potential offered by future micro- or nanoelectronic devices traditional on central structures oriented parallel architectures based on MIMD or SIMD approaches will fail. They require too long and too many global interconnects for the distribution of code or the access to common memory. On the other hand nature developed self-organising and emergent principles to manage successfully complex structures based on lots of interacting simple elements. Therefore we developed a new as Marching Pixels denoted emergent computing paradigm based on a mixture of bio-inspired computing models like cellular automaton and artificial ants. In the paper we present different Marching Pixels algorithms and the corresponding VLSI array architecture. A detailed synthesis result for a 0.18 &mgr;m CMOS process shows that a 256×256 pixel image is processed in less than 10 ms assuming a moderate 100 MHz clock rate for the processor array. Future higher integration densities and a 3D chip stacking technology will allow the integration and processing of Mega pixels within the same time since our architecture is fully scalable.

A Framework for Optimising Parameter Studies on a Cluster Computer by the Example of Micro-system Design

We present a framework to carry out optimising parameter studies on a cluster environment. The intention of such computation-intensive studies is to find an optimal parameter set concerning a specific objective function. We applied this framework on an example of an optimised design of a sophisticated composed optoelectronic detector. The characteristics of such a detector depend upon 25 different parameters which are input for a FEM program to simulate the detector’s behaviour. Depending on the input data the simulation time varies from 10 minutes up to two days for a single simulation. With our framework it was possible to automate the parallel execution of 9000 simulation runs in three days on a 9 node cluster. On a single 2 GHz PC computer all runs would have taken more than one month. As a result we found a structure which improved the detector’s former characteristics by a factor of 25.

Realizing real-time centroid detection of multiple objects with marching pixels algorithms on programmable customizing hardware

In this paper, we present a class of emergent algorithms called Marching Pixels and a corresponding programmable parallel chip architecture. Marching Pixels can be used for real‐time image processing in smart camera chips. They are based on hardware agents, which are virtually crawling in a pixel grid image to find attributes like centroid, rotation, and size of an arbitrary number of objects given in an image. Because of the distributed and local processing scheme of Marching Pixels, reply times in milliseconds can be fulfilled. This means that time is determined where pre‐known objects are located and how they are oriented to the main axes of the image. We present an example Marching Pixels algorithm and corresponding application‐specific and programmable parallel architectures. The latter contains a specific instruction set that allows not only the execution of Marching Pixels algorithms but also of arbitrary Cellular Automata algorithms as an embedded parallel processor. The strengths and weaknesses of this architecture concerning the realization as field‐programmable gate arrays and application‐specific integrated circuits are discussed by means of hardware synthesis results. These results are compared with the solution achievable on a real hardware like the Atom processor. Copyright