void checkTransformation(AffineTransformation trans0, AffineTransformation trans1) {
double[] m0 = trans0.getMatrixEntries();
double[] m1 = trans1.getMatrixEntries();
for (int i = 0; i < m0.length; i++) {
assertEquals(m0[i], m1[i], 0.000005);
}
}
public void testCompose2() {
AffineTransformation t0 = AffineTransformation.reflectionInstance(0, 0, 1, 0);
t0.reflect(0, 0, 0, -1);
AffineTransformation t1 = AffineTransformation.rotationInstance(Math.PI);
checkTransformation(t0, t1);
}
public void testCompose3() {
AffineTransformation t0 = AffineTransformation.reflectionInstance(0, 10, 10, 0);
t0.translate(-10, -10);
AffineTransformation t1 = AffineTransformation.reflectionInstance(0, 0, -1, 1);
checkTransformation(t0, t1);
}
public void testComposeRotation1() {
AffineTransformation t0 = AffineTransformation.rotationInstance(1, 10, 10);
AffineTransformation t1 = AffineTransformation.translationInstance(-10, -10);
t1.rotate(1);
t1.translate(10, 10);
checkTransformation(t0, t1);
}
void checkTransformation(String geomStr)
throws IOException, ParseException, NoninvertibleTransformationException {
Geometry geom = rdr.read(geomStr);
AffineTransformation trans = AffineTransformation.rotationInstance(Math.PI / 2);
AffineTransformation inv = trans.getInverse();
Geometry transGeom = (Geometry) geom.clone();
transGeom.apply(trans);
// System.out.println(transGeom);
transGeom.apply(inv);
// check if transformed geometry is equal to original
boolean isEqual = geom.equalsExact(transGeom, 0.0005);
assertTrue(isEqual);
}
public void testReflectXY2() throws IOException, ParseException {
AffineTransformation t = AffineTransformation.reflectionInstance(1, -1);
checkTransformation(10, 0, t, 0, -10);
checkTransformation(0, 10, t, -10, 0);
checkTransformation(-10, -10, t, 10, 10);
checkTransformation(-3, -4, t, 4, 3);
}
public void testRotateAroundPoint1() throws IOException, ParseException {
AffineTransformation t = AffineTransformation.rotationInstance(Math.PI / 2, 1, 1);
checkTransformation(1, 1, t, 1, 1);
checkTransformation(10, 0, t, 2, 10);
checkTransformation(0, 10, t, -8, 0);
checkTransformation(-10, -10, t, 12, -10);
}
/**
* Creates an AffineTransformation defined by a pair of control vectors. A control vector consists
* of a source point and a destination point, which is the image of the source point under the
* desired transformation. The computed transformation is a combination of one or more of a
* uniform scale, a rotation, and a translation (i.e. there is no shear component and no
* reflection)
*
* @param src0
* @param src1
* @param dest0
* @param dest1
* @return the computed transformation
* @return null if the control vectors do not determine a well-defined transformation
*/
public static AffineTransformation createFromControlVectors(
Coordinate src0, Coordinate src1, Coordinate dest0, Coordinate dest1) {
Coordinate rotPt = new Coordinate(dest1.x - dest0.x, dest1.y - dest0.y);
double ang = Angle.angleBetweenOriented(src1, src0, rotPt);
double srcDist = src1.distance(src0);
double destDist = dest1.distance(dest0);
if (srcDist == 0.0) return null;
double scale = destDist / srcDist;
AffineTransformation trans = AffineTransformation.translationInstance(-src0.x, -src0.y);
trans.rotate(ang);
trans.scale(scale, scale);
trans.translate(dest0.x, dest0.y);
return trans;
}
/**
* Creates an AffineTransformation defined by a maping between two baselines. The computed
* transformation consists of:
*
* <ul>
* <li>a translation from the start point of the source baseline to the start point of the
* destination baseline,
* <li>a rotation through the angle between the baselines fragment_about the destination start
* point,
* <li>and a scaling equal to the ratio of the baseline lengths.
* </ul>
*
* If the source baseline has zero length, an identity transformation is returned.
*
* @param src0 the start point of the source baseline
* @param src1 the end point of the source baseline
* @param dest0 the start point of the destination baseline
* @param dest1 the end point of the destination baseline
* @return the computed transformation
*/
public static AffineTransformation createFromBaseLines(
Coordinate src0, Coordinate src1, Coordinate dest0, Coordinate dest1) {
Coordinate rotPt = new Coordinate(src0.x + dest1.x - dest0.x, src0.y + dest1.y - dest0.y);
double ang = Angle.angleBetweenOriented(src1, src0, rotPt);
double srcDist = src1.distance(src0);
double destDist = dest1.distance(dest0);
// return identity if transformation would be degenerate
if (srcDist == 0.0) return new AffineTransformation();
double scale = destDist / srcDist;
AffineTransformation trans = AffineTransformation.translationInstance(-src0.x, -src0.y);
trans.rotate(ang);
trans.scale(scale, scale);
trans.translate(dest0.x, dest0.y);
return trans;
}
public void testCompose1() {
AffineTransformation t0 = AffineTransformation.translationInstance(10, 0);
t0.rotate(Math.PI / 2);
t0.translate(0, -10);
AffineTransformation t1 = AffineTransformation.translationInstance(0, 0);
t1.rotate(Math.PI / 2);
checkTransformation(t0, t1);
}
/**
* Checks that a transformation produces the expected result
*
* @param x the input pt x
* @param y the input pt y
* @param trans the transformation
* @param xp the expected output x
* @param yp the expected output y
*/
void checkTransformation(double x, double y, AffineTransformation trans, double xp, double yp) {
Coordinate p = new Coordinate(x, y);
Coordinate p2 = new Coordinate();
trans.transform(p, p2);
assertEquals(xp, p2.x, .00005);
assertEquals(yp, p2.y, .00005);
// if the transformation is invertible, test the inverse
try {
AffineTransformation invTrans = trans.getInverse();
Coordinate pInv = new Coordinate();
invTrans.transform(p2, pInv);
assertEquals(x, pInv.x, .00005);
assertEquals(y, pInv.y, .00005);
double det = trans.getDeterminant();
double detInv = invTrans.getDeterminant();
assertEquals(det, 1.0 / detInv, .00005);
} catch (NoninvertibleTransformationException ex) {
}
}
public void testTranslateRotate1() throws IOException, ParseException {
AffineTransformation t = AffineTransformation.translationInstance(3, 3).rotate(Math.PI / 2);
checkTransformation(10, 0, t, -3, 13);
checkTransformation(-10, -10, t, 7, -7);
}
public void testTranslate1() throws IOException, ParseException {
AffineTransformation t = AffineTransformation.translationInstance(2, 3);
checkTransformation(1, 0, t, 3, 3);
checkTransformation(0, 0, t, 2, 3);
checkTransformation(-10, -5, t, -8, -2);
}
public void testScale1() throws IOException, ParseException {
AffineTransformation t = AffineTransformation.scaleInstance(2, 3);
checkTransformation(10, 0, t, 20, 0);
checkTransformation(0, 10, t, 0, 30);
checkTransformation(-10, -10, t, -20, -30);
}
public void testReflectXYXY1() throws IOException, ParseException {
AffineTransformation t = AffineTransformation.reflectionInstance(0, 5, 5, 0);
checkTransformation(5, 0, t, 5, 0);
checkTransformation(0, 0, t, 5, 5);
checkTransformation(-10, -10, t, 15, 15);
}
public void testShear1() throws IOException, ParseException {
AffineTransformation t = AffineTransformation.shearInstance(2, 3);
checkTransformation(10, 0, t, 10, 30);
}
/**
* Creates an AffineTransformation defined by a single control vector. A control vector consists
* of a source point and a destination point, which is the image of the source point under the
* desired transformation. This produces a translation.
*
* @param src0 the start point of the control vector
* @param dest0 the end point of the control vector
* @return the computed transformation
*/
public static AffineTransformation createFromControlVectors(Coordinate src0, Coordinate dest0) {
double dx = dest0.x - src0.x;
double dy = dest0.y - src0.y;
return AffineTransformation.translationInstance(dx, dy);
}
public void testRotate1() throws IOException, ParseException {
AffineTransformation t = AffineTransformation.rotationInstance(Math.PI / 2);
checkTransformation(10, 0, t, 0, 10);
checkTransformation(0, 10, t, -10, 0);
checkTransformation(-10, -10, t, 10, -10);
}
