001: /*
002: * $RCSfile: MaxFilterPlusOpImage.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 MaxFilterPlusOpImage extends MaxFilterOpImage {
038:
039: /**
040: * Creates a MaxFilterPlusOpImage 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 MaxFilterPlusOpImage(RenderedImage source,
052: BorderExtender extender, Map config, ImageLayout layout,
053: int maskSize) {
054: super (source, extender, config, layout,
055: MaxFilterDescriptor.MAX_MASK_PLUS, 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: int offset = filterSize / 2;
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: maxval = Integer.MIN_VALUE;
089:
090: // figure out where the top of the plus starts
091: int imageOffset = srcPixelOffset + srcPixelStride
092: * offset;
093: for (int u = 0; u < wp; u++) {
094: val = (int) (srcData[imageOffset] & 0xff);
095: imageOffset += srcScanlineStride;
096: maxval = (val > maxval) ? val : maxval;
097: }
098:
099: // figure out where the left side of plus starts
100: imageOffset = srcPixelOffset + srcScanlineStride
101: * offset;
102:
103: for (int v = 0; v < wp; v++) {
104: val = (int) (srcData[imageOffset] & 0xff);
105: imageOffset += srcPixelStride;
106: maxval = (val > maxval) ? val : maxval;
107: }
108: dstData[dstPixelOffset] = (byte) maxval;
109: srcPixelOffset += srcPixelStride;
110: dstPixelOffset += dstPixelStride;
111: }
112: srcScanlineOffset += srcScanlineStride;
113: dstScanlineOffset += dstScanlineStride;
114: }
115: }
116: }
117:
118: protected void shortLoop(RasterAccessor src, RasterAccessor dst,
119: int filterSize) {
120: int dwidth = dst.getWidth();
121: int dheight = dst.getHeight();
122: int dnumBands = dst.getNumBands();
123:
124: short dstDataArrays[][] = dst.getShortDataArrays();
125: int dstBandOffsets[] = dst.getBandOffsets();
126: int dstPixelStride = dst.getPixelStride();
127: int dstScanlineStride = dst.getScanlineStride();
128:
129: short srcDataArrays[][] = src.getShortDataArrays();
130: int srcBandOffsets[] = src.getBandOffsets();
131: int srcPixelStride = src.getPixelStride();
132: int srcScanlineStride = src.getScanlineStride();
133:
134: int maxval, val;
135: int wp = filterSize;
136: int offset = filterSize / 2;
137:
138: for (int k = 0; k < dnumBands; k++) {
139: short dstData[] = dstDataArrays[k];
140: short srcData[] = srcDataArrays[k];
141: int srcScanlineOffset = srcBandOffsets[k];
142: int dstScanlineOffset = dstBandOffsets[k];
143: for (int j = 0; j < dheight; j++) {
144: int srcPixelOffset = srcScanlineOffset;
145: int dstPixelOffset = dstScanlineOffset;
146:
147: for (int i = 0; i < dwidth; i++) {
148: maxval = Integer.MIN_VALUE;
149:
150: // figure out where the top of the plus starts
151: int imageOffset = srcPixelOffset + srcPixelStride
152: * offset;
153: for (int u = 0; u < wp; u++) {
154: val = (int) (srcData[imageOffset]);
155: imageOffset += srcScanlineStride;
156: maxval = (val > maxval) ? val : maxval;
157: }
158:
159: // figure out where the left side of plus starts
160: imageOffset = srcPixelOffset + srcScanlineStride
161: * offset;
162:
163: for (int v = 0; v < wp; v++) {
164: val = srcData[imageOffset];
165: imageOffset += srcPixelStride;
166: maxval = (val > maxval) ? val : maxval;
167: }
168:
169: dstData[dstPixelOffset] = (short) maxval;
170: srcPixelOffset += srcPixelStride;
171: dstPixelOffset += dstPixelStride;
172: }
173: srcScanlineOffset += srcScanlineStride;
174: dstScanlineOffset += dstScanlineStride;
175: }
176: }
177: }
178:
179: protected void ushortLoop(RasterAccessor src, RasterAccessor dst,
180: int filterSize) {
181: int dwidth = dst.getWidth();
182: int dheight = dst.getHeight();
183: int dnumBands = dst.getNumBands();
184:
185: short dstDataArrays[][] = dst.getShortDataArrays();
186: int dstBandOffsets[] = dst.getBandOffsets();
187: int dstPixelStride = dst.getPixelStride();
188: int dstScanlineStride = dst.getScanlineStride();
189:
190: short srcDataArrays[][] = src.getShortDataArrays();
191: int srcBandOffsets[] = src.getBandOffsets();
192: int srcPixelStride = src.getPixelStride();
193: int srcScanlineStride = src.getScanlineStride();
194:
195: int maxval, val;
196: int wp = filterSize;
197: int offset = filterSize / 2;
198:
199: for (int k = 0; k < dnumBands; k++) {
200: short dstData[] = dstDataArrays[k];
201: short srcData[] = srcDataArrays[k];
202: int srcScanlineOffset = srcBandOffsets[k];
203: int dstScanlineOffset = dstBandOffsets[k];
204: for (int j = 0; j < dheight; j++) {
205: int srcPixelOffset = srcScanlineOffset;
206: int dstPixelOffset = dstScanlineOffset;
207:
208: for (int i = 0; i < dwidth; i++) {
209: maxval = Integer.MIN_VALUE;
210:
211: // figure out where the top of the plus starts
212: int imageOffset = srcPixelOffset + srcPixelStride
213: * offset;
214: for (int u = 0; u < wp; u++) {
215: val = (int) (srcData[imageOffset] & 0xffff);
216: imageOffset += srcScanlineStride;
217: maxval = (val > maxval) ? val : maxval;
218: }
219:
220: // figure out where the left side of plus starts
221: imageOffset = srcPixelOffset + srcScanlineStride
222: * offset;
223:
224: for (int v = 0; v < wp; v++) {
225: val = (int) (srcData[imageOffset] & 0xffff);
226: imageOffset += srcPixelStride;
227: maxval = (val > maxval) ? val : maxval;
228: }
229:
230: dstData[dstPixelOffset] = (short) maxval;
231: srcPixelOffset += srcPixelStride;
232: dstPixelOffset += dstPixelStride;
233: }
234: srcScanlineOffset += srcScanlineStride;
235: dstScanlineOffset += dstScanlineStride;
236: }
237: }
238: }
239:
240: protected void intLoop(RasterAccessor src, RasterAccessor dst,
241: int filterSize) {
242: int dwidth = dst.getWidth();
243: int dheight = dst.getHeight();
244: int dnumBands = dst.getNumBands();
245:
246: int dstDataArrays[][] = dst.getIntDataArrays();
247: int dstBandOffsets[] = dst.getBandOffsets();
248: int dstPixelStride = dst.getPixelStride();
249: int dstScanlineStride = dst.getScanlineStride();
250:
251: int srcDataArrays[][] = src.getIntDataArrays();
252: int srcBandOffsets[] = src.getBandOffsets();
253: int srcPixelStride = src.getPixelStride();
254: int srcScanlineStride = src.getScanlineStride();
255:
256: int maxval, val;
257: int wp = filterSize;
258: int offset = filterSize / 2;
259:
260: for (int k = 0; k < dnumBands; k++) {
261: int dstData[] = dstDataArrays[k];
262: int srcData[] = srcDataArrays[k];
263: int srcScanlineOffset = srcBandOffsets[k];
264: int dstScanlineOffset = dstBandOffsets[k];
265: for (int j = 0; j < dheight; j++) {
266: int srcPixelOffset = srcScanlineOffset;
267: int dstPixelOffset = dstScanlineOffset;
268:
269: for (int i = 0; i < dwidth; i++) {
270: maxval = Integer.MIN_VALUE;
271:
272: // figure out where the top of the plus starts
273: int imageOffset = srcPixelOffset + srcPixelStride
274: * offset;
275: for (int u = 0; u < wp; u++) {
276: val = srcData[imageOffset];
277: imageOffset += srcScanlineStride;
278: maxval = (val > maxval) ? val : maxval;
279: }
280:
281: // figure out where the left side of plus starts
282: imageOffset = srcPixelOffset + srcScanlineStride
283: * offset;
284:
285: for (int v = 0; v < wp; v++) {
286: val = srcData[imageOffset];
287: imageOffset += srcPixelStride;
288: maxval = (val > maxval) ? val : maxval;
289: }
290: dstData[dstPixelOffset] = maxval;
291: srcPixelOffset += srcPixelStride;
292: dstPixelOffset += dstPixelStride;
293: }
294: srcScanlineOffset += srcScanlineStride;
295: dstScanlineOffset += dstScanlineStride;
296: }
297: }
298: }
299:
300: protected void floatLoop(RasterAccessor src, RasterAccessor dst,
301: int filterSize) {
302: int dwidth = dst.getWidth();
303: int dheight = dst.getHeight();
304: int dnumBands = dst.getNumBands();
305:
306: float dstDataArrays[][] = dst.getFloatDataArrays();
307: int dstBandOffsets[] = dst.getBandOffsets();
308: int dstPixelStride = dst.getPixelStride();
309: int dstScanlineStride = dst.getScanlineStride();
310:
311: float srcDataArrays[][] = src.getFloatDataArrays();
312: int srcBandOffsets[] = src.getBandOffsets();
313: int srcPixelStride = src.getPixelStride();
314: int srcScanlineStride = src.getScanlineStride();
315:
316: float maxval, val;
317: int wp = filterSize;
318: int offset = filterSize / 2;
319:
320: for (int k = 0; k < dnumBands; k++) {
321: float dstData[] = dstDataArrays[k];
322: float srcData[] = srcDataArrays[k];
323: int srcScanlineOffset = srcBandOffsets[k];
324: int dstScanlineOffset = dstBandOffsets[k];
325: for (int j = 0; j < dheight; j++) {
326: int srcPixelOffset = srcScanlineOffset;
327: int dstPixelOffset = dstScanlineOffset;
328:
329: for (int i = 0; i < dwidth; i++) {
330: maxval = -Float.MAX_VALUE;
331:
332: // figure out where the top of the plus starts
333: int imageOffset = srcPixelOffset + srcPixelStride
334: * offset;
335: for (int u = 0; u < wp; u++) {
336: val = srcData[imageOffset];
337: imageOffset += srcScanlineStride;
338: maxval = (val > maxval) ? val : maxval;
339: }
340:
341: // figure out where the left side of plus starts
342: imageOffset = srcPixelOffset + srcScanlineStride
343: * offset;
344:
345: for (int v = 0; v < wp; v++) {
346: val = srcData[imageOffset];
347: imageOffset += srcPixelStride;
348: maxval = (val > maxval) ? val : maxval;
349: }
350:
351: dstData[dstPixelOffset] = maxval;
352: srcPixelOffset += srcPixelStride;
353: dstPixelOffset += dstPixelStride;
354: }
355: srcScanlineOffset += srcScanlineStride;
356: dstScanlineOffset += dstScanlineStride;
357: }
358: }
359: }
360:
361: protected void doubleLoop(RasterAccessor src, RasterAccessor dst,
362: int filterSize) {
363: int dwidth = dst.getWidth();
364: int dheight = dst.getHeight();
365: int dnumBands = dst.getNumBands();
366:
367: double dstDataArrays[][] = dst.getDoubleDataArrays();
368: int dstBandOffsets[] = dst.getBandOffsets();
369: int dstPixelStride = dst.getPixelStride();
370: int dstScanlineStride = dst.getScanlineStride();
371:
372: double srcDataArrays[][] = src.getDoubleDataArrays();
373: int srcBandOffsets[] = src.getBandOffsets();
374: int srcPixelStride = src.getPixelStride();
375: int srcScanlineStride = src.getScanlineStride();
376:
377: double maxval, val;
378: int wp = filterSize;
379: int offset = filterSize / 2;
380:
381: for (int k = 0; k < dnumBands; k++) {
382: double dstData[] = dstDataArrays[k];
383: double srcData[] = srcDataArrays[k];
384: int srcScanlineOffset = srcBandOffsets[k];
385: int dstScanlineOffset = dstBandOffsets[k];
386: for (int j = 0; j < dheight; j++) {
387: int srcPixelOffset = srcScanlineOffset;
388: int dstPixelOffset = dstScanlineOffset;
389:
390: for (int i = 0; i < dwidth; i++) {
391: maxval = -Double.MAX_VALUE;
392:
393: // figure out where the top of the plus starts
394: int imageOffset = srcPixelOffset + srcPixelStride
395: * offset;
396: for (int u = 0; u < wp; u++) {
397: val = srcData[imageOffset];
398: imageOffset += srcScanlineStride;
399: maxval = (val > maxval) ? val : maxval;
400: }
401:
402: // figure out where the left side of plus starts
403: imageOffset = srcPixelOffset + srcScanlineStride
404: * offset;
405:
406: for (int v = 0; v < wp; v++) {
407: val = srcData[imageOffset];
408: imageOffset += srcPixelStride;
409: maxval = (val > maxval) ? val : maxval;
410: }
411:
412: dstData[dstPixelOffset] = maxval;
413: srcPixelOffset += srcPixelStride;
414: dstPixelOffset += dstPixelStride;
415: }
416: srcScanlineOffset += srcScanlineStride;
417: dstScanlineOffset += dstScanlineStride;
418: }
419: }
420: }
421:
422: // public static OpImage createTestImage(OpImageTester oit) {
423: // return new MaxFilterPlusOpImage(oit.getSource(), null, null,
424: // new ImageLayout(oit.getSource()),
425: // 3);
426: // }
427: }
|