X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAlignmentSorter.java;h=6c46a3e2dd225ec43a5e1917e59a8bc2876cbd0d;hb=b0f76adef2787dd14566525e66a4073278e75d67;hp=881dc74b8020887d88325b805dfe58b7f0204b56;hpb=f52f7b378972cc884b5d3e5cc250f89667f558f7;p=jalview.git diff --git a/src/jalview/analysis/AlignmentSorter.java b/src/jalview/analysis/AlignmentSorter.java index 881dc74..6c46a3e 100755 --- a/src/jalview/analysis/AlignmentSorter.java +++ b/src/jalview/analysis/AlignmentSorter.java @@ -1,26 +1,40 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7) - * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle - * + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * * This file is part of Jalview. - * + * * Jalview is free software: you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. - * - * Jalview is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty - * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along with Jalview. If not, see . + * + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.analysis; -import java.util.*; - -import jalview.datamodel.*; -import jalview.util.*; +import jalview.analysis.scoremodels.PIDModel; +import jalview.analysis.scoremodels.SimilarityParams; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.AlignmentOrder; +import jalview.datamodel.SequenceFeature; +import jalview.datamodel.SequenceGroup; +import jalview.datamodel.SequenceI; +import jalview.datamodel.SequenceNode; +import jalview.util.MessageManager; +import jalview.util.QuickSort; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; /** * Routines for manipulating the order of a multiple sequence alignment TODO: @@ -53,7 +67,7 @@ public class AlignmentSorter static boolean sortOrderAscending = true; - static NJTree lastTree = null; + static TreeModel lastTree = null; static boolean sortTreeAscending = true; @@ -74,57 +88,40 @@ public class AlignmentSorter private static boolean sortLengthAscending; /** - * Sort by Percentage Identity w.r.t. s - * - * @param align - * AlignmentI - * @param s - * SequenceI - * @param tosort - * sequences from align that are to be sorted. - */ - public static void sortByPID(AlignmentI align, SequenceI s, - SequenceI[] tosort) - { - sortByPID(align, s, tosort, 0, -1); - } - - /** - * Sort by Percentage Identity w.r.t. s - * + * Sorts sequences in the alignment by Percentage Identity with the given + * reference sequence, sorting the highest identity to the top + * * @param align * AlignmentI * @param s * SequenceI - * @param tosort - * sequences from align that are to be sorted. - * @param start - * start column (0 for beginning * @param end */ - public static void sortByPID(AlignmentI align, SequenceI s, - SequenceI[] tosort, int start, int end) + public static void sortByPID(AlignmentI align, SequenceI s) { int nSeq = align.getHeight(); float[] scores = new float[nSeq]; SequenceI[] seqs = new SequenceI[nSeq]; + String refSeq = s.getSequenceAsString(); + SimilarityParams pidParams = new SimilarityParams(true, true, true, + true); for (int i = 0; i < nSeq; i++) { - scores[i] = Comparison.PID(align.getSequenceAt(i) - .getSequenceAsString(), s.getSequenceAsString()); + scores[i] = (float) PIDModel.computePID(align.getSequenceAt(i) + .getSequenceAsString(), refSeq, pidParams); seqs[i] = align.getSequenceAt(i); } - QuickSort.sort(scores, 0, scores.length - 1, seqs); + QuickSort.sort(scores, seqs); setReverseOrder(align, seqs); } /** * Reverse the order of the sort - * + * * @param align * DOCUMENT ME! * @param seqs @@ -160,20 +157,20 @@ public class AlignmentSorter /** * 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) + private static void setOrder(AlignmentI align, List tmp) { setOrder(align, vectorSubsetToArray(tmp, align.getSequences())); } /** * Sets the Alignment object with the given sequences - * + * * @param align * DOCUMENT ME! * @param seqs @@ -206,7 +203,7 @@ public class AlignmentSorter /** * Sorts by ID. Numbers are sorted before letters. - * + * * @param align * The alignment object to sort */ @@ -239,7 +236,7 @@ public class AlignmentSorter /** * Sorts by sequence length - * + * * @param align * The alignment object to sort */ @@ -274,7 +271,7 @@ public class AlignmentSorter * 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 */ @@ -282,7 +279,7 @@ public class AlignmentSorter { // MAINTAINS ORIGNAL SEQUENCE ORDER, // ORDERS BY GROUP SIZE - Vector groups = new Vector(); + List groups = new ArrayList(); if (groups.hashCode() != lastGroupHash) { @@ -300,11 +297,11 @@ public class AlignmentSorter { for (int j = 0; j < groups.size(); j++) { - SequenceGroup sg2 = (SequenceGroup) groups.elementAt(j); + SequenceGroup sg2 = groups.get(j); if (sg.getSize() > sg2.getSize()) { - groups.insertElementAt(sg, j); + groups.add(j, sg); break; } @@ -312,22 +309,22 @@ public class AlignmentSorter if (!groups.contains(sg)) { - groups.addElement(sg); + groups.add(sg); } } // NOW ADD SEQUENCES MAINTAINING ALIGNMENT ORDER // ///////////////////////////////////////////// - Vector seqs = new Vector(); + List seqs = new ArrayList(); for (int i = 0; i < groups.size(); i++) { - SequenceGroup sg = (SequenceGroup) groups.elementAt(i); + SequenceGroup sg = groups.get(i); SequenceI[] orderedseqs = sg.getSequencesInOrder(align); for (int j = 0; j < orderedseqs.length; j++) { - seqs.addElement(orderedseqs[j]); + seqs.add(orderedseqs[j]); } } @@ -343,39 +340,23 @@ public class AlignmentSorter } /** - * 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++) - { - seqs[i] = (SequenceI) tmp.elementAt(i); - } - - return seqs; - } - - /** * Select sequences in order from tmp that is present in mask, and any - * remaining seqeunces in mask not in tmp - * + * remaining sequences in mask not in tmp + * * @param tmp * thread safe collection of sequences * @param mask * thread safe collection of sequences - * + * * @return intersect(tmp,mask)+intersect(complement(tmp),mask) */ private static SequenceI[] vectorSubsetToArray(List tmp, List mask) { + // or? + // tmp2 = tmp.retainAll(mask); + // return tmp2.addAll(mask.removeAll(tmp2)) + ArrayList seqs = new ArrayList(); int i, idx; boolean[] tmask = new boolean[mask.size()]; @@ -409,7 +390,7 @@ public class AlignmentSorter /** * Sorts by a given AlignmentOrder object - * + * * @param align * Alignment to order * @param order @@ -418,7 +399,7 @@ public class AlignmentSorter 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(); + List tmp = order.getOrder(); if (lastOrder == order) { @@ -441,19 +422,20 @@ public class AlignmentSorter /** * DOCUMENT ME! - * + * * @param align * alignment to order * @param tree * tree which has - * + * * @return DOCUMENT ME! */ - private static Vector getOrderByTree(AlignmentI align, NJTree tree) + private static List getOrderByTree(AlignmentI align, + TreeModel tree) { int nSeq = align.getHeight(); - Vector tmp = new Vector(); + List tmp = new ArrayList(); tmp = _sortByTree(tree.getTopNode(), tmp, align.getSequences()); @@ -483,15 +465,15 @@ public class AlignmentSorter /** * 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) + public static void sortByTree(AlignmentI align, TreeModel tree) { - Vector tmp = getOrderByTree(align, tree); + List tmp = getOrderByTree(align, tree); // tmp should properly permute align with tree. if (lastTree != tree) @@ -516,25 +498,25 @@ public class AlignmentSorter /** * DOCUMENT ME! - * + * * @param align * DOCUMENT ME! - * @param seqs + * @param tmp * DOCUMENT ME! */ - private static void addStrays(AlignmentI align, Vector seqs) + private static void addStrays(AlignmentI align, List tmp) { int nSeq = align.getHeight(); for (int i = 0; i < nSeq; i++) { - if (!seqs.contains(align.getSequenceAt(i))) + if (!tmp.contains(align.getSequenceAt(i))) { - seqs.addElement(align.getSequenceAt(i)); + tmp.add(align.getSequenceAt(i)); } } - if (nSeq != seqs.size()) + if (nSeq != tmp.size()) { System.err .println("ERROR: Size still not right even after addStrays"); @@ -543,18 +525,18 @@ public class AlignmentSorter /** * 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, - List seqset) + private static List _sortByTree(SequenceNode node, + List tmp, List seqset) { if (node == null) { @@ -574,7 +556,7 @@ public class AlignmentSorter // seqset.size()==0 || // seqset.contains(tmp))) { - tmp.addElement(node.element()); + tmp.add((SequenceI) node.element()); } } } @@ -615,7 +597,7 @@ public class AlignmentSorter /** * Sort sequence in order of increasing score attribute for annotation with a * particular scoreLabel. Or reverse if same label was used previously - * + * * @param scoreLabel * exact label for sequence associated AlignmentAnnotation scores to * use for sorting. @@ -703,7 +685,7 @@ public class AlignmentSorter /** * sort the alignment using the features on each sequence found between start * and stop with the given featureLabel (and optional group qualifier) - * + * * @param featureLabel * (may not be null) * @param groupLabel @@ -721,13 +703,16 @@ public class AlignmentSorter public static void sortByFeature(String featureLabel, String groupLabel, int start, int stop, AlignmentI alignment, String method) { - sortByFeature(featureLabel == null ? null : new String[] - { featureLabel }, groupLabel == null ? null : new String[] - { groupLabel }, start, stop, alignment, method); + sortByFeature( + featureLabel == null ? null + : Arrays.asList(new String[] { featureLabel }), + groupLabel == null ? null : Arrays + .asList(new String[] { groupLabel }), start, stop, + alignment, method); } private static boolean containsIgnoreCase(final String lab, - final String[] labs) + final List labs) { if (labs == null) { @@ -737,9 +722,9 @@ public class AlignmentSorter { return false; } - for (int q = 0; q < labs.length; q++) + for (String label : labs) { - if (labs[q] != null && lab.equalsIgnoreCase(labs[q])) + if (lab.equalsIgnoreCase(label)) { return true; } @@ -747,30 +732,52 @@ public class AlignmentSorter return false; } - public static void sortByFeature(String[] featureLabels, - String[] groupLabels, int start, int stop, AlignmentI alignment, - String method) + public static void sortByFeature(List featureLabels, + List groupLabels, int start, int stop, + AlignmentI alignment, String method) { if (method != FEATURE_SCORE && method != FEATURE_LABEL && method != FEATURE_DENSITY) { throw new Error( - "Implementation Error - sortByFeature method must be one of FEATURE_SCORE, FEATURE_LABEL or FEATURE_DENSITY."); + MessageManager + .getString("error.implementation_error_sortbyfeature")); } + boolean ignoreScore = method != FEATURE_SCORE; StringBuffer scoreLabel = new StringBuffer(); scoreLabel.append(start + stop + method); // This doesn't quite work yet - we'd like to have a canonical ordering that // can be preserved from call to call - for (int i = 0; featureLabels != null && i < featureLabels.length; i++) + if (featureLabels != null) { - scoreLabel.append(featureLabels[i] == null ? "null" - : featureLabels[i]); + for (String label : featureLabels) + { + scoreLabel.append(label); + } } - for (int i = 0; groupLabels != null && i < groupLabels.length; i++) + if (groupLabels != null) { - scoreLabel.append(groupLabels[i] == null ? "null" : groupLabels[i]); + for (String label : groupLabels) + { + scoreLabel.append(label); + } } + + /* + * if resorting the same feature, toggle sort order + */ + if (lastSortByFeatureScore == null + || !scoreLabel.toString().equals(lastSortByFeatureScore)) + { + sortByFeatureScoreAscending = true; + } + else + { + sortByFeatureScoreAscending = !sortByFeatureScoreAscending; + } + lastSortByFeatureScore = scoreLabel.toString(); + SequenceI[] seqs = alignment.getSequencesArray(); boolean[] hasScore = new boolean[seqs.length]; // per sequence score @@ -783,10 +790,6 @@ public class AlignmentSorter for (int i = 0; i < seqs.length; i++) { SequenceFeature[] sf = seqs[i].getSequenceFeatures(); - if (sf == null && seqs[i].getDatasetSequence() != null) - { - sf = seqs[i].getDatasetSequence().getSequenceFeatures(); - } if (sf == null) { sf = new SequenceFeature[0]; @@ -827,7 +830,7 @@ public class AlignmentSorter else { // or, also take a look at the scores if necessary. - if (!ignoreScore && sf[f].getScore() != Float.NaN) + if (!ignoreScore && !Float.isNaN(sf[f].getScore())) { if (seqScores[i] == 0) { @@ -861,7 +864,7 @@ public class AlignmentSorter labs[l] = (fs[l].getDescription() != null ? fs[l] .getDescription() : fs[l].getType()); } - jalview.util.QuickSort.sort(labs, ((Object[]) feats[i])); + QuickSort.sort(labs, ((Object[]) feats[i])); } } if (hasScore[i]) @@ -904,58 +907,38 @@ public class AlignmentSorter } else { - int nf = (feats[i] == null) ? 0 - : ((SequenceFeature[]) feats[i]).length; - // System.err.println("Sorting on Score: seq "+seqs[i].getName()+ - // " Feats: "+nf+" Score : "+scores[i]); + // int nf = (feats[i] == null) ? 0 + // : ((SequenceFeature[]) feats[i]).length; + // // System.err.println("Sorting on Score: seq " + + // seqs[i].getName() + // + " Feats: " + nf + " Score : " + scores[i]); } } } - - jalview.util.QuickSort.sort(scores, seqs); + QuickSort.sortByDouble(scores, seqs, sortByFeatureScoreAscending); } else if (method == FEATURE_DENSITY) { - - // break ties between equivalent numbers for adjacent sequences by adding - // 1/Nseq*i on the original order - double fr = 0.9 / (1.0 * seqs.length); for (int i = 0; i < seqs.length; i++) { - double nf; - scores[i] = (0.05 + fr * i) - + (nf = ((feats[i] == null) ? 0.0 - : 1.0 * ((SequenceFeature[]) feats[i]).length)); + int featureCount = feats[i] == null ? 0 + : ((SequenceFeature[]) feats[i]).length; + scores[i] = featureCount; // System.err.println("Sorting on Density: seq "+seqs[i].getName()+ - // " Feats: "+nf+" Score : "+scores[i]); + // " Feats: "+featureCount+" Score : "+scores[i]); } - jalview.util.QuickSort.sort(scores, seqs); + QuickSort.sortByDouble(scores, seqs, sortByFeatureScoreAscending); } else { if (method == FEATURE_LABEL) { - throw new Error("Not yet implemented."); + throw new Error( + MessageManager.getString("error.not_yet_implemented")); } } - if (lastSortByFeatureScore == null - || !scoreLabel.toString().equals(lastSortByFeatureScore)) - { - sortByFeatureScoreAscending = true; - } - else - { - sortByFeatureScoreAscending = !sortByFeatureScoreAscending; - } - if (sortByFeatureScoreAscending) - { - setOrder(alignment, seqs); - } - else - { - setReverseOrder(alignment, seqs); - } - lastSortByFeatureScore = scoreLabel.toString(); + + setOrder(alignment, seqs); } }