X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAnnotationSorter.java;h=83f3adf238bce0f8a64c5476a875330e7666e8a5;hb=a2032664d7eb6954072d43b424e11d219f28df62;hp=fa9c1a83f82ca41bfeda16ca30d5de61f758f3c3;hpb=eaf9092bfa74b5162589c8775f68a19dd79dbb1d;p=jalview.git diff --git a/src/jalview/analysis/AnnotationSorter.java b/src/jalview/analysis/AnnotationSorter.java index fa9c1a8..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,28 +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 { - SEQUENCE_AND_LABEL, LABEL_AND_SEQUENCE, NONE + // 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; + /* + * 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 given an alignment and the location (top or bottom) of - * Consensus and similar. + * Constructor * - * @param alignmentI - * @param showAutocalculatedAbove + * @param av */ - public AnnotationSorter(AlignmentI alignmentI, - boolean showAutocalculatedAbove) + public AnnotationSorter(AlignViewportI av) { - this.alignment = alignmentI; - this.showAutocalcAbove = showAutocalculatedAbove; + this.alignment = av.getAlignment(); + this.showAutocalcAbove = av.isShowAutocalculatedAbove(); } /** @@ -46,7 +121,8 @@ public class AnnotationSorter * */ @@ -68,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"; + } }; /** @@ -86,7 +187,8 @@ public class AnnotationSorter * */ @@ -108,75 +210,141 @@ 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 before or after sequence-related. + * Sort autocalculated before or after sequence-related. */ - if (o1.sequenceRef == null) + if (o1auto) { return showAutocalcAbove ? -1 : 1; } - if (o2.sequenceRef == null) + if (o2auto) { 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"; + } }; /** - * 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). + * 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). */ private Comparator noSort = new Comparator() { @Override public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2) { + // 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) { - if (o1.sequenceRef == null && o2.sequenceRef != null) + if (o1auto && !o2auto) { return showAutocalcAbove ? -1 : 1; } - if (o1.sequenceRef != null && o2.sequenceRef == null) + if (!o1auto && o2auto) { return showAutocalcAbove ? 1 : -1; } } return 0; } + + @Override + public String toString() + { + return "No sort"; + } }; - + /** - * Sort by the specified ordering of sequence-specific annotations. + * 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 order + * @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(AlignmentAnnotation[] alignmentAnnotations, - SequenceAnnotationOrder order) + public void sort(SequenceAnnotationOrder sortBy, boolean autoCalcOnly) { - if (order != SequenceAnnotationOrder.NONE) + if (sortBy == null || sortBy == SequenceAnnotationOrder.CUSTOM) { - Comparator comparator = getComparator(order); + return; + } + + this.autocalcOnly = autoCalcOnly; - if (alignmentAnnotations != null) + /* + * 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. + */ + private void saveSequenceIndices() + { + sequenceIndices.clear(); + + Map seqPositions = alignment.getSequencePositions(); + + AlignmentAnnotation[] alignmentAnnotations = alignment + .getAlignmentAnnotation(); + for (AlignmentAnnotation ann : alignmentAnnotations) + { + SequenceI seq = ann.sequenceRef; + if (seq != null) { - synchronized (alignmentAnnotations) + Integer index = seqPositions.get(seq); + if (index != null) { - Arrays.sort(alignmentAnnotations, comparator); + sequenceIndices.put(seq, index); } } } @@ -241,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 @@ -256,8 +424,9 @@ public class AnnotationSorter { return 0; } + /* - * Sort non-sequence-related before or after sequence-related. + * Sort non-sequence-related before or after sequence-related */ if (seq1 == null) { @@ -267,21 +436,20 @@ public class AnnotationSorter { return showAutocalcAbove ? 1 : -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; - } - 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()); } }