X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAnnotationSorter.java;fp=src%2Fjalview%2Fanalysis%2FAnnotationSorter.java;h=a5d2164b655b4a9b1ef9c00595d07070a518b1e5;hb=49a7daf06cb98b45ce2d33ea25b15172c4204dda;hp=0000000000000000000000000000000000000000;hpb=227ee1c1c69c228b67d408a0a83ae51bf5811272;p=jalview.git diff --git a/src/jalview/analysis/AnnotationSorter.java b/src/jalview/analysis/AnnotationSorter.java new file mode 100644 index 0000000..a5d2164 --- /dev/null +++ b/src/jalview/analysis/AnnotationSorter.java @@ -0,0 +1,348 @@ +package jalview.analysis; + +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 + * various ways. + * + * @author gmcarstairs + * + */ +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"); + + 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; + + // user preference for placement of non-sequence annotations + private boolean showAutocalcAbove; + + // working map of sequence index in alignment + private final Map sequenceIndices = new HashMap(); + + /** + * Constructor given an alignment and the location (top or bottom) of + * Consensus and similar. + * + * @param alignmentI + * @param showAutocalculatedAbove + */ + public AnnotationSorter(AlignmentI alignmentI, + boolean showAutocalculatedAbove) + { + this.alignment = alignmentI; + this.showAutocalcAbove = showAutocalculatedAbove; + } + + /** + * Default comparator sorts as follows by annotation type within sequence + * order: + * + */ + private final Comparator bySequenceAndLabel = new Comparator() + { + @Override + public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2) + { + if (o1 == null && o2 == null) + { + return 0; + } + if (o1 == null) + { + return -1; + } + if (o2 == null) + { + return 1; + } + + /* + * Ignore label (keep existing ordering) for + * Conservation/Quality/Consensus etc + */ + if (o1.sequenceRef == null && o2.sequenceRef == null) + { + return 0; + } + int sequenceOrder = compareSequences(o1, o2); + return sequenceOrder == 0 ? compareLabels(o1, o2) : sequenceOrder; + } + }; + + /** + * This comparator sorts as follows by sequence order within annotation type + *
    + *
  • 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
    • + *
  • within the same label, sort by order of the related sequences
    • + *
+ */ + private final Comparator byLabelAndSequence = new Comparator() + { + @Override + public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2) + { + if (o1 == null && o2 == null) + { + return 0; + } + if (o1 == null) + { + return -1; + } + if (o2 == null) + { + return 1; + } + + /* + * Ignore label (keep existing ordering) for + * Conservation/Quality/Consensus etc + */ + if (o1.sequenceRef == null && o2.sequenceRef == null) + { + return 0; + } + + /* + * Sort non-sequence-related before or after sequence-related. + */ + if (o1.sequenceRef == null) + { + return showAutocalcAbove ? -1 : 1; + } + if (o2.sequenceRef == null) + { + return showAutocalcAbove ? 1 : -1; + } + int labelOrder = compareLabels(o1, o2); + return labelOrder == 0 ? compareSequences(o1, o2) : labelOrder; + } + }; + + /** + * noSort leaves sort order unchanged, within sequence- and + * non-sequence-related 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). + */ + private Comparator noSort = new Comparator() + { + @Override + public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2) + { + if (o1 != null && o2 != null) + { + if (o1.sequenceRef == null && o2.sequenceRef != null) + { + return showAutocalcAbove ? -1 : 1; + } + if (o1.sequenceRef != null && o2.sequenceRef == null) + { + return showAutocalcAbove ? 1 : -1; + } + } + return 0; + } + }; + + /** + * Sort by the specified ordering of sequence-specific annotations. + * + * @param alignmentAnnotations + * @param order + */ + public void sort(AlignmentAnnotation[] alignmentAnnotations, + SequenceAnnotationOrder order) + { + // cache 'alignment sequence position' for the annotations + saveSequenceIndices(alignmentAnnotations); + + Comparator comparator = getComparator(order); + + if (alignmentAnnotations != null) + { + synchronized (alignmentAnnotations) + { + Arrays.sort(alignmentAnnotations, comparator); + } + } + } + + /** + * Calculate and save in a temporary map the position of each annotation's + * sequence (if it has one) in the alignment. Faster to do this once than for + * every annotation comparison. + * + * @param alignmentAnnotations + */ + private void saveSequenceIndices( + AlignmentAnnotation[] alignmentAnnotations) + { + sequenceIndices.clear(); + for (AlignmentAnnotation ann : alignmentAnnotations) { + SequenceI seq = ann.sequenceRef; + if (seq != null) { + int index = AlignmentUtils.getSequenceIndex(alignment, seq); + 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. + * + * @param o1 + * @param o2 + * @return + */ + private int compareLabels(AlignmentAnnotation o1, AlignmentAnnotation o2) + { + if (o1 == null || o2 == null) + { + return 0; + } + String label1 = o1.label; + String label2 = o2.label; + if (label1 == null && label2 == null) + { + return 0; + } + if (label1 == null) + { + return -1; + } + if (label2 == null) + { + return 1; + } + return label1.toUpperCase().compareTo(label2.toUpperCase()); + } + + /** + * Comparison based on position of associated sequence (if any) in the + * alignment. Returns zero if either argument is null. + * + * @param o1 + * @param o2 + * @return + */ + private int compareSequences(AlignmentAnnotation o1, + AlignmentAnnotation o2) + { + SequenceI seq1 = o1.sequenceRef; + SequenceI seq2 = o2.sequenceRef; + if (seq1 == null && seq2 == null) + { + return 0; + } + /* + * Sort non-sequence-related before or after sequence-related. + */ + if (seq1 == null) + { + return showAutocalcAbove ? -1 : 1; + } + if (seq2 == null) + { + return showAutocalcAbove ? 1 : -1; + } + // get sequence index - but note -1 means 'at end' so needs special handling + int index1 = sequenceIndices.get(seq1); + int index2 = sequenceIndices.get(seq2); + if (index1 == index2) + { + return 0; + } + if (index1 == -1) + { + return -1; + } + if (index2 == -1) + { + return 1; + } + return Integer.compare(index1, index2); + } +}