/*
* Geotoolkit.org - An Open Source Java GIS Toolkit
* http://www.geotoolkit.org
*
* (C) 2011-2012, Open Source Geospatial Foundation (OSGeo)
* (C) 2011-2012, Geomatys
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*/
package org.geotoolkit.referencing.operation.projection;
import org.opengis.parameter.ParameterValueGroup;
import org.opengis.referencing.operation.TransformException;
import org.apache.sis.parameter.Parameters;
import org.apache.sis.test.DependsOn;
import org.junit.*;
import static org.junit.Assert.*;
import static java.lang.StrictMath.*;
import static org.geotoolkit.referencing.operation.provider.Stereographic.PARAMETERS;
/**
* Tests the {@link Stereographic} class.
*
* @author Rémi Maréchal (Geomatys)
*
* @since 3.19
*/
@DependsOn(UnitaryProjectionTest.class)
public final strictfp class StereographicTest extends ProjectionTestBase {
/**
* Creates a default test suite.
*/
public StereographicTest() {
super(Stereographic.class, null);
}
/**
* Returns a new instance of {@link Stereographic}.
*
* @param ellipse {@code false} for a sphere, or {@code true} for WGS84 ellipsoid.
* @return Newly created projection.
*/
private static Stereographic create(final boolean ellipse) {
final Parameters parameters = parameters(wrap(PARAMETERS), ellipse, 0);
if (ellipse) {
return new Stereographic(new org.geotoolkit.referencing.operation.provider.Stereographic(), parameters);
} else {
return new Stereographic.Spherical(new org.geotoolkit.referencing.operation.provider.Stereographic(), parameters);
}
}
/**
* Computes the difference between the ellipsoidal formulas and the spherical ones.
* The spherical formulas are assumed exact.
*
* @throws TransformException Should never happen.
*/
@Test
@Ignore
public void testAssertions() throws TransformException {
final ParameterValueGroup values = PARAMETERS.createValue();
values.parameter("semi_major").setValue(SPHERE_RADIUS);
values.parameter("semi_minor").setValue(SPHERE_RADIUS);
final Stereographic.Spherical sphere = null; // TODO
//new Stereographic.Spherical(new Parameters(wrap(PARAMETERS), values));
// Buffers to be recycled.
final double[] source = new double[2];
final double[] expected = new double[2];
final double[] actual = new double[2];
final double[] errors = new double[180];
for (int ivf=200; ivf<400; ivf+=10) {
values.parameter("semi_minor").setValue(SPHERE_RADIUS * (1 - 1 / (double) ivf));
final Stereographic projection = null; // TODO new Stereographic(new Parameters(wrap(PARAMETERS), values));
for (int x=0; x<180; x++) {
double error = 0;
for (int y=-90; y<90; y+=5) {
source[0] = toRadians(x);
source[1] = toRadians(y);
sphere.transform(source, 0, expected, 0, 1);
projection.transform(source, 0, actual, 0, 1);
final double e = hypot(expected[0]-actual[0], expected[1]-actual[1]);
if (e > error) {
error = e;
}
}
if (error > errors[x]) {
errors[x] = error;
}
}
}
// Not doing anything useful with the errors array at this time.
// The above test was mostly to ensure that no assertion failure occur.
}
/**
* Creates a projection and derivates a few points.
*
* @throws TransformException Should never happen.
*/
@Test
public void testSphericalDerivative() throws TransformException {
tolerance = 1E-9;
final double delta = toRadians(100.0 / 60) / 1852; // Approximatively 100 metres.
//test derivée sphérique
transform = create(false);
assertTrue(isSpherical());
derivativeDeltas = new double[] {delta, delta};
verifyDerivative(toRadians( 0), toRadians( 0));
verifyDerivative(toRadians(-3), toRadians(30));
verifyDerivative(toRadians(+6), toRadians(60));
}
/**
* Creates a projection and derivates a few points.
*
* @throws TransformException Should never happen.
*/
@Test
public void testEllipsoidalDerivative() throws TransformException {
tolerance = 1E-9;
final double delta = toRadians(100.0 / 60) / 1852; // Approximatively 100 metres.
//test derivée ellipsoidalle
transform = create(true);
derivativeDeltas = new double[] {delta, delta};
verifyDerivative(toRadians( 0), toRadians( 0));
verifyDerivative(toRadians(-3), toRadians(30));
verifyDerivative(toRadians(+6), toRadians(60));
}
}