001/** 002 * Copyright (c) 2011, The University of Southampton and the individual contributors. 003 * All rights reserved. 004 * 005 * Redistribution and use in source and binary forms, with or without modification, 006 * are permitted provided that the following conditions are met: 007 * 008 * * Redistributions of source code must retain the above copyright notice, 009 * this list of conditions and the following disclaimer. 010 * 011 * * Redistributions in binary form must reproduce the above copyright notice, 012 * this list of conditions and the following disclaimer in the documentation 013 * and/or other materials provided with the distribution. 014 * 015 * * Neither the name of the University of Southampton nor the names of its 016 * contributors may be used to endorse or promote products derived from this 017 * software without specific prior written permission. 018 * 019 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 020 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 021 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 022 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 023 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 024 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 025 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 026 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 027 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 028 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 029 */ 030package org.openimaj.image.processing.algorithm; 031 032import java.util.Set; 033 034import org.openimaj.image.FImage; 035import org.openimaj.image.pixel.Pixel; 036import org.openimaj.image.processor.SinglebandImageProcessor; 037 038/** 039 * Max filter; replaces each pixel with the maximum of its neighbours. This is 040 * equivalent to greyscale morphological dilation. 041 * 042 * @author Jonathon Hare (jsh2@ecs.soton.ac.uk) 043 * 044 */ 045public class MaxFilter implements SinglebandImageProcessor<Float, FImage> { 046 private Set<Pixel> support; 047 private int blockWidth; 048 private int blockHeight; 049 050 /** 051 * Construct with the given support region for selecting pixels to take the 052 * median from. The support mask is a set of <code>n</code> relative x, y 053 * offsets from the pixel currently being processed, and can be created 054 * using the methods or constants in the {@link FilterSupport} class. 055 * 056 * @param support 057 * the support coordinates 058 */ 059 public MaxFilter(Set<Pixel> support) { 060 this.support = support; 061 062 if (FilterSupport.isBlockSupport(support)) { 063 blockWidth = FilterSupport.getSupportWidth(support); 064 blockHeight = FilterSupport.getSupportHeight(support); 065 } 066 } 067 068 @Override 069 public void processImage(FImage image) { 070 if (blockWidth >= 1 && blockHeight >= 1) { 071 maxHorizontalSym(image, blockWidth); 072 maxVerticalSym(image, blockWidth); 073 } else { 074 final FImage tmpImage = new FImage(image.width, image.height); 075 076 for (int y = 0; y < image.height; y++) { 077 for (int x = 0; x < image.width; x++) { 078 float max = -Float.MAX_VALUE; 079 080 for (final Pixel sp : support) { 081 final int xx = x + sp.x; 082 final int yy = y + sp.y; 083 084 if (xx >= 0 && xx < image.width - 1 && yy >= 0 && yy < image.height - 1) { 085 max = Math.max(max, image.pixels[yy][xx]); 086 } 087 } 088 089 tmpImage.pixels[y][x] = max; 090 } 091 } 092 image.internalAssign(tmpImage); 093 } 094 } 095 096 private static void maxHorizontalSym(FImage image, int width) { 097 final int halfsize = width / 2; 098 final float buffer[] = new float[image.width + width]; 099 100 for (int r = 0; r < image.height; r++) { 101 for (int i = 0; i < halfsize; i++) 102 buffer[i] = image.pixels[r][0]; 103 for (int i = 0; i < image.width; i++) 104 buffer[halfsize + i] = image.pixels[r][i]; 105 for (int i = 0; i < halfsize; i++) 106 buffer[halfsize + image.width + i] = image.pixels[r][image.width - 1]; 107 108 final int l = buffer.length - width; 109 for (int i = 0; i < l; i++) { 110 float max = -Float.MAX_VALUE; 111 112 for (int j = 0; j < width; j++) 113 max = Math.max(buffer[i + j], max); 114 115 image.pixels[r][i] = max; 116 } 117 } 118 } 119 120 private static void maxVerticalSym(FImage image, int width) { 121 final int halfsize = width / 2; 122 123 final float buffer[] = new float[image.height + width]; 124 125 for (int c = 0; c < image.width; c++) { 126 for (int i = 0; i < halfsize; i++) 127 buffer[i] = image.pixels[0][c]; 128 for (int i = 0; i < image.height; i++) 129 buffer[halfsize + i] = image.pixels[i][c]; 130 for (int i = 0; i < halfsize; i++) 131 buffer[halfsize + image.height + i] = image.pixels[image.height - 1][c]; 132 133 final int l = buffer.length - width; 134 for (int i = 0; i < l; i++) { 135 float max = -Float.MAX_VALUE; 136 137 for (int j = 0; j < width; j++) 138 max = Math.max(buffer[i + j], max); 139 140 buffer[i] = max; 141 } 142 143 for (int r = 0; r < image.height; r++) 144 image.pixels[r][c] = buffer[r]; 145 } 146 } 147 148 /** 149 * Apply the filter some number of times to an image with the default 3x3 150 * block support 151 * 152 * @param img 153 * the image 154 * @param times 155 * the number of times to apply the dilation 156 */ 157 public static void filter(FImage img, int times) { 158 final MaxFilter d = new MaxFilter(FilterSupport.BLOCK_3x3); 159 for (int i = 0; i < times; i++) 160 img.processInplace(d); 161 } 162}