MinMaxAnalyser

/**
 * Copyright (c) 2011, The University of Southampton and the individual contributors.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 *   * 	Redistributions of source code must retain the above copyright notice,
 * 	this list of conditions and the following disclaimer.
 *
 *   *	Redistributions in binary form must reproduce the above copyright notice,
 * 	this list of conditions and the following disclaimer in the documentation
 * 	and/or other materials provided with the distribution.
 *
 *   *	Neither the name of the University of Southampton nor the names of its
 * 	contributors may be used to endorse or promote products derived from this
 * 	software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.openimaj.image.processing.algorithm;

import java.util.Set;

import org.openimaj.image.FImage;
import org.openimaj.image.analyser.ImageAnalyser;
import org.openimaj.image.pixel.Pixel;

/**
 * Analyser that computes for every pixel the minimum and maximum of its
 * neighbours. This is equivalent to greyscale morphological erosion and
 * dilation.
 *
 * @see MinFilter
 * @see MaxFilter
 *
 * @author Jonathon Hare (jsh2@ecs.soton.ac.uk)
 *
 */
public class MinMaxAnalyser implements ImageAnalyser<FImage> {
	private Set<Pixel> support;
	private int blockWidth = -1;
	private int blockHeight = -1;

	/**
	 * The min filtered image computed from the last call to
	 * {@link #analyseImage(FImage)}
	 */
	public FImage min;

	/**
	 * The max filtered image computed from the last call to
	 * {@link #analyseImage(FImage)}
	 */
	public FImage max;

	/**
	 * Construct with the given support region for selecting pixels to take the
	 * median from. The support mask is a set of <code>n</code> relative x, y
	 * offsets from the pixel currently being processed, and can be created
	 * using the methods or constants in the {@link FilterSupport} class.
	 *
	 * @param support
	 *            the support coordinates
	 */
	public MinMaxAnalyser(Set<Pixel> support) {
		this.support = support;

		if (FilterSupport.isBlockSupport(support)) {
			blockWidth = FilterSupport.getSupportWidth(support);
			blockHeight = FilterSupport.getSupportHeight(support);
		}
	}

	@Override
	public void analyseImage(FImage image) {
		min = new FImage(image.width, image.height);
		max = new FImage(image.width, image.height);

		if (blockHeight >= 1 && blockWidth >= 1) {
			processBlock(image, blockWidth, blockHeight);
		} else {
			for (int y = 0; y < image.height; y++) {
				for (int x = 0; x < image.width; x++) {
					float minv = Float.MAX_VALUE;
					float maxv = -Float.MAX_VALUE;

					for (final Pixel sp : support) {
						final int xx = x + sp.x;
						final int yy = y + sp.y;

						if (xx >= 0 && xx < image.width - 1 && yy >= 0 && yy < image.height -
								1)
						{
							minv = Math.min(minv, image.pixels[yy][xx]);
							maxv = Math.max(maxv, image.pixels[yy][xx]);
						}
					}

					min.pixels[y][x] = minv;
					max.pixels[y][x] = maxv;
				}
			}
		}
	}

	/**
	 * Efficient processing of block support regions through separable passes
	 * over the data.
	 *
	 * @param image
	 *            the image
	 * @param width
	 *            the width
	 * @param height
	 *            the height
	 */
	private void processBlock(FImage image, int width, int height) {
		final int halfWidth = width / 2;
		final float buffer[] = new float[image.width + width];

		for (int r = 0; r < image.height; r++) {
			for (int i = 0; i < halfWidth; i++)
				buffer[i] = image.pixels[r][0];
			for (int i = 0; i < image.width; i++)
				buffer[halfWidth + i] = image.pixels[r][i];
			for (int i = 0; i < halfWidth; i++)
				buffer[halfWidth + image.width + i] = image.pixels[r][image.width - 1];

			final int l = buffer.length - width;
			for (int i = 0; i < l; i++) {
				float min = Float.MAX_VALUE;
				float max = -Float.MAX_VALUE;

				for (int j = 0; j < width; j++) {
					min = Math.min(buffer[i + j], min);
					max = Math.max(buffer[i + j], max);
				}

				this.min.pixels[r][i] = min;
				this.max.pixels[r][i] = max;
			}
		}

		final int halfHeight = height / 2;

		final float minbuffer[] = new float[min.height + height];
		final float maxbuffer[] = new float[max.height + height];

		for (int c = 0; c < min.width; c++) {
			for (int i = 0; i < halfHeight; i++) {
				minbuffer[i] = min.pixels[0][c];
				maxbuffer[i] = max.pixels[0][c];
			}
			for (int i = 0; i < min.height; i++) {
				minbuffer[halfHeight + i] = min.pixels[i][c];
				maxbuffer[halfHeight + i] = max.pixels[i][c];
			}
			for (int i = 0; i < halfHeight; i++) {
				minbuffer[halfHeight + min.height + i] = min.pixels[min.height - 1][c];
				maxbuffer[halfHeight + min.height + i] = max.pixels[max.height - 1][c];
			}

			final int l = minbuffer.length - height;
			for (int i = 0; i < l; i++) {
				float minv = Float.MAX_VALUE;
				float maxv = -Float.MAX_VALUE;

				for (int j = 0; j < height; j++) {
					minv = Math.min(minbuffer[i + j], minv);
					maxv = Math.max(maxbuffer[i + j], maxv);
				}

				minbuffer[i] = minv;
				maxbuffer[i] = maxv;
			}

			for (int r = 0; r < min.height; r++) {
				min.pixels[r][c] = minbuffer[r];
				max.pixels[r][c] = maxbuffer[r];
			}
		}
	}
}