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