001: /*
002: * $RCSfile: MedianFilterSquareOpImage.java,v $
003: *
004: * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
005: *
006: * Use is subject to license terms.
007: *
008: * $Revision: 1.1 $
009: * $Date: 2005/02/11 04:56:34 $
010: * $State: Exp $
011: */
012: package com.sun.media.jai.opimage;
013:
014: import java.awt.Rectangle;
015: import java.awt.image.DataBuffer;
016: import java.awt.image.SampleModel;
017: import java.awt.image.Raster;
018: import java.awt.image.RenderedImage;
019: import java.awt.image.WritableRaster;
020: import java.awt.image.renderable.ParameterBlock;
021: import java.awt.image.renderable.RenderedImageFactory;
022: import javax.media.jai.AreaOpImage;
023: import javax.media.jai.BorderExtender;
024: import javax.media.jai.ImageLayout;
025: import javax.media.jai.OpImage;
026: import javax.media.jai.RasterAccessor;
027: import java.util.Map;
028: import javax.media.jai.operator.MedianFilterDescriptor;
029: import com.sun.media.jai.opimage.MedianFilterOpImage;
030:
031: // import com.sun.media.jai.test.OpImageTester;
032:
033: /**
034: * An OpImage class to perform median filtering on a source image.
035: *
036: *
037: */
038: final class MedianFilterSquareOpImage extends MedianFilterOpImage {
039:
040: /**
041: * Creates a MedianFilterSquareOpImage with the given source and
042: * maskSize. The image dimensions are derived from the source
043: * image. The tile grid layout, SampleModel, and ColorModel may
044: * optionally be specified by an ImageLayout object.
045: *
046: * @param source a RenderedImage.
047: * @param extender a BorderExtender, or null.
048: * @param layout an ImageLayout optionally containing the tile grid layout,
049: * SampleModel, and ColorModel, or null.
050: * @param maskSize the mask size.
051: */
052: public MedianFilterSquareOpImage(RenderedImage source,
053: BorderExtender extender, Map config, ImageLayout layout,
054: int maskSize) {
055: super (source, extender, config, layout,
056: MedianFilterDescriptor.MEDIAN_MASK_SQUARE, maskSize);
057: }
058:
059: protected void byteLoop(RasterAccessor src, RasterAccessor dst,
060: int filterSize) {
061: int dwidth = dst.getWidth();
062: int dheight = dst.getHeight();
063: int dnumBands = dst.getNumBands();
064:
065: byte dstDataArrays[][] = dst.getByteDataArrays();
066: int dstBandOffsets[] = dst.getBandOffsets();
067: int dstPixelStride = dst.getPixelStride();
068: int dstScanlineStride = dst.getScanlineStride();
069:
070: byte srcDataArrays[][] = src.getByteDataArrays();
071: int srcBandOffsets[] = src.getBandOffsets();
072: int srcPixelStride = src.getPixelStride();
073: int srcScanlineStride = src.getScanlineStride();
074:
075: int values[] = new int[filterSize * filterSize];
076: int wp = filterSize;
077:
078: for (int k = 0; k < dnumBands; k++) {
079: byte dstData[] = dstDataArrays[k];
080: byte srcData[] = srcDataArrays[k];
081: int srcScanlineOffset = srcBandOffsets[k];
082: int dstScanlineOffset = dstBandOffsets[k];
083: for (int j = 0; j < dheight; j++) {
084: int srcPixelOffset = srcScanlineOffset;
085: int dstPixelOffset = dstScanlineOffset;
086:
087: for (int i = 0; i < dwidth; i++) {
088: int imageVerticalOffset = srcPixelOffset;
089:
090: int valueCount = 0;
091: for (int u = 0; u < wp; u++) {
092: int imageOffset = imageVerticalOffset;
093: for (int v = 0; v < wp; v++) {
094: values[valueCount++] = (int) (srcData[imageOffset]) & 0xff;
095: imageOffset += srcPixelStride;
096: }
097: imageVerticalOffset += srcScanlineStride;
098: }
099: int val = medianFilter(values);
100:
101: dstData[dstPixelOffset] = (byte) val;
102: srcPixelOffset += srcPixelStride;
103: dstPixelOffset += dstPixelStride;
104: }
105: srcScanlineOffset += srcScanlineStride;
106: dstScanlineOffset += dstScanlineStride;
107: }
108: }
109: }
110:
111: protected void shortLoop(RasterAccessor src, RasterAccessor dst,
112: int filterSize) {
113: int dwidth = dst.getWidth();
114: int dheight = dst.getHeight();
115: int dnumBands = dst.getNumBands();
116:
117: short dstDataArrays[][] = dst.getShortDataArrays();
118: int dstBandOffsets[] = dst.getBandOffsets();
119: int dstPixelStride = dst.getPixelStride();
120: int dstScanlineStride = dst.getScanlineStride();
121:
122: short srcDataArrays[][] = src.getShortDataArrays();
123: int srcBandOffsets[] = src.getBandOffsets();
124: int srcPixelStride = src.getPixelStride();
125: int srcScanlineStride = src.getScanlineStride();
126:
127: int values[] = new int[filterSize * filterSize];
128: int wp = filterSize;
129:
130: for (int k = 0; k < dnumBands; k++) {
131: short dstData[] = dstDataArrays[k];
132: short srcData[] = srcDataArrays[k];
133: int srcScanlineOffset = srcBandOffsets[k];
134: int dstScanlineOffset = dstBandOffsets[k];
135: for (int j = 0; j < dheight; j++) {
136: int srcPixelOffset = srcScanlineOffset;
137: int dstPixelOffset = dstScanlineOffset;
138:
139: for (int i = 0; i < dwidth; i++) {
140: int imageVerticalOffset = srcPixelOffset;
141:
142: int valueCount = 0;
143: for (int u = 0; u < wp; u++) {
144: int imageOffset = imageVerticalOffset;
145: for (int v = 0; v < wp; v++) {
146: values[valueCount++] = (int) (srcData[imageOffset]);
147: imageOffset += srcPixelStride;
148: }
149: imageVerticalOffset += srcScanlineStride;
150: }
151: int val = medianFilter(values);
152:
153: dstData[dstPixelOffset] = (short) val;
154: srcPixelOffset += srcPixelStride;
155: dstPixelOffset += dstPixelStride;
156: }
157: srcScanlineOffset += srcScanlineStride;
158: dstScanlineOffset += dstScanlineStride;
159: }
160: }
161: }
162:
163: protected void ushortLoop(RasterAccessor src, RasterAccessor dst,
164: int filterSize) {
165: int dwidth = dst.getWidth();
166: int dheight = dst.getHeight();
167: int dnumBands = dst.getNumBands();
168:
169: short dstDataArrays[][] = dst.getShortDataArrays();
170: int dstBandOffsets[] = dst.getBandOffsets();
171: int dstPixelStride = dst.getPixelStride();
172: int dstScanlineStride = dst.getScanlineStride();
173:
174: short srcDataArrays[][] = src.getShortDataArrays();
175: int srcBandOffsets[] = src.getBandOffsets();
176: int srcPixelStride = src.getPixelStride();
177: int srcScanlineStride = src.getScanlineStride();
178:
179: int values[] = new int[filterSize * filterSize];
180: int wp = filterSize;
181:
182: for (int k = 0; k < dnumBands; k++) {
183: short dstData[] = dstDataArrays[k];
184: short srcData[] = srcDataArrays[k];
185: int srcScanlineOffset = srcBandOffsets[k];
186: int dstScanlineOffset = dstBandOffsets[k];
187: for (int j = 0; j < dheight; j++) {
188: int srcPixelOffset = srcScanlineOffset;
189: int dstPixelOffset = dstScanlineOffset;
190:
191: for (int i = 0; i < dwidth; i++) {
192: int imageVerticalOffset = srcPixelOffset;
193:
194: int valueCount = 0;
195: for (int u = 0; u < wp; u++) {
196: int imageOffset = imageVerticalOffset;
197: for (int v = 0; v < wp; v++) {
198: values[valueCount++] = (int) (srcData[imageOffset]) & 0xffff;
199: imageOffset += srcPixelStride;
200: }
201: imageVerticalOffset += srcScanlineStride;
202: }
203: int val = medianFilter(values);
204:
205: dstData[dstPixelOffset] = (short) val;
206: srcPixelOffset += srcPixelStride;
207: dstPixelOffset += dstPixelStride;
208: }
209: srcScanlineOffset += srcScanlineStride;
210: dstScanlineOffset += dstScanlineStride;
211: }
212: }
213: }
214:
215: protected void intLoop(RasterAccessor src, RasterAccessor dst,
216: int filterSize) {
217: int dwidth = dst.getWidth();
218: int dheight = dst.getHeight();
219: int dnumBands = dst.getNumBands();
220:
221: int dstDataArrays[][] = dst.getIntDataArrays();
222: int dstBandOffsets[] = dst.getBandOffsets();
223: int dstPixelStride = dst.getPixelStride();
224: int dstScanlineStride = dst.getScanlineStride();
225:
226: int srcDataArrays[][] = src.getIntDataArrays();
227: int srcBandOffsets[] = src.getBandOffsets();
228: int srcPixelStride = src.getPixelStride();
229: int srcScanlineStride = src.getScanlineStride();
230:
231: int values[] = new int[filterSize * filterSize];
232: int wp = filterSize;
233:
234: for (int k = 0; k < dnumBands; k++) {
235: int dstData[] = dstDataArrays[k];
236: int srcData[] = srcDataArrays[k];
237: int srcScanlineOffset = srcBandOffsets[k];
238: int dstScanlineOffset = dstBandOffsets[k];
239: for (int j = 0; j < dheight; j++) {
240: int srcPixelOffset = srcScanlineOffset;
241: int dstPixelOffset = dstScanlineOffset;
242:
243: for (int i = 0; i < dwidth; i++) {
244: int imageVerticalOffset = srcPixelOffset;
245:
246: int valueCount = 0;
247: for (int u = 0; u < wp; u++) {
248: int imageOffset = imageVerticalOffset;
249: for (int v = 0; v < wp; v++) {
250: values[valueCount++] = srcData[imageOffset];
251: imageOffset += srcPixelStride;
252: }
253: imageVerticalOffset += srcScanlineStride;
254: }
255: int val = medianFilter(values);
256:
257: dstData[dstPixelOffset] = val;
258: srcPixelOffset += srcPixelStride;
259: dstPixelOffset += dstPixelStride;
260: }
261: srcScanlineOffset += srcScanlineStride;
262: dstScanlineOffset += dstScanlineStride;
263: }
264: }
265: }
266:
267: protected void floatLoop(RasterAccessor src, RasterAccessor dst,
268: int filterSize) {
269: int dwidth = dst.getWidth();
270: int dheight = dst.getHeight();
271: int dnumBands = dst.getNumBands();
272:
273: float dstDataArrays[][] = dst.getFloatDataArrays();
274: int dstBandOffsets[] = dst.getBandOffsets();
275: int dstPixelStride = dst.getPixelStride();
276: int dstScanlineStride = dst.getScanlineStride();
277:
278: float srcDataArrays[][] = src.getFloatDataArrays();
279: int srcBandOffsets[] = src.getBandOffsets();
280: int srcPixelStride = src.getPixelStride();
281: int srcScanlineStride = src.getScanlineStride();
282:
283: float values[] = new float[filterSize * filterSize];
284: int wp = filterSize;
285:
286: for (int k = 0; k < dnumBands; k++) {
287: float dstData[] = dstDataArrays[k];
288: float srcData[] = srcDataArrays[k];
289: int srcScanlineOffset = srcBandOffsets[k];
290: int dstScanlineOffset = dstBandOffsets[k];
291: for (int j = 0; j < dheight; j++) {
292: int srcPixelOffset = srcScanlineOffset;
293: int dstPixelOffset = dstScanlineOffset;
294:
295: for (int i = 0; i < dwidth; i++) {
296: int imageVerticalOffset = srcPixelOffset;
297:
298: int valueCount = 0;
299: for (int u = 0; u < wp; u++) {
300: int imageOffset = imageVerticalOffset;
301: for (int v = 0; v < wp; v++) {
302: values[valueCount++] = srcData[imageOffset];
303: imageOffset += srcPixelStride;
304: }
305: imageVerticalOffset += srcScanlineStride;
306: }
307: float val = medianFilterFloat(values);
308:
309: dstData[dstPixelOffset] = val;
310: srcPixelOffset += srcPixelStride;
311: dstPixelOffset += dstPixelStride;
312: }
313: srcScanlineOffset += srcScanlineStride;
314: dstScanlineOffset += dstScanlineStride;
315: }
316: }
317: }
318:
319: protected void doubleLoop(RasterAccessor src, RasterAccessor dst,
320: int filterSize) {
321: int dwidth = dst.getWidth();
322: int dheight = dst.getHeight();
323: int dnumBands = dst.getNumBands();
324:
325: double dstDataArrays[][] = dst.getDoubleDataArrays();
326: int dstBandOffsets[] = dst.getBandOffsets();
327: int dstPixelStride = dst.getPixelStride();
328: int dstScanlineStride = dst.getScanlineStride();
329:
330: double srcDataArrays[][] = src.getDoubleDataArrays();
331: int srcBandOffsets[] = src.getBandOffsets();
332: int srcPixelStride = src.getPixelStride();
333: int srcScanlineStride = src.getScanlineStride();
334:
335: double values[] = new double[filterSize * filterSize];
336: int wp = filterSize;
337:
338: for (int k = 0; k < dnumBands; k++) {
339: double dstData[] = dstDataArrays[k];
340: double srcData[] = srcDataArrays[k];
341: int srcScanlineOffset = srcBandOffsets[k];
342: int dstScanlineOffset = dstBandOffsets[k];
343: for (int j = 0; j < dheight; j++) {
344: int srcPixelOffset = srcScanlineOffset;
345: int dstPixelOffset = dstScanlineOffset;
346:
347: for (int i = 0; i < dwidth; i++) {
348: int imageVerticalOffset = srcPixelOffset;
349:
350: int valueCount = 0;
351: for (int u = 0; u < wp; u++) {
352: int imageOffset = imageVerticalOffset;
353: for (int v = 0; v < wp; v++) {
354: values[valueCount++] = srcData[imageOffset];
355: imageOffset += srcPixelStride;
356: }
357: imageVerticalOffset += srcScanlineStride;
358: }
359: double val = medianFilterDouble(values);
360:
361: dstData[dstPixelOffset] = val;
362: srcPixelOffset += srcPixelStride;
363: dstPixelOffset += dstPixelStride;
364: }
365: srcScanlineOffset += srcScanlineStride;
366: dstScanlineOffset += dstScanlineStride;
367: }
368: }
369: }
370:
371: // public static OpImage createTestImage(OpImageTester oit) {
372: // return new MedianFilterSquareOpImage(oit.getSource(), null, null,
373: // new ImageLayout(oit.getSource()),
374: // 3);
375: // }
376: }
|