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