X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=inline;f=src%2Fjalview%2Fanalysis%2FAlignmentSorter.java;h=20101dc908c91448b86c396dc648548c6024b45c;hb=b8d09897dacc7b0ad203982b4578e2c1d8929142;hp=7c2a554c952b11a1803b079f13089aea97734000;hpb=588042b69abf8e60bcc950b24c283933c7dd422f;p=jalview.git
diff --git a/src/jalview/analysis/AlignmentSorter.java b/src/jalview/analysis/AlignmentSorter.java
index 7c2a554..20101dc 100755
--- a/src/jalview/analysis/AlignmentSorter.java
+++ b/src/jalview/analysis/AlignmentSorter.java
@@ -20,8 +20,6 @@ package jalview.analysis;
import jalview.datamodel.*;
-import jalview.io.*;
-
import jalview.util.*;
import java.util.*;
@@ -29,8 +27,8 @@ import java.util.*;
/** Data structure to hold and manipulate a multiple sequence alignment
*/
-public class AlignmentSorter {
- /** */
+public class AlignmentSorter
+{
static boolean sortIdAscending = true;
static int lastGroupHash = 0;
static boolean sortGroupAscending = true;
@@ -39,44 +37,21 @@ public class AlignmentSorter {
static NJTree lastTree = null;
static boolean sortTreeAscending = true;
- private AlignmentSorter() {
- try {
- jbInit();
- } catch (Exception ex) {
- ex.printStackTrace();
- }
- }
-
- public static void sortGroups(AlignmentI align) {
- Vector groups = align.getGroups();
- int nGroup = groups.size();
-
- float[] arr = new float[nGroup];
- Object[] s = new Object[nGroup];
-
- for (int i = 0; i < nGroup; i++) {
- arr[i] = ((SequenceGroup) groups.elementAt(i)).getSize();
- s[i] = groups.elementAt(i);
- }
-
- QuickSort.sort(arr, s);
-
- // align..setGroups(newg);
- }
-
/**
* Sort by Percentage Identity
*
* @param align AlignmentI
* @param s SequenceI
*/
- public static void sortByPID(AlignmentI align, SequenceI s) {
+ public static void sortByPID(AlignmentI align, SequenceI s)
+ {
int nSeq = align.getHeight();
float[] scores = new float[nSeq];
SequenceI[] seqs = new SequenceI[nSeq];
- for (int i = 0; i < nSeq; i++) {
+ for (int i = 0; i < nSeq; i++)
+ {
scores[i] = Comparison.PID(align.getSequenceAt(i), s);
seqs[i] = align.getSequenceAt(i);
}
@@ -86,171 +61,285 @@ public class AlignmentSorter {
setReverseOrder(align, seqs);
}
- private static void setReverseOrder(AlignmentI align, SequenceI[] seqs) {
+ /**
+ * Reverse the order of the sort
+ *
+ * @param align DOCUMENT ME!
+ * @param seqs DOCUMENT ME!
+ */
+ private static void setReverseOrder(AlignmentI align, SequenceI[] seqs)
+ {
int nSeq = seqs.length;
int len = 0;
- if ((nSeq % 2) == 0) {
+ if ((nSeq % 2) == 0)
+ {
len = nSeq / 2;
- } else {
+ }
+ else
+ {
len = (nSeq + 1) / 2;
}
// NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work
- for (int i = 0; i < len; i++) {
+ for (int i = 0; i < len; i++)
+ {
//SequenceI tmp = seqs[i];
align.getSequences().setElementAt(seqs[nSeq - i - 1], i);
align.getSequences().setElementAt(seqs[i], nSeq - i - 1);
}
}
- private static void setOrder(AlignmentI align, Vector tmp) {
+ /**
+ * Sets the Alignment object with the given sequences
+ *
+ * @param align Alignment object to be updated
+ * @param tmp sequences as a vector
+ */
+ private static void setOrder(AlignmentI align, Vector tmp)
+ {
setOrder(align, vectorSubsetToArray(tmp, align.getSequences()));
}
- private static void setOrder(AlignmentI align, SequenceI[] seqs) {
+ /**
+ * Sets the Alignment object with the given sequences
+ *
+ * @param align DOCUMENT ME!
+ * @param seqs sequences as an array
+ */
+ private static void setOrder(AlignmentI align, SequenceI[] seqs)
+ {
// NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work
Vector algn = align.getSequences();
- for (int i = 0, p = 0; i < seqs.length; i++)
- algn.setElementAt(seqs[i], p++);
+ for (int i = 0; i < seqs.length; i++)
+ {
+ algn.setElementAt(seqs[i], i);
+ }
}
- public static void sortByID(AlignmentI align) {
+ /**
+ * Sorts by ID. Numbers are sorted before letters.
+ *
+ * @param align The alignment object to sort
+ */
+ public static void sortByID(AlignmentI align)
+ {
int nSeq = align.getHeight();
String[] ids = new String[nSeq];
SequenceI[] seqs = new SequenceI[nSeq];
- for (int i = 0; i < nSeq; i++) {
+ for (int i = 0; i < nSeq; i++)
+ {
ids[i] = align.getSequenceAt(i).getName();
seqs[i] = align.getSequenceAt(i);
}
QuickSort.sort(ids, seqs);
- if (sortIdAscending) {
+ if (sortIdAscending)
+ {
setReverseOrder(align, seqs);
- } else {
+ }
+ else
+ {
setOrder(align, seqs);
}
sortIdAscending = !sortIdAscending;
}
- public static void sortByGroup(AlignmentI align) {
- Vector groups = align.getGroups();
-
- if (groups.hashCode() != lastGroupHash) {
+ /**
+ * Sorts the alignment by size of group.
+ *
Maintains the order of sequences in each group
+ * by order in given alignment object.
+ *
+ * @param align sorts the given alignment object by group
+ */
+ public static void sortByGroup(AlignmentI align)
+ {
+ //MAINTAINS ORIGNAL SEQUENCE ORDER,
+ //ORDERS BY GROUP SIZE
+ Vector groups = new Vector();
+
+ if (groups.hashCode() != lastGroupHash)
+ {
sortGroupAscending = true;
lastGroupHash = groups.hashCode();
- } else {
+ }
+ else
+ {
sortGroupAscending = !sortGroupAscending;
}
- Vector seqs = new Vector();
+ //SORTS GROUPS BY SIZE
+ //////////////////////
+ for (int i = 0; i < align.getGroups().size(); i++)
+ {
+ SequenceGroup sg = (SequenceGroup) align.getGroups().elementAt(i);
- for (int i = 0; i < groups.size(); i++) {
- SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
+ for (int j = 0; j < groups.size(); j++)
+ {
+ SequenceGroup sg2 = (SequenceGroup) groups.elementAt(j);
+
+ if (sg.getSize() > sg2.getSize())
+ {
+ groups.insertElementAt(sg, j);
- for (int j = 0; j < sg.getSize(); j++) {
- seqs.addElement(sg.getSequenceAt(j));
+ break;
+ }
+ }
+
+ if (!groups.contains(sg))
+ {
+ groups.addElement(sg);
}
}
- // Deletions can happen so this check may fail
+ //NOW ADD SEQUENCES MAINTAINING ALIGNMENT ORDER
+ ///////////////////////////////////////////////
+ Vector seqs = new Vector();
- /*
- if (seqs.size() != nSeq) {
- System.err.println("ERROR: tmp.size() != nseq in sortByGroups");
- if (seqs.size() < nSeq) {
- addStrays(align,seqs);
- }
+ for (int i = 0; i < groups.size(); i++)
+ {
+ SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
+ SequenceI[] orderedseqs = sg.getSequencesInOrder(align);
+
+ for (int j = 0; j < orderedseqs.length; j++)
+ {
+ seqs.addElement(orderedseqs[j]);
+ }
}
- */
- if (sortGroupAscending) {
+
+ if (sortGroupAscending)
+ {
setOrder(align, seqs);
- } else {
+ }
+ else
+ {
setReverseOrder(align,
vectorSubsetToArray(seqs, align.getSequences()));
}
}
- private static SequenceI[] vectorToArray(Vector tmp) {
+ /**
+ * Converts Vector to array.
+ * java 1.18 does not have Vector.toArray()
+ *
+ * @param tmp Vector of SequenceI objects
+ *
+ * @return array of Sequence[]
+ */
+ private static SequenceI[] vectorToArray(Vector tmp)
+ {
SequenceI[] seqs = new SequenceI[tmp.size()];
- for (int i = 0; i < tmp.size(); i++) {
+ for (int i = 0; i < tmp.size(); i++)
+ {
seqs[i] = (SequenceI) tmp.elementAt(i);
}
return seqs;
}
- private static SequenceI[] vectorSubsetToArray(Vector tmp, Vector mask) {
+ /**
+ * DOCUMENT ME!
+ *
+ * @param tmp DOCUMENT ME!
+ * @param mask DOCUMENT ME!
+ *
+ * @return DOCUMENT ME!
+ */
+ private static SequenceI[] vectorSubsetToArray(Vector tmp, Vector mask)
+ {
Vector seqs = new Vector();
int i;
- int m;
- int p;
- boolean[] tmask = new boolean[m = mask.size()];
+ boolean[] tmask = new boolean[mask.size()];
- for (i = 0; i < m; i++)
+ for (i = 0; i < mask.size(); i++)
tmask[i] = true;
- for (i = 0; i < tmp.size(); i++) {
- Object sq;
+ for (i = 0; i < tmp.size(); i++)
+ {
+ Object sq = tmp.elementAt(i);
- if (mask.contains(sq = tmp.elementAt(i))) {
+ if (mask.contains(sq) && tmask[mask.indexOf(sq)])
+ {
tmask[mask.indexOf(sq)] = false;
seqs.addElement(sq);
- m--;
}
}
for (i = 0; i < tmask.length; i++)
- if (tmask[i]) {
+ if (tmask[i])
+ {
seqs.addElement(mask.elementAt(i));
}
return vectorToArray(seqs);
}
- public static void sortBy(AlignmentI align, AlignmentOrder order) {
+ /**
+ * Sorts by a given AlignmentOrder object
+ *
+ * @param align Alignment to order
+ * @param order specified order for alignment
+ */
+ public static void sortBy(AlignmentI align, AlignmentOrder order)
+ {
// Get an ordered vector of sequences which may also be present in align
Vector tmp = order.getOrder();
- // if (tmp.size()