X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAlignmentSorter.java;h=8a387c7b8263c7f2ce89ddcaab286cede7167a9b;hb=4cebc1b8abfb0cf42798c8dc601ec5c1cd79c0e4;hp=9943a22d967687a2d6fecfdd10c8877bae2bf2b2;hpb=136c0793b90b72b928c4d77dc109dd5c644e00d3;p=jalview.git

diff --git a/src/jalview/analysis/AlignmentSorter.java b/src/jalview/analysis/AlignmentSorter.java
index 9943a22..8a387c7 100755
--- a/src/jalview/analysis/AlignmentSorter.java
+++ b/src/jalview/analysis/AlignmentSorter.java
@@ -86,6 +86,10 @@ public class AlignmentSorter
 
   private static boolean sortLengthAscending;
 
+  private static boolean sortEValueAscending;
+
+  private static boolean sortBitScoreAscending;
+
   /**
    * Sorts sequences in the alignment by Percentage Identity with the given
    * reference sequence, sorting the highest identity to the top
@@ -108,8 +112,9 @@ public class AlignmentSorter
             true);
     for (int i = 0; i < nSeq; i++)
     {
-      scores[i] = (float) PIDModel.computePID(align.getSequenceAt(i)
-              .getSequenceAsString(), refSeq, pidParams);
+      scores[i] = (float) PIDModel.computePID(
+              align.getSequenceAt(i).getSequenceAsString(), refSeq,
+              pidParams);
       seqs[i] = align.getSequenceAt(i);
     }
 
@@ -142,8 +147,8 @@ public class AlignmentSorter
     }
 
     // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work
-    List<SequenceI> asq;
-    synchronized (asq = align.getSequences())
+    List<SequenceI> asq = align.getSequences();
+    synchronized (asq)
     {
       for (int i = 0; i < len; i++)
       {
@@ -178,10 +183,10 @@ public class AlignmentSorter
   public static void setOrder(AlignmentI align, SequenceI[] seqs)
   {
     // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work
-    List<SequenceI> algn;
-    synchronized (algn = align.getSequences())
+    List<SequenceI> algn = align.getSequences();
+    synchronized (algn)
     {
-      List<SequenceI> tmp = new ArrayList<SequenceI>();
+      List<SequenceI> tmp = new ArrayList<>();
 
       for (int i = 0; i < seqs.length; i++)
       {
@@ -267,6 +272,90 @@ public class AlignmentSorter
   }
 
   /**
+   * Sorts by sequence evalue. Currently moves all sequences without an evalue to
+   * the top of the alignment.
+   * 
+   * @param align
+   *                The alignment object to sort
+   */
+  public static void sortByEValue(AlignmentI align)
+  {
+    int nSeq = align.getHeight();
+
+    double[] evalue = new double[nSeq];
+    SequenceI[] seqs = new SequenceI[nSeq];
+
+    for (int i = 0; i < nSeq; i++)
+    {
+      seqs[i] = align.getSequenceAt(i);
+      AlignmentAnnotation[] ann = seqs[i].getAnnotation("Search Scores");
+      if (ann != null)
+      {
+        evalue[i] = ann[0].getEValue();
+      }
+      else
+      {
+        evalue[i] = -1;
+      }
+    }
+
+    QuickSort.sort(evalue, seqs);
+
+    if (sortEValueAscending)
+    {
+      setReverseOrder(align, seqs);
+    }
+    else
+    {
+      setOrder(align, seqs);
+    }
+
+    sortEValueAscending = !sortEValueAscending;
+  }
+
+  /**
+   * Sorts by sequence bit score. Currently moves all sequences without a bit
+   * score to the top of the alignment
+   * 
+   * @param align
+   *                The alignment object to sort
+   */
+  public static void sortByBitScore(AlignmentI align)
+  {
+    int nSeq = align.getHeight();
+
+    double[] score = new double[nSeq];
+    SequenceI[] seqs = new SequenceI[nSeq];
+
+    for (int i = 0; i < nSeq; i++)
+    {
+      seqs[i] = align.getSequenceAt(i);
+      AlignmentAnnotation[] ann = seqs[i].getAnnotation("Search Scores");
+      if (ann != null)
+      {
+        score[i] = ann[0].getEValue();
+      }
+      else
+      {
+        score[i] = -1;
+      }
+    }
+
+    QuickSort.sort(score, seqs);
+
+    if (sortBitScoreAscending)
+    {
+      setReverseOrder(align, seqs);
+    }
+    else
+    {
+      setOrder(align, seqs);
+    }
+
+    sortBitScoreAscending = !sortBitScoreAscending;
+  }
+
+  /**
    * Sorts the alignment by size of group. <br>
    * Maintains the order of sequences in each group by order in given alignment
    * object.
@@ -278,7 +367,7 @@ public class AlignmentSorter
   {
     // MAINTAINS ORIGNAL SEQUENCE ORDER,
     // ORDERS BY GROUP SIZE
-    List<SequenceGroup> groups = new ArrayList<SequenceGroup>();
+    List<SequenceGroup> groups = new ArrayList<>();
 
     if (groups.hashCode() != lastGroupHash)
     {
@@ -314,7 +403,7 @@ public class AlignmentSorter
 
     // NOW ADD SEQUENCES MAINTAINING ALIGNMENT ORDER
     // /////////////////////////////////////////////
-    List<SequenceI> seqs = new ArrayList<SequenceI>();
+    List<SequenceI> seqs = new ArrayList<>();
 
     for (int i = 0; i < groups.size(); i++)
     {
@@ -356,7 +445,7 @@ public class AlignmentSorter
     // tmp2 = tmp.retainAll(mask);
     // return tmp2.addAll(mask.removeAll(tmp2))
 
-    ArrayList<SequenceI> seqs = new ArrayList<SequenceI>();
+    ArrayList<SequenceI> seqs = new ArrayList<>();
     int i, idx;
     boolean[] tmask = new boolean[mask.size()];
 
@@ -415,7 +504,8 @@ public class AlignmentSorter
     }
     else
     {
-      setReverseOrder(align, vectorSubsetToArray(tmp, align.getSequences()));
+      setReverseOrder(align,
+              vectorSubsetToArray(tmp, align.getSequences()));
     }
   }
 
@@ -434,7 +524,7 @@ public class AlignmentSorter
   {
     int nSeq = align.getHeight();
 
-    List<SequenceI> tmp = new ArrayList<SequenceI>();
+    List<SequenceI> tmp = new ArrayList<>();
 
     tmp = _sortByTree(tree.getTopNode(), tmp, align.getSequences());
 
@@ -450,12 +540,9 @@ public class AlignmentSorter
 
       if (tmp.size() != nSeq)
       {
-        System.err
-                .println("WARNING: tmp.size()="
-                        + tmp.size()
-                        + " != nseq="
-                        + nSeq
-                        + " in getOrderByTree - tree contains sequences not in alignment");
+        System.err.println("WARNING: tmp.size()=" + tmp.size() + " != nseq="
+                + nSeq
+                + " in getOrderByTree - tree contains sequences not in alignment");
       }
     }
 
@@ -491,7 +578,8 @@ public class AlignmentSorter
     }
     else
     {
-      setReverseOrder(align, vectorSubsetToArray(tmp, align.getSequences()));
+      setReverseOrder(align,
+              vectorSubsetToArray(tmp, align.getSequences()));
     }
   }
 
@@ -586,7 +674,7 @@ public class AlignmentSorter
 
     for (int i = 0; i < alignment.length; i++)
     {
-      ids[i] = (new Float(alignment[i].getName().substring(8)))
+      ids[i] = (Float.valueOf(alignment[i].getName().substring(8)))
               .floatValue();
     }
 
@@ -681,27 +769,6 @@ public class AlignmentSorter
 
   public static String FEATURE_DENSITY = "density";
 
-  private static boolean containsIgnoreCase(final String lab,
-          final List<String> labs)
-  {
-    if (labs == null)
-    {
-      return true;
-    }
-    if (lab == null)
-    {
-      return false;
-    }
-    for (String label : labs)
-    {
-      if (lab.equalsIgnoreCase(label))
-      {
-        return true;
-      }
-    }
-    return false;
-  }
-
   /**
    * Sort sequences by feature score or density, optionally restricted by
    * feature types, feature groups, or alignment start/end positions.