/**
* Test that point features are rendered at the expected image coordinates when the map is
* rotated. StreamingRenderer
*
* @throws Exception
*/
@Test
public void testRotatedTransform() throws Exception {
// If we rotate the world rectangle + 90 degrees around (0,0), we get the screen rectangle
final Rectangle screen = new Rectangle(0, 0, 100, 50);
final Envelope world = new Envelope(0, 50, 0, -100);
final AffineTransform worldToScreen =
AffineTransform.getRotateInstance(Math.toRadians(90), 0, 0);
DefaultFeatureCollection fc = new DefaultFeatureCollection();
fc.add(createPoint(0, 0));
fc.add(createPoint(world.getMaxX(), world.getMinY()));
MapContext mapContext = new DefaultMapContext(DefaultGeographicCRS.WGS84);
mapContext.addLayer((FeatureCollection) fc, createPointStyle());
BufferedImage image =
new BufferedImage(screen.width, screen.height, BufferedImage.TYPE_4BYTE_ABGR);
final StreamingRenderer sr = new StreamingRenderer();
sr.setContext(mapContext);
sr.paint(image.createGraphics(), screen, worldToScreen);
assertTrue("Pixel should be drawn at 0,0 ", image.getRGB(0, 0) != 0);
assertTrue(
"Pixel should not be drawn in image centre ",
image.getRGB(screen.width / 2, screen.height / 2) == 0);
assertTrue(
"Pixel should be drawn at image max corner ",
image.getRGB(screen.width - 1, screen.height - 1) != 0);
}
public class VectorDefinitionTest {
private static final double NoDifferenceAllowed = 0.0;
private static final double TestInitX1 = 0.0;
private static final double TestInitY1 = 0.0;
private static final double TestInitX2 = 1.0;
private static final double TestInitY2 = 1.0;
private static final double TestInitLength = Math.sqrt(2.0);
private static final double TestNewLength = 2.0 * TestInitLength;
private static final double TestScale = 2.0;
private static final double TestShiftedX2 = -1.0;
private static final double TestShiftedY2 = -1.0;
private static final double TestShiftValue = 7.8;
private static final double TestRotation = Math.toRadians(45.0);
private static final double TestRotatedX = 0.0;
private static final double TestRotatedY = Math.sqrt(2.0);
private static final double TestRotationAllowedDifference = Math.pow(10, -10);
private static final double TestNewX1 = 3.0;
private static final double TestNewY1 = 4.0;
private static final double TestNewX2 = 5.0;
private static final double TestNewY2 = 6.0;
private VectorDefinition vectorDefinition;
@Before
public void
setUp() // do not catch these, successful reflection must be successful to be able to test
throws NoSuchMethodException, SecurityException, InstantiationException,
IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Constructor<VectorDefinition> constructor =
VectorDefinition.class.getDeclaredConstructor(
double.class, double.class, double.class, double.class);
constructor.setAccessible(true);
vectorDefinition =
(VectorDefinition) constructor.newInstance(TestInitX1, TestInitY1, TestInitX2, TestInitY2);
}
@Test
public final void testGetLength() {
assertEquals(TestInitLength, vectorDefinition.getLength(), NoDifferenceAllowed);
}
@Test
public final void testAppendLength() {
vectorDefinition.AppendLength(TestInitLength);
assertEquals(TestNewLength, vectorDefinition.getLength(), NoDifferenceAllowed);
}
@Test
public final void testScale() {
vectorDefinition.Scale(TestScale);
assertEquals(TestInitX2 * TestScale, vectorDefinition.getX2(), NoDifferenceAllowed);
assertEquals(TestInitY2 * TestScale, vectorDefinition.getY2(), NoDifferenceAllowed);
}
@Test
public final void testSetLength() {
vectorDefinition.setLength(TestNewLength);
assertEquals(TestNewLength, vectorDefinition.getLength(), NoDifferenceAllowed);
}
@Test
public final void testShiftOrigin() {
vectorDefinition.shiftOrigin();
assertEquals(TestShiftedX2, vectorDefinition.getX2(), NoDifferenceAllowed);
assertEquals(TestShiftedY2, vectorDefinition.getY2(), NoDifferenceAllowed);
}
@Test
public final void testShiftOnArrow() {
vectorDefinition.shiftOnArrow(TestShiftValue);
assertEquals(
TestInitX2 - TestInitX1,
vectorDefinition.getX2() - vectorDefinition.getX1(),
NoDifferenceAllowed);
assertEquals(
TestInitY2 - TestInitY1,
vectorDefinition.getY2() - vectorDefinition.getY1(),
NoDifferenceAllowed);
}
@Test
public final void testRotate() {
vectorDefinition.Rotate(TestRotation);
assertEquals(TestRotatedX, vectorDefinition.getX2(), TestRotationAllowedDifference);
assertEquals(TestRotatedY, vectorDefinition.getY2(), TestRotationAllowedDifference);
}
@Test
public final void testGetX1() {
assertEquals(TestInitX1, vectorDefinition.getX1(), NoDifferenceAllowed);
}
@Test
public final void testSetX1() {
vectorDefinition.setX1(TestNewX1);
assertEquals(TestNewX1, vectorDefinition.getX1(), NoDifferenceAllowed);
}
@Test
public final void testGetY1() {
assertEquals(TestInitY1, vectorDefinition.getY1(), NoDifferenceAllowed);
}
@Test
public final void testSetY1() {
vectorDefinition.setY1(TestNewY1);
assertEquals(TestNewY1, vectorDefinition.getY1(), NoDifferenceAllowed);
}
@Test
public final void testGetX2() {
assertEquals(TestInitX2, vectorDefinition.getX2(), NoDifferenceAllowed);
}
@Test
public final void testSetX2() {
vectorDefinition.setX2(TestNewX2);
assertEquals(TestNewX2, vectorDefinition.getX2(), NoDifferenceAllowed);
}
@Test
public final void testGetY2() {
assertEquals(TestInitY2, vectorDefinition.getY2(), NoDifferenceAllowed);
}
@Test
public final void testSetY2() {
vectorDefinition.setY2(TestNewY2);
assertEquals(TestNewY2, vectorDefinition.getY2(), NoDifferenceAllowed);
}
@Test
public final void testGetPointStart() {
I2DPoint resultPoint = vectorDefinition.getPointStart();
assertEquals(TestInitX1, resultPoint.getX(), NoDifferenceAllowed);
assertEquals(TestInitY1, resultPoint.getY(), NoDifferenceAllowed);
}
@Test
public final void testGetPointEnd() {
I2DPoint resultPoint = vectorDefinition.getPointEnd();
assertEquals(TestInitX2, resultPoint.getX(), NoDifferenceAllowed);
assertEquals(TestInitY2, resultPoint.getY(), NoDifferenceAllowed);
}
}
/**
* Run the test in the flipped or unflipped case.
*
* @param f -1 for the flipped case, or +1 for the unflipped case.
*/
private static void runTest(final int f) {
// Test identity
final AffineTransform tr = new AffineTransform();
tr.setToScale(1, f);
assertEquals(1, XAffineTransform.getScaleX0(tr), EPS);
assertEquals(1, XAffineTransform.getScaleY0(tr), EPS);
assertEquals(0, XAffineTransform.getRotation(tr), EPS);
assertEquals(1, XAffineTransform.getSwapXY(tr));
assertEquals(f, XAffineTransform.getFlip(tr));
assertEquals(f, getFlipFromType(tr));
// Tests rotation (< 45°)
double r = Math.toRadians(25);
tr.rotate(r);
assertEquals(1, XAffineTransform.getScaleX0(tr), EPS);
assertEquals(1, XAffineTransform.getScaleY0(tr), EPS);
assertEquals(r, XAffineTransform.getRotation(tr), EPS);
assertEquals(1, XAffineTransform.getSwapXY(tr));
assertEquals(f, XAffineTransform.getFlip(tr));
assertEquals(f, getFlipFromType(tr));
// Tests more rotation (> 45°)
r = Math.toRadians(65);
tr.rotate(Math.toRadians(40));
assertEquals(1, XAffineTransform.getScaleX0(tr), EPS);
assertEquals(1, XAffineTransform.getScaleY0(tr), EPS);
assertEquals(r, XAffineTransform.getRotation(tr), EPS);
assertEquals(-1, XAffineTransform.getSwapXY(tr));
assertEquals(f, XAffineTransform.getFlip(tr));
assertEquals(f, getFlipFromType(tr));
// Tests scale
tr.setToScale(2, 3 * f);
assertEquals(2, XAffineTransform.getScaleX0(tr), EPS);
assertEquals(3, XAffineTransform.getScaleY0(tr), EPS);
assertEquals(0, XAffineTransform.getRotation(tr), EPS);
assertEquals(1, XAffineTransform.getSwapXY(tr));
assertEquals(f, XAffineTransform.getFlip(tr));
assertEquals(f, getFlipFromType(tr));
// Tests rotation + scale
tr.rotate(r);
assertEquals(2, XAffineTransform.getScaleX0(tr), EPS);
assertEquals(3, XAffineTransform.getScaleY0(tr), EPS);
assertEquals(r, XAffineTransform.getRotation(tr), EPS);
assertEquals(-1, XAffineTransform.getSwapXY(tr));
assertEquals(f, XAffineTransform.getFlip(tr));
assertEquals(1, getFlipFromType(tr)); // Always unflipped according Java 1.5.0_09...
// Tests axis swapping
r = Math.toRadians(-90 * f);
tr.setTransform(0, 1, f, 0, 0, 0);
assertEquals(1, XAffineTransform.getScaleX0(tr), EPS);
assertEquals(1, XAffineTransform.getScaleY0(tr), EPS);
assertEquals(r, XAffineTransform.getRotation(tr), EPS);
assertEquals(-1, XAffineTransform.getSwapXY(tr));
assertEquals(-f, XAffineTransform.getFlip(tr));
assertEquals(-f, getFlipFromType(tr));
// Tests axis swapping + scale
tr.scale(2, 3);
assertEquals(3, XAffineTransform.getScaleX0(tr), EPS);
assertEquals(2, XAffineTransform.getScaleY0(tr), EPS);
assertEquals(r, XAffineTransform.getRotation(tr), EPS);
assertEquals(-1, XAffineTransform.getSwapXY(tr));
assertEquals(-f, XAffineTransform.getFlip(tr));
assertEquals(-f, getFlipFromType(tr));
}
/** Test of moverPunto method, of class OperacionesGeométricas. */
@Test
public void testMoverPunto() {
System.out.println("MoverPunto");
// Mover distancia y ángulo 0
Point2D.Double punto = new Point2D.Double(3, 3);
double ángulo = 0.0F;
double distancia = 0.0F;
Point2D.Double expResult = punto;
Point2D.Double result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
assertEquals(expResult, result);
// Puntos Cardinales
ángulo = Math.toRadians(0);
distancia = 1;
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(4, 3);
assertEquals(expResult, result);
ángulo = Math.toRadians(90);
distancia = 1;
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(3, 4);
assertEquals(expResult, result);
ángulo = Math.toRadians(180);
distancia = 1;
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(2, 3);
assertEquals(expResult, result);
ángulo = Math.toRadians(-90);
distancia = 1;
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(3, 2);
assertEquals(expResult, result);
// Mover distancia 0
ángulo = Math.toRadians(0);
distancia = 0;
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(3, 3);
assertEquals(expResult, result);
ángulo = Math.toRadians(90);
distancia = 0;
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(3, 3);
assertEquals(expResult, result);
ángulo = Math.toRadians(180);
distancia = 0;
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(3, 3);
assertEquals(expResult, result);
ángulo = Math.toRadians(270);
distancia = 0;
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(3, 3);
assertEquals(expResult, result);
ángulo = Math.toRadians(33);
distancia = 0;
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(3, 3);
assertEquals(expResult, result);
// Mover en diagonal
double delta = 0.000001;
distancia = Math.sqrt(2);
ángulo = Math.toRadians(45);
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(4, 4);
// assertEquals(expResult, result);
assertTrue(estáEnRango(result.getX(), expResult.getX(), delta));
assertTrue(estáEnRango(result.getY(), expResult.getY(), delta));
ángulo = Math.toRadians(135);
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(2, 4);
// assertEquals(expResult, result);
assertTrue(estáEnRango(result.getX(), expResult.getX(), delta));
assertTrue(estáEnRango(result.getY(), expResult.getY(), delta));
ángulo = Math.toRadians(225);
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(2, 2);
assertTrue(estáEnRango(result.getX(), expResult.getX(), delta));
assertTrue(estáEnRango(result.getY(), expResult.getY(), delta));
ángulo = Math.toRadians(315);
result = OperacionesGeométricas.moverPunto(punto, ángulo, distancia);
expResult = new Point2D.Double(4, 2);
// assertEquals(expResult, result);
assertTrue(estáEnRango(result.getX(), expResult.getX(), delta));
assertTrue(estáEnRango(result.getY(), expResult.getY(), delta));
// assertEquals(expResult, result);
}
