X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAlignmentSorter.java;h=2aca5f3970bba4d3e178b885c6ff46b4b3ecb8f2;hb=dc82563dc0d6752da31ade9031035854e5c33409;hp=103fbf09c1fc4d6b1cb502763d4ebf1b301f93ec;hpb=838e4f91d4a53dd315640dbc9ff6ef7a815ee576;p=jalview.git diff --git a/src/jalview/analysis/AlignmentSorter.java b/src/jalview/analysis/AlignmentSorter.java index 103fbf0..2aca5f3 100755 --- a/src/jalview/analysis/AlignmentSorter.java +++ b/src/jalview/analysis/AlignmentSorter.java @@ -1,6 +1,6 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9.0b1) - * Copyright (C) 2015 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * @@ -20,6 +20,10 @@ */ package jalview.analysis; +import jalview.analysis.scoremodels.PIDModel; +import jalview.analysis.scoremodels.SimilarityParams; +import jalview.bin.ApplicationSingletonProvider; +import jalview.bin.ApplicationSingletonProvider.ApplicationSingletonI; import jalview.datamodel.AlignmentAnnotation; import jalview.datamodel.AlignmentI; import jalview.datamodel.AlignmentOrder; @@ -27,11 +31,12 @@ import jalview.datamodel.SequenceFeature; import jalview.datamodel.SequenceGroup; import jalview.datamodel.SequenceI; import jalview.datamodel.SequenceNode; -import jalview.util.Comparison; -import jalview.util.MessageManager; import jalview.util.QuickSort; import java.util.ArrayList; +import java.util.BitSet; +import java.util.Collections; +import java.util.Iterator; import java.util.List; /** @@ -49,195 +54,181 @@ import java.util.List; * from the first tobesorted position in the alignment. e.g. (a,tb2,b,tb1,c,tb3 * becomes a,tb1,tb2,tb3,b,c) */ -public class AlignmentSorter +public class AlignmentSorter implements ApplicationSingletonI { + + private AlignmentSorter() + { + // private singleton + } + + public static AlignmentSorter getInstance() + { + return ApplicationSingletonProvider.getInstance(AlignmentSorter.class); + } + /** + * types of feature ordering: Sort by score : average score - or total score - + * over all features in region Sort by feature label text: (or if null - + * feature type text) - numerical or alphabetical Sort by feature density: + * based on counts - ignoring individual text or scores for each feature + */ + public static final String FEATURE_SCORE = "average_score"; + + public static final String FEATURE_LABEL = "text"; + + public static final String FEATURE_DENSITY = "density"; + + /* * todo: refactor searches to follow a basic pattern: (search property, last * search state, current sort direction) */ - static boolean sortIdAscending = true; + boolean sortIdAscending = true; - static int lastGroupHash = 0; + int lastGroupHash = 0; - static boolean sortGroupAscending = true; + boolean sortGroupAscending = true; - static AlignmentOrder lastOrder = null; + AlignmentOrder lastOrder = null; - static boolean sortOrderAscending = true; + boolean sortOrderAscending = true; - static NJTree lastTree = null; + TreeModel lastTree = null; - static boolean sortTreeAscending = true; + boolean sortTreeAscending = true; /** - * last Annotation Label used by sortByScore + * last Annotation Label used for sort by Annotation score */ - private static String lastSortByScore; - - private static boolean sortByScoreAscending = true; + private String lastSortByAnnotation; /** - * compact representation of last arguments to SortByFeatureScore + * string hash of last arguments to sortByFeature (sort order toggles if this + * is unchanged between sorts) */ - private static String lastSortByFeatureScore; + private String sortByFeatureCriteria; - private static boolean sortByFeatureScoreAscending = true; + private boolean sortByFeatureAscending = true; - private static boolean sortLengthAscending; + private 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); - } + private static boolean sortEValueAscending; + + private static boolean sortBitScoreAscending; /** - * 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, seqs); - setReverseOrder(align, seqs); } /** - * Reverse the order of the sort + * Sorts by ID. Numbers are sorted before letters. * * @param align - * DOCUMENT ME! - * @param seqs - * DOCUMENT ME! + * The alignment object to sort */ - private static void setReverseOrder(AlignmentI align, SequenceI[] seqs) + public static void sortByID(AlignmentI align) { - int nSeq = seqs.length; - - int len = 0; + int nSeq = align.getHeight(); - if ((nSeq % 2) == 0) - { - len = nSeq / 2; - } - else - { - len = (nSeq + 1) / 2; - } + String[] ids = new String[nSeq]; + SequenceI[] seqs = new SequenceI[nSeq]; - // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work - List asq; - synchronized (asq = align.getSequences()) + for (int i = 0; i < nSeq; i++) { - for (int i = 0; i < len; i++) - { - // SequenceI tmp = seqs[i]; - asq.set(i, seqs[nSeq - i - 1]); - asq.set(nSeq - i - 1, seqs[i]); - } + ids[i] = align.getSequenceAt(i).getName(); + seqs[i] = align.getSequenceAt(i); } - } - /** - * 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, List tmp) - { - setOrder(align, vectorSubsetToArray(tmp, align.getSequences())); + QuickSort.sort(ids, seqs); + AlignmentSorter as = getInstance(); + as.sortIdAscending = !as.sortIdAscending; + set(align, seqs, as.sortIdAscending); } /** - * Sets the Alignment object with the given sequences + * Sorts by sequence length * * @param align - * DOCUMENT ME! - * @param seqs - * sequences as an array + * The alignment object to sort */ - public static void setOrder(AlignmentI align, SequenceI[] seqs) + public static void sortByLength(AlignmentI align) { - // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work - List algn; - synchronized (algn = align.getSequences()) - { - List tmp = new ArrayList(); + int nSeq = align.getHeight(); - for (int i = 0; i < seqs.length; i++) - { - if (algn.contains(seqs[i])) - { - tmp.add(seqs[i]); - } - } + float[] length = new float[nSeq]; + SequenceI[] seqs = new SequenceI[nSeq]; - algn.clear(); - // User may have hidden seqs, then clicked undo or redo - for (int i = 0; i < tmp.size(); i++) - { - algn.add(tmp.get(i)); - } + for (int i = 0; i < nSeq; i++) + { + seqs[i] = align.getSequenceAt(i); + length[i] = (seqs[i].getEnd() - seqs[i].getStart()); } + + QuickSort.sort(length, seqs); + AlignmentSorter as = getInstance(); + as.sortLengthAscending = !as.sortLengthAscending; + set(align, seqs, as.sortLengthAscending); } /** - * Sorts by ID. Numbers are sorted before letters. + * Sorts by sequence evalue. Currently moves all sequences without an evalue to + * the top of the alignment. * * @param align - * The alignment object to sort + * The alignment object to sort */ - public static void sortByID(AlignmentI align) + public static void sortByEValue(AlignmentI align) { int nSeq = align.getHeight(); - String[] ids = new String[nSeq]; + double[] evalue = new double[nSeq]; SequenceI[] seqs = new SequenceI[nSeq]; for (int i = 0; i < nSeq; i++) { - ids[i] = align.getSequenceAt(i).getName(); 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(ids, seqs); + QuickSort.sort(evalue, seqs); - if (sortIdAscending) + if (sortEValueAscending) { setReverseOrder(align, seqs); } @@ -246,31 +237,40 @@ public class AlignmentSorter setOrder(align, seqs); } - sortIdAscending = !sortIdAscending; + sortEValueAscending = !sortEValueAscending; } /** - * Sorts by sequence length + * 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 + * The alignment object to sort */ - public static void sortByLength(AlignmentI align) + public static void sortByBitScore(AlignmentI align) { int nSeq = align.getHeight(); - float[] length = new float[nSeq]; + double[] score = new double[nSeq]; SequenceI[] seqs = new SequenceI[nSeq]; for (int i = 0; i < nSeq; i++) { seqs[i] = align.getSequenceAt(i); - length[i] = (seqs[i].getEnd() - seqs[i].getStart()); + AlignmentAnnotation[] ann = seqs[i].getAnnotation("Search Scores"); + if (ann != null) + { + score[i] = ann[0].getEValue(); + } + else + { + score[i] = -1; + } } - QuickSort.sort(length, seqs); + QuickSort.sort(score, seqs); - if (sortLengthAscending) + if (sortBitScoreAscending) { setReverseOrder(align, seqs); } @@ -279,7 +279,7 @@ public class AlignmentSorter setOrder(align, seqs); } - sortLengthAscending = !sortLengthAscending; + sortBitScoreAscending = !sortBitScoreAscending; } /** @@ -294,16 +294,18 @@ public class AlignmentSorter { // MAINTAINS ORIGNAL SEQUENCE ORDER, // ORDERS BY GROUP SIZE - List groups = new ArrayList(); + List groups = new ArrayList<>(); + + AlignmentSorter as = getInstance(); - if (groups.hashCode() != lastGroupHash) + if (groups.hashCode() != as.lastGroupHash) { - sortGroupAscending = true; - lastGroupHash = groups.hashCode(); + as.sortGroupAscending = true; + as.lastGroupHash = groups.hashCode(); } else { - sortGroupAscending = !sortGroupAscending; + as.sortGroupAscending = !as.sortGroupAscending; } // SORTS GROUPS BY SIZE @@ -330,7 +332,7 @@ public class AlignmentSorter // NOW ADD SEQUENCES MAINTAINING ALIGNMENT ORDER // ///////////////////////////////////////////// - List seqs = new ArrayList(); + List tmp = new ArrayList<>(); for (int i = 0; i < groups.size(); i++) { @@ -339,68 +341,10 @@ public class AlignmentSorter for (int j = 0; j < orderedseqs.length; j++) { - seqs.add(orderedseqs[j]); - } - } - - if (sortGroupAscending) - { - setOrder(align, seqs); - } - else - { - setReverseOrder(align, - vectorSubsetToArray(seqs, align.getSequences())); - } - } - - /** - * Select sequences in order from tmp that is present in mask, and any - * 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()]; - - for (i = 0; i < mask.size(); i++) - { - tmask[i] = true; - } - - for (i = 0; i < tmp.size(); i++) - { - SequenceI sq = tmp.get(i); - idx = mask.indexOf(sq); - if (idx > -1 && tmask[idx]) - { - tmask[idx] = false; - seqs.add(sq); + tmp.add(orderedseqs[j]); } } - - for (i = 0; i < tmask.length; i++) - { - if (tmask[i]) - { - seqs.add(mask.get(i)); - } - } - - return seqs.toArray(new SequenceI[seqs.size()]); + set(align, tmp, as.sortGroupAscending); } /** @@ -416,23 +360,17 @@ public class AlignmentSorter // Get an ordered vector of sequences which may also be present in align List tmp = order.getOrder(); - if (lastOrder == order) - { - sortOrderAscending = !sortOrderAscending; - } - else - { - sortOrderAscending = true; - } + AlignmentSorter as = getInstance(); - if (sortOrderAscending) + if (as.lastOrder == order) { - setOrder(align, tmp); + as.sortOrderAscending = !as.sortOrderAscending; } else { - setReverseOrder(align, vectorSubsetToArray(tmp, align.getSequences())); + as.sortOrderAscending = true; } + set(align, tmp, as.sortOrderAscending); } /** @@ -446,11 +384,11 @@ public class AlignmentSorter * @return DOCUMENT ME! */ private static List getOrderByTree(AlignmentI align, - NJTree tree) + TreeModel tree) { int nSeq = align.getHeight(); - List tmp = new ArrayList(); + List tmp = new ArrayList<>(); tmp = _sortByTree(tree.getTopNode(), tmp, align.getSequences()); @@ -466,12 +404,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"); } } @@ -486,29 +421,23 @@ public class AlignmentSorter * @param tree * tree which has */ - public static void sortByTree(AlignmentI align, NJTree tree) + public static void sortByTree(AlignmentI align, TreeModel tree) { List tmp = getOrderByTree(align, tree); - // tmp should properly permute align with tree. - if (lastTree != tree) - { - sortTreeAscending = true; - lastTree = tree; - } - else - { - sortTreeAscending = !sortTreeAscending; - } + AlignmentSorter as = getInstance(); - if (sortTreeAscending) + // tmp should properly permute align with tree. + if (as.lastTree != tree) { - setOrder(align, tmp); + as.sortTreeAscending = true; + as.lastTree = tree; } else { - setReverseOrder(align, vectorSubsetToArray(tmp, align.getSequences())); + as.sortTreeAscending = !as.sortTreeAscending; } + set(align, tmp, as.sortTreeAscending); } /** @@ -602,7 +531,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(); } @@ -674,9 +603,12 @@ public class AlignmentSorter } jalview.util.QuickSort.sort(scores, seqs); - if (lastSortByScore != scoreLabel) + + AlignmentSorter as = getInstance(); + + if (as.lastSortByAnnotation != scoreLabel) { - lastSortByScore = scoreLabel; + as.lastSortByAnnotation = scoreLabel; setOrder(alignment, seqs); } else @@ -686,89 +618,42 @@ public class AlignmentSorter } /** - * types of feature ordering: Sort by score : average score - or total score - - * over all features in region Sort by feature label text: (or if null - - * feature type text) - numerical or alphabetical Sort by feature density: - * based on counts - ignoring individual text or scores for each feature - */ - public static String FEATURE_SCORE = "average_score"; - - public static String FEATURE_LABEL = "text"; - - public static String FEATURE_DENSITY = "density"; - - /** - * sort the alignment using the features on each sequence found between start - * and stop with the given featureLabel (and optional group qualifier) + * Sort sequences by feature score or density, optionally restricted by + * feature types, feature groups, or alignment start/end positions. + *

+ * If the sort is repeated for the same combination of types and groups, sort + * order is reversed. * - * @param featureLabel - * (may not be null) - * @param groupLabel - * (may be null) - * @param start - * (-1 to include non-positional features) - * @param stop - * (-1 to only sort on non-positional features) + * @param featureTypes + * a list of feature types to include (or null for all) + * @param groups + * a list of feature groups to include (or null for all) + * @param startCol + * start column position to include (base zero) + * @param endCol + * end column position to include (base zero) * @param alignment - * - aligned sequences containing features + * the alignment to be sorted * @param method - * - one of the string constants FEATURE_SCORE, FEATURE_LABEL, - * FEATURE_DENSITY + * either "average_score" or "density" ("text" not yet implemented) */ - 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); - } - - private static boolean containsIgnoreCase(final String lab, - final String[] labs) - { - if (labs == null) - { - return true; - } - if (lab == null) - { - return false; - } - for (int q = 0; q < labs.length; q++) - { - if (labs[q] != null && lab.equalsIgnoreCase(labs[q])) - { - return true; - } - } - return false; - } - - public static void sortByFeature(String[] featureLabels, - String[] groupLabels, int start, int stop, AlignmentI alignment, - String method) + public static void sortByFeature(List featureTypes, + List groups, final int startCol, final int endCol, + AlignmentI alignment, String method) { if (method != FEATURE_SCORE && method != FEATURE_LABEL && method != FEATURE_DENSITY) { - throw new Error( - 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++) - { - scoreLabel.append(featureLabels[i] == null ? "null" - : featureLabels[i]); - } - for (int i = 0; groupLabels != null && i < groupLabels.length; i++) - { - scoreLabel.append(groupLabels[i] == null ? "null" : groupLabels[i]); + String msg = String.format( + "Implementation Error - sortByFeature method must be either '%s' or '%s'", + FEATURE_SCORE, FEATURE_DENSITY); + System.err.println(msg); + return; } + + flipFeatureSortIfUnchanged(method, featureTypes, groups, startCol, + endCol); + SequenceI[] seqs = alignment.getSequencesArray(); boolean[] hasScore = new boolean[seqs.length]; // per sequence score @@ -776,52 +661,44 @@ public class AlignmentSorter int hasScores = 0; // number of scores present on set double[] scores = new double[seqs.length]; int[] seqScores = new int[seqs.length]; - Object[] feats = new Object[seqs.length]; - double min = 0, max = 0; + Object[][] feats = new Object[seqs.length][]; + double min = 0d; + double max = 0d; + for (int i = 0; i < seqs.length; i++) { - SequenceFeature[] sf = seqs[i].getSequenceFeatures(); - if (sf == null) - { - sf = new SequenceFeature[0]; - } - else - { - SequenceFeature[] tmp = new SequenceFeature[sf.length]; - for (int s = 0; s < tmp.length; s++) - { - tmp[s] = sf[s]; - } - sf = tmp; - } - int sstart = (start == -1) ? start : seqs[i].findPosition(start); - int sstop = (stop == -1) ? stop : seqs[i].findPosition(stop); + /* + * get sequence residues overlapping column region + * and features for residue positions and specified types + */ + String[] types = featureTypes == null ? null + : featureTypes.toArray(new String[featureTypes.size()]); + List sfs = seqs[i].findFeatures(startCol + 1, + endCol + 1, types); + seqScores[i] = 0; scores[i] = 0.0; - int n = sf.length; - for (int f = 0; f < sf.length; f++) + + Iterator it = sfs.listIterator(); + while (it.hasNext()) { - // filter for selection criteria - if ( - // ignore features outwith alignment start-stop positions. - (sf[f].end < sstart || sf[f].begin > sstop) || - // or ignore based on selection criteria - (featureLabels != null && !AlignmentSorter - .containsIgnoreCase(sf[f].type, featureLabels)) - || (groupLabels != null - // problem here: we cannot eliminate null feature group features - && (sf[f].getFeatureGroup() != null && !AlignmentSorter - .containsIgnoreCase(sf[f].getFeatureGroup(), - groupLabels)))) + SequenceFeature sf = it.next(); + + /* + * accept all features with null or empty group, otherwise + * check group is one of the currently visible groups + */ + String featureGroup = sf.getFeatureGroup(); + if (groups != null && featureGroup != null + && !"".equals(featureGroup) + && !groups.contains(featureGroup)) { - // forget about this feature - sf[f] = null; - n--; + it.remove(); } else { - // or, also take a look at the scores if necessary. - if (!ignoreScore && !Float.isNaN(sf[f].getScore())) + float score = sf.getScore(); + if (FEATURE_SCORE.equals(method) && !Float.isNaN(score)) { if (seqScores[i] == 0) { @@ -829,33 +706,26 @@ public class AlignmentSorter } seqScores[i]++; hasScore[i] = true; - scores[i] += sf[f].getScore(); // take the first instance of this - // score. + scores[i] += score; + // take the first instance of this score // ?? } } } - SequenceFeature[] fs; - feats[i] = fs = new SequenceFeature[n]; - if (n > 0) + + feats[i] = sfs.toArray(new SequenceFeature[sfs.size()]); + if (!sfs.isEmpty()) { - n = 0; - for (int f = 0; f < sf.length; f++) - { - if (sf[f] != null) - { - ((SequenceFeature[]) feats[i])[n++] = sf[f]; - } - } if (method == FEATURE_LABEL) { - // order the labels by alphabet - String[] labs = new String[fs.length]; - for (int l = 0; l < labs.length; l++) + // order the labels by alphabet (not yet implemented) + String[] labs = new String[sfs.size()]; + for (int l = 0; l < sfs.size(); l++) { - labs[l] = (fs[l].getDescription() != null ? fs[l] - .getDescription() : fs[l].getType()); + SequenceFeature sf = sfs.get(l); + String description = sf.getDescription(); + labs[l] = (description != null ? description : sf.getType()); } - jalview.util.QuickSort.sort(labs, ((Object[]) feats[i])); + QuickSort.sort(labs, feats[i]); } } if (hasScore[i]) @@ -865,23 +735,20 @@ public class AlignmentSorter // update the score bounds. if (hasScores == 1) { - max = min = scores[i]; + min = scores[i]; + max = min; } else { - if (max < scores[i]) - { - max = scores[i]; - } - if (min > scores[i]) - { - min = scores[i]; - } + max = Math.max(max, scores[i]); + min = Math.min(min, scores[i]); } } } - if (method == FEATURE_SCORE) + boolean doSort = false; + + if (FEATURE_SCORE.equals(method)) { if (hasScores == 0) { @@ -898,59 +765,238 @@ 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); + doSort = true; } - else if (method == FEATURE_DENSITY) + else if (FEATURE_DENSITY.equals(method)) { - - // 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); + doSort = true; } - else + if (doSort) { - if (method == FEATURE_LABEL) - { - throw new Error( - MessageManager.getString("error.not_yet_implemented")); - } + QuickSort.sortByDouble(scores, seqs, + getInstance().sortByFeatureAscending); } - if (lastSortByFeatureScore == null - || !scoreLabel.toString().equals(lastSortByFeatureScore)) + setOrder(alignment, seqs); + } + + /** + * Builds a string hash of criteria for sorting, and if unchanged from last + * time, reverse the sort order + * + * @param method + * @param featureTypes + * @param groups + * @param startCol + * @param endCol + */ + protected static void flipFeatureSortIfUnchanged(String method, + List featureTypes, List groups, + final int startCol, final int endCol) + { + StringBuilder sb = new StringBuilder(64); + sb.append(startCol).append(method).append(endCol); + if (featureTypes != null) { - sortByFeatureScoreAscending = true; + Collections.sort(featureTypes); + sb.append(featureTypes.toString()); + } + if (groups != null) + { + Collections.sort(groups); + sb.append(groups.toString()); + } + String scoreCriteria = sb.toString(); + + /* + * if resorting on the same criteria, toggle sort order + */ + AlignmentSorter as = getInstance(); + if (as.sortByFeatureCriteria == null + || !scoreCriteria.equals(as.sortByFeatureCriteria)) + { + as.sortByFeatureAscending = true; } else { - sortByFeatureScoreAscending = !sortByFeatureScoreAscending; + as.sortByFeatureAscending = !as.sortByFeatureAscending; } - if (sortByFeatureScoreAscending) + as.sortByFeatureCriteria = scoreCriteria; + } + + /** + * Set the alignment's sequences list to contain the sequences from a + * temporary list, first adding all the elements from the tmp list, then adding all sequences in the alignment that + * are not in the list. Option to do the final sort either in order or in reverse order. + * + * @param align The alignment being sorted + * @param tmp + * the temporary sequence list + * @param ascending + * false for reversed order; only sequences already in + * the alignment will be used (which is actually already guaranteed + * by vectorSubsetToArray) + */ + private static void set(AlignmentI align, List tmp, + boolean ascending) + { + set(align, vectorSubsetToArray(align.getSequences(), tmp), ascending); + } + + /** + * Set the alignment's sequences list to contain these sequences, either in + * this order or its reverse. + * + * @param align + * @param seqs + * the new sequence array + * @param ascending + * false for reversed order; if ascending, only sequences already in + * the alignment will be used; if descending, then a direct 1:1 + * replacement is made + */ + private static void set(AlignmentI align, SequenceI[] seqs, + boolean ascending) + { + if (ascending) { - setOrder(alignment, seqs); + setOrder(align, seqs); } else { - setReverseOrder(alignment, seqs); + setReverseOrder(align, seqs); + } + + } + + /** + * Replace the alignment's sequences with values in an array, clearing the + * alignment's sequence list and filtering for sequences that are actually in + * the alignment already. + * + * @param align + * the Alignment + * @param seqs + * the array of replacement values, of any length + */ + public static void setOrder(AlignmentI align, SequenceI[] seqs) + { + // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work + List seqList = align.getSequences(); + synchronized (seqList) + { + List tmp = new ArrayList<>(); + + for (int i = 0; i < seqs.length; i++) + { + if (seqList.contains(seqs[i])) + { + tmp.add(seqs[i]); + } + } + + seqList.clear(); + // User may have hidden seqs, then clicked undo or redo + for (int i = 0; i < tmp.size(); i++) + { + seqList.add(tmp.get(i)); + } } - lastSortByFeatureScore = scoreLabel.toString(); + } + + /** + * Replace the alignment's sequences or a subset of those sequences with + * values in an array in reverse order. All sequences are replaced; no check + * is made that these sequences are in the alignment already. + * + * @param align + * the Alignment + * @param seqs + * the array of replacement values, length must be less than or equal + * to Alignment.sequences.size() + */ + private static void setReverseOrder(AlignmentI align, SequenceI[] seqs) + { + int nSeq = seqs.length; + + int len = (nSeq + (nSeq % 2)) / 2; + // int len = 0; + // + // if ((nSeq % 2) == 0) + // { + // len = nSeq / 2; + // } + // else + // { + // len = (nSeq + 1) / 2; + // } + + // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work + List seqList = align.getSequences(); + synchronized (seqList) + { + for (int i = 0; i < len; i++) + { + // SequenceI tmp = seqs[i]; + seqList.set(i, seqs[nSeq - i - 1]); + seqList.set(nSeq - i - 1, seqs[i]); + } + } + } + + /** + * Create and array of reordered sequences in order first from tmp that are + * present in seqList already, then, after that, any remaining sequences in + * seqList not in tmp. Any sequences in tmp that are not in seqList already + * are discarded. + * + * @param seqList + * thread safe collection of sequences originally in the alignment + * @param tmp + * thread safe collection of sequences or subsequences possibly in + * seqList + * + * @return intersect(tmp,seqList)+intersect(complement(tmp),seqList) + */ + private static SequenceI[] vectorSubsetToArray(List seqList, + List tmp) + { + ArrayList seqs = new ArrayList<>(); + int n = seqList.size(); + BitSet bs = new BitSet(n); + bs.set(0, n); + for (int i = 0, nt = tmp.size(); i < nt; i++) + { + SequenceI sq = tmp.get(i); + int idx = seqList.indexOf(sq); + if (idx >= 0 && bs.get(idx)) + { + seqs.add(sq); + bs.clear(idx); + } + } + + for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i + 1)) + { + seqs.add(seqList.get(i)); + } + + return seqs.toArray(new SequenceI[seqs.size()]); } }