X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=inline;f=src%2Fjalview%2Fdatamodel%2FSequenceGroup.java;h=cffe0d9208fe0ce0382069e98850a97f6c7e9033;hb=3490e38574052242c9440d162a427f7c59234a0a;hp=752c6d4335dca76cc37d0b3e04449ca958d94fe9;hpb=2273eba5668e5340354da60fed329c6c716cc439;p=jalview.git diff --git a/src/jalview/datamodel/SequenceGroup.java b/src/jalview/datamodel/SequenceGroup.java index 752c6d4..cffe0d9 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.2) - * 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. * @@ -22,16 +22,19 @@ package jalview.datamodel; import jalview.analysis.AAFrequency; import jalview.analysis.Conservation; +import jalview.renderer.ResidueShader; +import jalview.renderer.ResidueShaderI; import jalview.schemes.ColourSchemeI; -import jalview.schemes.ResidueProperties; +import jalview.util.MessageManager; +import jalview.workers.InformationThread; import java.awt.Color; +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; import java.util.ArrayList; -import java.util.Enumeration; -import java.util.Hashtable; +import java.util.Arrays; import java.util.List; import java.util.Map; -import java.util.Vector; /** * Collects a set contiguous ranges on a set of sequences @@ -41,85 +44,121 @@ import java.util.Vector; */ public class SequenceGroup implements AnnotatedCollectionI { - String groupName; + // TODO ideally this event notification functionality should be separated into + // a subclass of ViewportProperties similarly to ViewportRanges. + // Done here as a quick fix for JAL-2665 + public static final String SEQ_GROUP_CHANGED = "Sequence group changed"; - String description; + private String groupName; - Conservation conserve; + private String description; - Vector aaFrequency; + private AnnotatedCollectionI context; - boolean displayBoxes = true; + private Conservation conservationData; - boolean displayText = true; + private ProfilesI consensusProfiles; - boolean colourText = false; + private ProfilesI hmmProfiles; - /** + private boolean displayBoxes = true; + + private boolean displayText = true; + + private boolean colourText = false; + + /* + * true if the group is defined as a group on the alignment, false if it is + * just a selection + */ + private boolean isDefined; + + /* * after Olivier's non-conserved only character display */ - boolean showNonconserved = false; + private boolean showNonconserved; - /** - * group members + /* + * sequences in the group */ - private Vector sequences = new Vector(); + private List sequences = new ArrayList<>(); - /** + /* * representative sequence for this group (if any) */ - private SequenceI seqrep = null; + private SequenceI seqrep; - int width = -1; + private int width = -1; - /** - * Colourscheme applied to group if any + /* + * colour scheme applied to group if any */ - public ColourSchemeI cs; + public ResidueShaderI cs; - int startRes = 0; + // start column (base 0) + private int startRes; - int endRes = 0; + // end column (base 0) + private int endRes; public Color outlineColour = Color.black; - public Color idColour = null; + public Color idColour; - public int thresholdTextColour = 0; + public int thresholdTextColour; public Color textColour = Color.black; public Color textColour2 = Color.white; - /** - * consensus calculation property + /* + * properties for consensus annotation */ private boolean ignoreGapsInConsensus = true; - /** - * consensus calculation property + private boolean showSequenceLogo; + + private boolean normaliseSequenceLogo; + + private boolean showConsensusHistogram; + + /* + * properties for HMM information annotation */ - private boolean showSequenceLogo = false; + private boolean hmmIgnoreBelowBackground = true; - /** - * flag indicating if logo should be rendered normalised + private boolean hmmUseInfoLetterHeight; + + private boolean hmmShowSequenceLogo; + + private boolean hmmNormaliseSequenceLogo; + + private boolean hmmShowHistogram; + + /* + * visibility of rows or represented rows covered by group */ - private boolean normaliseSequenceLogo; + private boolean hidereps; - /** - * @return the includeAllConsSymbols + /* + * visibility of columns intersecting this group */ - public boolean isShowSequenceLogo() - { - return showSequenceLogo; - } + private boolean hidecols; + + private AlignmentAnnotation consensus; + + private AlignmentAnnotation conservation; + + private AlignmentAnnotation hmmInformation; /** - * Creates a new SequenceGroup object. + * Constructor, assigning a generated default name of "JGroup:" with object + * hashcode appended */ public SequenceGroup() { groupName = "JGroup:" + this.hashCode(); + cs = new ResidueShader(); } /** @@ -136,16 +175,17 @@ public class SequenceGroup implements AnnotatedCollectionI * @param end * last column of group */ - public SequenceGroup(Vector sequences, String groupName, + public SequenceGroup(List sequences, String groupName, 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(); @@ -158,15 +198,27 @@ public class SequenceGroup implements AnnotatedCollectionI */ public SequenceGroup(SequenceGroup seqsel) { + this(seqsel, true); + } + + /** + * copy constructor + * + * @param seqsel + * @param keepsequences + * if false do not add sequences from seqsel to new instance + */ + public SequenceGroup(SequenceGroup seqsel, boolean keepsequences) + { + this(); + if (seqsel != null) { - sequences = new Vector(); - Enumeration sq = seqsel.sequences.elements(); - while (sq.hasMoreElements()) + sequences = new ArrayList<>(); + if (keepsequences) { - sequences.addElement(sq.nextElement()); + sequences.addAll(seqsel.sequences); } - ; if (seqsel.groupName != null) { groupName = new String(seqsel.groupName); @@ -176,13 +228,20 @@ public class SequenceGroup implements AnnotatedCollectionI 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; + hmmShowSequenceLogo = seqsel.hmmShowSequenceLogo; + hmmNormaliseSequenceLogo = seqsel.hmmNormaliseSequenceLogo; + hmmShowHistogram = seqsel.hmmShowHistogram; idColour = seqsel.idColour; outlineColour = seqsel.outlineColour; seqrep = seqsel.seqrep; @@ -191,15 +250,38 @@ public class SequenceGroup implements AnnotatedCollectionI thresholdTextColour = seqsel.thresholdTextColour; width = seqsel.width; ignoreGapsInConsensus = seqsel.ignoreGapsInConsensus; - if (seqsel.conserve != null) + hmmIgnoreBelowBackground = seqsel.hmmIgnoreBelowBackground; + hmmUseInfoLetterHeight = seqsel.hmmUseInfoLetterHeight; + if (keepsequences && seqsel.conservationData != null) { + // todo avoid doing this if we don't actually want derived calculations + // ! recalcConservation(); // safer than // aaFrequency = (Vector) seqsel.aaFrequency.clone(); // ?? } } } - public SequenceI[] getSelectionAsNewSequences(AlignmentI align) + protected PropertyChangeSupport changeSupport = new PropertyChangeSupport( + this); + + public void addPropertyChangeListener(PropertyChangeListener listener) + { + changeSupport.addPropertyChangeListener(listener); + } + + public void removePropertyChangeListener(PropertyChangeListener listener) + { + changeSupport.removePropertyChangeListener(listener); + } + + public boolean isShowSequenceLogo() + { + return showSequenceLogo; + } + + public SequenceI[] getSelectionAsNewSequences(AlignmentI align, + boolean copyAnnotation) { int iSize = sequences.size(); SequenceI[] seqs = new SequenceI[iSize]; @@ -213,14 +295,8 @@ public class SequenceGroup implements AnnotatedCollectionI if (seqs[ipos] != 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) + if (seq.getAnnotation() != null && copyAnnotation) { AlignmentAnnotation[] alann = align.getAlignmentAnnotation(); // Only copy annotation that is either a score or referenced by the @@ -310,16 +386,15 @@ public class SequenceGroup implements AnnotatedCollectionI { if (hiddenReps == null) { + // TODO: need a synchronizedCollection here ? return sequences; } else { - Vector allSequences = new Vector(); - SequenceI seq; - for (int i = 0; i < sequences.size(); i++) + List allSequences = new ArrayList<>(); + for (SequenceI seq : sequences) { - seq = sequences.elementAt(i); - allSequences.addElement(seq); + allSequences.add(seq); if (hiddenReps.containsKey(seq)) { SequenceCollectionI hsg = hiddenReps.get(seq); @@ -327,7 +402,7 @@ public class SequenceGroup implements AnnotatedCollectionI { if (seq2 != seq && !allSequences.contains(seq2)) { - allSequences.addElement(seq2); + allSequences.add(seq2); } } } @@ -445,7 +520,7 @@ public class SequenceGroup implements AnnotatedCollectionI */ public Conservation getConservation() { - return conserve; + return conservationData; } /** @@ -456,7 +531,7 @@ public class SequenceGroup implements AnnotatedCollectionI */ public void setConservation(Conservation c) { - conserve = c; + conservationData = c; } /** @@ -471,14 +546,19 @@ public class SequenceGroup implements AnnotatedCollectionI */ public void addSequence(SequenceI s, boolean recalc) { - if (s != null && !sequences.contains(s)) + synchronized (sequences) { - sequences.addElement(s); - } + if (s != null && !sequences.contains(s)) + { + sequences.add(s); + changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, + sequences.size() - 1, sequences.size()); + } - if (recalc) - { - recalcConservation(); + if (recalc) + { + recalcConservation(); + } } } @@ -506,32 +586,63 @@ 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() { - if (cs == null && consensus == null && conservation == null) + return recalcAnnotations(false); + } + + /** + * Recalculates column consensus, conservation, and HMM annotation for the + * group (as applicable). 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 recalcAnnotations(boolean defer) + { + if (cs == null && consensus == null && conservation == null + && hmmInformation == 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 (hmmInformation != null) + { + HiddenMarkovModel hmm = hmmInformation.sequenceRef.getHMM(); + + ProfilesI info = AAFrequency.calculateHMMProfiles(hmm, + (endRes + 1) - startRes, startRes, endRes + 1, + hmmIgnoreBelowBackground, hmmUseInfoLetterHeight); + _updateInformationRow(info); + upd = true; + } 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); @@ -546,17 +657,25 @@ 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); } - + return upd; } private void _updateConservationRow(Conservation c) @@ -570,8 +689,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 @@ -579,9 +700,7 @@ public class SequenceGroup implements AnnotatedCollectionI c.completeAnnotations(conservation, null, startRes, endRes + 1); } - public Hashtable[] consensusData = null; - - private void _updateConsensusRow(Hashtable[] cnsns, long nseq) + private void _updateConsensusRow(ProfilesI cnsns, long nseq) { if (consensus == null) { @@ -589,10 +708,12 @@ public class SequenceGroup implements AnnotatedCollectionI } consensus.label = "Consensus for " + getName(); consensus.description = "Percent Identity"; - consensusData = cnsns; + consensusProfiles = 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 @@ -605,6 +726,33 @@ public class SequenceGroup implements AnnotatedCollectionI } /** + * Recalculates the information content on the HMM annotation + * + * @param cnsns + */ + private void _updateInformationRow(ProfilesI cnsns) + { + if (hmmInformation == null) + { + createInformationAnnotation(); + } + hmmInformation.description = MessageManager + .getString("label.information_description"); + setHmmProfiles(cnsns); + // preserve width if already set + int aWidth = (hmmInformation.annotations != null) + ? (endRes < hmmInformation.annotations.length + ? hmmInformation.annotations.length : endRes + 1) + : endRes + 1; + hmmInformation.annotations = null; + hmmInformation.annotations = new Annotation[aWidth]; // should be alignment + // width + hmmInformation.setCalcId(InformationThread.HMM_CALC_ID); + AAFrequency.completeInformation(hmmInformation, cnsns, startRes, + endRes + 1); + } + + /** * @param s * sequence to either add or remove from group * @param recalc @@ -613,31 +761,39 @@ public class SequenceGroup implements AnnotatedCollectionI */ public void addOrRemove(SequenceI s, boolean recalc) { - if (sequences.contains(s)) - { - deleteSequence(s, recalc); - } - else + synchronized (sequences) { - addSequence(s, recalc); + if (sequences.contains(s)) + { + deleteSequence(s, recalc); + } + else + { + addSequence(s, recalc); + } } } /** - * DOCUMENT ME! + * remove * * @param s - * DOCUMENT ME! + * to be removed * @param recalc - * DOCUMENT ME! + * true means recalculate conservation */ public void deleteSequence(SequenceI s, boolean recalc) { - sequences.removeElement(s); - - if (recalc) + synchronized (sequences) { - recalcConservation(); + sequences.remove(s); + changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, + sequences.size() + 1, sequences.size()); + + if (recalc) + { + recalcConservation(); + } } } @@ -669,7 +825,9 @@ public class SequenceGroup implements AnnotatedCollectionI */ public void setStartRes(int i) { + int before = startRes; startRes = i; + changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, before, startRes); } /** @@ -679,13 +837,13 @@ public class SequenceGroup implements AnnotatedCollectionI */ public void setEndRes(int i) { + int before = endRes; endRes = i; + changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, before, endRes); } /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! + * @return number of sequences in group */ public int getSize() { @@ -693,23 +851,17 @@ public class SequenceGroup implements AnnotatedCollectionI } /** - * DOCUMENT ME! - * * @param i - * DOCUMENT ME! - * - * @return DOCUMENT ME! + * @return the ith sequence */ public SequenceI getSequenceAt(int i) { - return sequences.elementAt(i); + return sequences.get(i); } /** - * DOCUMENT ME! - * * @param state - * DOCUMENT ME! + * colourText */ public void setColourText(boolean state) { @@ -769,30 +921,27 @@ public class SequenceGroup implements AnnotatedCollectionI } /** - * DOCUMENT ME! + * computes the width of current set of sequences and returns it * * @return DOCUMENT ME! */ @Override public int getWidth() { - // MC This needs to get reset when characters are inserted and deleted - if (sequences.size() > 0) - { - width = sequences.elementAt(0).getLength(); - } - - for (int i = 1; i < sequences.size(); i++) + synchronized (sequences) { - SequenceI seq = sequences.elementAt(i); - - if (seq.getLength() > width) + // MC This needs to get reset when characters are inserted and deleted + boolean first = true; + for (SequenceI seq : sequences) { - width = seq.getLength(); + if (first || seq.getLength() > width) + { + width = seq.getLength(); + first = false; + } } + return width; } - - return width; } /** @@ -843,39 +992,42 @@ public class SequenceGroup implements AnnotatedCollectionI */ public SequenceI[] getSequencesInOrder(AlignmentI al, boolean trim) { - int sSize = sequences.size(); - int alHeight = al.getHeight(); + synchronized (sequences) + { + int sSize = sequences.size(); + int alHeight = al.getHeight(); - SequenceI[] seqs = new SequenceI[(trim) ? sSize : alHeight]; + SequenceI[] seqs = new SequenceI[(trim) ? sSize : alHeight]; - int index = 0; - for (int i = 0; i < alHeight && index < sSize; i++) - { - if (sequences.contains(al.getSequenceAt(i))) + int index = 0; + for (int i = 0; i < alHeight && index < sSize; i++) { - seqs[(trim) ? index : i] = al.getSequenceAt(i); - index++; + if (sequences.contains(al.getSequenceAt(i))) + { + seqs[(trim) ? index : i] = al.getSequenceAt(i); + index++; + } } - } - if (index == 0) - { - return null; - } - if (!trim) - { - return seqs; - } - if (index < seqs.length) - { - SequenceI[] dummy = seqs; - seqs = new SequenceI[index]; - while (--index >= 0) + if (index == 0) { - seqs[index] = dummy[index]; - dummy[index] = null; + return null; } + if (!trim) + { + return seqs; + } + if (index < seqs.length) + { + SequenceI[] dummy = seqs; + seqs = new SequenceI[index]; + while (--index >= 0) + { + seqs[index] = dummy[index]; + dummy[index] = null; + } + } + return seqs; } - return seqs; } /** @@ -898,6 +1050,7 @@ public class SequenceGroup implements AnnotatedCollectionI /** * @return the representative sequence for this group */ + @Override public SequenceI getSeqrep() { return seqrep; @@ -910,6 +1063,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; @@ -919,17 +1073,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. * @@ -951,11 +1101,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 @@ -989,23 +1134,14 @@ public class SequenceGroup implements AnnotatedCollectionI { SequenceGroup sgroup = new SequenceGroup(this); SequenceI[] insect = getSequencesInOrder(alignment); - sgroup.sequences = new Vector(); + sgroup.sequences = new ArrayList<>(); for (int s = 0; insect != null && s < insect.length; s++) { if (map == null || map.containsKey(insect[s])) { - sgroup.sequences.addElement(insect[s]); + sgroup.sequences.add(insect[s]); } } - // Enumeration en =getSequences(hashtable).elements(); - // while (en.hasMoreElements()) - // { - // SequenceI elem = (SequenceI) en.nextElement(); - // if (alignment.getSequences().contains(elem)) - // { - // sgroup.addSequence(elem, false); - // } - // } return sgroup; } @@ -1026,13 +1162,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 @@ -1049,7 +1178,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() { @@ -1076,6 +1206,22 @@ public class SequenceGroup implements AnnotatedCollectionI } /** + * Creates the Hidden Markov Model annotation for this group + */ + void createInformationAnnotation() + { + hmmInformation = new AlignmentAnnotation("", "", new Annotation[1], 0f, + 6.25f, AlignmentAnnotation.BAR_GRAPH); + hmmInformation.hasText = true; + hmmInformation.autoCalculated = false; + hmmInformation.groupRef = this; + hmmInformation.label = getName(); + hmmInformation.description = MessageManager + .getString("label.information_description"); + hmmInformation.setCalcId(InformationThread.HMM_CALC_ID); + } + + /** * set this alignmentAnnotation object as the one used to render consensus * annotation * @@ -1128,9 +1274,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 { @@ -1156,11 +1303,31 @@ public class SequenceGroup implements AnnotatedCollectionI ignoreGapsInConsensus = state; } - public boolean getIgnoreGapsConsensus() + public boolean isIgnoreGapsConsensus() { return ignoreGapsInConsensus; } + public void setIgnoreBelowBackground(boolean state) + { + hmmIgnoreBelowBackground = state; + } + + public boolean isIgnoreBelowBackground() + { + return hmmIgnoreBelowBackground; + } + + public void setInfoLetterHeight(boolean state) + { + hmmUseInfoLetterHeight = state; + } + + public boolean isUseInfoLetterHeight() + { + return hmmUseInfoLetterHeight; + } + /** * @param showSequenceLogo * indicates if a sequence logo is shown for consensus annotation @@ -1224,28 +1391,31 @@ public class SequenceGroup implements AnnotatedCollectionI { // TODO add in other methods like 'getAlignmentAnnotation(String label), // etc' - ArrayList annot = new ArrayList(); - for (SequenceI seq : sequences) + ArrayList annot = new ArrayList<>(); + synchronized (sequences) { - AlignmentAnnotation[] aa = seq.getAnnotation(); - if (aa != null) + for (SequenceI seq : sequences) { - for (AlignmentAnnotation al : aa) + AlignmentAnnotation[] aa = seq.getAnnotation(); + if (aa != null) { - if (al.groupRef == this) + for (AlignmentAnnotation al : aa) { - annot.add(al); + if (al.groupRef == this) + { + annot.add(al); + } } } } - } - if (consensus != null) - { - annot.add(consensus); - } - if (conservation != null) - { - annot.add(conservation); + if (consensus != null) + { + annot.add(consensus); + } + if (conservation != null) + { + annot.add(conservation); + } } return annot.toArray(new AlignmentAnnotation[0]); } @@ -1253,38 +1423,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); } /** @@ -1295,34 +1443,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() { - sequences.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; } /* @@ -1335,4 +1512,129 @@ 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); + } + + public boolean isShowInformationHistogram() + { + return hmmShowHistogram; + } + + public void setShowInformationHistogram(boolean state) + { + if (hmmShowHistogram != state && hmmInformation != null) + { + this.hmmShowHistogram = state; + // recalcConservation(); TODO don't know what to do here next + } + this.hmmShowHistogram = state; + } + + public boolean isShowHMMSequenceLogo() + { + return hmmShowSequenceLogo; + } + + public void setShowHMMSequenceLogo(boolean state) + { + hmmShowSequenceLogo = state; + } + + public boolean isNormaliseHMMSequenceLogo() + { + return hmmNormaliseSequenceLogo; + } + + public void setNormaliseHMMSequenceLogo(boolean state) + { + hmmNormaliseSequenceLogo = state; + } + + public ProfilesI getConsensusData() + { + return consensusProfiles; + } + + public ProfilesI getHmmProfiles() + { + return hmmProfiles; + } + + public void setHmmProfiles(ProfilesI hmmProfiles) + { + this.hmmProfiles = hmmProfiles; + } + + @Override + public List getHmmSequences() + { + List result = new ArrayList<>(); + for (int i = 0; i < sequences.size(); i++) + { + SequenceI seq = sequences.get(i); + if (seq.hasHMMProfile()) + { + result.add(seq); + } + } + return result; + } + }