1:
36:
37: package ;
38:
39: import ;
40: import ;
41:
42:
45: public class SinglePixelPackedSampleModel extends SampleModel
46: {
47: private int scanlineStride;
48: private int[] bitMasks;
49: private int[] bitOffsets;
50: private int[] sampleSize;
51:
52: public SinglePixelPackedSampleModel(int dataType, int w, int h,
53: int[] bitMasks)
54: {
55: this(dataType, w, h, w, bitMasks);
56: }
57:
58: public SinglePixelPackedSampleModel(int dataType, int w, int h,
59: int scanlineStride, int[] bitMasks)
60: {
61: super(dataType, w, h, bitMasks.length);
62:
63: switch (dataType)
64: {
65: case DataBuffer.TYPE_BYTE:
66: case DataBuffer.TYPE_USHORT:
67: case DataBuffer.TYPE_INT:
68: break;
69: default:
70: throw new IllegalArgumentException("SinglePixelPackedSampleModel unsupported dataType");
71: }
72:
73: this.scanlineStride = scanlineStride;
74: this.bitMasks = bitMasks;
75:
76: bitOffsets = new int[numBands];
77: sampleSize = new int[numBands];
78:
79: BitMaskExtent extent = new BitMaskExtent();
80: for (int b=0; b<numBands; b++)
81: {
82: extent.setMask(bitMasks[b]);
83: sampleSize[b] = extent.bitWidth;
84: bitOffsets[b] = extent.leastSignificantBit;
85: }
86: }
87:
88: public int getNumDataElements()
89: {
90: return 1;
91: }
92:
93: public SampleModel createCompatibleSampleModel(int w, int h)
94: {
95:
98: return new SinglePixelPackedSampleModel(dataType, w, h, bitMasks);
99: }
100:
101:
102:
107: public DataBuffer createDataBuffer()
108: {
109: int size;
110:
111:
112:
113:
114: size = scanlineStride * (height - 1) + width;
115:
116: return Buffers.createBuffer(getDataType(), size);
117: }
118:
119:
120: public int[] getSampleSize()
121: {
122: return sampleSize;
123: }
124:
125: public int getSampleSize(int band)
126: {
127: return sampleSize[band];
128: }
129:
130: public int getOffset(int x, int y)
131: {
132: return scanlineStride*y + x;
133: }
134:
135: public int[] getBitOffsets()
136: {
137: return bitOffsets;
138: }
139:
140: public int[] getBitMasks()
141: {
142: return bitMasks;
143: }
144:
145: public int getScanlineStride()
146: {
147: return scanlineStride;
148: }
149:
150: public SampleModel createSubsetSampleModel(int[] bands)
151: {
152:
153:
154: int numBands = bands.length;
155:
156: int[] bitMasks = new int[numBands];
157:
158: for (int b=0; b<numBands; b++)
159: bitMasks[b] = this.bitMasks[bands[b]];
160:
161: return new SinglePixelPackedSampleModel(dataType, width, height,
162: scanlineStride, bitMasks);
163: }
164:
165: public Object getDataElements(int x, int y, Object obj,
166: DataBuffer data)
167: {
168: int offset = scanlineStride*y + x + data.getOffset();
169:
170: return Buffers.getData(data, offset, obj,
171: 0,
172: 1
173: );
174: }
175:
176:
188: public Object getDataElements(int x, int y, int w, int h, Object obj,
189: DataBuffer data)
190: {
191: int size = w*h;
192: int dataSize = size;
193: Object pixelData = null;
194: switch (getTransferType())
195: {
196: case DataBuffer.TYPE_BYTE:
197: pixelData = ((DataBufferByte) data).getData();
198: if (obj == null) obj = new byte[dataSize];
199: break;
200: case DataBuffer.TYPE_USHORT:
201: pixelData = ((DataBufferUShort) data).getData();
202: if (obj == null) obj = new short[dataSize];
203: break;
204: case DataBuffer.TYPE_INT:
205: pixelData = ((DataBufferInt) data).getData();
206: if (obj == null) obj = new int[dataSize];
207: break;
208: default:
209:
210: throw new ClassCastException();
211: }
212: if(x==0 && scanlineStride == w)
213: {
214:
215: System.arraycopy(pixelData, scanlineStride*y + data.getOffset(), obj, 0, size);
216: }
217: else
218: {
219:
220: int outOffset = 0;
221: int dataOffset = scanlineStride*y + x + data.getOffset();
222: for (int yy = y; yy<(y+h); yy++)
223: {
224: System.arraycopy(pixelData, dataOffset, obj, outOffset, w);
225: dataOffset += scanlineStride;
226: outOffset += w;
227: }
228: }
229: return obj;
230: }
231:
232:
233: public int[] getPixel(int x, int y, int[] iArray, DataBuffer data)
234: {
235: int offset = scanlineStride*y + x;
236: if (iArray == null) iArray = new int[numBands];
237: int samples = data.getElem(offset);
238:
239: for (int b=0; b<numBands; b++)
240: iArray[b] = (samples & bitMasks[b]) >>> bitOffsets[b];
241:
242: return iArray;
243: }
244:
245: public int[] getPixels(int x, int y, int w, int h, int[] iArray,
246: DataBuffer data)
247: {
248: int offset = scanlineStride*y + x;
249: if (iArray == null) iArray = new int[numBands*w*h];
250: int outOffset = 0;
251: for (y=0; y<h; y++)
252: {
253: int lineOffset = offset;
254: for (x=0; x<w; x++)
255: {
256: int samples = data.getElem(lineOffset++);
257: for (int b=0; b<numBands; b++)
258: iArray[outOffset++] = (samples & bitMasks[b]) >>> bitOffsets[b];
259: }
260: offset += scanlineStride;
261: }
262: return iArray;
263: }
264:
265: public int getSample(int x, int y, int b, DataBuffer data)
266: {
267: int offset = scanlineStride*y + x;
268: int samples = data.getElem(offset);
269: return (samples & bitMasks[b]) >>> bitOffsets[b];
270: }
271:
272:
284: public void setDataElements(int x, int y, int w, int h,
285: Object obj, DataBuffer data)
286: {
287:
288: Object pixelData;
289: switch (getTransferType())
290: {
291: case DataBuffer.TYPE_BYTE:
292: pixelData = ((DataBufferByte) data).getData();
293: break;
294: case DataBuffer.TYPE_USHORT:
295: pixelData = ((DataBufferUShort) data).getData();
296: break;
297: case DataBuffer.TYPE_INT:
298: pixelData = ((DataBufferInt) data).getData();
299: break;
300: default:
301:
302: throw new ClassCastException();
303: }
304:
305: int inOffset = 0;
306: int dataOffset = scanlineStride*y + x + data.getOffset();
307: for (int yy=y; yy<(y+h); yy++)
308: {
309: System.arraycopy(obj,inOffset,pixelData,dataOffset,w);
310: dataOffset += scanlineStride;
311: inOffset += w;
312: }
313: }
314:
315:
316: public void setDataElements(int x, int y, Object obj, DataBuffer data)
317: {
318: int offset = scanlineStride*y + x + data.getOffset();
319:
320: int transferType = getTransferType();
321: if (getTransferType() != data.getDataType())
322: {
323: throw new IllegalArgumentException("transfer type ("+
324: getTransferType()+"), "+
325: "does not match data "+
326: "buffer type (" +
327: data.getDataType() +
328: ").");
329: }
330:
331: try
332: {
333: switch (transferType)
334: {
335: case DataBuffer.TYPE_BYTE:
336: {
337: DataBufferByte out = (DataBufferByte) data;
338: byte[] in = (byte[]) obj;
339: out.getData()[offset] = in[0];
340: return;
341: }
342: case DataBuffer.TYPE_USHORT:
343: {
344: DataBufferUShort out = (DataBufferUShort) data;
345: short[] in = (short[]) obj;
346: out.getData()[offset] = in[0];
347: return;
348: }
349: case DataBuffer.TYPE_INT:
350: {
351: DataBufferInt out = (DataBufferInt) data;
352: int[] in = (int[]) obj;
353: out.getData()[offset] = in[0];
354: return;
355: }
356:
357: default:
358: throw new InternalError();
359: }
360: }
361: catch (ArrayIndexOutOfBoundsException aioobe)
362: {
363: String msg = "While writing data elements" +
364: ", x="+x+", y="+y+
365: ", width="+width+", height="+height+
366: ", scanlineStride="+scanlineStride+
367: ", offset="+offset+
368: ", data.getSize()="+data.getSize()+
369: ", data.getOffset()="+data.getOffset()+
370: ": " +
371: aioobe;
372: throw new ArrayIndexOutOfBoundsException(msg);
373: }
374: }
375:
376: public void setPixel(int x, int y, int[] iArray, DataBuffer data)
377: {
378: int offset = scanlineStride*y + x;
379:
380: int samples = 0;
381: for (int b=0; b<numBands; b++)
382: samples |= (iArray[b] << bitOffsets[b]) & bitMasks[b];
383:
384: data.setElem(offset, samples);
385: }
386:
387:
399: public void setPixels(int x, int y, int w, int h, int[] iArray,
400: DataBuffer data)
401: {
402: int inOffset = 0;
403: int[] pixel = new int[numBands];
404: for (int yy=y; yy<(y+h); yy++)
405: {
406: int offset = scanlineStride*yy + x;
407: for (int xx=x; xx<(x+w); xx++)
408: {
409: int samples = 0;
410: for (int b=0; b<numBands; b++)
411: samples |= (iArray[inOffset+b] << bitOffsets[b]) & bitMasks[b];
412: data.setElem(0, offset, samples);
413: inOffset += numBands;
414: offset += 1;
415: }
416: }
417: }
418:
419:
420: public void setSample(int x, int y, int b, int s, DataBuffer data)
421: {
422: int offset = scanlineStride*y + x;
423: int samples = data.getElem(offset);
424: int bitMask = bitMasks[b];
425: samples &= ~bitMask;
426: samples |= (s << bitOffsets[b]) & bitMask;
427: data.setElem(offset, samples);
428: }
429:
430:
435: public String toString()
436: {
437: StringBuffer result = new StringBuffer();
438: result.append(getClass().getName());
439: result.append("[");
440: result.append("scanlineStride=").append(scanlineStride);
441: for(int i=0; i < bitMasks.length; i+=1)
442: {
443: result.append(", mask[").append(i).append("]=0x").append(Integer.toHexString(bitMasks[i]));
444: }
445:
446: result.append("]");
447: return result.toString();
448: }
449: }