// returns a value specifying some kind of average brightness in the image.
protected int getAverageBrightness(BufferedImage img) {
Raster r = img.getData();
int total = 0;
for (int y = 0; y < r.getHeight(); y++) {
for (int x = 0; x < r.getWidth(); x++) {
total += r.getSample(r.getMinX() + x, r.getMinY() + y, 0);
}
}
return (int) (total / ((r.getWidth() / factorD) * (r.getHeight() / factorD)));
}
public static BufferedImage toGrayScale(BufferedImage image) {
BufferedImage result =
new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
Raster raster = image.getData();
WritableRaster grayRaster = result.getRaster();
int height = raster.getHeight();
int sample = 0;
for (int x = 0; x < raster.getWidth(); ++x) {
for (int y = 0; y < height; ++y) {
sample = raster.getSample(x, y, 0) + raster.getSample(x, y, 1) + raster.getSample(x, y, 2);
grayRaster.setSample(x, y, 0, (int) ((float) sample / 3.0));
}
}
return result;
}
/**
* 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);
}
}
}
}
}
/**
* Loads PNG files and returns the result as an int[][]. The only PNG formats permitted are those
* with up to 256 grays (including simple black and white) or indexed colors from an up to
* 256-sized color table. Each integer value represents the gray level or the color table index
* value of the pixel. The Y dimension is not flipped.
*/
public static int[][] loadPNGFile(InputStream str) throws IOException {
// read the bytes into a byte array
BufferedInputStream stream = new BufferedInputStream(str);
ArrayList list = new ArrayList();
int count = 0;
while (true) {
byte[] buffer = new byte[16384 * 16];
int len = stream.read(buffer);
if (len <= 0) // all done
break;
else if (len < buffer.length) {
byte[] buf2 = new byte[len];
System.arraycopy(buffer, 0, buf2, 0, len);
buffer = buf2;
}
count += len;
list.add(buffer);
}
byte[] data = new byte[count];
int cur = 0;
for (int i = 0; i < list.size(); i++) {
byte[] b = (byte[]) (list.get(i));
System.arraycopy(b, 0, data, cur, b.length);
cur += b.length;
}
// Next convert the byte array to a buffered image
BufferedImage image = ((ToolkitImage) (new ImageIcon(data).getImage())).getBufferedImage();
// Is the color model something we can use?
int type = image.getType();
if (type == BufferedImage.TYPE_BYTE_BINARY || type == BufferedImage.TYPE_BYTE_GRAY) {
int w = image.getWidth();
int h = image.getHeight();
int[][] result = new int[w][h];
// obviously this could be done more efficiently
for (int i = 0; i < w; i++)
for (int j = 0; j < h; j++) result[i][j] = (image.getRGB(i, j) & 0xFF);
return result;
} else if (type == BufferedImage.TYPE_BYTE_INDEXED) {
Raster raster = image.getRaster();
if (raster.getTransferType() != DataBuffer.TYPE_BYTE) // uh oh
throw new IOException("Input Stream must contain an image with byte data if indexed.");
byte[] pixel = new byte[1];
int w = image.getWidth();
int h = image.getHeight();
int[][] result = new int[w][h];
// obviously this could be done more efficiently
for (int i = 0; i < w; i++)
for (int j = 0; j < h; j++) {
result[i][j] = ((byte[]) (raster.getDataElements(i, j, pixel)))[0];
if (result[i][j] < 0) result[i][j] += 256;
}
return result;
}
// else if (type == TYPE_USHORT_GRAY) // at present we don't handle shorts
// {
// }
else
throw new IOException(
"Input Stream must contain a binary, byte-sized grayscale, or byte-sized indexed color scheme: "
+ image);
}
public Raster getRaster(int x, int y, int w, int h) {
return Raster.createBandedRaster(0, 0, 0, 0, NULL_POINT);
}
