A while back I needed to implement fast minimum and maximum filters for images. I devised (what I thought was) a clever approximation scheme where the execution time is not dependent on the window size of the filter. But the method had some issues, and I looked at some other algorithms. In retrospect, the method I used seems foolish. At the time, I did not realise the obvious: a 1D filter could be applied to first the rows, and then the columns of an image, which makes the slow algorithm faster, or allows you to use one of the many published fast 1D algorithms.

I wanted to write down my gained knowledge, and started to work on a blog post. But soon it became quite long, so I decided to put it into a PDF document instead. You can download it below.

The document is somewhat weird: it is very detailed for a “simple” image algorithm (it is more than 50 pages!). It does have several tips that applies to implementation of other image processing algorithms. It also has, what I believe to be, a very clear description of the Monotonic Wedge Algorithm, with code that reflects the explanation in text closely. (I had trouble understanding the algorithm from the original journal publication. And the authors provide code that was even further optimised and thus less clear to follow).

I intended to give some performance analysis and results, but other activities has robbed me of any free time. Perhaps later.

Also, the code has been edited for readability, and hence, might contain typos that were introduced in the process. If you spot any, please let me know.

Download

minmax_filters.pdf (230 KB)

Table of Contents

1 The Problem

2 Exact Algorithms

2.1 The Naive Algorithm

2.2 The Max-Queue

2.3 Implicit Queue Algorithm

2.4 The Monotonic Wedge Algorithm

3 Approximate Algorithms

3.1 The Power Mean Approximation

3.2 The Power Mean Variant Algorithm

3.3 The Contra-Harmonic Mean Approximation

4 Other Algorithm Concepts

4.1 Separation

4.2 Implementing Minimum Filters

4.3 Windows with Even Diameters

4.4 Filtering a Region of Interest

4.5 Maximum and Minimum Filters for Binary Images

A Image Containers

A.1 Image Class Interface

A.2 Image Loops

A.3 Image Iterators

A.4 Image Access Modifiers

B Fixed-width Deques

C Max-queues

D Summed Area Tables

D.1 Calculating a SAT

D.2 Finding a Sum from a SAT

D.3 Checking for Overflow 50

D.4 Large SATs 53

Related posts:

1. Simple, Fast* Approximate Minimum / Maximum Filters
2. 5 Tips for Prototyping Slow Algorithms
3. A simple texture algorithm – faster code and more results

(Original image by GoAwayStupidAI).

Below are four C++ implementations of the region quadtree (the kind used for image compression, for example). The different implementations were made in an attempt to optimise construction of quadtrees. (For a tutorial on implementing region quadtrees, see Issue 26 [6.39 MB zip] of Dev.Mag).

• NaiveQuadtree is the straightforward implementation.
• AreaSumTableQuadtree uses a summed area table to perform fast calculations of the mean and variance of regions in the data grid.
• AugmentedAreaSumTableQuadtree is the same, except that the area sum table has an extra row and column of zeros to prevents if-then logic that slows it down and makes it tricky to understand.
• SimpleQuadtree is the same as AugmentedAreaSumTableQuadtree , except that no distinction is made (at a class level) between different node types.

The interfaces of all quadtrees are the same, but I did not want to extend from a base class. (Instead, a compile time check is performed on the classes, using boost concepts).

The results of the performance (on my machine!) of the trees are as follows:

As it turns out, the different implementations do not differ significantly. Constructing the nodes takes long, and not so much the calculations necessary to determine whether a node should split or not, and what data should be in the node. Had I profiled properly before I started I would not have gone through this exercise…

Between these four implementations, the NaiveQuadtree is the one I recommend; I left in the other implementations for anyone interested.

The one good thing that came from this experiment is that I found out that using a zero-augmented summed area table can increase performance quite a bit. This is useful for max-filters and other algorithms that use these tables.

You can download the source code:

Quadtree.zip (44 KB, Visual Studio).

(It requires the boost library for concept checking, but nothing else. Everything will still work if you remove all references to the boost library. If you already have boost, just hook up to the include path in Visual Studio).

…or read the online documentation.

Related posts:

1. Quadtrees
2. Quadtrees
3. A simple texture algorithm – faster code and more results

Faster Code

A while back I wrote about a simple texture algorithm that I have been exploring. The Python implementation was very slow – so much, that I decided to implement it in C++ to see what performance gain I would get. Surprisingly, the C++ version is about 100 faster, if not more. I expected a decent increase, but what once took several hours can now be done in a minute!

Not all of the performance gain is because of using C++ instead of Python. The Python version uses a data structure (an “enhanced” grid) that provides a lot of fancy syntax for operating on a grid. For instance:

The “enhanced” grid also provides several iterators that allow easy processing, for example:

• a cell iterator, that iterates over all values in the grid;
• an index iterator, that iterates over all possible tuples that can be used to index the grid; and
• a window iterator, that iterates over all cells in a rectangular portion of the grid.

The speed problem is caused by the implementation that supports the above features – an implementation that I thought was rather elegant. I knew there was a performance penalty, but after seeing to what extent I realise that I must have a hard look at how these features are implemented.

I am a big fan of late optimisation, especially for experimental code. But this incident has made me re-evaluate my position. After I had the fast C++ version running, I could do hordes of experiments very quickly – which meant I got a much better intuition of how parameters influence the resulting texture.

It also made me realise how important it is to check the performance of supporting data structures, even if they are merely convenience structures in non-production code (as is the “enhanced” grid).

More results

One of the things that struck me about the textures that this algorithm typically produces is the shapes of blotches of similar colour. I have been trying to enhance (and take advantage) these shapes by applying various filters on the texture; below are the results.

Original (generated from a random 5×5 matrix)	Dilation	Posterisation
Sobel edge detection	Median filter and Sobel edge detection	Median filter, differential edge detection
Emboss	Alien (Gimp filter)	Median filter.

The texture is also suitable for organic blend animations (compare with organic blending using Perlin noise).

Download

C++ Implementation

cpp_texture.zip (1.78 MB) (Visual Studio Solution)

The example uses PNG Writer , libpng and zlib (library files included with the download).

Related posts:

1. A Simple Procedural Texture Algorithm – More Results and Code
2. A Simple Procedural Texture Algorithm
3. Python Image Code