MultiPolygon reprojectRoiArea( CoordinateReferenceSystem maskCrs, CoordinateReferenceSystem resourceCrs, MultiPolygon roiArea) { try { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine("Mask layer CRS: " + maskCrs.getName()); } if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine("Resource CRS: " + resourceCrs.getName()); } if ((resourceCrs != null) && !CRS.equalsIgnoreMetadata(maskCrs, resourceCrs)) { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine("Mask and Resource CRS differ, ROI area will be reprojected"); } MathTransform mt = CRS.findMathTransform(maskCrs, resourceCrs, true); return (MultiPolygon) JTS.transform(roiArea, mt); } else { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine("Mask and Resource CRS coincide, no reprojection is necessary"); } } } catch (Exception e) { throw new RuntimeException( "Failed to reproject the restricted area to the layer's native SRS", e); } return roiArea; }
/** * Display the name of the coordinate reference system * * @param crs the CRS to display */ public void displayCRS(CoordinateReferenceSystem crs) { if (crs == null) { crsBtn.setText(stringRes.getString("crs_undefined")); } else { crsBtn.setText(crs.getName().toString()); } }
/** {@inheritDoc} */ @Override public CoordinateReferenceSystem getResponseCRS() throws FactoryException { if (output == null || output.getGridCRS() == null || output.getGridCRS().getSrsName() == null || output.getGridCRS().getSrsName().getValue() == null) { return null; } final CoordinateReferenceSystem objCrs = CRS.forCode(output.getGridCRS().getSrsName().getValue()); final BoundingBoxType boundingBox = domainSubset.getBoundingBox().getValue(); /* * If the bounding box contains at least 3 dimensions and the CRS specified is just * a 2D one, then we have to add a VerticalCRS to the one gotten by the crs decoding step. * Otherwise the CRS decoded is already fine, and we just return it. */ if (boundingBox.getDimensions().intValue() > 2 && objCrs.getCoordinateSystem().getDimension() < 3) { final VerticalCRS verticalCRS = CommonCRS.Vertical.ELLIPSOIDAL.crs(); return new GeodeticObjectBuilder() .addName(objCrs.getName().getCode() + " (3D)") .createCompoundCRS(objCrs, verticalCRS); } else { return objCrs; } }
/** {@inheritDoc} */ @Override public CoordinateReferenceSystem getCRS() throws FactoryException { if (domainSubset == null || domainSubset.getBoundingBox() == null) { return null; } final BoundingBoxType boundingBox = domainSubset.getBoundingBox().getValue(); final CoordinateReferenceSystem objCrs = AbstractCRS.castOrCopy(CRS.forCode(boundingBox.getCrs())) .forConvention(AxesConvention.RIGHT_HANDED); // final List<DirectPositionType> positions = // domainSubset.getSpatialSubSet().getEnvelope().getPos(); /* * If the bounding box contains at least 3 dimensions and the CRS specified is just * a 2D one, then we have to add a VerticalCRS to the one gotten by the crs decoding step. * Otherwise the CRS decoded is already fine, and we just return it. */ if (boundingBox.getUpperCorner().size() > 2 && objCrs.getCoordinateSystem().getDimension() < 3) { final VerticalCRS verticalCRS = CommonCRS.Vertical.ELLIPSOIDAL.crs(); return new GeodeticObjectBuilder() .addName(objCrs.getName().getCode() + " (3D)") .createCompoundCRS(objCrs, verticalCRS); } else { return objCrs; } }
void transformCoverage( final File sourceFile, final File file, final WcsReaderRequest targetRequest, final WcsReaderRequest executedRequest, final boolean handleFormatTranform) throws IOException { final CoordinateReferenceSystem original = targetRequest.responseCRS; CoordinateReferenceSystem actual = executedRequest.responseCRS; if (!CRS.equalsIgnoreMetadata(original, actual)) { try { LOG.info( "Need to reproject coverage from " + CRS.lookupIdentifier(actual, false) + " to " + CRS.lookupIdentifier(original, false)); } catch (FactoryException e) { LOG.info( "Need to reproject coverage from " + actual.getName() + " to " + original.getName()); } if (targetRequest.useCommandLineGDAL) { GDALCommandLine.gdalTransformation(sourceFile, file, executedRequest, targetRequest); } else { geotoolsTranformation(sourceFile, file, targetRequest, original); } LOG.info("Coverage reprojection/transformation complete"); } else if (handleFormatTranform) { if (targetRequest.useCommandLineGDAL) { GDALCommandLine.gdalTransformation(sourceFile, file, executedRequest, targetRequest); } else { // we need to re-implement convertFormat so it can handle non-world+image outputformats throw new UnsupportedOperationException( "We do not convert format from geotiff to another format yet in localReproject mode. Should be pretty easy to implement though"); } } else if (!sourceFile.equals(file)) { FileUtils.moveFile(sourceFile, file); } String name = file.getName().toLowerCase(); if (name.endsWith(".tif") || name.endsWith("tiff")) { // writeWorldImageExt(targetRequest, file); } }
/** * Convenience method for checking coordinate reference system validity. * * @param crs The coordinate reference system to check. * @param expected the dimension expected. * @throws MismatchedDimensionException if the CRS dimension is not valid. */ static void checkCoordinateReferenceSystemDimension( final CoordinateReferenceSystem crs, final int expected) throws MismatchedDimensionException { if (crs != null) { final int dimension = crs.getCoordinateSystem().getDimension(); if (dimension != expected) { throw new MismatchedDimensionException( Errors.format( ErrorKeys.MISMATCHED_DIMENSION_$3, crs.getName().getCode(), dimension, expected)); } } }
/** * Compara las proyecciones de la vista y la capa. En caso de ser diferentes pregunta por las * opciones a realizar. * * @param lyr * @param mapControl */ private void compareProjections(FLyrRasterSE lyr) { CoordinateReferenceSystem viewCrs = getMapControl().getCrs(); CoordinateReferenceSystem lyrCrs = lyr.readProjection(); if (lyrCrs == null) { lyr.setCrs(viewCrs); actionList.add(new Integer(defaultActionLayer)); return; } if (viewCrs == null) { getMapControl().setCrs(lyrCrs); actionList.add(new Integer(defaultActionLayer)); return; } /* * Si las proyecciones de vista y raster son distintas se lanza el * dialogo de selección de opciones. Este dialogo solo se lanza en caso * de que el checkbox de aplicar a todos los ficheros no haya sido * marcado. En este caso para el resto de ficheros de esa selección se * hará la misma acción que se hizo para el primero. */ if (!viewCrs.getName().equals(lyrCrs.getName())) { boolean showDialog = false; if (!RasterProjectionActionsPanel.selectAllFiles) showDialog = true; if (showDialog) { dialog = new RasterProjectionActionsDialog(lyr); } else { if (defaultActionLayer == FileOpenRaster.REPROJECT && !lyr.isReproyectable()) dialog = new RasterProjectionActionsDialog(lyr); } int select = defaultActionLayer; if (dialog != null) select = dialog.getRasterProjectionActionsPanel().getSelection(); actionList.add(new Integer(select)); return; } actionList.add(new Integer(defaultActionLayer)); }
/** * Transforms the referenced envelope to the specified coordinate reference system using the * specified amount of points. * * <p>This method can handle the case where the envelope contains the North or South pole, or when * it cross the ±180� longitude. * * @param targetCRS The target coordinate reference system. * @param lenient {@code true} if datum shift should be applied even if there is insuffisient * information. Otherwise (if {@code false}), an exception is thrown in such case. * @param numPointsForTransformation The number of points to use for sampling the envelope. * @return The transformed envelope. * @throws FactoryException if the math transform can't be determined. * @throws TransformException if at least one coordinate can't be transformed. * @see CRS#transform(CoordinateOperation, org.opengis.geometry.Envelope) * @since 2.3 */ public ReferencedEnvelope transform( final CoordinateReferenceSystem targetCRS, final boolean lenient, final int numPointsForTransformation) throws TransformException, FactoryException { if (crs == null) { if (isEmpty()) { // We don't have a CRS yet because we are still empty, being empty is // something we can represent in the targetCRS return new ReferencedEnvelope(targetCRS); } else { // really this is a the code that created this ReferencedEnvelope throw new NullPointerException( "Unable to transform referenced envelope, crs has not yet been provided."); } } if (getDimension() != targetCRS.getCoordinateSystem().getDimension()) { if (lenient) { return JTS.transformTo3D(this, targetCRS, lenient, numPointsForTransformation); } else { throw new MismatchedDimensionException( Errors.format( ErrorKeys.MISMATCHED_DIMENSION_$3, crs.getName().getCode(), new Integer(getDimension()), new Integer(targetCRS.getCoordinateSystem().getDimension()))); } } /* * Gets a first estimation using an algorithm capable to take singularity in account * (North pole, South pole, 180� longitude). We will expand this initial box later. */ CoordinateOperationFactory coordinateOperationFactory = CRS.getCoordinateOperationFactory(lenient); final CoordinateOperation operation = coordinateOperationFactory.createOperation(crs, targetCRS); final GeneralEnvelope transformed = CRS.transform(operation, this); transformed.setCoordinateReferenceSystem(targetCRS); /* * Now expands the box using the usual utility methods. */ final ReferencedEnvelope target = new ReferencedEnvelope(transformed); final MathTransform transform = operation.getMathTransform(); JTS.transform(this, target, transform, numPointsForTransformation); return target; }
/** * Convenience method for checking coordinate reference system validity. * * @throws IllegalArgumentException if the CRS dimension is not valid. */ protected void checkCoordinateReferenceSystemDimension() throws MismatchedDimensionException { if (crs != null) { final int expected = getDimension(); final int dimension = crs.getCoordinateSystem().getDimension(); if (dimension > expected) { // check dimensions and choose ReferencedEnvelope or ReferencedEnvelope3D // or the factory method ReferencedEnvelope.reference( CoordinateReferenceSystem ) throw new MismatchedDimensionException( Errors.format( ErrorKeys.MISMATCHED_DIMENSION_$3, crs.getName().getCode(), new Integer(dimension), new Integer(expected))); } } }
public synchronized void render( Graphics2D destination, ReferencedEnvelope bounds, IProgressMonitor monitor) throws RenderException { int endLayerStatus = ILayer.DONE; try { if (bounds == null || bounds.isNull()) { bounds = getContext().getImageBounds(); } if (monitor.isCanceled()) return; getContext().setStatus(ILayer.WAIT); WebMapServer wms = getWMS(); GetMapRequest request = wms.createGetMapRequest(); // put in default exception format we understand as a client // (if suppoted by the server) WMSCapabilities capabilities = wms.getCapabilities(); if (capabilities .getRequest() .getGetMap() .getFormats() .contains(GetMapRequest.EXCEPTION_XML)) { request.setExceptions(GetMapRequest.EXCEPTION_XML); } setImageFormat(wms, request); if (monitor.isCanceled()) return; double currScale = getContext().getViewportModel().getScaleDenominator(); List<ILayer> layers = getLayers(); for (int i = layers.size() - 1; i >= 0; i--) { ILayer ilayer = layers.get(i); Layer layer; double minScale = 0; double maxScale = Double.MAX_VALUE; layer = ilayer.getResource(org.geotools.data.ows.Layer.class, null); // check if there are min/max scale rules StyleBlackboard sb = (StyleBlackboard) ilayer.getStyleBlackboard(); Style style = (Style) sb.lookup(Style.class); if (style != null) { Rule rule = style.getFeatureTypeStyles()[0].getRules()[0]; minScale = rule.getMinScaleDenominator(); maxScale = rule.getMaxScaleDenominator(); } if (currScale >= minScale && currScale <= maxScale) { // check for a wms style StyleImpl wmsStyle = (StyleImpl) ilayer.getStyleBlackboard().get(WMSStyleContent.WMSSTYLE); if (wmsStyle != null) { request.addLayer(layer, wmsStyle); } else { request.addLayer(layer); } } } if (monitor.isCanceled()) return; List<Layer> wmsLayers = getWMSLayers(); if (wmsLayers == null || wmsLayers.isEmpty()) { endLayerStatus = ILayer.WARNING; return; } // figure out request CRS String requestCRScode = findRequestCRS(wmsLayers, getViewportCRS(), getContext().getMap()); // TODO: make findRequestCRS more efficient (we are running CRS.decode at *least* twice) CoordinateReferenceSystem requestCRS = CRS.decode(requestCRScode); // figure out viewport // ReferencedEnvelope viewport; // Envelope viewportBBox = getViewportBBox(); // CoordinateReferenceSystem viewportCRS = getViewportCRS(); // if (viewportBBox == null) { // // change viewport to world // viewportBBox = new Envelope(-180, 180, -90, 90); // if (!DefaultGeographicCRS.WGS84.equals(viewportCRS)) { // reproject // viewport = new ReferencedEnvelope(viewportBBox, // DefaultGeographicCRS.WGS84); // viewportBBox = viewport.transform(viewportCRS, true); // } // } ReferencedEnvelope requestBBox = null; Envelope backprojectedBBox = null; // request bbox projected to the viewport crs // viewport = new ReferencedEnvelope(viewportBBox, viewportCRS); // requestBBox = calculateRequestBBox(wmsLayers, viewport, requestCRS); requestBBox = calculateRequestBBox(wmsLayers, bounds, requestCRS, capabilities.getVersion()); // check that a request is needed (not out of a bounds, invalid, etc) if (requestBBox == NILL_BOX) { endLayerStatus = ILayer.WARNING; return; } assert requestBBox.getCoordinateReferenceSystem().equals(requestCRS); if (requestBBox.getCoordinateReferenceSystem().equals(getViewportCRS())) { backprojectedBBox = (Envelope) requestBBox; } else { backprojectedBBox = (Envelope) requestBBox.transform(getViewportCRS(), true); } if (WMSPlugin.isDebugging(Trace.RENDER)) { WMSPlugin.trace("Viewport CRS: " + getViewportCRS().getName()); // $NON-NLS-1$ WMSPlugin.trace("Request CRS: " + requestCRS.getName()); // $NON-NLS-1$ WMSPlugin.trace("Context Image bounds: " + getContext().getImageBounds()); // $NON-NLS-1$ WMSPlugin.trace("Request BBox bounds: " + requestBBox); // $NON-NLS-1$ WMSPlugin.trace("Backprojected request bounds: " + backprojectedBBox); // $NON-NLS-1$ } Service wmsService = capabilities.getService(); Dimension maxDimensions = new Dimension(wmsService.getMaxWidth(), wmsService.getMaxHeight()); // Dimension imageDimensions = // calculateImageDimensions(getContext().getMapDisplay() // .getDisplaySize(), maxDimensions, getViewportBBox(), backprojectedBBox); Dimension imageDimensions = calculateImageDimensions( getContext().getImageSize(), maxDimensions, bounds, backprojectedBBox); if (imageDimensions.height < 1 || imageDimensions.width < 1) { endLayerStatus = ILayer.WARNING; return; } request.setDimensions( imageDimensions.width + "", imageDimensions.height + ""); // $NON-NLS-1$ //$NON-NLS-2$ // epsg could be under identifiers or authority. Set<ReferenceIdentifier> identifiers = requestCRS.getIdentifiers(); String srs = identifiers.isEmpty() ? EPSG_4326 : identifiers.iterator().next().toString(); request.setSRS(srs); // EPSG_4326 request.setBBox(requestBBox); // request.setBBox(requestBBox.getMinX() + "," + requestBBox.getMinY()+ "," + // requestBBox.getMaxX()+ "," + requestBBox.getMaxY()); if (monitor.isCanceled()) return; setFilter(wms, request); // request.setProperty("DACS_ACS", null); BufferedImage image = readImage(wms, request, monitor); if (monitor.isCanceled()) return; if (image == null) { Exception e = new RuntimeException(Messages.BasicWMSRenderer2_unable_to_decode_image); throw wrapException(e); } // backprojectedBBox or viewportBBox renderGridCoverage(destination, backprojectedBBox, imageDimensions, requestBBox, image); } catch (Exception e) { if (e instanceof RenderException) throw (RenderException) e; throw new RenderException(e); } finally { getContext().setStatus(endLayerStatus); if (endLayerStatus == ILayer.DONE) { // clear the status message (rendering was successful) getContext().setStatusMessage(null); } } }
/** * Applies a crop operation to a coverage. * * @see * org.geotools.coverage.processing.AbstractOperation#doOperation(org.opengis.parameter.ParameterValueGroup, * org.geotools.factory.Hints) */ @SuppressWarnings("unchecked") public Coverage doOperation(ParameterValueGroup parameters, Hints hints) { final Geometry cropRoi; // extracted from parameters GeneralEnvelope cropEnvelope = null; // extracted from parameters final GridCoverage2D source; // extracted from parameters final double roiTolerance = parameters.parameter(Crop.PARAMNAME_ROITOLERANCE).doubleValue(); final boolean forceMosaic = parameters.parameter(Crop.PARAMNAME_FORCEMOSAIC).booleanValue(); // ///////////////////////////////////////////////////////////////////// // // Assigning and checking input parameters // // /////////////////////////////////////////////////////////////////// // source coverage final ParameterValue sourceParameter = parameters.parameter("Source"); if (sourceParameter == null || !(sourceParameter.getValue() instanceof GridCoverage2D)) { throw new CannotCropException( Errors.format(ErrorKeys.NULL_PARAMETER_$2, "Source", GridCoverage2D.class.toString())); } source = (GridCoverage2D) sourceParameter.getValue(); // Check Envelope and ROI existence - we need at least one of them final ParameterValue envelopeParameter = parameters.parameter(PARAMNAME_ENVELOPE); final ParameterValue roiParameter = parameters.parameter(PARAMNAME_ROI); if ((envelopeParameter == null || envelopeParameter.getValue() == null) && (roiParameter == null || roiParameter.getValue() == null)) throw new CannotCropException( Errors.format( ErrorKeys.NULL_PARAMETER_$2, PARAMNAME_ENVELOPE, GeneralEnvelope.class.toString())); Object envelope = envelopeParameter.getValue(); if (envelope != null) { if (envelope instanceof GeneralEnvelope) { cropEnvelope = (GeneralEnvelope) envelope; } else if (envelope instanceof Envelope) { cropEnvelope = new GeneralEnvelope((Envelope) envelope); } } // may be null // Check crop ROI try { cropRoi = IntersectUtils.unrollGeometries( (Geometry) roiParameter.getValue()); // may throw if format not correct } catch (IllegalArgumentException ex) { throw new CannotCropException( Errors.format(ErrorKeys.ILLEGAL_ARGUMENT_$2, PARAMNAME_ROI, ex.getMessage()), ex); } // Setting a GeneralEnvelope from ROI if needed if (cropRoi != null && cropEnvelope == null) { Envelope e2d = JTS.getEnvelope2D(cropRoi.getEnvelopeInternal(), source.getCoordinateReferenceSystem()); cropEnvelope = new GeneralEnvelope(e2d); } // ///////////////////////////////////////////////////////////////////// // // Initialization // // We take the crop envelope and the source envelope then we check their // crs and we also check if they ever overlap. // // ///////////////////////////////////////////////////////////////////// // envelope of the source coverage final Envelope2D sourceEnvelope = source.getEnvelope2D(); // crop envelope Envelope2D destinationEnvelope = new Envelope2D(cropEnvelope); CoordinateReferenceSystem sourceCRS = sourceEnvelope.getCoordinateReferenceSystem(); CoordinateReferenceSystem destinationCRS = destinationEnvelope.getCoordinateReferenceSystem(); if (destinationCRS == null) { // Do not change the user provided object - clone it first. final Envelope2D ge = new Envelope2D(destinationEnvelope); destinationCRS = source.getCoordinateReferenceSystem2D(); ge.setCoordinateReferenceSystem(destinationCRS); destinationEnvelope = ge; } // // // // Source and destination crs must be equals // // // if (!CRS.equalsIgnoreMetadata(sourceCRS, destinationCRS)) { throw new CannotCropException( Errors.format( ErrorKeys.MISMATCHED_ENVELOPE_CRS_$2, sourceCRS.getName().getCode(), destinationCRS.getName().getCode())); } if (cropRoi != null) { // TODO: check ROI SRID } // // // // Check the intersection and, if needed, do the crop operation. // // // final GeneralEnvelope intersectionEnvelope = new GeneralEnvelope((Envelope) destinationEnvelope); intersectionEnvelope.setCoordinateReferenceSystem(source.getCoordinateReferenceSystem()); // intersect the envelopes intersectionEnvelope.intersect(sourceEnvelope); if (intersectionEnvelope.isEmpty()) throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP)); // intersect the ROI with the intersection envelope and throw an error if they do not intersect if (cropRoi != null) { final Geometry jis = JTS.toGeometry( (com.vividsolutions.jts.geom.Envelope) new ReferencedEnvelope(intersectionEnvelope)); if (!IntersectUtils.intersects(cropRoi, jis)) throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP)); } // // // // Get the grid-to-world transform by keeping into account translation // of grid geometry constructor for respecting OGC PIXEL-IS-CENTER // ImageDatum assumption. // // // final AffineTransform sourceCornerGridToWorld = (AffineTransform) ((GridGeometry2D) source.getGridGeometry()).getGridToCRS(PixelInCell.CELL_CORNER); // // // // I set the tolerance as half the scale factor of the grid-to-world // transform. This should more or less means in most cases "don't bother // to crop if the new envelope is as close to the old one that we go // deep under pixel size." // // // final double tolerance = XAffineTransform.getScale(sourceCornerGridToWorld); if (cropRoi != null || !intersectionEnvelope.equals(sourceEnvelope, tolerance / 2.0, false)) { cropEnvelope = intersectionEnvelope.clone(); return buildResult( cropEnvelope, cropRoi, roiTolerance, forceMosaic, (hints instanceof Hints) ? (Hints) hints : new Hints(hints), source, sourceCornerGridToWorld); } else { // // // // Note that in case we don't crop at all, WE DO NOT UPDATE the // envelope. If we did we might end up doing multiple successive // crop without actually cropping the image but, still, we would // shrink the envelope each time. Just think about having a loop // that crops recursively the same coverage specifying each time an // envelope whose URC is only a a scale quarter close to the LLC of // the old one. We would never crop the raster but we would modify // the grid-to-world transform each time. // // // return source; } }
public boolean extractTiffMetadata(File tifFile, TiffMeta surface) throws UnknownCRSException, FactoryException, TransformException, IOException { Preconditions.checkArgument(tifFile != null, "File is null."); GeoTiffReader gtr = new GeoTiffReader(tifFile); try { CoordinateReferenceSystem crs = gtr.getCoordinateReferenceSystem(); surface.setCRS(crs); Integer epsgCode = CRS.lookupEpsgCode(crs, true); if (epsgCode == null) { ReferenceIdentifier name = crs.getName(); String crsName = "Unknown"; if (name != null) { crsName = name.toString(); } throw new UnknownCRSException(crsName); } String srid = "EPSG:" + epsgCode; surface.setSrid(srid); // // extremaOp(surface, gtr.read(null)); /* * Build the envelope and set to WGS84 */ GeneralEnvelope origEnv = gtr.getOriginalEnvelope(); DirectPosition ll = origEnv.getLowerCorner(); DirectPosition ur = origEnv.getUpperCorner(); Envelope e = new Envelope(); e.expandToInclude(ll.getOrdinate(0), ll.getOrdinate(1)); e.expandToInclude(ur.getOrdinate(0), ur.getOrdinate(1)); Geometry poly = envelopeToWgs84(epsgCode, e); if (poly instanceof Polygon) { surface.setEnvelope((Polygon) poly); } /* * Figure out the pixel size */ ImageLayout imageLayout = gtr.getImageLayout(); int imageWidth = imageLayout.getWidth(null); int imageHeight = imageLayout.getHeight(null); double pixelSizeX = e.getWidth() / imageWidth; double pixelSizeY = e.getHeight() / imageHeight; surface.setPixelSizeX(pixelSizeX); surface.setPixelSizeY(pixelSizeY); surface.setMinVal(0d); surface.setMaxVal(100d); GridCoverage2D gridCoverage2D = gtr.read(null); try { int nDims = gridCoverage2D.getNumSampleDimensions(); surface.setNumSampleDimensions(nDims); extremaOp(surface, gridCoverage2D); } finally { gridCoverage2D.dispose(false); } } finally { gtr.dispose(); } return true; }
/** * Writes the systems byte order to the out stream. In java only high byte first. * * @param out the stream to write to * @param rasterDataNode */ private static void writeMapProjectionInfo(PrintWriter out, RasterDataNode rasterDataNode) { Product product = rasterDataNode.getProduct(); if (product == null) { return; } String mapProjectionName = "Arbitrary"; String mapUnits = "Meters"; double referencePixelX = 0, referencePixelY = 0; double easting = 0, northing = 0; double pixelSizeX = 0, pixelSizeY = 0; String datumName = ""; int utmZone = -1; String utmHemisphere = ""; MapProjection mapProjection = null; if (product.getGeoCoding() instanceof CrsGeoCoding) { final CrsGeoCoding crsGeoCoding = (CrsGeoCoding) product.getGeoCoding(); final CoordinateReferenceSystem crs = crsGeoCoding.getMapCRS(); final ImageGeometry imgGeom = ImageGeometry.createTargetGeometry( product, crs, null, null, null, null, null, null, null, null, null); final String crsName = crs.getName().toString().toUpperCase(); if (crsName.equals("WGS84(DD)")) { mapProjectionName = "Geographic Lat/Lon"; mapUnits = "Degrees"; } else if (crsName.contains("UTM")) { mapProjectionName = "UTM"; String zoneStr = crsName.substring(crsName.indexOf("ZONE") + 5, crsName.length()).trim(); int i = 0; String zoneNumStr = ""; while (Character.isDigit(zoneStr.charAt(i))) { zoneNumStr += zoneStr.charAt(i++); } utmZone = Integer.parseInt(zoneNumStr); GeoPos centrePos = crsGeoCoding.getGeoPos( new PixelPos(product.getSceneRasterWidth() / 2, product.getSceneRasterHeight() / 2), null); utmHemisphere = centrePos.getLat() > 0 ? "North" : "South"; } referencePixelX = imgGeom.getReferencePixelX(); referencePixelY = imgGeom.getReferencePixelY(); easting = imgGeom.getEasting(); northing = imgGeom.getNorthing(); pixelSizeX = imgGeom.getPixelSizeX(); pixelSizeY = imgGeom.getPixelSizeY(); datumName = crsGeoCoding.getDatum().getName(); } else if (product.getGeoCoding() instanceof MapGeoCoding) { final MapGeoCoding mapGeoCoding = (MapGeoCoding) product.getGeoCoding(); final MapInfo info = mapGeoCoding.getMapInfo(); if (info == null) { return; } mapProjection = info.getMapProjection(); if (mapProjection instanceof UTMProjection) { mapProjectionName = "UTM"; final UTMProjection utmProjection = (UTMProjection) mapProjection; utmZone = utmProjection.getZone(); utmHemisphere = utmProjection.isNorth() ? "North" : "South"; } else if (mapProjection.isPreDefined()) { mapProjectionName = mapProjection.getName(); } if ("meter".equals(mapProjection.getMapUnit())) { mapUnits = "Meters"; } else if ("degree".equals(mapProjection.getMapUnit())) { mapUnits = "Degrees"; } else { mapUnits = mapProjection.getMapUnit(); } datumName = mapGeoCoding.getDatum().getName(); } else { return; } out.print(_enviMapInfo); out.print(" = {"); out.print(mapProjectionName); out.print(","); out.print(referencePixelX + 1.0f); out.print(","); out.print(referencePixelY + 1.0f); out.print(","); out.print(easting); out.print(","); out.print(northing); out.print(","); out.print(pixelSizeX); out.print(","); out.print(pixelSizeY); out.print(","); if (utmZone != -1) { out.print(utmZone); out.print(","); out.print(utmHemisphere); out.print(","); } out.print(datumName); out.print(","); out.print("units=" + mapUnits); out.print("}"); out.println(); if (mapProjection != null && !mapProjection.isPreDefined()) { final MapTransform mapTransform = mapProjection.getMapTransform(); final double[] parameterValues = mapTransform.getParameterValues(); final String transformName = mapTransform.getDescriptor().getName(); out.print(_enviProjectionInfo); out.print(" = {"); if (transformName.equals(TransverseMercatorDescriptor.NAME)) { out.print(3); out.print(","); out.print(parameterValues[0]); // semi_major (meters) out.print(","); out.print(parameterValues[1]); // semi_minor (meters) out.print(","); out.print(parameterValues[2]); // latitude_of_origin (degree) out.print(","); out.print(parameterValues[3]); // central_meridian (degree) out.print(","); out.print(parameterValues[5]); // false_easting (meters) out.print(","); out.print(parameterValues[6]); // false_northing (meters) out.print(","); out.print(parameterValues[4]); // scaling_factor (no unit) out.print(","); } else if (transformName.equals(LambertConformalConicDescriptor.NAME)) { out.print(4); out.print(","); out.print(parameterValues[0]); // semi_major (meters) out.print(","); out.print(parameterValues[1]); // semi_minor (meters) out.print(","); out.print(parameterValues[2]); // latitude_of_origin (degree) out.print(","); out.print(parameterValues[3]); // central_meridian (degree) out.print(","); out.print(0.0); // false_easting (meters) out.print(","); out.print(0.0); // false_northing (meters) out.print(","); out.print(parameterValues[4]); // latitude_of_intersection_1 (meters) out.print(","); out.print(parameterValues[5]); // latitude_of_intersection_2 (meters) out.print(","); } out.print(mapProjectionName); out.print(","); out.print("units=" + mapUnits); out.print("}"); out.println(); } }
public ReferenceIdentifier getName() { return base.getName(); }