public void testCropRectangle() throws Exception {
final Envelope rasterEnvelope = geoRasterSrc.getMetadata().getEnvelope();
geoRasterSrc.save(tmpData + "1.tif");
final int buffer = (int) (rasterEnvelope.getWidth() / 2.3);
final Rectangle2D cropRectangle =
new Rectangle2D.Double(
rasterEnvelope.getMinX() + buffer,
rasterEnvelope.getMinY() + buffer,
rasterEnvelope.getWidth() - 2 * buffer,
rasterEnvelope.getHeight() - 2 * buffer);
geoRasterDst = geoRasterSrc.doOperation(new Crop(cropRectangle));
geoRasterDst.save(tmpData + "2.tif");
assertTrue(geoRasterDst.getWidth() > 0);
assertTrue(geoRasterDst.getHeight() > 0);
final ImagePlus srcImagePlus = geoRasterSrc.getImagePlus();
final ImagePlus dstImagePlus = geoRasterDst.getImagePlus();
RasterMetadata dstMetadata = geoRasterDst.getMetadata();
RasterMetadata srcMetadata = geoRasterSrc.getMetadata();
assertTrue(dstMetadata.getEnvelope().getMinX() < cropRectangle.getMinX());
assertTrue(dstMetadata.getEnvelope().getMinY() < cropRectangle.getMinY());
assertTrue(dstMetadata.getEnvelope().getMaxX() > cropRectangle.getMaxX());
assertTrue(dstMetadata.getEnvelope().getMaxY() > cropRectangle.getMaxY());
assertTrue(dstMetadata.getEnvelope().getWidth() < srcMetadata.getEnvelope().getWidth());
checkCrop(geoRasterDst.getMetadata().getEnvelope(), srcImagePlus, dstImagePlus);
}
private Envelope getMetaTileEnvelope(
GetMapRequest request, Point tileCoords, Point metaTileCoords) {
Envelope bbox = request.getBbox();
double minx = bbox.getMinX() + (metaTileCoords.x - tileCoords.x) * bbox.getWidth();
double miny = bbox.getMinY() + (metaTileCoords.y - tileCoords.y) * bbox.getHeight();
double maxx = minx + bbox.getWidth() * 3;
double maxy = miny + bbox.getHeight() * 3;
return new Envelope(minx, maxx, miny, maxy);
}
/**
* Given an envelope and origin, find the tile coordinate (row,col)
*
* @param env
* @param origin
* @return
*/
Point getTileCoordinates(Envelope env, Point2D origin) {
// this was using the low left corner and Math.round, but turned
// out to be fragile when fairly zoomed in. Using the tile center
// and then flooring the division seems to work much more reliably.
double centerx = env.getMinX() + env.getWidth() / 2;
double centery = env.getMinY() + env.getHeight() / 2;
int x = (int) Math.floor((centerx - origin.getX()) / env.getWidth());
int y = (int) Math.floor((centery - origin.getY()) / env.getWidth());
return new Point(x, y);
}
/** @throws RuntimeException */
private void calculateAffineTransform() {
if (extent == null) {
return;
} else if (image == null || getWidth() == 0 || getHeight() == 0) {
return;
}
if (adjustExtent) {
double escalaX = getWidth() / extent.getWidth();
double escalaY = getHeight() / extent.getHeight();
double xCenter = extent.getMinX() + extent.getWidth() / 2.0;
double yCenter = extent.getMinY() + extent.getHeight() / 2.0;
adjustedExtent = new Envelope();
double scale;
if (escalaX < escalaY) {
scale = escalaX;
double newHeight = getHeight() / scale;
double newX = xCenter - (extent.getWidth() / 2.0);
double newY = yCenter - (newHeight / 2.0);
adjustedExtent = new Envelope(newX, newX + extent.getWidth(), newY, newY + newHeight);
} else {
scale = escalaY;
double newWidth = getWidth() / scale;
double newX = xCenter - (newWidth / 2.0);
double newY = yCenter - (extent.getHeight() / 2.0);
adjustedExtent = new Envelope(newX, newX + newWidth, newY, newY + extent.getHeight());
}
trans.setToIdentity();
trans.concatenate(AffineTransform.getScaleInstance(scale, -scale));
trans.concatenate(
AffineTransform.getTranslateInstance(
-adjustedExtent.getMinX(), -adjustedExtent.getMinY() - adjustedExtent.getHeight()));
} else {
adjustedExtent = new Envelope(extent);
trans.setToIdentity();
double scaleX = getWidth() / extent.getWidth();
double scaleY = getHeight() / extent.getHeight();
/** Map Y axis grows downward but CRS grows upward => -1 */
trans.concatenate(AffineTransform.getScaleInstance(scaleX, -scaleY));
trans.concatenate(
AffineTransform.getTranslateInstance(
-extent.getMinX(), -extent.getMinY() - extent.getHeight()));
}
try {
transInv = trans.createInverse();
} catch (NoninvertibleTransformException ex) {
transInv = null;
throw new RuntimeException(ex);
}
}
/**
* This adjusts the bounds by zooming out 2%, but also ensuring that the maximum bounds do not
* exceed the world bounding box
*
* <p>This only applies if the SRS is EPSG:4326 or EPSG:900913
*
* @param reqSRS the SRS
* @param bbox the current bounding box
* @return the adjusted bounding box
*/
private static Envelope adjustBounds(String reqSRS, Envelope bbox) {
if (reqSRS.equalsIgnoreCase("EPSG:4326")) {
bbox.expandBy(bbox.getWidth() / 100, bbox.getHeight() / 100);
Envelope maxEnv = new Envelope(-180.0, -90.0, 180.0, 90.0);
return bbox.intersection(maxEnv);
} else if (reqSRS.equalsIgnoreCase("EPSG:900913")) {
bbox.expandBy(bbox.getWidth() / 100, bbox.getHeight() / 100);
Envelope maxEnv = new Envelope(-20037508.33, -20037508.33, 20037508.33, 20037508.33);
return bbox.intersection(maxEnv);
}
return bbox;
}
/**
* Gets the scale denominator. If the scale is 1:1000 this method returns 1000. The scale is not
* absolutely precise and errors of 2% have been measured.
*
* @return
*/
public double getScaleDenominator() {
if (adjustedExtent.isNull()) {
return 0;
} else {
return adjustedExtent.getWidth() / getImageMeters();
}
}
public static double diagonalSize(Envelope env) {
if (env.isNull()) return 0.0;
double width = env.getWidth();
double hgt = env.getHeight();
return Math.sqrt(width * width + hgt * hgt);
}
/**
* Ajusta el tamaño de la ventana al envelope pasado como parámetro
*
* @param ctx
* @param newWrapperEnvelope
* @param viewport
*/
public static void resizeViewToEnvelope(
PlugInContext ctx, Envelope newWrapperEnvelope, IViewport viewport) {
// ajustamos las proporciones de la ventana a las de la feature
JInternalFrame activeInternalFrame = ctx.getActiveInternalFrame();
Dimension dimView = ((Dimension) ctx.getLayerViewPanel()).getSize();
Double widthView = dimView.getWidth();
Double heightView = dimView.getHeight();
int widthDiff = (int) (activeInternalFrame.getWidth() - widthView);
int heightDiff = (int) (activeInternalFrame.getHeight() - heightView);
Integer newWidth =
(int)
((newWrapperEnvelope.getWidth() / viewport.getEnvelopeInModelCoordinates().getWidth())
* widthView);
Integer newHeight =
(int)
((newWrapperEnvelope.getHeight() / viewport.getEnvelopeInModelCoordinates().getHeight())
* heightView);
Dimension newDimensionView = new Dimension(newWidth + widthDiff, newHeight + heightDiff);
activeInternalFrame.setSize(newDimensionView);
// zoom al envelope actual
try {
viewport.zoom(newWrapperEnvelope);
} catch (NoninvertibleTransformException e) {
log.warn("No se ha podido alcanzar el zoom " + newWrapperEnvelope);
}
}
/**
* Creates a elliptical arc, as a LineString.
*
* @return an elliptical arc
*/
public LineString createArc(double startAng, double endAng) {
Envelope env = dim.getEnvelope();
double xRadius = env.getWidth() / 2.0;
double yRadius = env.getHeight() / 2.0;
double centreX = env.getMinX() + xRadius;
double centreY = env.getMinY() + yRadius;
double angSize = (endAng - startAng);
if (angSize <= 0.0 || angSize > 2 * Math.PI) angSize = 2 * Math.PI;
double angInc = angSize / nPts;
Coordinate[] pts = new Coordinate[nPts];
int iPt = 0;
for (int i = 0; i < nPts; i++) {
double ang = startAng + i * angInc;
double x = xRadius * Math.cos(ang) + centreX;
double y = yRadius * Math.sin(ang) + centreY;
Coordinate pt = new Coordinate(x, y);
geomFact.getPrecisionModel().makePrecise(pt);
pts[iPt++] = pt;
}
LineString line = geomFact.createLineString(pts);
return line;
}
private void addEnv(@Nullable Bounded node) {
if (node == null) {
return;
}
Envelope env = envBuff;
env.setToNull();
node.expand(env);
if (env.isNull()) {
return;
}
if (isPoint(env)) {
points.add(env.getMinX(), env.getMinY());
} else if (isOrthoLine(env)) {
// handle the case where the envelope is given by an orthogonal line so we don't add a
// zero area polygon
double width = env.getWidth();
GrowableCoordinateSequence cs = new GrowableCoordinateSequence();
if (width == 0D) {
cs.add(env.getMinX(), env.getMinY());
cs.add(env.getMinX(), env.getMaxY());
} else {
cs.add(env.getMinX(), env.getMinY());
cs.add(env.getMaxX(), env.getMinY());
}
nonPoints.add(GEOM_FACTORY.createLineString(cs));
} else {
nonPoints.add(JTS.toGeometry(env, GEOM_FACTORY));
}
}
void matchAspect() {
/* Basic sinusoidal projection of lat/lon data to square pixels */
double yCenter = modelBounds.centre().y;
float xScale = cos(radians((float) yCenter));
double newX =
modelBounds.getHeight() * (1 / xScale) * ((float) this.getWidth() / this.getHeight());
modelBounds.expandBy((newX - modelBounds.getWidth()) / 2f, 0);
}
/** Compute the parameters need to create each cells */
private void initParameters() {
this.minX = envelope.getMinX();
this.minY = envelope.getMinY();
double cellWidth = envelope.getWidth();
double cellHeight = envelope.getHeight();
this.maxI = (int) Math.ceil(cellWidth / deltaX);
this.maxJ = (int) Math.ceil(cellHeight / deltaY);
}
public void testProducedRasterEnvelope() throws Exception {
DataSource ds = dsf.getDataSource("raster");
ds.open();
SpatialDataSourceDecorator sds = new SpatialDataSourceDecorator(ds);
Envelope env = sds.getFullExtent();
assertTrue(env.getWidth() > 0);
assertTrue(env.getHeight() > 0);
ds.close();
}
protected Shape getShape() {
if (zoomBoxEnd == null) return null;
Envelope envModel = getEnvelope();
Point2D base = toView(new Coordinate(envModel.getMinX(), envModel.getMaxY()));
double width = toView(envModel.getWidth());
double height = toView(envModel.getHeight());
return new Rectangle2D.Double(base.getX(), base.getY(), width, height);
}
/**
* @param li ImageLevelInfo object
* @param con JDBC Connection
* @return the resolution for li, based on a random chosen tile
* @throws SQLException
* @throws IOException
*/
protected double[] getPixelResolution(ImageLevelInfo li, Connection con)
throws SQLException, IOException {
double[] result = null;
String statementString = getRandomTileStatement(li);
PreparedStatement s = con.prepareStatement(statementString);
ResultSet r = s.executeQuery();
while (r.next()) {
byte[] tileBytes = getTileBytes(r);
if (tileBytes == null) {
continue;
}
BufferedImage buffImage = null;
li.setCanImageIOReadFromInputStream(true);
try {
buffImage = ImageIO.read(new ByteArrayInputStream(tileBytes));
} catch (IOException e) {
}
if (buffImage == null) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.warning(
"Image IO cannot read from ByteInputStream,use less efficient jai methods");
}
li.setCanImageIOReadFromInputStream(false);
SeekableStream stream = new ByteArraySeekableStream(tileBytes);
String decoderName = null;
for (String dn : ImageCodec.getDecoderNames(stream)) {
decoderName = dn;
break;
}
ImageDecoder decoder = ImageCodec.createImageDecoder(decoderName, stream, null);
PlanarImage img = PlanarImage.wrapRenderedImage(decoder.decodeAsRenderedImage());
buffImage = img.getAsBufferedImage();
}
Envelope env = getEnvelopeFromResultSet(r);
result =
new double[] {
env.getWidth() / buffImage.getWidth(), env.getHeight() / buffImage.getHeight()
};
break;
}
r.close();
s.close();
return result;
}
public void highlightVertex(Vertex v) {
Coordinate c = v.getCoordinate();
double xd = 0, yd = 0;
while (!modelBounds.contains(c)) {
xd = modelBounds.getWidth() / 100;
yd = modelBounds.getHeight() / 100;
modelBounds.expandBy(xd, yd);
}
modelBounds.expandBy(xd, yd);
highlightedVertex = v;
drawLevel = DRAW_ALL;
}
/*
* Zoom in/out. Translate the viewing window such that the place under the mouse pointer is a fixed point. If p is null, zoom around the center of
* the viewport.
*/
void zoom(double f, Point p) {
double ex = modelBounds.getWidth() * f;
double ey = modelBounds.getHeight() * f;
modelBounds.expandBy(ex / 2, ey / 2);
if (p != null) {
// Note: Graphics Y coordinates increase down the screen, hence the opposite signs.
double tx = ex * -((p.getX() / this.width) - 0.5);
double ty = ey * +((p.getY() / this.height) - 0.5);
modelBounds.translate(tx, ty);
}
// update the display
drawLevel = DRAW_PARTIAL;
}
public static int findZoomLevel(Envelope extent) {
double resolution = Math.max(extent.getWidth() / 256d, extent.getHeight() / 256d);
int i;
for (i = 1; i < TILE_RESOLUTIONS.length; i++) {
if (resolution > TILE_RESOLUTIONS[i]) {
i--;
break;
}
}
return i;
}
/**
* Determines the dimensions of the image to request, usually 1:1 to display, but sometimes more
* (too fuzzy) or less (image too large) when reprojecting.
*
* @param maxDimensions TODO
* @param viewport
* @param request
* @param context
* @return
* @throws RenderException
*/
public static Dimension calculateImageDimensions(
Dimension displaySize, Dimension maxDimensions, Envelope viewport, Envelope request)
throws RenderException {
double xScale = request.getWidth() / viewport.getWidth();
double yScale = request.getHeight() / viewport.getHeight();
// TODO: adjust height and width when we are reprojecting to make things less fuzzy
int width = (int) (xScale * displaySize.getWidth());
int height = (int) (yScale * displaySize.getHeight());
// ensure we don't exceed the dimensions the server will allow
int maxWidth = (int) maxDimensions.getWidth();
if ((maxWidth > 0) && (width > maxWidth)) {
width = maxWidth;
}
int maxHeight = (int) maxDimensions.getHeight();
if ((maxHeight > 0) && (height > maxHeight)) {
height = maxHeight;
}
WMSPlugin.trace(
"WMS request image dimensions: " + width + ", " + height); // $NON-NLS-1$ //$NON-NLS-2$
return new Dimension(width, height);
}
/**
* @param geom
* @param seq
*/
private boolean decimateOnEnvelope(Geometry geom, LiteCoordinateSequence seq) {
Envelope env = geom.getEnvelopeInternal();
if (env.getWidth() <= spanx && env.getHeight() <= spany) {
double[] coords = seq.getArray();
int dim = seq.getDimension();
double[] newcoords = new double[dim * 2];
for (int i = 0; i < dim; i++) {
newcoords[i] = coords[i];
newcoords[dim + i] = coords[coords.length - dim + i];
}
seq.setArray(coords);
return true;
}
return false;
}
/**
* Given a tiled request, builds a key that can be used to access the cache looking for a specific
* meta-tile, and also as a synchronization tool to avoid multiple requests to trigger parallel
* computation of the same meta-tile
*
* @param request
* @return
*/
public MetaTileKey getMetaTileKey(GetMapRequest request) {
String mapDefinition = buildMapDefinition(request.getHttpServletRequest());
Envelope bbox = request.getBbox();
Point2D origin = request.getTilesOrigin();
MapKey mapKey =
new MapKey(mapDefinition, normalize(bbox.getWidth() / request.getWidth()), origin);
Point tileCoords = getTileCoordinates(bbox, origin);
Point metaTileCoords = getMetaTileCoordinates(tileCoords);
Envelope metaTileEnvelope = getMetaTileEnvelope(request, tileCoords, metaTileCoords);
MetaTileKey key = new MetaTileKey(mapKey, metaTileCoords, metaTileEnvelope);
// since this will be used for thread synchronization, we have to make
// sure two thread asking for the same meta tile will get the same key
// object
return (MetaTileKey) metaTileKeys.unique(key);
}
public void testCropAll() throws Exception {
final Envelope rasterEnvelope = geoRasterSrc.getMetadata().getEnvelope();
final Rectangle2D cropRectangle =
new Rectangle2D.Double(
rasterEnvelope.getMinX(),
rasterEnvelope.getMinY(),
rasterEnvelope.getWidth(),
rasterEnvelope.getHeight());
geoRasterDst = geoRasterSrc.doOperation(new Crop(cropRectangle));
assertTrue(geoRasterDst.getWidth() > 0);
assertTrue(geoRasterDst.getHeight() > 0);
RasterMetadata dstMetadata = geoRasterDst.getMetadata();
RasterMetadata srcMetadata = geoRasterSrc.getMetadata();
assertTrue(dstMetadata.equals(srcMetadata));
}
private void displayCopiedFeatures(Envelope env) {
if (!getMap().getViewportModel().getBounds().intersects(env) && !env.isNull()
|| tooSmallOnScreen(env)) {
double d = env.getHeight() / 2;
double e = env.getWidth() / 2;
ViewportModel viewportModel = getMap().getViewportModelInternal();
viewportModel.eSetDeliver(false);
try {
viewportModel.setBounds(
env.getMinX() - e, env.getMaxX() + e,
env.getMinY() - d, env.getMaxY() + d);
} finally {
viewportModel.eSetDeliver(true);
}
}
}
public void fit() throws Exception {
MapContent generalMapContext = getGeneralMapContext();
Dimension size = getSize();
Envelope projectedBounds = generalMapContext.getMaxBounds();
double destWidth = projectedBounds.getWidth();
double destHeight = projectedBounds.getHeight();
Coordinate centre = projectedBounds.centre();
Point2D.Double screenLT = awtScreen2Cartesian(new Point(0, 0));
Point2D.Double screenBR = awtScreen2Cartesian(new Point(size.width, size.height));
double srcWidth = screenBR.x - screenLT.x;
double srcHeight = screenBR.y - screenLT.y;
double sx = srcWidth / destWidth;
double sy = srcHeight / destHeight;
double coef = Math.min(sx, sy);
coef = snapScale(coef);
scaleView(coef, coef, false);
Point2D.Double projectedScreenCenter = screen2Cartesian(new Point(0, 0));
translateView(projectedScreenCenter.x - centre.x, projectedScreenCenter.y - centre.y, true);
repaint();
}
public void mouseDragged(MouseEvent e) {
Point c = e.getPoint();
if (startDrag == null) {
startDrag = c;
dragX = c.x;
dragY = c.y;
}
double dx = dragX - c.x;
double dy = c.y - dragY;
if (ctrlPressed || mouseButton == RIGHT) {
zoom(dy * 0.01, startDrag);
} else {
double tx = modelBounds.getWidth() * dx / getWidth();
double ty = modelBounds.getHeight() * dy / getHeight();
modelBounds.translate(tx, ty);
}
dragX = c.x;
dragY = c.y;
drawLevel = DRAW_PARTIAL;
}
/**
* Sets the extent of the transformation. This extent is not used directly to calculate the
* transformation but is adjusted to obtain an extent with the same ratio than the image
*
* @param newExtent The new base extent.
*/
public void setExtent(Envelope newExtent) {
if ((newExtent != null) && ((newExtent.getWidth() == 0) || (newExtent.getHeight() == 0))) {
newExtent.expandBy(10);
}
Envelope oldExtent = this.extent;
boolean modified = true;
/* Set extent when Envelope is modified */
if (extent != null) {
if (extent.equals(newExtent)) {
modified = false;
}
}
if (modified) {
this.extent = newExtent;
calculateAffineTransform();
for (TransformListener listener : listeners) {
listener.extentChanged(oldExtent, this);
}
}
}
public void testCropPolygon() throws Exception {
Envelope rasterEnvelope = geoRasterSrc.getMetadata().getEnvelope();
final int bufferSize = (int) (rasterEnvelope.getWidth() / 2.3);
rasterEnvelope =
new Envelope(
new Coordinate(
rasterEnvelope.getMinX() + bufferSize, rasterEnvelope.getMinY() + bufferSize),
new Coordinate(
rasterEnvelope.getMaxX() - bufferSize, rasterEnvelope.getMaxY() - bufferSize));
final LinearRing polygon = (LinearRing) EnvelopeUtil.toGeometry(rasterEnvelope);
geoRasterSrc.save(tmpData + "1.tif");
geoRasterDst = geoRasterSrc.doOperation(new Crop(polygon));
geoRasterDst.save(tmpData + "2.png");
assertTrue(geoRasterDst.getWidth() > 0);
assertTrue(geoRasterDst.getHeight() > 0);
final ImagePlus srcImagePlus = geoRasterSrc.getImagePlus();
final ImagePlus dstImagePlus = geoRasterDst.getImagePlus();
checkCrop(geoRasterDst.getMetadata().getEnvelope(), srcImagePlus, dstImagePlus);
}
/**
* Creates a circular {@link Polygon}.
*
* @return a circle
*/
public Polygon createCircle() {
Envelope env = dim.getEnvelope();
double xRadius = env.getWidth() / 2.0;
double yRadius = env.getHeight() / 2.0;
double centreX = env.getMinX() + xRadius;
double centreY = env.getMinY() + yRadius;
Coordinate[] pts = new Coordinate[nPts + 1];
int iPt = 0;
for (int i = 0; i < nPts; i++) {
double ang = i * (2 * Math.PI / nPts);
double x = xRadius * Math.cos(ang) + centreX;
double y = yRadius * Math.sin(ang) + centreY;
Coordinate pt = new Coordinate(x, y);
pts[iPt++] = pt;
}
pts[iPt] = pts[0];
LinearRing ring = geomFact.createLinearRing(pts);
Polygon poly = geomFact.createPolygon(ring, null);
return poly;
}
public static Envelope expandToTile(Envelope extent) {
double resolution = Math.max(extent.getWidth() / 256d, extent.getHeight() / 256d);
int i = findZoomLevel(extent);
while (i > 0) {
resolution = TILE_RESOLUTIONS[i];
double tilelon = resolution * 256;
double tilelat = resolution * 256;
double lon0 = extent.getMinX() - WORLD_BOUNDS_WGS84.getMinX();
double lon1 = extent.getMaxX() - WORLD_BOUNDS_WGS84.getMinX();
int col0 = (int) Math.floor(lon0 / tilelon);
int col1 = (int) Math.floor((lon1 / tilelon) - 1E-9);
double lat0 = extent.getMinY() - WORLD_BOUNDS_WGS84.getMinY();
double lat1 = extent.getMaxY() - WORLD_BOUNDS_WGS84.getMinY();
int row0 = (int) Math.floor(lat0 / tilelat);
int row1 = (int) Math.floor((lat1 / tilelat) - 1E-9);
if ((col0 == col1) && (row0 == row1)) {
double tileoffsetlon = WORLD_BOUNDS_WGS84.getMinX() + (col0 * tilelon);
double tileoffsetlat = WORLD_BOUNDS_WGS84.getMinY() + (row0 * tilelat);
return new Envelope(
tileoffsetlon, tileoffsetlon + tilelon, tileoffsetlat, tileoffsetlat + tilelat);
} else {
i--;
}
}
return WORLD_BOUNDS_WGS84;
}
/*
* (non-Javadoc)
*
* @see org.geotools.gce.imagemosaic.jdbc.JDBCAccess#startTileDecoders(java.awt.Rectangle,
* org.geotools.geometry.GeneralEnvelope,
* org.geotools.gce.imagemosaic.jdbc.ImageLevelInfo,
* java.util.concurrent.LinkedBlockingQueue)
*/
public void startTileDecoders(
Rectangle pixelDimension,
GeneralEnvelope requestEnvelope,
ImageLevelInfo levelInfo,
LinkedBlockingQueue<TileQueueElement> tileQueue,
GridCoverageFactory coverageFactory)
throws IOException {
Date start = new Date();
Connection con = null;
List<ImageDecoderThread> threads = new ArrayList<ImageDecoderThread>();
ExecutorService pool = getExecutorServivicePool();
String statementString = getGridSelectStatement(levelInfo);
try {
con = dataSource.getConnection();
PreparedStatement s = con.prepareStatement(statementString);
setGridSelectParams(s, requestEnvelope, levelInfo);
ResultSet r = s.executeQuery();
while (r.next()) {
byte[] tileBytes = getTileBytes(r);
Envelope env = getEnvelopeFromResultSet(r);
String location = r.getString(config.getKeyAttributeNameInSpatialTable());
Rectangle2D tmp =
new Rectangle2D.Double(env.getMinX(), env.getMinY(), env.getWidth(), env.getHeight());
GeneralEnvelope tileGeneralEnvelope = new GeneralEnvelope(tmp);
tileGeneralEnvelope.setCoordinateReferenceSystem(
requestEnvelope.getCoordinateReferenceSystem());
ImageDecoderThread thread =
new ImageDecoderThread(
tileBytes,
location,
tileGeneralEnvelope,
pixelDimension,
requestEnvelope,
levelInfo,
tileQueue,
config);
// thread.start();
threads.add(thread);
pool.execute(thread);
}
;
r.close();
s.close();
// if (con.getAutoCommit() == false) {
// con.commit();
// }
con.close();
} catch (SQLException e) {
try {
// if (con.getAutoCommit() == false) {
// con.rollback();
// }
con.close();
} catch (SQLException e1) {
}
LOGGER.log(Level.SEVERE, e.getMessage(), e);
throw new IOException(e);
}
if (LOGGER.isLoggable(Level.INFO))
LOGGER.info(
"Getting "
+ threads.size()
+ " Tiles needs "
+ ((new Date()).getTime() - start.getTime())
+ " millisecs");
// wait for all threads dto finish and write end marker
pool.shutdown();
try {
pool.awaitTermination(3600, TimeUnit.SECONDS); // wait for one hour
} catch (InterruptedException e) {
throw new RuntimeException(e.getLocalizedMessage());
}
// for (AbstractThread thread : threads) {
// try {
// thread.join();
// } catch (InterruptedException e) {
// throw new RuntimeException(e.getLocalizedMessage());
// }
// }
tileQueue.add(TileQueueElement.ENDELEMENT);
if (LOGGER.isLoggable(Level.INFO))
LOGGER.info(
"Getting and decoding "
+ threads.size()
+ " Tiles needs "
+ ((new Date()).getTime() - start.getTime())
+ " millisecs");
}
