Tabnine Logo
CRS
Code IndexAdd Tabnine to your IDE (free)

How to use
CRS
in
org.geotools.referencing

Best Java code snippets using org.geotools.referencing.CRS (Showing top 20 results out of 2,277)

Refine searchRefine arrow

  • ReferencedEnvelope
  • GeneralEnvelope
  • MathTransform
  • GridCoverage2D
  • CoordinateReferenceSystem
  • GridGeometry2D
  • GeoTiffReader
  • GridEnvelope
  • CoordinateSystem
  • FileUtils
origin: geoserver/geoserver

@Test
public void testLatLonBounds() throws Exception {
  ReferencedEnvelope nativeBounds =
      new ReferencedEnvelope(700000, 800000, 4000000, 4100000, null);
  CoordinateReferenceSystem crs = CRS.decode("EPSG:32632", true);
  CatalogBuilder cb = new CatalogBuilder(getCatalog());
  ReferencedEnvelope re = cb.getLatLonBounds(nativeBounds, crs);
  assertEquals(DefaultGeographicCRS.WGS84, re.getCoordinateReferenceSystem());
  assertEquals(11.22, re.getMinX(), 0.01);
  assertEquals(36.1, re.getMinY(), 0.01);
}
origin: geoserver/geoserver

/**
 * Test method for {@link CoordinateOperationFactoryUsingWKT#createCoordinateOperation}.
 *
 * @throws TransformException
 */
@Test
public void testCreateOperationFromCustomCodes() throws Exception {
  // Test CRSs
  CoordinateReferenceSystem source = CRS.decode(SOURCE_CRS);
  CoordinateReferenceSystem target = CRS.decode(TARGET_CRS);
  MathTransform mt = CRS.findMathTransform(source, target, true);
  // Test MathTransform
  double[] p = new double[2];
  mt.transform(SRC_TEST_POINT, 0, p, 0, 1);
  assertEquals(p[0], DST_TEST_POINT[0], 1e-8);
  assertEquals(p[1], DST_TEST_POINT[1], 1e-8);
}
origin: geoserver/geoserver

/**
 * Computes the geographic bounds of a {@link ResourceInfo} by reprojecting the available native
 * bounds
 *
 * @param rinfo
 * @return the geographic bounds, or null if the native bounds are not available
 * @throws IOException
 */
public ReferencedEnvelope getLatLonBounds(
    ReferencedEnvelope nativeBounds, CoordinateReferenceSystem declaredCRS)
    throws IOException {
  if (nativeBounds != null && declaredCRS != null) {
    // make sure we use the declared CRS, not the native one, the may differ
    if (!CRS.equalsIgnoreMetadata(DefaultGeographicCRS.WGS84, declaredCRS)) {
      // transform
      try {
        ReferencedEnvelope bounds =
            new ReferencedEnvelope(nativeBounds, CRS.getHorizontalCRS(declaredCRS));
        return bounds.transform(DefaultGeographicCRS.WGS84, true);
      } catch (Exception e) {
        throw (IOException) new IOException("transform error").initCause(e);
      }
    } else {
      return new ReferencedEnvelope(nativeBounds, DefaultGeographicCRS.WGS84);
    }
  }
  return null;
}
origin: geoserver/geoserver

  @Override
  public Object fromString(String str) {
    if (str.toUpperCase().startsWith("EPSG:")) {
      try {
        return CRS.decode(str);
      } catch (Exception e) {
        XStreamPersister.LOGGER.log(Level.WARNING, "Error decode epsg code: " + str, e);
      }
    } else {
      try {
        return CRS.parseWKT(str);
      } catch (FactoryException e) {
        XStreamPersister.LOGGER.log(Level.WARNING, "Error decode wkt: " + str, e);
      }
    }
    return null;
  }
}
origin: geoserver/geoserver

final CoordinateReferenceSystem sourceCRS = envelope.getCoordinateReferenceSystem();
if (CRS.equalsIgnoreMetadata(sourceCRS, DefaultGeographicCRS.WGS84)) {
  return new GeneralEnvelope(envelope);
if (!CRS.equalsIgnoreMetadata(sourceCRS, targetCRS)) {
  targetEnvelope = CRS.transform(envelope, targetCRS);
} else {
  targetEnvelope = new GeneralEnvelope(envelope);
origin: org.geoserver/gs-wcs2_0

@Test
public void testBasic() throws Exception {
  final File xml =
      new File("./src/test/resources/rangesubset/requestGetCoverageRangeSubsetting.xml");
  final String request = FileUtils.readFileToString(xml);
  MockHttpServletResponse response = postAsServletResponse("wcs", request);
  assertEquals("image/tiff", response.getContentType());
  byte[] tiffContents = getBinary(response);
  File file = File.createTempFile("bm_gtiff", "bm_gtiff.tiff", new File("./target"));
  FileUtils.writeByteArrayToFile(file, tiffContents);
  final GeoTiffReader reader = new GeoTiffReader(file);
  assertTrue(
      CRS.equalsIgnoreMetadata(
          reader.getCoordinateReferenceSystem(), CRS.decode("EPSG:4326", true)));
  assertEquals(360, reader.getOriginalGridRange().getSpan(0));
  assertEquals(360, reader.getOriginalGridRange().getSpan(1));
  final GridCoverage2D coverage = reader.read(null);
  assertEquals(1, coverage.getSampleDimensions().length);
  GridCoverage2D sourceCoverage =
      (GridCoverage2D)
          this.getCatalog()
              .getCoverageByName("BlueMarble")
              .getGridCoverageReader(null, null)
              .read(null);
  assertEnvelopeEquals(sourceCoverage, coverage);
  reader.dispose();
  scheduleForCleaning(coverage);
  scheduleForCleaning(sourceCoverage);
}
origin: geotools/geotools

final CoordinateReferenceSystem sourceCRS = sourceCoverage.getCoordinateReferenceSystem();
if (targetCRS == null) {
  if (targetGG != null && targetGG.isDefined(GridGeometry2D.CRS_BITMASK)) {
    if (!CRS.equalsIgnoreMetadata(targetCRS, targetGGCRS)
        && !CRS.findMathTransform(targetCRS, targetGGCRS).isIdentity()) {
      throw new IllegalArgumentException(
          Errors.format(
  return targetCoverage;
if (CRS.equalsIgnoreMetadata(sourceCRS, targetCRS)) {
      gridRange = CRS.transform(allSteps.inverse(), gridRange);
  targetEnvelope = CRS.transform(operation, sourceEnvelope);
  targetEnvelope.setCoordinateReferenceSystem(targetCRS);
      GeneralEnvelope gridRange = CRS.transform(step1.inverse(), targetEnvelope);
        case DataBuffer.TYPE_FLOAT:
            Envelope source = CRS.transform(sourceGG.getEnvelope(), targetCRS);
            Envelope target = CRS.transform(targetGG.getEnvelope(), targetCRS);
assert CRS.equalsIgnoreMetadata(targetCoverage.getCoordinateReferenceSystem(), targetCRS)
origin: geotools/geotools

/** Tests {@link CRS#getHorizontalCRS} from a Geographic 3D CR. */
public void testHorizontalFromGeodetic() throws FactoryException {
  // retrives "WGS 84 (geographic 3D)"
  CoordinateReferenceSystem compound = CRS.decode("EPSG:4327");
  CoordinateReferenceSystem horizontal = CRS.getHorizontalCRS(compound);
  // the horizonal version is basically 4326, but it won't compare positively
  // with 4326, not even using CRS.equalsIgnoreMetadata(), so we check the axis directly
  CoordinateSystem cs = horizontal.getCoordinateSystem();
  assertEquals(2, cs.getDimension());
  assertEquals(AxisDirection.NORTH, cs.getAxis(0).getDirection());
  assertEquals(AxisDirection.EAST, cs.getAxis(1).getDirection());
}
origin: geotools/geotools

    ImageUtilities.getReferencedEnvelopeFromGeographicBoundingBox(
        new GeographicBoundingBoxImpl(coverageEnvelope));
coverageGeographicCRS2D = coverageGeographicBBox.getCoordinateReferenceSystem();
coverageCRS2D = CRS.getHorizontalCRS(coverageCRS);
assert coverageCRS2D.getCoordinateSystem().getDimension() == 2;
if (coverageCRS.getCoordinateSystem().getDimension() != 2) {
  final MathTransform transform =
      CRS.findMathTransform(
          coverageCRS, (CoordinateReferenceSystem) coverageCRS2D);
  final GeneralEnvelope bbox = CRS.transform(transform, coverageEnvelope);
  bbox.setCoordinateReferenceSystem(coverageCRS2D);
  coverageBBox = new ReferencedEnvelope(bbox);
} else {
  coverageBBox = new ReferencedEnvelope(coverageEnvelope);
origin: geotools/geotools

    (GridCoverage2DReader) GRID_PROPERTY_NAME.evaluate(gridWrapper);
if (CRS.equalsIgnoreMetadata(
    reader.getCoordinateReferenceSystem(),
    gridGeometry.getCoordinateReferenceSystem())) {
          gridGeometry.getEnvelope();
      GeneralEnvelope transformed =
          org.geotools.referencing.CRS.transform(
              atOriginal.inverse(), worldEnvelope);
      int minx = (int) Math.floor(transformed.getMinimum(0));
      int miny = (int) Math.floor(transformed.getMinimum(1));
      int maxx = (int) Math.ceil(transformed.getMaximum(0));
      int maxy = (int) Math.ceil(transformed.getMaximum(1));
      Rectangle rect =
      new ReferencedEnvelope(readGG.getEnvelope());
  CoordinateReferenceSystem coverageCRS =
      coverage.getCoordinateReferenceSystem2D();
  if (!CRS.equalsIgnoreMetadata(
      renderingEnvelope.getCoordinateReferenceSystem(), coverageCRS)) {
    renderingEnvelope = renderingEnvelope.transform(coverageCRS, true);
  if (coverage.getEnvelope2D().intersects(renderingEnvelope)) {
origin: geotools/geotools

    cropEnvelope = (GeneralEnvelope) envelope;
  } else if (envelope instanceof Envelope) {
    cropEnvelope = new GeneralEnvelope((Envelope) envelope);
  Envelope e2d =
      JTS.getEnvelope2D(
          cropRoi.getEnvelopeInternal(), source.getCoordinateReferenceSystem());
  cropEnvelope = new GeneralEnvelope(e2d);
final Envelope2D sourceEnvelope = source.getEnvelope2D();
  destinationCRS = source.getCoordinateReferenceSystem2D();
  ge.setCoordinateReferenceSystem(destinationCRS);
  destinationEnvelope = ge;
if (!CRS.equalsIgnoreMetadata(sourceCRS, destinationCRS)) {
  throw new CannotCropException(
      Errors.format(
          ErrorKeys.MISMATCHED_ENVELOPE_CRS_$2,
          sourceCRS.getName().getCode(),
          destinationCRS.getName().getCode()));
    new GeneralEnvelope((Envelope) destinationEnvelope);
intersectionEnvelope.setCoordinateReferenceSystem(source.getCoordinateReferenceSystem());
    (AffineTransform)
        ((GridGeometry2D) source.getGridGeometry())
            .getGridToCRS(PixelInCell.CELL_CORNER);
origin: geotools/geotools

@Test
public void testConic() throws Exception {
  // setup a request large enough to cause severe reprojection deformation
  CoordinateReferenceSystem crs = CRS.decode("EPSG:32632", true);
  ReferencedEnvelope mapExtent = new ReferencedEnvelope(-1.5e7, 1.5e7, 0, 1e6, crs);
  // System.out.println(mapExtent.transform(DefaultGeographicCRS.WGS84, true));
  GridCoverageReaderHelper helper =
      new GridCoverageReaderHelper(
          reader,
          new Rectangle(400, 200),
          mapExtent,
          Interpolation.getInstance(Interpolation.INTERP_NEAREST));
  // read single coverage with no projection handling, we should get the full requested area
  GridCoverage2D coverage = helper.readCoverage(null);
  Envelope2D envelope = coverage.getEnvelope2D();
  // System.out.println(envelope);
  assertTrue(envelope.getMinX() < -100);
  assertTrue(envelope.getMaxX() > 100);
  // now read via the projection handlers
  ProjectionHandler handler =
      ProjectionHandlerFinder.getHandler(
          mapExtent, reader.getCoordinateReferenceSystem(), true);
  List<GridCoverage2D> coverages = helper.readCoverages(null, handler);
  // System.out.println(coverages);
  assertEquals(1, coverages.size());
  envelope = coverages.get(0).getEnvelope2D();
  // west/east limited to 45 degrees from the central meridian
  assertEquals(-36, envelope.getMinX(), EPS);
  assertEquals(54, envelope.getMaxX(), EPS);
}
origin: geotools/geotools

graphics.dispose();
CoordinateReferenceSystem nativeCrs = CRS.decode("EPSG:4326", true);
ReferencedEnvelope mapExtent = new ReferencedEnvelope(0, 90, 0, 90, nativeCrs);
GridCoverage2D coverage =
    CoverageFactoryFinder.getGridCoverageFactory(null)
        .create("test", bi, new ReferencedEnvelope(0, 90, 0, 90, nativeCrs));
assertEquals(coverage.getNumSampleDimensions(), 3);
GridCoverage2DReader reader = new GeoTiffReader(coverageFile);
origin: geotools/geotools

final MathTransform transformTo2D;
CoordinateReferenceSystem requestedEnvelopeCRS2D =
    requestedEnvelope.getCoordinateReferenceSystem();
if (requestedEnvelopeCRS2D.getCoordinateSystem().getDimension() != 2) {
  transformTo2D =
      CRS.findMathTransform(
          requestedEnvelopeCRS2D, CRS.getHorizontalCRS(requestedEnvelopeCRS2D));
  requestedEnvelopeCRS2D = CRS.getHorizontalCRS(requestedEnvelopeCRS2D);
} else transformTo2D = IdentityTransform.create(2);
if (!transformTo2D.isIdentity()) {
  requestedEnvelope2D = CRS.transform(transformTo2D, requestedEnvelope);
  requestedEnvelope2D.setCoordinateReferenceSystem(requestedEnvelopeCRS2D);
} else requestedEnvelope2D = new GeneralEnvelope(requestedEnvelope);
assert requestedEnvelopeCRS2D.getCoordinateSystem().getDimension() == 2;
return requestedEnvelope2D;
origin: geotools/geotools

            "test",
            new float[200][100],
            new ReferencedEnvelope(
                -180, 180, -90, 90, DefaultGeographicCRS.WGS84));
GridCoverage2DReader reader =
            new GeneralEnvelope((BoundingBox) coverage.getEnvelope2D());
        this.originalGridRange = coverage.getGridGeometry().getGridRange();
CoordinateReferenceSystem crs = CRS.decode("EPSG:3031", true);
ReferencedEnvelope mapExtent =
    new ReferencedEnvelope(-20000000, 20000000, -20000000, 20000000, crs);
origin: geoserver/geoserver

    CoordinateReferenceSystem crs = CRS.decode(srs);
    wli.setSRS(srs);
    wli.setNativeCRS(crs);
    wli.setSRS("EPSG:4326");
    srs = "EPSG:4326";
    wli.setNativeCRS(CRS.decode("EPSG:4326"));
  } else if (srs.equals("CRS:83")) {
    wli.setSRS("EPSG:4269");
    srs = "EPSG:4269";
    wli.setNativeCRS(CRS.decode("EPSG:4269"));
  } else if (srs.equals("CRS:27")) {
    wli.setSRS("EPSG:4267");
    srs = "EPSG:4267";
    wli.setNativeCRS(CRS.decode("EPSG:4267"));
if (llbbox != null) {
  ReferencedEnvelope re =
      new ReferencedEnvelope(
          llbbox.getMinX(),
          llbbox.getMaxX(),
  try {
    wli.setLatLonBoundingBox(
        wli.getNativeBoundingBox().transform(DefaultGeographicCRS.WGS84, true));
  } catch (Exception e) {
    LOGGER.log(Level.INFO, "Could not transform native bbox into a lat/lon one", e);
origin: geotools/geotools

ReferencedEnvelope targetEnvelope = ReferencedEnvelope.reference(renderingEnvelope);
ReferencedEnvelope coveragesEnvelope = null;
for (GridCoverage2D coverage : coverages) {
  ReferencedEnvelope re = ReferencedEnvelope.reference(coverage.getEnvelope2D());
  if (coveragesEnvelope == null) {
    coveragesEnvelope = re;
  } else {
    coveragesEnvelope.expandToInclude(re);
    new ReferencedEnvelope(
        targetEnvelope.intersection(coveragesEnvelope),
        renderingEnvelope.getCoordinateReferenceSystem());
if (targetEnvelope.isEmpty() || targetEnvelope.isNull()) {
  return null;
MathTransform2D mt = coverages.get(0).getGridGeometry().getCRSToGrid2D();
Rectangle rasterSpaceEnvelope;
rasterSpaceEnvelope = CRS.transform(mt, targetEnvelope).toRectangle2D().getBounds();
GridEnvelope2D gridRange = new GridEnvelope2D(rasterSpaceEnvelope);
GridGeometry2D gridGeometry = new GridGeometry2D(gridRange, targetEnvelope);
origin: geotools/geotools

CoordinateReferenceSystem nativeCrs = CRS.decode("EPSG:26915", true);
GridCoverage2D coverage =
    CoverageFactoryFinder.getGridCoverageFactory(null)
            "test",
            bi,
            new ReferencedEnvelope(
                baseX,
                baseX + bi.getWidth(),
MathTransform r2m = coverage.getGridGeometry().getGridToCRS();
Envelope env = new Envelope(25, 75, 25, 75);
ReferencedEnvelope read26915 = new ReferencedEnvelope(JTS.transform(env, r2m), nativeCrs);
CoordinateReferenceSystem mapCRS = CRS.decode("EPSG:3857", true);
ReferencedEnvelope read3857 = read26915.transform(mapCRS, true);
Layer layer =
    new GridReaderLayer(
        new GeoTiffReader(testFile), sb.createStyle(sb.createRasterSymbolizer()));
MapContent mc = new MapContent();
mc.getViewport().setBounds(read3857);
origin: opentripplanner/OpenTripPlanner

@Override
public void createIndividuals() {
  try {
    coverageCRS = CRS.decode(crsCode, true);
  } catch (Exception e) {
    LOG.error("error decoding coordinate reference system code.", e);
    return;
  }
  if (boundsFromGraph) {
    // autowire graph service or pass in
  }
  gridEnvelope = new GridEnvelope2D(0, 0, cols, rows);
  refEnvelope = new ReferencedEnvelope(left, right, bottom, top, coverageCRS);
  gridGeometry = new GridGeometry2D(gridEnvelope, refEnvelope);
  super.createIndividuals0();
}
origin: geotools/geotools

coverageGeographicCRS2D =
    coverageGeographicBBox != null
        ? coverageGeographicBBox.getCoordinateReferenceSystem()
        : null;
coverageCRS2D = CRS.getHorizontalCRS(coverageCRS);
assert coverageCRS2D.getCoordinateSystem().getDimension() == 2;
if (coverageCRS.getCoordinateSystem().getDimension() != 2) {
  final MathTransform transform = CRS.findMathTransform(coverageCRS, coverageCRS2D);
  final GeneralEnvelope bbox = CRS.transform(transform, coverageEnvelope);
  coverageBBox = ReferencedEnvelope.create(bbox, coverageCRS2D);
} else {
      ReferencedEnvelope.create(
          coverageEnvelope, coverageEnvelope.getCoordinateReferenceSystem());
org.geotools.referencingCRS

Javadoc

Simple utility class for making use of the CoordinateReferenceSystem and associated org.opengis.referencing.Factory implementations. This utility class is made up of static final functions. This class is not a factory or a builder. It makes use of the GeoAPI factory interfaces provided by ReferencingFactoryFinder.

The following methods may be added in a future version:

  • CoordinateReferenceSystem parseXML(String)

When using CoordinateReferenceSystem matching methods of this class ( #equalsIgnoreMetadata(Object,Object), #lookupIdentifier(IdentifiedObject,boolean), #lookupEpsgCode(CoordinateReferenceSystem,boolean), #lookupIdentifier(IdentifiedObject,boolean), #lookupIdentifier(Citation,CoordinateReferenceSystem,boolean)) against objects derived from a database other than the official EPSG one it may be advisable to set a non zero comparison tolerance with Hints#putSystemDefault(java.awt.RenderingHints.Key,Object) using the Hints#COMPARISON_TOLERANCE key. A value of 10e-9 has proved to give satisfactory results with definitions commonly found in .prj files accompaining shapefiles and georeferenced images.
Warning: the tolerance value is used in all internal comparison, this will also change the way math transforms are setup. Use with care.

Most used methods

  • decode
  • findMathTransform
  • equalsIgnoreMetadata
  • parseWKT
  • lookupEpsgCode
  • transform
    Implementation of #transform(MathTransform,Envelope) with the opportunity to save the projected cent
  • getAxisOrder
  • lookupIdentifier
  • toSRS
  • getHorizontalCRS
  • getEnvelope
  • getCoordinateOperationFactory
  • getEnvelope,
  • getCoordinateOperationFactory,
  • getAuthorityFactory,
  • getMapProjection,
  • getSupportedCodes,
  • getGeographicBoundingBox,
  • reset,
  • getEllipsoid,
  • getProjectedCRS,
  • getTemporalCRS

Popular in Java

  • Start an intent from android
  • onRequestPermissionsResult (Fragment)
  • getApplicationContext (Context)
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • Pointer (com.sun.jna)
    An abstraction for a native pointer data type. A Pointer instance represents, on the Java side, a na
  • EOFException (java.io)
    Thrown when a program encounters the end of a file or stream during an input operation.
  • InputStreamReader (java.io)
    A class for turning a byte stream into a character stream. Data read from the source input stream is
  • Socket (java.net)
    Provides a client-side TCP socket.
  • Options (org.apache.commons.cli)
    Main entry-point into the library. Options represents a collection of Option objects, which describ
  • Get (org.apache.hadoop.hbase.client)
    Used to perform Get operations on a single row. To get everything for a row, instantiate a Get objec
  • CodeWhisperer alternatives
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now