Frederick M. Waltz

Efficient algorithm for Gaussian blur using finite-state machines

2D Gaussian blur operations are used in many image processing applications. The execution times of these operations can be rather long, especially where large kernels are involved. Proper use of two properties of Gaussian blurs can help to reduce these long execution times: (1) Large kernels can be decomposed into the sequential application of small kernels. (2) Gaussian blurs are separable into row and column operations. This paper makes use of both of these characteristics and adds a third one: (3) The row and column operations can be formulated as finite-state machines to produce highly efficient code and, for multi-step decompositions, eliminate writing to intermediate images. This paper shows the FSM formulation of the Gaussian blur for the general case and provides examples. Speed comparisons between various implementations are provided for some of the examples. The emphasis is on software implementations, but implementations in pipelined hardware are also discussed. Straightforward extensions of these concepts to 3- and higher-dimensional image processing are also presented. Implementation techniques for DOG (Difference-of-Gaussian filters) are also provided.

Bladder Volume Sensing by Resistance Measurement

The resistance of the urinary bladder, as measured between two electrodes attached to the external bladder wall at frequencies above 100 kHz, is proportional to the bladder volume for properly placed electrodes. The feasibility of using an oscillator, the frequency of which is controlled by the bladder interelectrode resistance, to provide an electrical signal proportional to bladder volume for use in connection with an electronic bladder stimulator is presented. The implications of this result are discussed.

Application of SKIPSM to grey-level morphology

An overview of SKIPSM (eparated-Kemel Jinage rocessing using Finite state Machines), a powerful new way to implement many standard image processing operations, is presented in a two companion ape2 This paper describes the application of SKJPSM to grey-level morphology, which involves . in some cases, the reformulation of the grey-level morphology problem as a set of binary morphology operations, . the separation of 2-D morphological operations into a row operation followed by a column operation, . the formulation of these row and column operations in a form compatible with pipelined operation, S the implementation of the resulting operations as simple finite-state machines, and S theautomated generation of the finite-state machine configuration data. Grey-level morphology presents some difficulties to the SKJPSM paradigm having to do with word length. In spite of this, some very useful results can be obtained. Some key features of SKIPSM, as applied to grey-level morphology, are S There is a tradeoffbetween structuring element (SE) size and number of grey levels. . The SEs can be arbitrary . With currently-available components, SEa up to 5x5 and larger can be obtained. S Jfl certain special cases, SEs up to 9x9 and larger can be obtained. . Multiple SEs can be applied simultaneously in a single pipeline pass. S The user specifies the SE or SEs. All other steps can be automated. This paper includes some simple examples of the results and gives implementation feasibility guidelines based on SE size and number of grey levels. The limitations of SKIPSM in this application all relate to the capabilities of the available RAM microchips. As chip capabilities expand, larger SE sizes and greater numbers of grey levels will become feasible. KEYWORDS: image processing, separability, real time, implementations, finite-state machines, grey-level morphology

SKIPSM implementations: morphology and much, much more

A new method of implementing a wide range of standard image processing operations in a real-time finite-state-machine architecture has been presented at various conferences in the past year. This architecture, under the generic name SKIPSM (separated-kernel image processing using finite state machines), has been shown to be capable of carrying out binary morphology with very large arbitrary structuring elements, simultaneous application of many binary structuring elements, gray-level morphology, binary and gray-level template matching, binary skeletonization, binary correlation, row and column summations, and many other operations. This paper describes inexpensive hardware implementations of the SKIPSM architecture, including a daughter board compatible with commercially available pipelined image processing hardware.

Bladder Motility Detection Using the Hall Effect

A displacement transducer employing the Hall effect is discussed. The leakage flux density of a permanent magnet is sensed and converted to an output voltage by a Hall crystal providing a low force, undirectional, biological displacement transducer. This device was used to monitor topographical movement of the urinary bladder in dogs and cats during isovolumetric reflex activity, and the results are reported and discussed.

Software implementation of the SKIPSM paradigm under PIP

SKIPSM (separated-kernel image processing using finite state machines) is a technique for implementing large-kernel binary- morphology operators and many other operations. While earlier papers on SKIPSM concentrated mainly on implementations using pipelined hardware, there is considerable scope for achieving major speed improvements in software systems. Using identical control software, one-pass binary erosion and dilation structuring elements (SEs) ranging from the trivial (3 by 3) to the gigantic (51 by 51, or even larger), are readily available. Processing speed is independent of the size of the SE, making the SKIPSM approach practical for work with very large SEs on ordinary desktop computers. PIP (prolog image processing) is an interactive machine vision prototyping environment developed at the University of Wales Cardiff. It consists of a large number of image processing operators embedded within the standard AI language Prolog. This paper describes the SKIPSM implementation of binary morphology operators within PIP. A large set of binary erosion and dilation operations (circles, squares, diamonds, octagons, etc.) is available to the user through a command-line driven dialogue, via pull-down menus, or incorporated into standard (Prolog) programs. Little has been done thus far to optimize speed on this first software implementation of SKIPSM. Nevertheless, the results are impressive. The paper describes sample applications and presents timing figures. Readers have the opportunity to try out these operations on demonstration software written by the University of Wales, or via their WWW home page at http://bruce.cs.cf.ac.uk/bruce/index.html .

Implementation of SKIPSM for 3D binary morphology

The SKIPSM finite-state machine image processing paradigm can be extended to 3-dimensional (and to n-dimensional) image processing in a very straightforward way. Two-dimensional SKIPSM involves an R-machine (row machine) and a C-machine (column machine) in sequence (in either order). Three- dimensional SKIPSM uses what will be called X-machines, Y- machines, and Z-machines (in any order). This means that large 3-D structuring elements can be applied to 3-D images in a single scan through the image, with three lookup-table accesses per volume element, and no other operations, regardless of the size of the structuring element. It is even possible to apply more than one 3-D structuring element simultaneously, with no increase in execution time. For binary erosion, which has interesting applications to the 3-D packing problem, many of the same lookup tables used for 2-D erosion can be used for 3-D erosion. This implies that the same software programs used to create these 2-D lookup tables can be used for 3-D tables, so that no new tools are required. For 3-D dilation, some changes are required, but all the tables needed can be created in a routine way from the corresponding 3-D erosion tables. A brief discussion of the use of SKIPSM for 3-D operations other than binary erosion and dilation is also included.

Binary openings and closings in one pass using finite-state machines

In a series of ten papers published since 1994, a radically new technique for implementing a wide range of standard image processing operations has been presented, under the acronym SKIPSM (Separated-Kernel Image Processing using finite State Machines). Key steps are: (1) the operation is separated into a row operation followed by a column operation, (2) these row and column operations are put in recursive form. That is, in a form compatible with either one-step software implementation or pipelined raster-scan hardware implementation, (3) the resulting operations are realized as FSMs (finite-state machines), and (4) these FSMs are implemented in software or in inexpensive off-the-shelf integrated circuits. Note that this technique does not require separability, in the usual sense. In this paper, the SKIPSM technique is applied to computing binary openings and closings in one pass using arbitrary binary structuring elements. Whether the resulting finite state machines are implemented in software or hardware, the result is generally much faster and/or much cheaper than conventional implementations. Furthermore, this same SKIPSM architecture is highly versatile and programmable, allowing it to be software-reconfigured to perform hundreds of other software- based or pipelined image processing operations, such a binary and grey-level morphology, the Grassfire Transform, binary and grey-level template matching, binary skeletonization, etc.

Image processing operations in color space using finite-state machines

The SKIPSM (Separated-Kernel Image Processing using finite- State Machines) has recently been extended with excellent results to various grey-scale operations (morphology, Gaussian Blur, ranked filters, etc.) as well as 3D binary operations. Another interesting direction, initiated in this paper, is the extension to color spaces. After a discussion of some possible goals of such image processing, this paper presents implementation techniques and examples. Because of the extra costs involved with the printing of colored images in journals, the example images are presented here in grey- scale only. Color images will be provided via e-mail on request.

Application of SKIPSM to various 3x3 image processing operations

Most of the published work about SKIPSM (Separated-Kernel Image Processing using finite-State Machines) has concentrated on large-neighborhood operations (e.g., binary morphology, Gaussian blur), because the speed improvements are the most dramatic in such cases. However, there are many frequently, used 3 X 3 operations that could also benefit from speed improvements that arise from separability and the use of finite-state machines. This paper shows SKIPSM implementations for an extensive list of 3 X 3 operations, including various edge detectors, connectivity detectors, direction of brightest neighbor, largest gradient, and direction of largest gradient. A generic implementation applicable to all 3 X 3 binary operations, whether separable of non-separate, is also given.