/** {@inheritDoc} */ @Override public ParameterValueGroup getParameterValues() { final ParameterValueGroup values = super.getParameterValues(); return values; }
final double x = ptSrc.getX(); final double y = ptSrc.getY(); if (verifyCoordinateRanges()) { if (verifyGeographicRanges(this, x, y)) { warningLogged(); transformNormalized( centralMeridian != 0 ? rollLongitude(toRadians(x) - centralMeridian) : toRadians(x), toRadians(y), assert checkReciprocal( ptDst, (ptSrc != ptDst) ? ptSrc : new Point2D.Double(x, y), true);
/** Compares the specified object with this map projection for equality. */ @Override public boolean equals(final Object object) { // Do not check 'object==this' here, since this // optimization is usually done in subclasses. if (super.equals(object)) { final MapProjection that = (MapProjection) object; return equals(this.semiMajor, that.semiMajor) && equals(this.semiMinor, that.semiMinor) && equals(this.centralMeridian, that.centralMeridian) && equals(this.latitudeOfOrigin, that.latitudeOfOrigin) && equals(this.scaleFactor, that.scaleFactor) && equals(this.falseEasting, that.falseEasting) && equals(this.falseNorthing, that.falseNorthing); } return false; }
/** * Returns the parameter values for this map projection. * * @return A copy of the parameter values for this map projection. */ @Override public ParameterValueGroup getParameterValues() { final ParameterDescriptorGroup descriptor = getParameterDescriptors(); final Collection<GeneralParameterDescriptor> expected = descriptor.descriptors(); final ParameterValueGroup values = descriptor.createValue(); set(expected, AbstractProvider.SEMI_MAJOR, values, semiMajor); set(expected, AbstractProvider.SEMI_MINOR, values, semiMinor); set(expected, AbstractProvider.CENTRAL_MERIDIAN, values, centralMeridian); set(expected, AbstractProvider.LATITUDE_OF_ORIGIN, values, latitudeOfOrigin); set(expected, AbstractProvider.SCALE_FACTOR, values, scaleFactor); set(expected, AbstractProvider.FALSE_EASTING, values, falseEasting); set(expected, AbstractProvider.FALSE_NORTHING, values, falseNorthing); return values; }
throws ParameterNotFoundException { if (expected == null) { expected = getParameterDescriptors().descriptors(); semiMajor = doubleValue(expected, AbstractProvider.SEMI_MAJOR, values); semiMinor = doubleValue(expected, AbstractProvider.SEMI_MINOR, values); centralMeridian = doubleValue(expected, AbstractProvider.CENTRAL_MERIDIAN, values); latitudeOfOrigin = doubleValue(expected, AbstractProvider.LATITUDE_OF_ORIGIN, values); scaleFactor = doubleValue(expected, AbstractProvider.SCALE_FACTOR, values); falseEasting = doubleValue(expected, AbstractProvider.FALSE_EASTING, values); falseNorthing = doubleValue(expected, AbstractProvider.FALSE_NORTHING, values); isSpherical = (semiMajor == semiMinor); excentricitySquared = 1.0 - (semiMinor * semiMinor) / (semiMajor * semiMajor); excentricity = sqrt(excentricitySquared); globalScale = scaleFactor * semiMajor; ensureLongitudeInRange(AbstractProvider.CENTRAL_MERIDIAN, centralMeridian, true); ensureLatitudeInRange(AbstractProvider.LATITUDE_OF_ORIGIN, latitudeOfOrigin, true);
if (inverse) { point = inverse().transform(point, point); distance = orthodromicDistance(point, target); longitude = point.getX(); latitude = point.getY(); point = transform(point, point); distance = point.distance(target); if (distance > getToleranceForAssertions(longitude, latitude)) { new Longitude(longitude - toDegrees(centralMeridian)), new Latitude(latitude - toDegrees(latitudeOfOrigin)), getName()));
final MapProjection projTransf, final String name, GeoTiffIIOMetadataEncoder metadata) { final ParameterValueGroup parameters = projTransf.getParameterValues(); throw new IllegalArgumentException("Unable to map projection" + projTransf.getName());
/** Returns a hash value for this projection. */ @Override public int hashCode() { final long code = Double.doubleToLongBits(ml0); return ((int) code ^ (int) (code >>> 32)) + 37 * super.hashCode(); }
/** Test we can round trip well behaved points, and that checkReciprocal() works properly. */ @Test public void testCheckReciprocal() throws TransformException, FactoryException { final double[] dst = new double[PROJECTED.length]; MapProjection mt = createGoogleMercator(); mt.transform(GEOGRAPHIC, 0, dst, 0, PROJECTED.length / 2); for (int i = 0; i < PROJECTED.length; i++) { assertEquals(PROJECTED[i], dst[i], 0.1); // 10 cm precision } for (int i = 0; i < PROJECTED.length / 2; i++) { Point2D src = new Point2D.Double(GEOGRAPHIC[i * 2 + 0], GEOGRAPHIC[i * 2 + 1]); Point2D target = new Point2D.Double(PROJECTED[i * 2 + 0], PROJECTED[i * 2 + 1]); assertEquals(true, mt.checkReciprocal(src, target, false)); assertEquals(true, mt.checkReciprocal(target, src, true)); } mt.inverse().transform(PROJECTED, 0, dst, 0, PROJECTED.length / 2); for (int i = 0; i < GEOGRAPHIC.length; i++) { assertEquals(GEOGRAPHIC[i], dst[i], 0.0001); // About 10 m precision } }
final double y0 = ptSrc.getY(); ptDst = inverseTransformNormalized( (x0 - falseEasting) / globalScale, (y0 - falseNorthing) / globalScale, final double y = toDegrees(ptDst.getY()); ptDst.setLocation(x, y); if (verifyCoordinateRanges()) { if (verifyGeographicRanges(this, x, y)) { warningLogged(); assert checkReciprocal( ptDst, (ptSrc != ptDst) ? ptSrc : new Point2D.Double(x0, y0), false); return ptDst;
assertEquals( classification, ((MapProjection) mt).getParameterDescriptors().getName().getCode());
mt.orthodromicDistance(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0)), 0.001); assertEquals( 111319.49079, mt.orthodromicDistance(new Point2D.Double(0.0, 0.0), new Point2D.Double(1.0, 0.0)), 0.001); assertEquals( 111319.49079, mt.orthodromicDistance( new Point2D.Double(0.0, 89.0), new Point2D.Double(0.0, 90.0)), 0.001); assertEquals( 1942.76834, mt.orthodromicDistance( new Point2D.Double(0.0, 89.0), new Point2D.Double(1.0, 89.0)), 0.001); assertEquals( 10018754.17139, mt.orthodromicDistance(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 90.0)), 0.001); assertEquals(0.0, mt.orthodromicDistance(src, src), 0.000000001); assertEquals(0.011131948840096939, mt.orthodromicDistance(src, target), 1E-12); assertEquals(1.1117412E-7, mt.orthodromicDistance(src, target2), 1E-12);
/** Returns a hash value for this projection. */ @Override public int hashCode() { final long code = Double.doubleToLongBits(standardParallel); return ((int) code ^ (int) (code >>> 32)) + 37 * super.hashCode(); }
/** Some tests for the Oblique Mercator Projection. */ @Test public void testObliqueMercator() throws FactoryException, TransformException { if (VERBOSE) { printParameters("Oblique Mercator"); } MathTransform transform; ParameterValueGroup params; params = mtFactory.getDefaultParameters("Oblique Mercator"); setObliqueMercatorParameter(params); transform = mtFactory.createParameterizedTransform(params); assertEquals(transform.getClass(), ObliqueMercator.class); assertEquals(transform, new ObliqueMercator(params)); ParameterDescriptorGroup descriptor = ((MapProjection) transform).getParameterDescriptors(); assertTrue(AbstractIdentifiedObject.nameMatches(descriptor, "Oblique Mercator")); assertFalse(AbstractIdentifiedObject.nameMatches(descriptor, "Hotine Oblique Mercator")); final MathTransform standard = transform; params = mtFactory.getDefaultParameters("Hotine Oblique Mercator"); setObliqueMercatorParameter(params); transform = mtFactory.createParameterizedTransform(params); assertEquals(transform.getClass(), HotineObliqueMercator.class); assertEquals(transform, new HotineObliqueMercator(params)); descriptor = ((MapProjection) transform).getParameterDescriptors(); assertFalse(AbstractIdentifiedObject.nameMatches(descriptor, "Oblique Mercator")); assertTrue(AbstractIdentifiedObject.nameMatches(descriptor, "Hotine Oblique Mercator")); assertFalse(transform.equals(standard)); }
/** {@inheritDoc} */ @Override public ParameterValueGroup getParameterValues() { final ParameterValueGroup values = super.getParameterValues(); if (!Double.isNaN(standardParallel)) { final Collection<GeneralParameterDescriptor> expected = getParameterDescriptors().descriptors(); set(expected, Provider.STANDARD_PARALLEL_1, values, standardParallel); } return values; }
/** Compares the specified object with this map projection for equality. */ @Override public boolean equals(final Object object) { if (object == this) { // Slight optimization return true; } if (super.equals(object)) { final Polyconic that = (Polyconic) object; return equals(this.ml0, that.ml0); } return false; }
/** Returns a hash value for this projection. */ @Override public int hashCode() { final long code = Double.doubleToLongBits(cosphi1); return ((int) code ^ (int) (code >>> 32)) + 37 * super.hashCode(); }
/** {@inheritDoc} */ @Override public ParameterValueGroup getParameterValues() { final ParameterValueGroup values = super.getParameterValues(); if (!Double.isNaN(standardParallel)) { final Collection<GeneralParameterDescriptor> expected = getParameterDescriptors().descriptors(); set(expected, AbstractProvider.STANDARD_PARALLEL_1, values, standardParallel); } return values; }
/** Compares the specified object with this map projection for equality. */ @Override public boolean equals(final Object object) { if (object == this) { // Slight optimization return true; } if (super.equals(object)) { final EquidistantCylindrical that = (EquidistantCylindrical) object; return equals(this.standardParallel, that.standardParallel); } return false; }
/** Returns a hash value for this projection. */ @Override public int hashCode() { final long code = Double.doubleToLongBits(ml0); return ((int) code ^ (int) (code >>> 32)) + 37 * super.hashCode(); }