@Override
protected void computeRect(
final PlanarImage[] sources, final WritableRaster dest, final Rectangle destRect) {
final PlanarImage source = sources[0];
final Rectangle bounds = destRect.intersection(source.getBounds());
if (!destRect.equals(bounds)) {
// TODO: Check if this case occurs sometime, and fill pixel values if it does.
// If it happen to occurs, we will need to fix other GeoTools operations
// as well.
Logging.getLogger(TransformException.class)
.warning("Bounds mismatch: " + destRect + " and " + bounds);
}
WritableRectIter iterator = RectIterFactory.createWritable(dest, bounds);
// TODO: Detect if source and destination rasters are the same. If they are
// the same, we should skip this block. Iteration will then be faster.
iterator = TransfertRectIter.create(RectIterFactory.create(source, bounds), iterator);
if (!iterator.finishedBands()) {
do {
recode(iterator);
} while (!iterator.nextBandDone());
}
}
/**
* 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);
}
}
}
}
}
private void readTileData(
File outputFile,
int tileX,
int tileY,
int tileWidth,
int tileHeight,
int jp2TileX,
int jp2TileY,
int jp2TileWidth,
int jp2TileHeight,
short[] tileData,
Rectangle destRect)
throws IOException {
synchronized (this) {
if (!locks.containsKey(outputFile)) {
locks.put(outputFile, new Object());
}
}
final Object lock = locks.get(outputFile);
synchronized (lock) {
Jp2File jp2File = getOpenJ2pFile(outputFile);
int jp2Width = jp2File.width;
int jp2Height = jp2File.height;
if (jp2Width > jp2TileWidth || jp2Height > jp2TileHeight) {
throw new IllegalStateException(
String.format(
"width (=%d) > tileWidth (=%d) || height (=%d) > tileHeight (=%d)",
jp2Width, jp2TileWidth, jp2Height, jp2TileHeight));
}
int jp2X = destRect.x - jp2TileX * jp2TileWidth;
int jp2Y = destRect.y - jp2TileY * jp2TileHeight;
if (jp2X < 0 || jp2Y < 0) {
throw new IllegalStateException(
String.format("jp2X (=%d) < 0 || jp2Y (=%d) < 0", jp2X, jp2Y));
}
final ImageInputStream stream = jp2File.stream;
if (jp2X == 0
&& jp2Width == tileWidth
&& jp2Y == 0
&& jp2Height == tileHeight
&& tileWidth * tileHeight == tileData.length) {
stream.seek(jp2File.dataPos);
stream.readFully(tileData, 0, tileData.length);
} else {
final Rectangle jp2FileRect = new Rectangle(0, 0, jp2Width, jp2Height);
final Rectangle tileRect = new Rectangle(jp2X, jp2Y, tileWidth, tileHeight);
final Rectangle intersection = jp2FileRect.intersection(tileRect);
System.out.printf(
"%s: tile=(%d,%d): jp2FileRect=%s, tileRect=%s, intersection=%s\n",
jp2File.file, tileX, tileY, jp2FileRect, tileRect, intersection);
if (!intersection.isEmpty()) {
long seekPos =
jp2File.dataPos + NUM_SHORT_BYTES * (intersection.y * jp2Width + intersection.x);
int tilePos = 0;
for (int y = 0; y < intersection.height; y++) {
stream.seek(seekPos);
stream.readFully(tileData, tilePos, intersection.width);
seekPos += NUM_SHORT_BYTES * jp2Width;
tilePos += tileWidth;
for (int x = intersection.width; x < tileWidth; x++) {
tileData[y * tileWidth + x] = (short) 0;
}
}
for (int y = intersection.height; y < tileWidth; y++) {
for (int x = 0; x < tileWidth; x++) {
tileData[y * tileWidth + x] = (short) 0;
}
}
} else {
Arrays.fill(tileData, (short) 0);
}
}
}
}