public static BufferedImage convertImageData(ImageData data) {
BufferedImage bimg = null;
int height = data.getHeight(), width = data.getWidth();
Object pixels = data.getData();
if (pixels instanceof int[] && data.getElementWidth() == 1) {
int[] arr = (int[]) pixels;
byte[] barray = new byte[arr.length * 3];
int k = 0;
for (int j = 0; j < arr.length; j++) {
int l = arr[j];
barray[k++] = (byte) (l & 0xFF);
barray[k++] = (byte) ((l >>> 8) & 0xFF);
barray[k++] = (byte) ((l >>> 16) & 0xFF);
}
ColorModel ccm =
new ComponentColorModel(
ICC_ColorSpace.getInstance(ICC_ColorSpace.CS_sRGB),
new int[] {8, 8, 8},
false,
false,
Transparency.OPAQUE,
DataBuffer.TYPE_BYTE);
DataBuffer bbuf = new DataBufferByte(barray, barray.length);
SampleModel bmodel =
new PixelInterleavedSampleModel(
DataBuffer.TYPE_BYTE, width, height, 3, 3 * width, new int[] {2, 1, 0});
WritableRaster raster = Raster.createWritableRaster(bmodel, bbuf, new Point(0, 0));
bimg = new BufferedImage(ccm, raster, false, new Hashtable());
} else if (pixels instanceof byte[]
&& data.getElementWidth() == 1) { // Assume gray scale model?
byte[] arr = (byte[]) pixels;
byte[] barray = new byte[arr.length * 3];
int k = 0;
for (int j = 0; j < arr.length; j++) {
byte l = arr[j];
barray[k++] = l;
barray[k++] = l;
barray[k++] = l;
}
ColorModel ccm =
new ComponentColorModel(
ICC_ColorSpace.getInstance(ICC_ColorSpace.CS_sRGB),
new int[] {8, 8, 8},
false,
false,
Transparency.OPAQUE,
DataBuffer.TYPE_BYTE);
DataBuffer bbuf = new DataBufferByte(barray, barray.length);
SampleModel bmodel =
new PixelInterleavedSampleModel(
DataBuffer.TYPE_BYTE, width, height, 3, 3 * width, new int[] {2, 1, 0});
WritableRaster raster = Raster.createWritableRaster(bmodel, bbuf, new Point(0, 0));
bimg = new BufferedImage(ccm, raster, false, new Hashtable());
} else {
throw new RuntimeException("Unexpected data.");
}
return bimg;
}
/**
* Constructs IntegerRaster with the given size.
*
* @param _nrow the number of rows
* @param _ncol the number of columns
*/
public IntegerRaster(int _nrow, int _ncol) {
nrow = _nrow;
ncol = _ncol;
dimension = new Dimension(ncol, nrow);
int size = nrow * ncol;
ComponentColorModel ccm =
new ComponentColorModel(
ColorSpace.getInstance(ColorSpace.CS_sRGB),
new int[] {8, 8, 8},
false, // hasAlpha
false,
Transparency.OPAQUE,
DataBuffer.TYPE_BYTE);
BandedSampleModel csm =
new BandedSampleModel(
DataBuffer.TYPE_BYTE, ncol, nrow, ncol, new int[] {0, 1, 2}, new int[] {0, 0, 0});
rgbData = new byte[3][size];
DataBuffer databuffer = new DataBufferByte(rgbData, size);
WritableRaster raster = Raster.createWritableRaster(csm, databuffer, new Point(0, 0));
image = new BufferedImage(ccm, raster, false, null);
// col in x direction, row in y direction
xmin = 0;
xmax = ncol;
ymin = nrow;
ymax = 0; // zero is on top
}
@BeforeClass
public static void init() {
width = 10;
height = 10;
sm = new BandedSampleModel(DataBuffer.TYPE_DOUBLE, width, height, 1);
numbered = Raster.createWritableRaster(sm, new Point(0, 0));
numberedWithNoData = Raster.createWritableRaster(sm, new Point(0, 0));
numberedWithNanNoData = Raster.createWritableRaster(sm, new Point(0, 0));
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
int pixelId = getPixelId(x, y, width);
numbered.setSample(x, y, 0, (double) pixelId);
numberedWithNoData.setSample(
x, y, 0, ((pixelId % noDataModValue) == 0) ? NON_NAN_NODATA_VALUE : (double) pixelId);
numberedWithNanNoData.setSample(
x, y, 0, ((pixelId % noDataModValue) == 0) ? Double.NaN : (double) pixelId);
}
}
}
/**
* Paint the image onto a Graphics object. The painting is performed tile-by-tile, and includes a
* grey region covering the unused portion of image tiles as well as the general background. At
* this point the image must be byte data.
*/
public synchronized void paintComponent(Graphics g) {
Graphics2D g2D = null;
if (g instanceof Graphics2D) {
g2D = (Graphics2D) g;
} else {
return;
}
// if source is null, it's just a component
if (source == null) {
g2D.setColor(getBackground());
g2D.fillRect(0, 0, componentWidth, componentHeight);
return;
}
int transX = -originX;
int transY = -originY;
// Get the clipping rectangle and translate it into image coordinates.
Rectangle clipBounds = g.getClipBounds();
if (clipBounds == null) {
clipBounds = new Rectangle(0, 0, componentWidth, componentHeight);
}
// clear the background (clip it) [minimal optimization here]
if (transX > 0
|| transY > 0
|| transX < (componentWidth - source.getWidth())
|| transY < (componentHeight - source.getHeight())) {
g2D.setColor(getBackground());
g2D.fillRect(0, 0, componentWidth, componentHeight);
}
clipBounds.translate(-transX, -transY);
// Determine the extent of the clipping region in tile coordinates.
int txmin, txmax, tymin, tymax;
int ti, tj;
txmin = XtoTileX(clipBounds.x);
txmin = Math.max(txmin, minTileX);
txmin = Math.min(txmin, maxTileX);
txmax = XtoTileX(clipBounds.x + clipBounds.width - 1);
txmax = Math.max(txmax, minTileX);
txmax = Math.min(txmax, maxTileX);
tymin = YtoTileY(clipBounds.y);
tymin = Math.max(tymin, minTileY);
tymin = Math.min(tymin, maxTileY);
tymax = YtoTileY(clipBounds.y + clipBounds.height - 1);
tymax = Math.max(tymax, minTileY);
tymax = Math.min(tymax, maxTileY);
Insets insets = getInsets();
// Loop over tiles within the clipping region
for (tj = tymin; tj <= tymax; tj++) {
for (ti = txmin; ti <= txmax; ti++) {
int tx = TileXtoX(ti);
int ty = TileYtoY(tj);
Raster tile = source.getTile(ti, tj);
if (tile != null) {
DataBuffer dataBuffer = tile.getDataBuffer();
WritableRaster wr = tile.createWritableRaster(sampleModel, dataBuffer, null);
BufferedImage bi =
new BufferedImage(colorModel, wr, colorModel.isAlphaPremultiplied(), null);
// correctly handles band offsets
if (brightnessEnabled == true) {
SampleModel sm =
sampleModel.createCompatibleSampleModel(tile.getWidth(), tile.getHeight());
WritableRaster raster = RasterFactory.createWritableRaster(sm, null);
BufferedImage bimg =
new BufferedImage(colorModel, raster, colorModel.isAlphaPremultiplied(), null);
// don't move this code
ByteLookupTable lutTable = new ByteLookupTable(0, lutData);
LookupOp lookup = new LookupOp(lutTable, null);
lookup.filter(bi, bimg);
g2D.drawImage(bimg, biop, tx + transX + insets.left, ty + transY + insets.top);
} else {
AffineTransform transform;
transform =
AffineTransform.getTranslateInstance(
tx + transX + insets.left, ty + transY + insets.top);
g2D.drawRenderedImage(bi, transform);
}
}
}
}
}
/** Convert standard img to a buffered image. */
public static BufferedImage convertImage(Image img) {
int height = img.getHeight(null), width = img.getWidth(null);
// FloatMatrix fm = new FloatMatrix( height, width ) ;
PixelGrabber grabber = new PixelGrabber(img, 0, 0, width, height, false);
try {
grabber.grabPixels();
} catch (InterruptedException e) {
System.out.println(e);
}
Object pixels = grabber.getPixels();
ColorModel cm = grabber.getColorModel();
BufferedImage bimg = null;
// REVISIT Makes some unwarranted assumptions about the layout of the PixelGrabber data
// as being either int (ARGB?) or byte (gray scale?)
if (pixels instanceof int[]) {
int[] arr = (int[]) pixels;
byte[] barray = new byte[arr.length * 3];
int k = 0;
for (int j = 0; j < arr.length; j++) {
int l = arr[j];
barray[k++] = (byte) (l & 0xFF);
barray[k++] = (byte) ((l >>> 8) & 0xFF);
barray[k++] = (byte) ((l >>> 16) & 0xFF);
}
ColorModel ccm =
new ComponentColorModel(
ICC_ColorSpace.getInstance(ICC_ColorSpace.CS_sRGB),
new int[] {8, 8, 8},
false,
false,
Transparency.OPAQUE,
DataBuffer.TYPE_BYTE);
DataBuffer bbuf = new DataBufferByte(barray, barray.length);
SampleModel bmodel =
new PixelInterleavedSampleModel(
DataBuffer.TYPE_BYTE, width, height, 3, 3 * width, new int[] {2, 1, 0});
WritableRaster raster = Raster.createWritableRaster(bmodel, bbuf, new Point(0, 0));
bimg = new BufferedImage(ccm, raster, false, new Hashtable());
} else if (pixels instanceof byte[]) { // Assume gray scale model?
byte[] arr = (byte[]) pixels;
byte[] barray = new byte[arr.length * 3];
int k = 0;
for (int j = 0; j < arr.length; j++) {
byte l = arr[j];
barray[k++] = l;
barray[k++] = l;
barray[k++] = l;
}
ColorModel ccm =
new ComponentColorModel(
ICC_ColorSpace.getInstance(ICC_ColorSpace.CS_sRGB),
new int[] {8, 8, 8},
false,
false,
Transparency.OPAQUE,
DataBuffer.TYPE_BYTE);
DataBuffer bbuf = new DataBufferByte(barray, barray.length);
SampleModel bmodel =
new PixelInterleavedSampleModel(
DataBuffer.TYPE_BYTE, width, height, 3, 3 * width, new int[] {2, 1, 0});
WritableRaster raster = Raster.createWritableRaster(bmodel, bbuf, new Point(0, 0));
bimg = new BufferedImage(ccm, raster, false, new Hashtable());
} else {
throw new RuntimeException("Unexpected data.");
}
return bimg;
}
public BufferedImage read(int imageIndex, ImageReadParam param) throws IOException {
checkIndex(imageIndex);
readHeader();
if (iis == null) throw new IllegalStateException("input is null");
BufferedImage img;
clearAbortRequest();
processImageStarted(imageIndex);
if (param == null) param = getDefaultReadParam();
sourceRegion = new Rectangle(0, 0, 0, 0);
destinationRegion = new Rectangle(0, 0, 0, 0);
computeRegions(
param, this.width, this.height, param.getDestination(), sourceRegion, destinationRegion);
scaleX = param.getSourceXSubsampling();
scaleY = param.getSourceYSubsampling();
// If the destination band is set used it
sourceBands = param.getSourceBands();
destBands = param.getDestinationBands();
seleBand = (sourceBands != null) && (destBands != null);
noTransform = destinationRegion.equals(new Rectangle(0, 0, width, height)) || seleBand;
if (!seleBand) {
sourceBands = new int[colorPlanes];
destBands = new int[colorPlanes];
for (int i = 0; i < colorPlanes; i++) destBands[i] = sourceBands[i] = i;
}
// If the destination is provided, then use it. Otherwise, create new one
bi = param.getDestination();
// Get the image data.
WritableRaster raster = null;
if (bi == null) {
if (sampleModel != null && colorModel != null) {
sampleModel =
sampleModel.createCompatibleSampleModel(
destinationRegion.width + destinationRegion.x,
destinationRegion.height + destinationRegion.y);
if (seleBand) sampleModel = sampleModel.createSubsetSampleModel(sourceBands);
raster = Raster.createWritableRaster(sampleModel, new Point(0, 0));
bi = new BufferedImage(colorModel, raster, false, null);
}
} else {
raster = bi.getWritableTile(0, 0);
sampleModel = bi.getSampleModel();
colorModel = bi.getColorModel();
noTransform &= destinationRegion.equals(raster.getBounds());
}
byte bdata[] = null; // buffer for byte data
if (sampleModel.getDataType() == DataBuffer.TYPE_BYTE)
bdata = (byte[]) ((DataBufferByte) raster.getDataBuffer()).getData();
readImage(bdata);
if (abortRequested()) processReadAborted();
else processImageComplete();
return bi;
}
