public MapTransform createTransform() { Debug.trace("DefaultMapTransformUI.createTransform"); traceParameterValues(); final MapTransform transform = _transform.getDescriptor().createTransform(getParameterValues()); final double[] parameterValues = transform.getParameterValues(); for (int i = 0; i < parameterValues.length; i++) { Debug.trace(" MapTransform.parameterValues[" + i + "] = " + parameterValues[i]); } return transform; }
private Point2D geoToMap(final GeoPos geoPosNorm, Point2D mapPos) { return mapTransform.forward(geoPosNorm, mapPos); }
private GeoPos mapToGeo(final Point2D mapPos, GeoPos geoPos) { return mapTransform.inverse(mapPos, geoPos); }
public MapProjection(String name, MapTransform mapTransform, boolean preDefined) { this(name, mapTransform, mapTransform.getDescriptor().getMapUnit(), preDefined); }
public void testForwardAndInverseTransform() { final MapTransform transform = MapTransformFactory.createTransform(StereographicDescriptor.TYPE_ID, DEFAULT_PARAMS); float lat = 90f, lon = 11.87305555f; GeoPos geoPos = new GeoPos(lat, lon); Point2D mapPoint = transform.forward(geoPos, null); GeoPos testPos = transform.inverse(mapPoint, null); assertEquals(90.0, testPos.getLat(), EPSILON); assertEquals(0, testPos.getLon(), EPSILON); lat = 53.786666666f; lon = 11.87305555f; geoPos = new GeoPos(lat, lon); mapPoint = transform.forward(geoPos, null); testPos = transform.inverse(mapPoint, null); assertEquals(lat, testPos.getLat(), EPSILON); assertEquals(lon, testPos.getLon(), EPSILON); }
public void testX() { final TransverseMercatorDescriptor tmd = new TransverseMercatorDescriptor(); final MapProjection mp = new MapProjection("bibo", tmd.createTransform(null), "meter"); assertEquals(Ellipsoid.WGS_84.getSemiMajor(), mp.getMapTransform().getParameterValues()[0], 1e-5); assertEquals(Ellipsoid.WGS_84.getSemiMinor(), mp.getMapTransform().getParameterValues()[1], 1e-5); mp.alterMapTransform(Ellipsoid.BESSEL); assertEquals(Ellipsoid.BESSEL.getSemiMajor(), mp.getMapTransform().getParameterValues()[0], 1e-5); assertEquals(Ellipsoid.BESSEL.getSemiMinor(), mp.getMapTransform().getParameterValues()[1], 1e-5); }
@Override public Object clone() { try { final MapProjection mapProjection = (MapProjection) super.clone(); mapProjection.setMapTransform(_mapTransform.createDeepClone()); return mapProjection; } catch (CloneNotSupportedException e) { throw new IllegalStateException(e); } }
public MapProjection(String name, MapTransform mapTransform) { this(name, mapTransform, mapTransform.getDescriptor().getMapUnit()); }
public void testForwarAndInverseTransform() { // values for this test are from Frank Fell! double[] params = new double[]{Ellipsoid.WGS_84.getSemiMajor(), Ellipsoid.WGS_84.getSemiMinor(), 0.0, 9.0, 0.9996, 500000.0, 0.0}; MapTransform transform = MapTransformFactory.createTransform("Transverse_Mercator", params); float lat = 53.786666666f, lon = 11.87305555f; GeoPos geoPos = new GeoPos(lat, lon); Point2D mapPoint = transform.forward(geoPos, null); assertEquals(689265.13, mapPoint.getX(), _metricDelta); assertEquals(5963616.5, mapPoint.getY(), _metricDelta); GeoPos testPos = transform.inverse(mapPoint, null); assertEquals(lon, testPos.getLon(), _geodeticDelta); assertEquals(lat, testPos.getLat(), _geodeticDelta); }
private static MathTransform getMathTransform(MapTransform mapTransform) throws FactoryException { if (mapTransform.getDescriptor() instanceof AffineTransformDescriptor) { return new AffineTransform2D(new AffineTransform(mapTransform.getParameterValues())); } if (mapTransform instanceof AlbersEqualAreaConicDescriptor.AEAC) { return createAlbersConicEqualAreaMathTransform((AlbersEqualAreaConicDescriptor.AEAC) mapTransform); } if (mapTransform instanceof LambertConformalConicDescriptor.LCCT) { return createLambertConformalConicMathTransform((LambertConformalConicDescriptor.LCCT) mapTransform); } if (mapTransform instanceof StereographicDescriptor.ST) { return createStereographicMathTransform((StereographicDescriptor.ST) mapTransform); } if (mapTransform instanceof TransverseMercatorDescriptor.TMT) { return createTransverseMercatorMathTransform((TransverseMercatorDescriptor.TMT) mapTransform); } return null; }
/** * Tests if a user interface is available. The method is a shorthand for * <pre> * getMapTransform().getDescriptor().hasTransformUI(); * </pre> * * @return <code>true</code> if a user interface is available, in this case the {@link #getMapTransformUI} method * never returns null. */ public boolean hasMapTransformUI() { return getMapTransform().getDescriptor().hasTransformUI(); }
public static Point2D[] createMapBoundary(Product product, Rectangle rect, int step, MapTransform mapTransform) { GeoPos[] geoPoints = createGeoBoundary(product, rect, step); normalizeGeoPolygon(geoPoints); Point2D[] mapPoints = new Point2D[geoPoints.length]; for (int i = 0; i < geoPoints.length; i++) { mapPoints[i] = mapTransform.forward(geoPoints[i], new Point2D.Float()); } return mapPoints; }
public void testInverseTransform() { GeoPos geoPt = new GeoPos(); Point2D mapPt = new Point2D.Double(); MapTransformDescriptor desc = new LambertConformalConicDescriptor(); // Parameter set 1 // --------------- MapTransform trans = desc.createTransform(_params_1); for (int n = 0; n < _targCoords_1.length; n++) { mapPt.setLocation(_targCoords_1[n][0], _targCoords_1[n][1]); geoPt = trans.inverse(mapPt, geoPt); assertEquals(_srcCoords_1[n][1], geoPt.getLat(), _angleDelta); assertEquals(_srcCoords_1[n][0], geoPt.getLon(), _angleDelta); } // Parameter set 2 // --------------- trans = desc.createTransform(_params_2); for (int n = 0; n < _targCoords_2.length; n++) { mapPt.setLocation(_targCoords_2[n][0], _targCoords_2[n][1]); geoPt = trans.inverse(mapPt, geoPt); assertEquals(_srcCoords_2[n][1], geoPt.getLat(), _angleDelta); assertEquals(_srcCoords_2[n][0], geoPt.getLon(), _angleDelta); } } }
public DefaultMapTransformUI(MapTransform transform) { Guardian.assertNotNull("transform", transform); Debug.trace("DefaultMapTransformUI.init"); _transform = transform; _parameters = cloneParameterArray(transform.getDescriptor().getParameters()); setParameterValues(transform.getParameterValues()); traceParameterValues(); }
/** * Gets a user interface for editing the transformation properties of this map projection. * * @return the user interface or null if editing is not supported. The {@link #hasMapTransformUI()} hasTransformUI} method shall return * <code>false</code> in this case. */ public MapTransformUI getMapTransformUI() { MapTransform mapTransform = getMapTransform(); MapTransformDescriptor descriptor = mapTransform.getDescriptor(); return descriptor.getTransformUI(mapTransform); }
final MapProjection mapProjection = mapGeoCoding.getMapInfo().getMapProjection(); final MapTransform mapTransform = mapProjection.getMapTransform(); final Point2D mapPoint = mapTransform.forward(geoPos, null); final String mapUnit = mapProjection.getMapUnit();
/** * Alters the underlying map transformation by changing the values of the transform parameters named * "semi_major" and "semi_minor" (if any) to the ones of the supplied ellipsoid. * * @param ellipsoid the ellipsoid */ public void alterMapTransform(Ellipsoid ellipsoid) { final MapTransform oldTransform = getMapTransform(); final Parameter[] parameters = oldTransform.getDescriptor().getParameters(); final double[] parameterValues = oldTransform.getParameterValues(); boolean altered = false; for (int i = 0; i < parameters.length; i++) { if ("semi_minor".equals(parameters[i].getName())) { parameterValues[i] = ellipsoid.getSemiMinor(); altered = true; } else if ("semi_major".equals(parameters[i].getName())) { parameterValues[i] = ellipsoid.getSemiMajor(); altered = true; } } if (altered) { final MapTransform newTransform = oldTransform.getDescriptor().createTransform(parameterValues); setMapTransform(newTransform); } }
public void resetToDefaults() { Debug.trace("DefaultMapTransformUI.resetToDefaults"); setParameterValues(_transform.getDescriptor().getParameterDefaultValues()); }
public void testForwardTransform() { final MapTransform transform = MapTransformFactory.createTransform(StereographicDescriptor.TYPE_ID, DEFAULT_PARAMS); final float lat = 90.0f, lon = 25.0f; GeoPos geoPos = new GeoPos(lat, lon); Point2D mapPoint = transform.forward(geoPos, null); assertEquals(0.0, mapPoint.getX(), EPSILON); assertEquals(0.0, mapPoint.getY(), EPSILON); }
@Override public boolean equals(Object obj) { if (obj == this) { return true; } if (obj == null) { return false; } if (obj instanceof MapProjection) { MapProjection other = (MapProjection) obj; return ObjectUtils.equalObjects(other.getName(), getName()) && ObjectUtils.equalObjects(other.getMapUnit(), getMapUnit()) && ObjectUtils.equalObjects(other.getMapTransform().getDescriptor(), getMapTransform().getDescriptor()) && ObjectUtils.equalObjects(other.getMapTransform().getParameterValues(), getMapTransform().getParameterValues()); } return false; } }