X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAlignmentSorter.java;h=af7db0af83daebba1f86816e3e5012e2e63d05b7;hb=ace99d5556a3f546b98d32f73d7cf78cbe9bcb32;hp=8634db68d2bedf572eaa2d94c3ffeece92a33e9e;hpb=8d25e88f6a9d1bea9569c23e425df7b1b498fd14;p=jalview.git diff --git a/src/jalview/analysis/AlignmentSorter.java b/src/jalview/analysis/AlignmentSorter.java index 8634db6..af7db0a 100755 --- a/src/jalview/analysis/AlignmentSorter.java +++ b/src/jalview/analysis/AlignmentSorter.java @@ -34,6 +34,7 @@ import jalview.datamodel.SequenceNode; import jalview.util.QuickSort; import java.util.ArrayList; +import java.util.BitSet; import java.util.Collections; import java.util.Iterator; import java.util.List; @@ -61,7 +62,7 @@ public class AlignmentSorter implements ApplicationSingletonI // private singleton } - private static AlignmentSorter getInstance() + public static AlignmentSorter getInstance() { return (AlignmentSorter) ApplicationSingletonProvider .getInstance(AlignmentSorter.class); @@ -97,7 +98,6 @@ public class AlignmentSorter implements ApplicationSingletonI boolean sortTreeAscending = true; - /** * last Annotation Label used for sort by Annotation score */ @@ -142,93 +142,10 @@ public class AlignmentSorter implements ApplicationSingletonI } QuickSort.sort(scores, seqs); - setReverseOrder(align, 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) - { - len = nSeq / 2; - } - else - { - len = (nSeq + 1) / 2; - } - - // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work - List asq = align.getSequences(); - synchronized (asq) - { - 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]); - } - } - } - - /** - * 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())); - } - - /** - * Sets the Alignment object with the given sequences - * - * @param align - * DOCUMENT ME! - * @param seqs - * sequences as an array - */ - public static void setOrder(AlignmentI align, SequenceI[] seqs) - { - // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work - List algn = align.getSequences(); - synchronized (algn) - { - List tmp = new ArrayList<>(); - - for (int i = 0; i < seqs.length; i++) - { - if (algn.contains(seqs[i])) - { - tmp.add(seqs[i]); - } - } - - 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)); - } - } - } - - /** * Sorts by ID. Numbers are sorted before letters. * * @param align @@ -248,18 +165,9 @@ public class AlignmentSorter implements ApplicationSingletonI } QuickSort.sort(ids, seqs); - AlignmentSorter as = getInstance(); - if (as.sortIdAscending) - { - setReverseOrder(align, seqs); - } - else - { - setOrder(align, seqs); - } - as.sortIdAscending = !as.sortIdAscending; + set(align, seqs, as.sortIdAscending); } /** @@ -282,19 +190,9 @@ public class AlignmentSorter implements ApplicationSingletonI } QuickSort.sort(length, seqs); - AlignmentSorter as = getInstance(); - - if (as.sortLengthAscending) - { - setReverseOrder(align, seqs); - } - else - { - setOrder(align, seqs); - } - as.sortLengthAscending = !as.sortLengthAscending; + set(align, seqs, as.sortLengthAscending); } /** @@ -347,7 +245,7 @@ public class AlignmentSorter implements ApplicationSingletonI // NOW ADD SEQUENCES MAINTAINING ALIGNMENT ORDER // ///////////////////////////////////////////// - List seqs = new ArrayList<>(); + List tmp = new ArrayList<>(); for (int i = 0; i < groups.size(); i++) { @@ -356,68 +254,10 @@ public class AlignmentSorter implements ApplicationSingletonI for (int j = 0; j < orderedseqs.length; j++) { - seqs.add(orderedseqs[j]); - } - } - - if (as.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); - } - } - - for (i = 0; i < tmask.length; i++) - { - if (tmask[i]) - { - seqs.add(mask.get(i)); + tmp.add(orderedseqs[j]); } } - - return seqs.toArray(new SequenceI[seqs.size()]); + set(align, tmp, as.sortGroupAscending); } /** @@ -443,16 +283,7 @@ public class AlignmentSorter implements ApplicationSingletonI { as.sortOrderAscending = true; } - - if (as.sortOrderAscending) - { - setOrder(align, tmp); - } - else - { - setReverseOrder(align, - vectorSubsetToArray(tmp, align.getSequences())); - } + set(align, tmp, as.sortOrderAscending); } /** @@ -519,16 +350,7 @@ public class AlignmentSorter implements ApplicationSingletonI { as.sortTreeAscending = !as.sortTreeAscending; } - - if (as.sortTreeAscending) - { - setOrder(align, tmp); - } - else - { - setReverseOrder(align, - vectorSubsetToArray(tmp, align.getSequences())); - } + set(align, tmp, as.sortTreeAscending); } /** @@ -622,7 +444,7 @@ public class AlignmentSorter implements ApplicationSingletonI 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(); } @@ -735,14 +557,15 @@ public class AlignmentSorter implements ApplicationSingletonI if (method != FEATURE_SCORE && method != FEATURE_LABEL && method != FEATURE_DENSITY) { - String msg = String - .format("Implementation Error - sortByFeature method must be either '%s' or '%s'", - FEATURE_SCORE, FEATURE_DENSITY); + 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); + flipFeatureSortIfUnchanged(method, featureTypes, groups, startCol, + endCol); SequenceI[] seqs = alignment.getSequencesArray(); @@ -761,8 +584,8 @@ public class AlignmentSorter implements ApplicationSingletonI * 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()]); + String[] types = featureTypes == null ? null + : featureTypes.toArray(new String[featureTypes.size()]); List sfs = seqs[i].findFeatures(startCol + 1, endCol + 1, types); @@ -879,7 +702,8 @@ public class AlignmentSorter implements ApplicationSingletonI } if (doSort) { - QuickSort.sortByDouble(scores, seqs, getInstance().sortByFeatureAscending); + QuickSort.sortByDouble(scores, seqs, + getInstance().sortByFeatureAscending); } setOrder(alignment, seqs); } @@ -928,4 +752,164 @@ public class AlignmentSorter implements ApplicationSingletonI 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(align, seqs); + } + else + { + 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)); + } + } + } + + /** + * 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()]); + } + }