X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAnnotationSorter.java;h=83f3adf238bce0f8a64c5476a875330e7666e8a5;hb=a2032664d7eb6954072d43b424e11d219f28df62;hp=4ee2b8661c0efcde1edcf8301d11c3c279f79339;hpb=ec493e27abc6b3be84b3c8a873c295a3f589bd53;p=jalview.git diff --git a/src/jalview/analysis/AnnotationSorter.java b/src/jalview/analysis/AnnotationSorter.java index 4ee2b86..83f3adf 100644 --- a/src/jalview/analysis/AnnotationSorter.java +++ b/src/jalview/analysis/AnnotationSorter.java @@ -1,11 +1,34 @@ +/* + * 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 + * 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 . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ package jalview.analysis; +import jalview.api.AlignViewportI; import jalview.datamodel.AlignmentAnnotation; import jalview.datamodel.AlignmentI; import jalview.datamodel.SequenceI; import java.util.Arrays; import java.util.Comparator; +import java.util.HashMap; +import java.util.Map; /** * A helper class to sort all annotations associated with an alignment in @@ -16,12 +39,80 @@ import java.util.Comparator; */ public class AnnotationSorter { + /** + * enum for annotation sort options. The text description is used in the + * Preferences drop-down options. The enum name is saved in the preferences + * file. + * + * @author gmcarstairs + * + */ + public enum SequenceAnnotationOrder + { + // Text descriptions surface in the Preferences Sort by... options + SEQUENCE_AND_LABEL("Sequence"), LABEL_AND_SEQUENCE("Label"), + NONE("No sort"), + + /** + * custom is set if user drags to reorder annotations + */ + CUSTOM("Customised"); + + private String description; + + private SequenceAnnotationOrder(String s) + { + description = s; + } + @Override + public String toString() + { + return description; + } + + public static SequenceAnnotationOrder forDescription(String d) + { + for (SequenceAnnotationOrder order : values()) + { + if (order.toString().equals(d)) + { + return order; + } + } + return null; + } + } + + /* + * the alignment with respect to which annotations are sorted + */ private final AlignmentI alignment; - public AnnotationSorter(AlignmentI alignmentI) + /* + * if true, autocalculated are sorted first, if false, last + */ + private boolean showAutocalcAbove; + + /* + * working map of sequence index in alignment + */ + private final Map sequenceIndices = new HashMap<>(); + + /* + * if true, sort only repositions auto-calculated annotation (to top or bottom) + */ + private boolean autocalcOnly; + + /** + * Constructor + * + * @param av + */ + public AnnotationSorter(AlignViewportI av) { - this.alignment = alignmentI; + this.alignment = av.getAlignment(); + this.showAutocalcAbove = av.isShowAutocalculatedAbove(); } /** @@ -30,11 +121,12 @@ public class AnnotationSorter * */ - private final Comparator bySequenceAndType = new Comparator() + private final Comparator bySequenceAndLabel = new Comparator() { @Override public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2) @@ -52,17 +144,42 @@ public class AnnotationSorter return 1; } + // TODO how to treat sequence-related autocalculated annotation + boolean o1auto = o1.autoCalculated && o1.sequenceRef == null; + boolean o2auto = o2.autoCalculated && o2.sequenceRef == null; /* * Ignore label (keep existing ordering) for * Conservation/Quality/Consensus etc */ - if (o1.sequenceRef == null && o2.sequenceRef == null) + if (o1auto && o2auto) { return 0; } + + /* + * Sort autocalculated before or after sequence-related. + */ + if (o1auto) + { + return showAutocalcAbove ? -1 : 1; + } + if (o2auto) + { + return showAutocalcAbove ? 1 : -1; + } + if (autocalcOnly) + { + return 0; // don't reorder other annotations + } int sequenceOrder = compareSequences(o1, o2); return sequenceOrder == 0 ? compareLabels(o1, o2) : sequenceOrder; } + + @Override + public String toString() + { + return "Sort by sequence and label"; + } }; /** @@ -70,11 +187,12 @@ public class AnnotationSorter *
    *
  • annotations with a reference to a sequence in the alignment are sorted * on label (non-case-sensitive)
    • - *
  • other annotations go 'at the end', with their mutual order unchanged
    • + *
  • other annotations go 'at the end', with their mutual order + * unchanged
    • *
  • within the same label, sort by order of the related sequences
    • *
*/ - private final Comparator byTypeAndSequence = new Comparator() + private final Comparator byLabelAndSequence = new Comparator() { @Override public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2) @@ -92,68 +210,173 @@ public class AnnotationSorter return 1; } + // TODO how to treat sequence-related autocalculated annotation + boolean o1auto = o1.autoCalculated && o1.sequenceRef == null; + boolean o2auto = o2.autoCalculated && o2.sequenceRef == null; /* * Ignore label (keep existing ordering) for * Conservation/Quality/Consensus etc */ - if (o1.sequenceRef == null && o2.sequenceRef == null) + if (o1auto && o2auto) { return 0; } /* - * Sort non-sequence-related after sequence-related. + * Sort autocalculated before or after sequence-related. */ - if (o1.sequenceRef == null) + if (o1auto) { - return 1; + return showAutocalcAbove ? -1 : 1; } - if (o2.sequenceRef == null) + if (o2auto) { - return -1; + return showAutocalcAbove ? 1 : -1; + } + if (autocalcOnly) + { + return 0; // don't reorder other annotations } int labelOrder = compareLabels(o1, o2); return labelOrder == 0 ? compareSequences(o1, o2) : labelOrder; } + + @Override + public String toString() + { + return "Sort by label and sequence"; + } }; /** - * Sort by annotation type (label), within sequence order. - * Non-sequence-related annotations sort to the end. - * - * @param alignmentAnnotations + * noSort leaves sort order unchanged, within sequence- and autocalculated + * annotations, but may switch the ordering of these groups. Note this is + * guaranteed (at least in Java 7) as Arrays.sort() is guaranteed to be + * 'stable' (not change ordering of equal items). */ - public void sortBySequenceAndType( - AlignmentAnnotation[] alignmentAnnotations) + private Comparator noSort = new Comparator() { - if (alignmentAnnotations != null) + @Override + public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2) { - synchronized (alignmentAnnotations) + // TODO how to treat sequence-related autocalculated annotation + boolean o1auto = o1.autoCalculated && o1.sequenceRef == null; + boolean o2auto = o2.autoCalculated && o2.sequenceRef == null; + // TODO skip this test to allow customised ordering of all annotations + // - needs a third option: place autocalculated first / last / none + if (o1 != null && o2 != null) { - Arrays.sort(alignmentAnnotations, bySequenceAndType); + if (o1auto && !o2auto) + { + return showAutocalcAbove ? -1 : 1; + } + if (!o1auto && o2auto) + { + return showAutocalcAbove ? 1 : -1; + } } + return 0; } - } + + @Override + public String toString() + { + return "No sort"; + } + }; /** - * Sort by sequence order within annotation type (label). Non-sequence-related - * annotations sort to the end. + * Sorts by the specified ordering. If order is {@code CUSTOM}, meaning + * annotations have been manually ordered by the user, no sort is performed. * - * @param alignmentAnnotations + * @param sortBy + * the sort order to apply + * @param autoCalcOnly + * if true, only autocalculated annotations are repositioned (to top + * or bottom), others are left in their current order + */ + public void sort(SequenceAnnotationOrder sortBy, boolean autoCalcOnly) + { + if (sortBy == null || sortBy == SequenceAnnotationOrder.CUSTOM) + { + return; + } + + this.autocalcOnly = autoCalcOnly; + + /* + * cache 'alignment sequence positions' if required for sorting + */ + if (sortBy == SequenceAnnotationOrder.SEQUENCE_AND_LABEL + || sortBy == SequenceAnnotationOrder.LABEL_AND_SEQUENCE) + { + saveSequenceIndices(); + } + + Comparator comparator = getComparator( + sortBy); + + AlignmentAnnotation[] annotations = alignment.getAlignmentAnnotation(); + synchronized (annotations) + { + Arrays.sort(annotations, comparator); + } + } + + /** + * Calculates and saves in a temporary map the position of each annotation's + * associated sequence (if it has one) in the alignment. Faster to do this + * once than for every annotation comparison. */ - public void sortByTypeAndSequence( - AlignmentAnnotation[] alignmentAnnotations) + private void saveSequenceIndices() { - if (alignmentAnnotations != null) + sequenceIndices.clear(); + + Map seqPositions = alignment.getSequencePositions(); + + AlignmentAnnotation[] alignmentAnnotations = alignment + .getAlignmentAnnotation(); + for (AlignmentAnnotation ann : alignmentAnnotations) { - synchronized (alignmentAnnotations) + SequenceI seq = ann.sequenceRef; + if (seq != null) { - Arrays.sort(alignmentAnnotations, byTypeAndSequence); + Integer index = seqPositions.get(seq); + if (index != null) + { + sequenceIndices.put(seq, index); + } } } } /** + * Get the comparator for the specified sort order. + * + * @param order + * @return + */ + private Comparator getComparator( + SequenceAnnotationOrder order) + { + if (order == null) + { + return noSort; + } + switch (order) + { + case NONE: + return this.noSort; + case SEQUENCE_AND_LABEL: + return this.bySequenceAndLabel; + case LABEL_AND_SEQUENCE: + return this.byLabelAndSequence; + default: + throw new UnsupportedOperationException(order.toString()); + } + } + + /** * Non-case-sensitive comparison of annotation labels. Returns zero if either * argument is null. * @@ -186,7 +409,7 @@ public class AnnotationSorter /** * Comparison based on position of associated sequence (if any) in the - * alignment. Returns zero if either argument is null. + * alignment * * @param o1 * @param o2 @@ -201,29 +424,32 @@ public class AnnotationSorter { return 0; } + + /* + * Sort non-sequence-related before or after sequence-related + */ if (seq1 == null) { - return 1; + return showAutocalcAbove ? -1 : 1; } if (seq2 == null) { - return -1; - } - // get sequence index - but note -1 means 'at end' so needs special handling - int index1 = AlignmentUtils.getSequenceIndex(alignment, seq1); - int index2 = AlignmentUtils.getSequenceIndex(alignment, seq2); - if (index1 == index2) - { - return 0; + return showAutocalcAbove ? 1 : -1; } - if (index1 == -1) + + /* + * else sort by associated sequence position + */ + Integer index1 = sequenceIndices.get(seq1); + Integer index2 = sequenceIndices.get(seq2); + if (index1 == null) { - return -1; + return index2 == null ? 0 : -1; } - if (index2 == -1) + if (index2 == null) { return 1; } - return Integer.compare(index1, index2); + return Integer.compare(index1.intValue(), index2.intValue()); } }