X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAlignmentSorter.java;h=20101dc908c91448b86c396dc648548c6024b45c;hb=fbec1b33d0fc169d72be059a5d2cf12b248270e1;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.
+     * <br>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()<align.getHeight())
-        //      addStrays(align, tmp);
-        if (lastOrder == order) {
+        if (lastOrder == order)
+        {
             sortOrderAscending = !sortOrderAscending;
-        } else {
+        }
+        else
+        {
             sortOrderAscending = true;
         }
 
-        if (sortOrderAscending) {
+        if (sortOrderAscending)
+        {
             setOrder(align, tmp);
-        } else {
+        }
+        else
+        {
             setReverseOrder(align,
                 vectorSubsetToArray(tmp, align.getSequences()));
         }
     }
 
-    public static Vector getOrderByTree(AlignmentI align, NJTree tree) {
+    /**
+     * DOCUMENT ME!
+     *
+     * @param align alignment to order
+     * @param tree tree which has
+     *
+     * @return DOCUMENT ME!
+     */
+    private static Vector getOrderByTree(AlignmentI align, NJTree tree)
+    {
         int nSeq = align.getHeight();
 
         Vector tmp = new Vector();
 
         tmp = _sortByTree(tree.getTopNode(), tmp, align.getSequences());
 
-        if (tmp.size() != nSeq) {
+        if (tmp.size() != nSeq)
+        {
             // TODO: JBPNote - decide if this is always an error
             // (eg. not when a tree is associated to another alignment which has more
             //  sequences)
-            if (tmp.size() < nSeq) {
+            if (tmp.size() < nSeq)
+            {
                 addStrays(align, tmp);
             }
 
-            if (tmp.size() != nSeq) {
+            if (tmp.size() != nSeq)
+            {
                 System.err.println("ERROR: tmp.size()=" + tmp.size() +
                     " != nseq=" + nSeq + " in getOrderByTree");
             }
@@ -259,60 +348,100 @@ public class AlignmentSorter {
         return tmp;
     }
 
-    public static void sortByTree(AlignmentI align, NJTree tree) {
+    /**
+     * Sorts the alignment by a given tree
+     *
+     * @param align alignment to order
+     * @param tree tree which has
+     */
+    public static void sortByTree(AlignmentI align, NJTree tree)
+    {
         Vector tmp = getOrderByTree(align, tree);
 
         // tmp should properly permute align with tree.
-        if (lastTree != tree) {
+        if (lastTree != tree)
+        {
             sortTreeAscending = true;
             lastTree = tree;
-        } else {
+        }
+        else
+        {
             sortTreeAscending = !sortTreeAscending;
         }
 
-        if (sortTreeAscending) {
+        if (sortTreeAscending)
+        {
             setOrder(align, tmp);
-        } else {
+        }
+        else
+        {
             setReverseOrder(align,
                 vectorSubsetToArray(tmp, align.getSequences()));
         }
     }
 
-    private static void addStrays(AlignmentI align, Vector seqs) {
+    /**
+     * DOCUMENT ME!
+     *
+     * @param align DOCUMENT ME!
+     * @param seqs DOCUMENT ME!
+     */
+    private static void addStrays(AlignmentI align, Vector seqs)
+    {
         int nSeq = align.getHeight();
 
-        for (int i = 0; i < nSeq; i++) {
-            if (!seqs.contains(align.getSequenceAt(i))) {
+        for (int i = 0; i < nSeq; i++)
+        {
+            if (!seqs.contains(align.getSequenceAt(i)))
+            {
                 seqs.addElement(align.getSequenceAt(i));
             }
         }
 
-        if (nSeq != seqs.size()) {
+        if (nSeq != seqs.size())
+        {
             System.err.println(
                 "ERROR: Size still not right even after addStrays");
         }
     }
 
-    public static Vector _sortByTree(SequenceNode node, Vector tmp,
-        Vector seqset) {
-        if (node == null) {
+    /**
+     * DOCUMENT ME!
+     *
+     * @param node DOCUMENT ME!
+     * @param tmp DOCUMENT ME!
+     * @param seqset DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    private static Vector _sortByTree(SequenceNode node, Vector tmp,
+        Vector seqset)
+    {
+        if (node == null)
+        {
             return tmp;
         }
 
         SequenceNode left = (SequenceNode) node.left();
         SequenceNode right = (SequenceNode) node.right();
 
-        if ((left == null) && (right == null)) {
-            if (!node.isPlaceholder() && (node.element() != null)) {
-                if (node.element() instanceof SequenceI) {
-                    if (!tmp.contains(node.element())) {
+        if ((left == null) && (right == null))
+        {
+            if (!node.isPlaceholder() && (node.element() != null))
+            {
+                if (node.element() instanceof SequenceI)
+                {
+                    if (!tmp.contains(node.element()))
+                    {
                         tmp.addElement((SequenceI) node.element());
                     }
                 }
             }
 
             return tmp;
-        } else {
+        }
+        else
+        {
             _sortByTree(left, tmp, seqset);
             _sortByTree(right, tmp, seqset);
         }
@@ -328,7 +457,8 @@ public class AlignmentSorter {
      * recover the order of sequences given by the safe numbering scheme introducd
      * SeqsetUtils.uniquify.
      */
-    public static void recoverOrder(SequenceI[] alignment) {
+    public static void recoverOrder(SequenceI[] alignment)
+    {
         float[] ids = new float[alignment.length];
 
         for (int i = 0; i < alignment.length; i++)
@@ -336,7 +466,4 @@ public class AlignmentSorter {
 
         jalview.util.QuickSort.sort(ids, alignment);
     }
-
-    private void jbInit() throws Exception {
-    }
 }