X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequenceGroup.java;h=7e53c46229629db5c7532baab9032245d3616ff4;hb=HEAD;hp=dec4fa433dac9c8d4562233b568650944049b414;hpb=25aaaa87042b3f507ad4348120df7dd073182759;p=jalview.git diff --git a/src/jalview/datamodel/SequenceGroup.java b/src/jalview/datamodel/SequenceGroup.java index dec4fa4..7e53c46 100755 --- a/src/jalview/datamodel/SequenceGroup.java +++ b/src/jalview/datamodel/SequenceGroup.java @@ -1,6 +1,6 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2b1) - * Copyright (C) 2014 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,17 +20,20 @@ */ package jalview.datamodel; -import jalview.analysis.AAFrequency; -import jalview.analysis.Conservation; -import jalview.schemes.ColourSchemeI; -import jalview.schemes.ResidueProperties; - import java.awt.Color; +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; import java.util.ArrayList; -import java.util.Hashtable; +import java.util.Arrays; +import java.util.Collection; import java.util.List; import java.util.Map; -import java.util.Vector; + +import jalview.analysis.AAFrequency; +import jalview.analysis.Conservation; +import jalview.renderer.ResidueShader; +import jalview.renderer.ResidueShaderI; +import jalview.schemes.ColourSchemeI; /** * Collects a set contiguous ranges on a set of sequences @@ -40,14 +43,32 @@ import java.util.Vector; */ public class SequenceGroup implements AnnotatedCollectionI { + // TODO ideally this event notification functionality should be separated into + // a + // subclass of ViewportProperties similarly to ViewportRanges. Done here as + // quick fix for JAL-2665 + public static final String SEQ_GROUP_CHANGED = "Sequence group changed"; + + protected PropertyChangeSupport changeSupport = new PropertyChangeSupport( + this); + + public void addPropertyChangeListener(PropertyChangeListener listener) + { + changeSupport.addPropertyChangeListener(listener); + } + + public void removePropertyChangeListener(PropertyChangeListener listener) + { + changeSupport.removePropertyChangeListener(listener); + } + // end of event notification functionality initialisation + String groupName; String description; Conservation conserve; - Vector aaFrequency; - boolean displayBoxes = true; boolean displayText = true; @@ -55,6 +76,12 @@ public class SequenceGroup implements AnnotatedCollectionI boolean colourText = false; /** + * True if the group is defined as a group on the alignment, false if it is + * just a selection. + */ + boolean isDefined = false; + + /** * after Olivier's non-conserved only character display */ boolean showNonconserved = false; @@ -62,7 +89,7 @@ public class SequenceGroup implements AnnotatedCollectionI /** * group members */ - private List sequences = new ArrayList(); + private List sequences; /** * representative sequence for this group (if any) @@ -74,11 +101,17 @@ public class SequenceGroup implements AnnotatedCollectionI /** * Colourscheme applied to group if any */ - public ColourSchemeI cs; + public ResidueShaderI cs; - int startRes = 0; + /** + * start column (base 0) + */ + private int startRes = 0; - int endRes = 0; + /** + * end column (base 0) + */ + private int endRes = 0; public Color outlineColour = Color.black; @@ -105,13 +138,23 @@ public class SequenceGroup implements AnnotatedCollectionI */ private boolean normaliseSequenceLogo; - /** - * @return the includeAllConsSymbols + /* + * visibility of rows or represented rows covered by group */ - public boolean isShowSequenceLogo() - { - return showSequenceLogo; - } + private boolean hidereps = false; + + /* + * visibility of columns intersecting this group + */ + private boolean hidecols = false; + + AlignmentAnnotation consensus = null; + + AlignmentAnnotation conservation = null; + + private boolean showConsensusHistogram; + + private AnnotatedCollectionI context; /** * Creates a new SequenceGroup object. @@ -119,6 +162,8 @@ public class SequenceGroup implements AnnotatedCollectionI public SequenceGroup() { groupName = "JGroup:" + this.hashCode(); + cs = new ResidueShader(); + sequences = new ArrayList<>(); } /** @@ -139,12 +184,13 @@ public class SequenceGroup implements AnnotatedCollectionI ColourSchemeI scheme, boolean displayBoxes, boolean displayText, boolean colourText, int start, int end) { + this(); this.sequences = sequences; this.groupName = groupName; this.displayBoxes = displayBoxes; this.displayText = displayText; this.colourText = colourText; - this.cs = scheme; + this.cs = new ResidueShader(scheme); startRes = start; endRes = end; recalcConservation(); @@ -157,9 +203,10 @@ public class SequenceGroup implements AnnotatedCollectionI */ public SequenceGroup(SequenceGroup seqsel) { + this(); if (seqsel != null) { - sequences = new ArrayList(); + sequences = new ArrayList<>(); sequences.addAll(seqsel.sequences); if (seqsel.groupName != null) { @@ -168,15 +215,20 @@ public class SequenceGroup implements AnnotatedCollectionI displayBoxes = seqsel.displayBoxes; displayText = seqsel.displayText; colourText = seqsel.colourText; + startRes = seqsel.startRes; endRes = seqsel.endRes; - cs = seqsel.cs; + cs = new ResidueShader((ResidueShader) seqsel.cs); if (seqsel.description != null) { description = new String(seqsel.description); } hidecols = seqsel.hidecols; hidereps = seqsel.hidereps; + showNonconserved = seqsel.showNonconserved; + showSequenceLogo = seqsel.showSequenceLogo; + normaliseSequenceLogo = seqsel.normaliseSequenceLogo; + showConsensusHistogram = seqsel.showConsensusHistogram; idColour = seqsel.idColour; outlineColour = seqsel.outlineColour; seqrep = seqsel.seqrep; @@ -193,6 +245,22 @@ public class SequenceGroup implements AnnotatedCollectionI } } + /** + * Constructor that copies the given list of sequences + * + * @param seqs + */ + public SequenceGroup(List seqs) + { + this(); + this.sequences.addAll(seqs); + } + + public boolean isShowSequenceLogo() + { + return showSequenceLogo; + } + public SequenceI[] getSelectionAsNewSequences(AlignmentI align) { int iSize = sequences.size(); @@ -202,18 +270,10 @@ public class SequenceGroup implements AnnotatedCollectionI for (int i = 0, ipos = 0; i < inorder.length; i++) { SequenceI seq = inorder[i]; - - seqs[ipos] = seq.getSubSequence(startRes, endRes + 1); - if (seqs[ipos] != null) + SequenceI seqipos = seqs[ipos] = seq.getSubSequence(startRes, + endRes + 1); + if (seqipos != null) { - seqs[ipos].setDescription(seq.getDescription()); - seqs[ipos].setDBRef(seq.getDBRef()); - seqs[ipos].setSequenceFeatures(seq.getSequenceFeatures()); - if (seq.getDatasetSequence() != null) - { - seqs[ipos].setDatasetSequence(seq.getDatasetSequence()); - } - if (seq.getAnnotation() != null) { AlignmentAnnotation[] alann = align.getAlignmentAnnotation(); @@ -225,7 +285,7 @@ public class SequenceGroup implements AnnotatedCollectionI if (alann != null) { boolean found = false; - for (int pos = 0; pos < alann.length; pos++) + for (int pos = 0, np = alann.length; pos < np; pos++) { if (alann[pos] == tocopy) { @@ -243,7 +303,13 @@ public class SequenceGroup implements AnnotatedCollectionI newannot.restrict(startRes, endRes); newannot.setSequenceRef(seqs[ipos]); newannot.adjustForAlignment(); - seqs[ipos].addAlignmentAnnotation(newannot); + ContactMatrixI cm = seq + .getContactMatrixFor(seq.getAnnotation()[a]); + if (cm != null) + { + seqs[ipos].addContactListFor(newannot, cm); + } + seqipos.addAlignmentAnnotation(newannot); } } ipos++; @@ -309,7 +375,7 @@ public class SequenceGroup implements AnnotatedCollectionI } else { - List allSequences = new ArrayList(); + List allSequences = new ArrayList<>(); for (SequenceI seq : sequences) { allSequences.add(seq); @@ -469,6 +535,8 @@ public class SequenceGroup implements AnnotatedCollectionI if (s != null && !sequences.contains(s)) { sequences.add(s); + changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, + sequences.size() - 1, sequences.size()); } if (recalc) @@ -502,32 +570,51 @@ public class SequenceGroup implements AnnotatedCollectionI } /** - * calculate residue conservation for group - but only if necessary. + * calculate residue conservation and colourschemes for group - but only if + * necessary. returns true if the calculation resulted in a visible change to + * group */ - public void recalcConservation() + public boolean recalcConservation() + { + return recalcConservation(false); + } + + /** + * calculate residue conservation for group - but only if necessary. returns + * true if the calculation resulted in a visible change to group + * + * @param defer + * when set, colourschemes for this group are not refreshed after + * recalculation + */ + public boolean recalcConservation(boolean defer) { if (cs == null && consensus == null && conservation == null) { - return; + return false; } + // TODO: try harder to detect changes in state in order to minimise + // recalculation effort + boolean upd = false; try { - Hashtable cnsns[] = AAFrequency.calculate(sequences, startRes, + ProfilesI cnsns = AAFrequency.calculate(sequences, startRes, endRes + 1, showSequenceLogo); if (consensus != null) { _updateConsensusRow(cnsns, sequences.size()); + upd = true; } if (cs != null) { cs.setConsensus(cnsns); + upd = true; } if ((conservation != null) || (cs != null && cs.conservationApplied())) { - Conservation c = new Conservation(groupName, - ResidueProperties.propHash, 3, sequences, startRes, + Conservation c = new Conservation(groupName, sequences, startRes, endRes + 1); c.calculate(); c.verdict(false, consPercGaps); @@ -542,17 +629,26 @@ public class SequenceGroup implements AnnotatedCollectionI cs.setConservation(c); } } + // eager update - will cause a refresh of overview regardless + upd = true; } - if (cs != null) + if (cs != null && !defer) { + // TODO: JAL-2034 should cs.alignmentChanged modify return state cs.alignmentChanged(context != null ? context : this, null); + return true; + } + else + { + return upd; } } catch (java.lang.OutOfMemoryError err) { // TODO: catch OOM - System.out.println("Out of memory loading groups: " + err); + jalview.bin.Console + .outPrintln("Out of memory loading groups: " + err); } - + return upd; } private void _updateConservationRow(Conservation c) @@ -566,8 +662,10 @@ public class SequenceGroup implements AnnotatedCollectionI conservation.description = "Conservation for group " + getName() + " less than " + consPercGaps + "% gaps"; // preserve width if already set - int aWidth = (conservation.annotations != null) ? (endRes < conservation.annotations.length ? conservation.annotations.length - : endRes + 1) + int aWidth = (conservation.annotations != null) + ? (endRes < conservation.annotations.length + ? conservation.annotations.length + : endRes + 1) : endRes + 1; conservation.annotations = null; conservation.annotations = new Annotation[aWidth]; // should be alignment @@ -575,9 +673,9 @@ public class SequenceGroup implements AnnotatedCollectionI c.completeAnnotations(conservation, null, startRes, endRes + 1); } - public Hashtable[] consensusData = null; + public ProfilesI consensusData = null; - private void _updateConsensusRow(Hashtable[] cnsns, long nseq) + private void _updateConsensusRow(ProfilesI cnsns, long nseq) { if (consensus == null) { @@ -587,8 +685,10 @@ public class SequenceGroup implements AnnotatedCollectionI consensus.description = "Percent Identity"; consensusData = cnsns; // preserve width if already set - int aWidth = (consensus.annotations != null) ? (endRes < consensus.annotations.length ? consensus.annotations.length - : endRes + 1) + int aWidth = (consensus.annotations != null) + ? (endRes < consensus.annotations.length + ? consensus.annotations.length + : endRes + 1) : endRes + 1; consensus.annotations = null; consensus.annotations = new Annotation[aWidth]; // should be alignment width @@ -611,13 +711,13 @@ public class SequenceGroup implements AnnotatedCollectionI { synchronized (sequences) { - if (sequences.contains(s)) - { - deleteSequence(s, recalc); - } - else - { - addSequence(s, recalc); + if (sequences.contains(s)) + { + deleteSequence(s, recalc); + } + else + { + addSequence(s, recalc); } } } @@ -635,6 +735,8 @@ public class SequenceGroup implements AnnotatedCollectionI synchronized (sequences) { sequences.remove(s); + changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, + sequences.size() + 1, sequences.size()); if (recalc) { @@ -667,11 +769,15 @@ public class SequenceGroup implements AnnotatedCollectionI /** * Set the first column selected by this group. Runs from 0<=i width) { width = seq.getLength(); @@ -891,6 +1000,7 @@ public class SequenceGroup implements AnnotatedCollectionI /** * @return the representative sequence for this group */ + @Override public SequenceI getSeqrep() { return seqrep; @@ -903,6 +1013,7 @@ public class SequenceGroup implements AnnotatedCollectionI * @param seqrep * the seqrep to set (null means no sequence representative) */ + @Override public void setSeqrep(SequenceI seqrep) { this.seqrep = seqrep; @@ -912,17 +1023,13 @@ public class SequenceGroup implements AnnotatedCollectionI * * @return true if group has a sequence representative */ + @Override public boolean hasSeqrep() { return seqrep != null; } /** - * visibility of rows or represented rows covered by group - */ - private boolean hidereps = false; - - /** * set visibility of sequences covered by (if no sequence representative is * defined) or represented by this group. * @@ -944,11 +1051,6 @@ public class SequenceGroup implements AnnotatedCollectionI } /** - * visibility of columns intersecting this group - */ - private boolean hidecols = false; - - /** * set intended visibility of columns covered by this group * * @param visibility @@ -982,7 +1084,7 @@ public class SequenceGroup implements AnnotatedCollectionI { SequenceGroup sgroup = new SequenceGroup(this); SequenceI[] insect = getSequencesInOrder(alignment); - sgroup.sequences = new ArrayList(); + sgroup.sequences = new ArrayList<>(); for (int s = 0; insect != null && s < insect.length; s++) { if (map == null || map.containsKey(insect[s])) @@ -1010,13 +1112,6 @@ public class SequenceGroup implements AnnotatedCollectionI this.showNonconserved = displayNonconserved; } - AlignmentAnnotation consensus = null, conservation = null; - - /** - * flag indicating if consensus histogram should be rendered - */ - private boolean showConsensusHistogram; - /** * set this alignmentAnnotation object as the one used to render consensus * annotation @@ -1033,7 +1128,8 @@ public class SequenceGroup implements AnnotatedCollectionI /** * - * @return automatically calculated consensus row + * @return automatically calculated consensus row note: the row is a stub if a + * consensus calculation has not yet been performed on the group */ public AlignmentAnnotation getConsensus() { @@ -1112,9 +1208,10 @@ public class SequenceGroup implements AnnotatedCollectionI { if (consensus.annotations[i] != null) { - if (consensus.annotations[i].description.charAt(0) == '[') + String desc = consensus.annotations[i].description; + if (desc.length() > 1 && desc.charAt(0) == '[') { - seqs.append(consensus.annotations[i].description.charAt(1)); + seqs.append(desc.charAt(1)); } else { @@ -1208,7 +1305,7 @@ public class SequenceGroup implements AnnotatedCollectionI { // TODO add in other methods like 'getAlignmentAnnotation(String label), // etc' - ArrayList annot = new ArrayList(); + ArrayList annot = new ArrayList<>(); synchronized (sequences) { for (SequenceI seq : sequences) @@ -1240,38 +1337,16 @@ public class SequenceGroup implements AnnotatedCollectionI @Override public Iterable findAnnotation(String calcId) { - ArrayList aa = new ArrayList(); - for (AlignmentAnnotation a : getAlignmentAnnotation()) - { - if (a.getCalcId() == calcId) - { - aa.add(a); - } - } - return aa; + return AlignmentAnnotation.findAnnotation( + Arrays.asList(getAlignmentAnnotation()), calcId); } - /** - * Returns a list of annotations that match the specified sequenceRef, calcId - * and label, ignoring null values. - * - * @return list of AlignmentAnnotation objects - */ @Override public Iterable findAnnotations(SequenceI seq, String calcId, String label) { - ArrayList aa = new ArrayList(); - for (AlignmentAnnotation ann : getAlignmentAnnotation()) - { - if (ann.getCalcId() != null && ann.getCalcId().equals(calcId) - && ann.sequenceRef != null && ann.sequenceRef == seq - && ann.label != null && ann.label.equals(label)) - { - aa.add(ann); - } - } - return aa; + return AlignmentAnnotation.findAnnotations( + Arrays.asList(getAlignmentAnnotation()), seq, calcId, label); } /** @@ -1282,37 +1357,63 @@ public class SequenceGroup implements AnnotatedCollectionI */ public boolean hasAnnotation(String calcId) { - if (calcId != null && !"".equals(calcId)) - { - for (AlignmentAnnotation a : getAlignmentAnnotation()) - { - if (a.getCalcId() == calcId) - { - return true; - } - } - } - return false; + return AlignmentAnnotation + .hasAnnotation(Arrays.asList(getAlignmentAnnotation()), calcId); } + /** + * Remove all sequences from the group (leaving other properties unchanged). + */ public void clear() { synchronized (sequences) { + int before = sequences.size(); sequences.clear(); + changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, before, + sequences.size()); } } - private AnnotatedCollectionI context; + /** + * Sets the alignment or group context for this group, and whether it is + * defined as a group + * + * @param ctx + * the context for the group + * @param defined + * whether the group is defined on the alignment or is just a + * selection + * @throws IllegalArgumentException + * if setting the context would result in a circular reference chain + */ + public void setContext(AnnotatedCollectionI ctx, boolean defined) + { + setContext(ctx); + this.isDefined = defined; + } /** - * set the alignment or group context for this group + * Sets the alignment or group context for this group * - * @param context + * @param ctx + * the context for the group + * @throws IllegalArgumentException + * if setting the context would result in a circular reference chain */ - public void setContext(AnnotatedCollectionI context) + public void setContext(AnnotatedCollectionI ctx) { - this.context = context; + AnnotatedCollectionI ref = ctx; + while (ref != null) + { + if (ref == this || ref.getContext() == ctx) + { + throw new IllegalArgumentException( + "Circular reference in SequenceGroup.context"); + } + ref = ref.getContext(); + } + this.context = ctx; } /* @@ -1325,4 +1426,110 @@ public class SequenceGroup implements AnnotatedCollectionI { return context; } + + public boolean isDefined() + { + return isDefined; + } + + public void setColourScheme(ColourSchemeI scheme) + { + if (cs == null) + { + cs = new ResidueShader(); + } + cs.setColourScheme(scheme); + } + + public void setGroupColourScheme(ResidueShaderI scheme) + { + cs = scheme; + } + + public ColourSchemeI getColourScheme() + { + return cs == null ? null : cs.getColourScheme(); + } + + public ResidueShaderI getGroupColourScheme() + { + return cs; + } + + @Override + public boolean isNucleotide() + { + if (context != null) + { + return context.isNucleotide(); + } + return false; + } + + /** + * @param seq + * @return true if seq is a member of the group + */ + + public boolean contains(SequenceI seq1) + { + return sequences.contains(seq1); + } + + /** + * @param seq + * @param apos + * @return true if startRes<=apos and endRes>=apos and seq is in the group + */ + public boolean contains(SequenceI seq, int apos) + { + return (startRes <= apos && endRes >= apos) && sequences.contains(seq); + } + + //// + //// Contact Matrix Holder Boilerplate + //// + ContactMapHolder cmholder = new ContactMapHolder(); + + @Override + public Collection getContactMaps() + { + return cmholder.getContactMaps(); + } + + @Override + public ContactMatrixI getContactMatrixFor(AlignmentAnnotation ann) + { + return cmholder.getContactMatrixFor(ann); + } + + @Override + public ContactListI getContactListFor(AlignmentAnnotation _aa, int column) + { + return cmholder.getContactListFor(_aa, column); + } + + @Override + public AlignmentAnnotation addContactList(ContactMatrixI cm) + { + AlignmentAnnotation aa = cmholder.addContactList(cm); + + Annotation _aa[] = new Annotation[getWidth()]; + Annotation dummy = new Annotation(0.0f); + for (int i = 0; i < _aa.length; _aa[i++] = dummy) + { + ; + } + aa.annotations = _aa; + // TODO passing annotations back to context to be added + return aa; + } + + @Override + public void addContactListFor(AlignmentAnnotation annotation, + ContactMatrixI cm) + { + cmholder.addContactListFor(annotation, cm); + } + }