Calc.transform() documentation and testing

lafita · lafita · commit fdb5cb0a2dea · 2015-07-22T15:49:38.000+02:00
diff --git a/biojava-structure-gui/src/main/java/demo/AlignmentGuiDemo.java b/biojava-structure-gui/src/main/java/demo/AlignmentGuiDemo.java
@@ -24,20 +24,20 @@
 
 
 import org.biojava.nbio.structure.align.gui.AlignmentGui;
+import org.biojava.nbio.structure.align.gui.MultipleAlignmentGUI;
 
 /**
+ * Get an instance of the two alignment GUIs.
+ * Try to align 2hyn vs. 1zll, for example.
  * 
  * @author Andreas Prlic
  *
  */
 public class AlignmentGuiDemo {
 
-	/** e.g. try to align 2hyn vs 1zll
-	 * 
-	 */
 	public static void main(String[] args) {
-			
+
 		AlignmentGui.getInstance();
-		
+		MultipleAlignmentGUI.getInstance();
 	}
 }
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/Calc.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/Calc.java
@@ -20,8 +20,6 @@
  * Created on 08.05.2004
  *
  */
-
-
 package org.biojava.nbio.structure ;
 
 import org.biojava.nbio.structure.jama.Matrix;
@@ -33,17 +31,15 @@
 import javax.vecmath.Point3d;
 import javax.vecmath.Vector3d;
 
-
-
-/** utility operations on Atoms, AminoAcids, etc.
+/** 
+ * Utility operations on Atoms, AminoAcids, etc.
  * <p>
- * Currently the
- * coordinates of an Atom are stored as an array of size 3
- * (double[3]). It would be more powerful to use Point3D from
- * javax.vecmath.  but unfortunately this is not a part of standard
- * java installations, since it comes with java3d . So to keep things
+ * Currently the coordinates of an Atom are stored as an array 
+ * of size 3 (double[3]). It would be more powerful to use Point3D from
+ * javax.vecmath, but unfortunately this is not a part of standard
+ * java installations, since it comes with java3d. So to keep things
  * simple at the moment biojava does not depend on java3d.
- * </p>
+ * 
  * @author Andreas Prlic
  * @since 1.4
  * @version %I% %G%
@@ -53,7 +49,6 @@ public class Calc {
 
 	private final static Logger logger = LoggerFactory.getLogger(Calc.class);
 
-
 	/**
 	 * calculate distance between two atoms.
 	 *
@@ -73,7 +68,7 @@ public static final double getDistance(Atom a, Atom b) {
 
 
 	/**
-	 * Will calculate the *square* of distances between two atoms. This will be
+	 * Will calculate the square of distances between two atoms. This will be
 	 * faster as it will not perform the final square root to get the actual
 	 * distance. Use this if doing large numbers of distance comparisons - it is
 	 * marginally faster than getDistance().
@@ -314,10 +309,9 @@ public static final boolean isConnected(AminoAcid a, AminoAcid b) {
 		return distance < 2.5;
 	}
 
-
-
-	/** rotate a single atom aroud a rotation matrix.
-	 * matrix must be a 3x3 matrix.
+	/** 
+	 * Rotate a single Atom aroud a rotation matrix.
+	 * The rotation Matrix must be a pre-multiplication 3x3 Matrix.
 	 *
 	 * If the matrix is indexed m[row][col], then the matrix will be
 	 * pre-multiplied (y=atom*M)
@@ -340,15 +334,18 @@ public static final void rotate(Atom atom, double[][] m){
 		atom.setZ(nz);
 	}
 
-	/** Rotate a structure.
+	/** 
+	 * Rotate a structure.
+	 * The rotation Matrix must be a pre-multiplication Matrix.
 	 *
 	 * @param structure a Structure object
-	 * @param rotationmatrix an array (3x3) of double representing the rotation matrix. 
+	 * @param rotationmatrix an array (3x3) of double 
+	 * 			representing the rotation matrix. 
 	 * @throws StructureException ...
 	 */
-	public static final void rotate(Structure structure, double[][] rotationmatrix)
-			throws StructureException
-	{
+	public static final void rotate(Structure structure, 
+			double[][] rotationmatrix) throws StructureException {
+		
 		if ( rotationmatrix.length != 3 ) {
 			throw new StructureException ("matrix does not have size 3x3 !");
 		}
@@ -359,13 +356,17 @@ public static final void rotate(Structure structure, double[][] rotationmatrix)
 		}
 	}
 
-	/** rotate a structure .
+	/** 
+	 * Rotate a Group.
+	 * The rotation Matrix must be a pre-multiplication Matrix.
 	 *
 	 * @param group a group object
-	 * @param rotationmatrix an array (3x3) of double representing the rotation matrix. 
+	 * @param rotationmatrix an array (3x3) of double 
+	 * 			representing the rotation matrix. 
 	 * @throws StructureException ...
 	 */
-	public static final void rotate(Group group, double[][] rotationmatrix) throws StructureException {
+	public static final void rotate(Group group, 
+			double[][] rotationmatrix) throws StructureException {
 
 		if ( rotationmatrix.length != 3 ) {
 			throw new StructureException ("matrix does not have size 3x3 !");
@@ -380,7 +381,9 @@ public static final void rotate(Group group, double[][] rotationmatrix) throws S
 		}
 	}
 
-	/** Rotate an atom around a Matrix object.
+	/** 
+	 * Rotate an Atom around a Matrix object.
+	 * The rotation Matrix must be a pre-multiplication Matrix.
 	 *
 	 * @param atom atom to be rotated
 	 * @param m rotation matrix to be applied to the atom
@@ -401,7 +404,9 @@ public static final void rotate(Atom atom, Matrix m){
 
 	}
 
-	/** Rotate a group object.
+	/** 
+	 * Rotate a group object.
+	 * The rotation Matrix must be a pre-multiplication Matrix.
 	 *
 	 * @param group  a group to be rotated
 	 * @param m a Matrix object representing the rotation matrix
@@ -418,7 +423,9 @@ public static final void rotate(Group group, Matrix m){
 
 	}
 
-	/** Rotate a structure object.
+	/** 
+	 * Rotate a structure object.
+	 * The rotation Matrix must be a pre-multiplication Matrix.
 	 *
 	 * @param structure the structure to be rotated
 	 * @param m rotation matrix to be applied 
@@ -437,6 +444,8 @@ public static final void rotate(Structure structure, Matrix m){
 
 	/**
 	 * Transform an array of atoms at once.
+	 * The transformation Matrix must be a post-multiplication Matrix.
+	 * 
 	 * @param ca array of Atoms to shift
 	 * @param t transformation Matrix4d
 	 */
@@ -446,7 +455,9 @@ public static void transform(Atom[] ca, Matrix4d t) {
 
 	/**
 	 * Transforms an atom object, given a Matrix4d (i.e. the vecmath library 
-	 * double-precision 4x4 rotation+translation matrix)
+	 * double-precision 4x4 rotation+translation matrix).
+	 * The transformation Matrix must be a post-multiplication Matrix.
+	 * 
 	 * @param atom
 	 * @param m
 	 */
@@ -462,7 +473,9 @@ public static final void transform (Atom atom, Matrix4d m) {
 
 	/**
 	 * Transforms a group object, given a Matrix4d (i.e. the vecmath library 
-	 * double-precision 4x4 rotation+translation matrix)
+	 * double-precision 4x4 rotation+translation matrix).
+	 * The transformation Matrix must be a post-multiplication Matrix.
+	 * 
 	 * @param group
 	 * @param m
 	 */
@@ -478,7 +491,9 @@ public static final void transform (Group group, Matrix4d m) {
 
 	/**
 	 * Transforms a structure object, given a Matrix4d (i.e. the vecmath library 
-	 * double-precision 4x4 rotation+translation matrix)
+	 * double-precision 4x4 rotation+translation matrix).
+	 * The transformation Matrix must be a post-multiplication Matrix.
+	 * 
 	 * @param structure
 	 * @param m
 	 */
@@ -494,7 +509,9 @@ public static final void transform (Structure structure, Matrix4d m) {
 
 	/**
 	 * Transforms a chain object, given a Matrix4d (i.e. the vecmath library 
-	 * double-precision 4x4 rotation+translation matrix)
+	 * double-precision 4x4 rotation+translation matrix).
+	 * The transformation Matrix must be a post-multiplication Matrix.
+	 * 
 	 * @param chain
 	 * @param m
 	 */
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/align/multiple/AbstractScoresCache.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/align/multiple/AbstractScoresCache.java
@@ -15,36 +15,36 @@
  */
 public abstract class AbstractScoresCache implements ScoresCache {
 	private Map<String,Double> scores = null;
-	
+
 	protected AbstractScoresCache() {
 		scores = null;
 	}
 	protected AbstractScoresCache(AbstractScoresCache cache) {
 		this.scores = cache.scores;
 	}
-	
+
 	@Override
 	public void putScore(String property, Double score) {
-			if(scores == null) {
-				scores = new HashMap<String, Double>();
-			}
-			scores.put(property, score);
+		if(scores == null) {
+			scores = new HashMap<String, Double>();
+		}
+		scores.put(property, score);
 	}
-	
+
 	@Override
 	public Double getScore(String property) {
 		if(scores != null && scores.containsKey(property)) {
 			return scores.get(property);
 		}
 		return null;
 	}
-	
+
 	@Override
 	public Set<String> getScores() {
 		if(scores == null) return Collections.emptySet();
 		return Collections.unmodifiableSet(scores.keySet());
 	}
-	
+
 	/**
 	 * Subclasses should override clone and use the copy constructor.
 	 * 
@@ -55,7 +55,7 @@ public Set<String> getScores() {
 	protected Object clone(Object e) throws CloneNotSupportedException {
 		throw new CloneNotSupportedException("Subclasses must override clone");
 	}
-	
+
 	/**
 	 * Clear the cached scores. This frees memory after the alignment changed.
 	 */
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/align/multiple/util/MultipleAlignmentScorer.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/align/multiple/util/MultipleAlignmentScorer.java
@@ -13,8 +13,6 @@
 
 /**
  * Utility class for calculating common scores of {@link MultipleAlignment}s.
- * <p>
- * 
  * 
  * @author Spencer Bliven
  * @author Aleix Lafita
diff --git a/biojava-structure/src/test/java/org/biojava/nbio/structure/TestCalc.java b/biojava-structure/src/test/java/org/biojava/nbio/structure/TestCalc.java
@@ -2,6 +2,11 @@
 
 import static org.junit.Assert.*;
 
+import javax.vecmath.Matrix4d;
+import javax.vecmath.Point3d;
+
+import org.biojava.nbio.structure.align.util.RotationAxis;
+import org.biojava.nbio.structure.jama.Matrix;
 import org.junit.Test;
 
 public class TestCalc {
@@ -35,7 +40,6 @@ public void testAngle() {
 		assertTrue(Calc.angle(ref, a6)>=0 && Calc.angle(ref,a6)<=180.0);
 		assertTrue(Calc.angle(ref, a7)>=0 && Calc.angle(ref,a7)<=180.0);
 		
-	
 		Atom c = getAtom(0,0,0);
 		Atom d = getAtom(0,0,0);
 		
@@ -80,7 +84,59 @@ public void testTorsionAngle() {
 		assertEquals(0, Calc.torsionAngle(a, b, c, d),0.00001);
 	}
 	
+	@Test
+	public void testJamaTransformation() {
+		
+		Atom atom = getAtom(1.0, 1.0, 1.0);
+		
+		//Identity transform
+		Matrix identR = Matrix.identity(3, 3);
+		Atom identT = getAtom(0, 0, 0);
+		Calc.rotate(atom, identR);
+		Calc.shift(atom, identT);
+		
+		Point3d expected = new Point3d(1.0, 1.0, 1.0);
+		Point3d actual = new Point3d(atom.getCoords());
+		
+		assertEquals(expected, actual);
+		
+		//Sample transform: calc transposes automatically the matrix
+		//because it is a pre-multiplication rotation matrix
+		Matrix sampleR = Calc.getRotationMatrix(getSampleTransform());
+		Atom sampleT = Calc.getTranslationVector(getSampleTransform());
+		Calc.rotate(atom, sampleR);
+		Calc.shift(atom, sampleT);
+		
+		expected = new Point3d(2.0, 7.0, -1.3);
+		actual = new Point3d(atom.getCoords());
+		
+		assertEquals(expected, actual);
+	}
 	
+	@Test
+	public void testVecmathTransformation() {
+		
+		Atom atom = getAtom(1.0, 1.0, 1.0);
+		
+		//Identity transform
+		Matrix4d ident = new Matrix4d();
+		ident.setIdentity();
+		Calc.transform(atom, ident);
+		
+		Point3d expected = new Point3d(1.0, 1.0, 1.0);
+		Point3d actual = new Point3d(atom.getCoords());
+		
+		assertEquals(expected, actual);
+		
+		//Sample transform
+		Matrix4d sample = getSampleTransform();
+		Calc.transform(atom, sample);
+		
+		expected = new Point3d(2.0, 7.0, -1.3);
+		actual = new Point3d(atom.getCoords());
+		
+		assertEquals(expected, actual);
+	}
 	
 	private static Atom getAtom(double x, double y, double z) {
 		Atom a = new AtomImpl();
@@ -89,6 +145,14 @@ private static Atom getAtom(double x, double y, double z) {
 		a.setZ(z);
 		return a;
 	}
-
 	
+	private static Matrix4d getSampleTransform(){
+		
+		Matrix4d sample = new Matrix4d(new double[] {1.0,1.5,0.5,-1.0,
+		                                0.5,0.5,1.0,5.0,
+		                                0.3,0.4,0.5,-2.5,
+		                                0.0,0.0,0.0,1.0});
+		return sample;
+	}
+
 }

Original file line number	Diff line number	Diff line change
`@@ -24,20 +24,20 @@`
`24`	`24`
`25`	`25`
`26`	`26`	`import org.biojava.nbio.structure.align.gui.AlignmentGui;`
	`27`	`+import org.biojava.nbio.structure.align.gui.MultipleAlignmentGUI;`
`27`	`28`
`28`	`29`	`/**`
	`30`	`+ * Get an instance of the two alignment GUIs.`
	`31`	`+ * Try to align 2hyn vs. 1zll, for example.`
`29`	`32`	`*`
`30`	`33`	`* @author Andreas Prlic`
`31`	`34`	`*`
`32`	`35`	`*/`
`33`	`36`	`public class AlignmentGuiDemo {`
`34`	`37`
`35`		`- /** e.g. try to align 2hyn vs 1zll`
`36`		`- *`
`37`		`- */`
`38`	`38`	`public static void main(String[] args) {`
`39`		`-`
	`39`	`+`
`40`	`40`	`AlignmentGui.getInstance();`
`41`		`-`
	`41`	`+ MultipleAlignmentGUI.getInstance();`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,6 @@`
`13`	`13`
`14`	`14`	`/**`
`15`	`15`	`* Utility class for calculating common scores of {@link MultipleAlignment}s.`
`16`		`- * <p>`
`17`		`- *`
`18`	`16`	`*`
`19`	`17`	`* @author Spencer Bliven`
`20`	`18`	`* @author Aleix Lafita`