Examples of org.geotools.referencing.crs.DefaultProjectedCRS

org.geotools.referencing.crs.DefaultProjectedCRS
A 2D coordinate reference system used to approximate the shape of the earth on a planar surface. It is done in such a way that the distortion that is inherent to the approximation is carefully controlled and known. Distortion correction is commonly applied to calculated bearings and distances to produce values that are a close match to actual field values.

Used with CS type(s)

{@link CartesianCS Cartesian}
@since 2.1 @source $URL$ @version $Id$ @author Martin Desruisseaux (IRD)

Used with CS type(s)
{@link CartesianCS Cartesian}

        assertEquals(datum, geoCrs.getDatum());


        CoordinateReferenceSystem mercatorCRS = Utilities.getMercator2SPProjectedCRS(10, 0, 0,
                geoCrs, null);
        assertTrue(mercatorCRS instanceof DefaultProjectedCRS);
        DefaultProjectedCRS mercator = (DefaultProjectedCRS) mercatorCRS;
        assertEquals(datum, mercator.getDatum());
        assertEquals(geoCrs, mercator.getBaseCRS());


    }

View Full Code Here

      //
      // //
      final Conversion conversionFromBase=new DefiningConversion(
              pcrs.getConversionFromBase().getName().getCode(), 
              pcrs.getConversionFromBase().getParameterValues());
      return new DefaultProjectedCRS(
              java.util.Collections.singletonMap("name",DefaultEllipsoidalCS.getName(pcrs,new CitationImpl("EPSG"))),
              conversionFromBase,
              pcrs.getBaseCRS(),
              pcrs.getConversionFromBase().getMathTransform(),
              createProjectedCS(linearUnit)

View Full Code Here

                    // user defined projection




                        // standard unit of measure
      if (linearUnit != null && linearUnit.equals(SI.METER)){
                          return new DefaultProjectedCRS(
                                  java.util.Collections.singletonMap("name",projectedCrsName),
                                  conversionFromBase,
                                  baseCRS,
                                  transform,
                                  DefaultCartesianCS.PROJECTED);
      }
        
      // unit of measure is not standard
      return new DefaultProjectedCRS(
                                java.util.Collections.singletonMap("name",projectedCrsName),
                                conversionFromBase,
                                baseCRS,
                                transform,
                                DefaultCartesianCS.PROJECTED.usingUnit(linearUnit));
                        
    }
    
    // standard projection
    if (linearUnit != null && !linearUnit.equals(SI.METER)){
        return new DefaultProjectedCRS(
                          Collections.singletonMap("name",projectedCrsName), 
                          conversionFromBase,
                          baseCRS, 
                          transform,
                          DefaultCartesianCS.PROJECTED.usingUnit(linearUnit));
    }
    return new DefaultProjectedCRS(
            Collections.singletonMap("name",projectedCrsName), 
                        conversionFromBase,
                        baseCRS, 
                        transform,
            DefaultCartesianCS.PROJECTED);

View Full Code Here

      } catch (FactoryException exception) {
        fail(exception.getLocalizedMessage());
        return null;
      }
      //create the projected crs
      return new DefaultProjectedCRS(
          java.util.Collections.singletonMap("name", "Stereographic"),
           base, 
           mt,
           DefaultCartesianCS.PROJECTED);
    } catch (NoSuchIdentifierException exception) {

View Full Code Here

    /**
     * Tests the distance between points function
     */
    public void testOrthodromicDistance() throws Exception {
        final Parser parser = new Parser();
        final DefaultProjectedCRS crs  = (DefaultProjectedCRS) parser.parseObject(NAD83_BC);
        double d = JTS.orthodromicDistance(new Coordinate(1402848.1938534670, 651571.1729878788),
                                           new Coordinate(1389481.3104009738, 641990.9430108378), crs);
        double realValue = 16451.33114;
        assertEquals(realValue, d, 0.1);
    }

View Full Code Here

        assertNotNull(transform);
        
        CoordinateReferenceSystem crs = reader.getCRS();
        
        assertTrue(crs instanceof DefaultProjectedCRS);
        DefaultProjectedCRS geocrs = (DefaultProjectedCRS) crs;
        assertEquals("WGS_1984", geocrs.getDatum().getName().toString());
        assertEquals("Transverse_Mercator", geocrs.getConversionFromBase().getMethod().getName().toString());
    }

View Full Code Here

     */
    @Test
    public void testHardCoded() throws ParseException {
        final Parser parser = new Parser();
        String              wkt1, wkt2;
        DefaultProjectedCRS crs1, crs2;
        ParameterValueGroup param;
        /*
         * First, rather simple Mercator projection.
         * Uses standard units and axis order.
         */
        wkt1 = "PROJCS[\"Mercator test\",\n"                             +
               "  GEOGCS[\"WGS84\",\n"                                   +
               "    DATUM[\"WGS84\",\n"                                  +
               "      SPHEROID[\"WGS84\", 6378137.0, 298.257223563]],\n" +
               "    PRIMEM[\"Greenwich\", 0.0],\n"                       +
               "    UNIT[\"degree\", 0.017453292519943295],\n"           +
               "    AXIS[\"Longitude\", EAST],\n"                        +
               "    AXIS[\"Latitude\", NORTH]],\n"                       +
               "  PROJECTION[\"Mercator_1SP\"],\n"                       +
               "  PARAMETER[\"central_meridian\", -20.0],\n"             +
               "  PARAMETER[\"scale_factor\", 1.0],\n"                   +
               "  PARAMETER[\"false_easting\", 500000.0],\n"             +
               "  PARAMETER[\"false_northing\", 0.0],\n"                 +
               "  UNIT[\"m\", 1.0],\n"                                   +
               "  AXIS[\"x\", EAST],\n"                                  +
               "  AXIS[\"y\", NORTH]]\n";
        assertTrue(Symbols.DEFAULT.containsAxis(wkt1));
        crs1  = (DefaultProjectedCRS) parser.parseObject(wkt1);
        wkt2  = parser.format(crs1);
        crs2  = (DefaultProjectedCRS) parser.parseObject(wkt2);
        param = crs1.getConversionFromBase().getParameterValues();
        assertEquals(crs1, crs2);
        assertEquals("Mercator_1SP", crs1.getConversionFromBase().getMethod().getName().getCode());
        assertTrue(crs1.getConversionFromBase().getMathTransform().toWKT().startsWith("PARAM_MT[\"Mercator_1SP\""));
        assertFalse (wkt2.contains("semi_major"));
        assertFalse (wkt2.contains("semi_minor"));
        assertEquals("semi_major",   6378137.0, param.parameter("semi_major"      ).doubleValue(), 1E-4);
        assertEquals("semi_minor",   6356752.3, param.parameter("semi_minor"      ).doubleValue(), 1E-1);
        assertEquals("central_meridian", -20.0, param.parameter("central_meridian").doubleValue(), 1E-8);
        assertEquals("scale_factor",       1.0, param.parameter("scale_factor"    ).doubleValue(), 1E-8);
        assertEquals("false_easting", 500000.0, param.parameter("false_easting"   ).doubleValue(), 1E-4);
        assertEquals("false_northing",     0.0, param.parameter("false_northing"  ).doubleValue(), 1E-4);
        /*
         * Same Mercator projection as above, but
         * switch longitude and latitude axis.
         */
        wkt1 = "PROJCS[\"Mercator test\",\n"                             +
               "  GEOGCS[\"WGS84\",\n"                                   +
               "    DATUM[\"WGS84\",\n"                                  +
               "      SPHEROID[\"WGS84\", 6378137.0, 298.257223563]],\n" +
               "    PRIMEM[\"Greenwich\", 0.0],\n"                       +
               "    UNIT[\"degree\", 0.017453292519943295],\n"           +
               "    AXIS[\"Latitude\", NORTH],\n"                        +
               "    AXIS[\"Longitude\", EAST]],\n"                       +
               "  PROJECTION[\"Mercator_1SP\"],\n"                       +
               "  PARAMETER[\"central_meridian\", -20.0],\n"             +
               "  PARAMETER[\"scale_factor\", 1.0],\n"                   +
               "  PARAMETER[\"false_easting\", 500000.0],\n"             +
               "  PARAMETER[\"false_northing\", 0.0],\n"                 +
               "  UNIT[\"m\", 1.0],\n"                                   +
               "  AXIS[\"x\", EAST],\n"                                  +
               "  AXIS[\"y\", NORTH]]\n";
        assertTrue(Symbols.DEFAULT.containsAxis(wkt1));
        crs1  = (DefaultProjectedCRS) parser.parseObject(wkt1);
        wkt2  = parser.format(crs1);
        crs2  = (DefaultProjectedCRS) parser.parseObject(wkt2);
        param = crs1.getConversionFromBase().getParameterValues();
        assertEquals(crs1, crs2);
        assertEquals("Mercator_1SP", crs1.getConversionFromBase().getMethod().getName().getCode());
        assertTrue(crs1.getConversionFromBase().getMathTransform().toWKT().startsWith("CONCAT_MT[PARAM_MT["));
        assertFalse (wkt2.contains("semi_major"));
        assertFalse (wkt2.contains("semi_minor"));
        assertEquals("semi_major",   6378137.0, param.parameter("semi_major"      ).doubleValue(), 1E-4);
        assertEquals("semi_minor",   6356752.3, param.parameter("semi_minor"      ).doubleValue(), 1E-1);
        assertEquals("central_meridian", -20.0, param.parameter("central_meridian").doubleValue(), 1E-8);
        assertEquals("scale_factor",       1.0, param.parameter("scale_factor"    ).doubleValue(), 1E-8);
        assertEquals("false_easting", 500000.0, param.parameter("false_easting"   ).doubleValue(), 1E-4);
        assertEquals("false_northing",     0.0, param.parameter("false_northing"  ).doubleValue(), 1E-4);
        /*
         * Try an other projection (Transverse Mercator).
         */
        wkt1 = "PROJCS[\"OSGB 1936 / British National Grid\",\n"                                          +
               "  GEOGCS[\"OSGB 1936\",\n"                                                                +
               "    DATUM[\"OSGB_1936\",\n"                                                               +
               "      SPHEROID[\"Airy 1830\", 6377563.396, 299.3249646, AUTHORITY[\"EPSG\",\"7001\"]],\n" +
               "      TOWGS84[375.0, -111.0, 431.0, 0.0, 0.0, 0.0, 0.0],\n"                               +
               "      AUTHORITY[\"EPSG\",\"6277\"]],\n"                                                   +
               "    PRIMEM[\"Greenwich\",0.0, AUTHORITY[\"EPSG\",\"8901\"]],\n"                           +
               "    UNIT[\"DMSH\",0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]],\n"                   +
               "    AXIS[\"Lat\",NORTH],AXIS[\"Long\",EAST], AUTHORITY[\"EPSG\",\"4277\"]],\n"            +
               "  PROJECTION[\"Transverse_Mercator\"],\n"                                                 +
               "  PARAMETER[\"latitude_of_origin\", 49.0],\n"                                             +
               "  PARAMETER[\"central_meridian\", -2.0],\n"                                               +
               "  PARAMETER[\"scale_factor\", 0.999601272],\n"                                            +
               "  PARAMETER[\"false_easting\", 400000.0],\n"                                              +
               "  PARAMETER[\"false_northing\", -100000.0],\n"                                            +
               "  UNIT[\"metre\", 1.0, AUTHORITY[\"EPSG\",\"9001\"]],\n"                                  +
               "  AXIS[\"E\",EAST],\n"                                                                    +
               "  AXIS[\"N\",NORTH],\n"                                                                   +
               "  AUTHORITY[\"EPSG\",\"27700\"]]\n";
        assertTrue(Symbols.DEFAULT.containsAxis(wkt1));
        crs1  = (DefaultProjectedCRS) parser.parseObject(wkt1);
        wkt2  = parser.format(crs1);
        crs2  = (DefaultProjectedCRS) parser.parseObject(wkt2);
        param = crs1.getConversionFromBase().getParameterValues();
        assertEquals(crs1, crs2);
        assertFalse (wkt2.contains("semi_major"));
        assertFalse (wkt2.contains("semi_minor"));
        assertEquals("Transverse_Mercator", crs1.getConversionFromBase().getMethod().getName().getCode());
        assertEquals("semi_major",   6377563.396, param.parameter("semi_major"        ).doubleValue(), 1E-4);
        assertEquals("semi_minor",   6356256.909, param.parameter("semi_minor"        ).doubleValue(), 1E-3);
        assertEquals("latitude_of_origin",  49.0, param.parameter("latitude_of_origin").doubleValue(), 1E-8);
        assertEquals("central_meridian",    -2.0, param.parameter("central_meridian"  ).doubleValue(), 1E-8);
        assertEquals("scale_factor",      0.9996, param.parameter("scale_factor"      ).doubleValue(), 1E-5);
        assertEquals("false_easting",   400000.0, param.parameter("false_easting"     ).doubleValue(), 1E-4);
        assertEquals("false_northing", -100000.0, param.parameter("false_northing"    ).doubleValue(), 1E-4);
        /*
         * Try a projection with feet units.
         */
        wkt1 = "PROJCS[\"TransverseMercator\",\n"                     +
               "  GEOGCS[\"Sphere\",\n"                               +
               "    DATUM[\"Sphere\",\n"                              +
               "      SPHEROID[\"Sphere\", 6370997.0, 0.0],\n"        +
               "      TOWGS84[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],\n" +
               "    PRIMEM[\"Greenwich\", 0.0],\n"                    +
               "    UNIT[\"degree\", 0.017453292519943295],\n"        +
               "    AXIS[\"Longitude\", EAST],\n"                     +
               "    AXIS[\"Latitude\", NORTH]],\n"                    +
               "  PROJECTION[\"Transverse_Mercator\",\n"              +
               "    AUTHORITY[\"OGC\",\"Transverse_Mercator\"]],\n"   +
               "  PARAMETER[\"central_meridian\", 170.0],\n"          +
               "  PARAMETER[\"latitude_of_origin\", 50.0],\n"         +
               "  PARAMETER[\"scale_factor\", 0.95],\n"               +
               "  PARAMETER[\"false_easting\", 0.0],\n"               +
               "  PARAMETER[\"false_northing\", 0.0],\n"              +
               "  UNIT[\"feet\", 0.304800609601219],\n"               +
               "  AXIS[\"x\", EAST],\n"                               +
               "  AXIS[\"y\", NORTH]]\n";
        assertTrue(Symbols.DEFAULT.containsAxis(wkt1));
        crs1  = (DefaultProjectedCRS) parser.parseObject(wkt1);
        wkt2  = parser.format(crs1);
        crs2  = (DefaultProjectedCRS) parser.parseObject(wkt2);
        param = crs1.getConversionFromBase().getParameterValues();
        assertEquals(crs1, crs2);
        assertFalse (wkt2.contains("semi_major"));
        assertFalse (wkt2.contains("semi_minor"));
        assertEquals("Transverse_Mercator", crs1.getConversionFromBase().getMethod().getName().getCode());
        assertEquals("semi_major",     6370997.0, param.parameter("semi_major"        ).doubleValue(), 1E-5);
        assertEquals("semi_minor",     6370997.0, param.parameter("semi_minor"        ).doubleValue(), 1E-5);
        assertEquals("latitude_of_origin",  50.0, param.parameter("latitude_of_origin").doubleValue(), 1E-8);
        assertEquals("central_meridian",   170.0, param.parameter("central_meridian"  ).doubleValue(), 1E-8);
        assertEquals("scale_factor",        0.95, param.parameter("scale_factor"      ).doubleValue(), 1E-8);

View Full Code Here

        parameters.parameter("false_northing").setValue(0.0);


        GeographicCRS base = DefaultGeographicCRS.WGS84;
        MathTransform mt   = factory.createParameterizedTransform(parameters);
        CartesianCS cs = DefaultCartesianCS.PROJECTED;
        CoordinateReferenceSystem crs = new DefaultProjectedCRS("Lambert", base, mt, cs);


        final String wkt = crs.toWKT();
        assertTrue(wkt.contains("semi_major"));
        assertTrue(wkt.contains("semi_minor"));
        final Parser parser = new Parser();
        CoordinateReferenceSystem check = parser.parseCoordinateReferenceSystem(wkt);
        assertEquals(wkt, check.toWKT());

View Full Code Here

    @Test
    public void testCreateLinearConversion() throws FactoryException {
        final double                     EPS = 1E-12;
        final MathTransformFactory   factory = new DefaultMathTransformFactory();
        final ParameterValueGroup parameters = factory.getDefaultParameters("Mercator_1SP");
        DefaultProjectedCRS sourceCRS, targetCRS;
        MathTransform transform;
        Matrix conversion;


        parameters.parameter("semi_major").setValue(DefaultEllipsoid.WGS84.getSemiMajorAxis());
        parameters.parameter("semi_minor").setValue(DefaultEllipsoid.WGS84.getSemiMinorAxis());
        transform = factory.createParameterizedTransform(parameters);
        sourceCRS = new DefaultProjectedCRS("source", WGS84, transform, PROJECTED);


        parameters.parameter("false_easting" ).setValue(1000);
        parameters.parameter("false_northing").setValue(2000);
        transform = factory.createParameterizedTransform(parameters);
        targetCRS = new DefaultProjectedCRS("source", WGS84, transform, PROJECTED);


        conversion = ProjectionAnalyzer.createLinearConversion(sourceCRS, targetCRS, EPS);
        assertEquals(new Matrix3(
            1,  0,  1000,
            0,  1,  2000,
            0,  0,     1
        ), conversion);


        parameters.parameter("scale_factor").setValue(2);
        transform = factory.createParameterizedTransform(parameters);
        targetCRS = new DefaultProjectedCRS("source", WGS84, transform, PROJECTED);


        conversion = ProjectionAnalyzer.createLinearConversion(sourceCRS, targetCRS, EPS);
        assertEquals(new Matrix3(
            2,  0,  1000,
            0,  2,  2000,
            0,  0,     1
        ), conversion);


        parameters.parameter("semi_minor").setValue(DefaultEllipsoid.WGS84.getSemiMajorAxis());
        transform = factory.createParameterizedTransform(parameters);
        targetCRS = new DefaultProjectedCRS("source", WGS84, transform, PROJECTED);
        conversion = ProjectionAnalyzer.createLinearConversion(sourceCRS, targetCRS, EPS);
        assertNull(conversion);
    }

View Full Code Here

                mt = factory.createParameterizedTransform(parameters);
            } catch (FactoryException exception) {
                fail(exception.getLocalizedMessage());
                return null;
            }
            return new DefaultProjectedCRS("Stereographic", base, mt, DefaultCartesianCS.PROJECTED);
        } catch (NoSuchIdentifierException exception) {
            fail(exception.getLocalizedMessage());
            return null;
        }
    }

View Full Code Here

0 1

TOP

Related Classes of org.geotools.referencing.crs.DefaultProjectedCRS

org.geotools.coverage.grid.imageio.geotiff.metadata.GeoTiffMetadata2CRSAdapter

org.geotools.coverage.grid.io.imageio.geotiff.GeoTiffMetadata2CRSAdapter

org.geotools.coverage.io.util.UtilitiesTest

org.geotools.coverage.processing.ResampleTest

org.geotools.data.MapInfoFileReaderTest

org.geotools.gce.imagemosaic.GranuleTest

org.geotools.geometry.jts.JTSTest

org.geotools.referencing.operation.LinearConversionTest

org.geotools.referencing.wkt.ParserTest

org.geotools.renderer.lite.GridCoverageRendererTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.