X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequenceGroup.java;h=871e4cf5d9410603870e2020da3ad3388deb3dca;hb=c16c1633e1a5acc9f44e4de40b9abbb8a59b99b4;hp=acd0b513a33f0d60ccd97353bfe112b437bc589b;hpb=17db615607025afd96b0da5227dee6eba38c69c0;p=jalview.git diff --git a/src/jalview/datamodel/SequenceGroup.java b/src/jalview/datamodel/SequenceGroup.java index acd0b51..871e4cf 100755 --- a/src/jalview/datamodel/SequenceGroup.java +++ b/src/jalview/datamodel/SequenceGroup.java @@ -1,17 +1,17 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer - * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle - * + * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1) + * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle + * * This program 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 2 * of the License, or (at your option) any later version. - * + * * This program 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 this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA @@ -26,33 +26,78 @@ import jalview.analysis.*; import jalview.schemes.*; /** - * DOCUMENT ME! - * + * Collects a set contiguous ranges on a set of sequences + * * @author $author$ * @version $Revision$ */ public class SequenceGroup { String groupName; + String description; + Conservation conserve; + Vector aaFrequency; + boolean displayBoxes = true; + boolean displayText = true; - boolean colourText = true; + + boolean colourText = false; + /** + * after Olivier's non-conserved only character display + */ + boolean showUnconserved = false; + + /** + * group members + */ private Vector sequences = new Vector(); + /** + * representative sequence for this group (if any) + */ + private SequenceI seqrep = null; int width = -1; - /** DOCUMENT ME!! */ + /** + * Colourscheme applied to group if any */ public ColourSchemeI cs; + int startRes = 0; + int endRes = 0; - Color outlineColour = Color.black; + + public Color outlineColour = Color.black; + + public Color idColour = null; + public int thresholdTextColour = 0; + public Color textColour = Color.black; + public Color textColour2 = Color.white; /** + * consensus calculation property + */ + private boolean ignoreGapsInConsensus=true; + /** + * consensus calculation property + */ + private boolean showConsensusProfile=false; + + /** + * @return the includeAllConsSymbols + */ + public boolean isIncludeAllConsSymbols() + { + return showConsensusProfile; + } + + + /** * Creates a new SequenceGroup object. */ public SequenceGroup() @@ -62,20 +107,21 @@ public class SequenceGroup /** * Creates a new SequenceGroup object. - * - * @param sequences DOCUMENT ME! - * @param groupName DOCUMENT ME! - * @param scheme DOCUMENT ME! - * @param displayBoxes DOCUMENT ME! - * @param displayText DOCUMENT ME! - * @param colourText DOCUMENT ME! - * @param start DOCUMENT ME! - * @param end DOCUMENT ME! + * + * @param sequences + * @param groupName + * @param scheme + * @param displayBoxes + * @param displayText + * @param colourText + * @param start + * first column of group + * @param end + * last column of group */ public SequenceGroup(Vector sequences, String groupName, - ColourSchemeI scheme, boolean displayBoxes, - boolean displayText, - boolean colourText, int start, int end) + ColourSchemeI scheme, boolean displayBoxes, boolean displayText, + boolean colourText, int start, int end) { this.sequences = sequences; this.groupName = groupName; @@ -87,6 +133,48 @@ public class SequenceGroup endRes = end; recalcConservation(); } + /** + * copy constructor + * @param seqsel + */ + public SequenceGroup(SequenceGroup seqsel) + { + if (seqsel!=null) + { + sequences=new Vector(); + Enumeration sq = seqsel.sequences.elements(); + while (sq.hasMoreElements()) { + sequences.addElement(sq.nextElement()); + }; + if (seqsel.groupName!=null) + { + groupName = new String(seqsel.groupName); + } + displayBoxes = seqsel.displayBoxes; + displayText = seqsel.displayText; + colourText = seqsel.colourText; + startRes = seqsel.startRes; + endRes = seqsel.endRes; + cs =seqsel.cs; + if (seqsel.description!=null) + description = new String(seqsel.description); + hidecols = seqsel.hidecols; + hidereps = seqsel.hidereps; + idColour = seqsel.idColour; + outlineColour = seqsel.outlineColour; + seqrep = seqsel.seqrep; + textColour = seqsel.textColour; + textColour2 = seqsel.textColour2; + thresholdTextColour = seqsel.thresholdTextColour; + width = seqsel.width; + ignoreGapsInConsensus = seqsel.ignoreGapsInConsensus; + if (seqsel.conserve!=null) + { + recalcConservation(); // safer than + // aaFrequency = (Vector) seqsel.aaFrequency.clone(); // ?? + } + } + } public SequenceI[] getSelectionAsNewSequences(AlignmentI align) { @@ -94,41 +182,73 @@ public class SequenceGroup SequenceI[] seqs = new SequenceI[iSize]; SequenceI[] inorder = getSequencesInOrder(align); - for (int i = 0; i < iSize; i++) + for (int i = 0, ipos = 0; i < inorder.length; i++) { SequenceI seq = inorder[i]; - seqs[i] = seq.getSubSequence(startRes, endRes+1); - - seqs[i].setDescription(seq.getDescription()); - seqs[i].setDBRef(seq.getDBRef()); - seqs[i].setSequenceFeatures(seq.getSequenceFeatures()); - if (seq.getDatasetSequence() != null) + seqs[ipos] = seq.getSubSequence(startRes, endRes + 1); + if (seqs[ipos] != null) { - seqs[i].setDatasetSequence(seq.getDatasetSequence()); - } + 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) - { - for (int a = 0; a < seq.getAnnotation().length; a++) + if (seq.getAnnotation() != null) { - AlignmentAnnotation newannot = new AlignmentAnnotation(seq.getAnnotation()[a]); - newannot.restrict(startRes, endRes); - newannot.setSequenceRef(seqs[i]); - newannot.adjustForAlignment(); - seqs[i].addAlignmentAnnotation(newannot); + AlignmentAnnotation[] alann = align.getAlignmentAnnotation(); + // Only copy annotation that is either a score or referenced by the + // alignment's annotation vector + for (int a = 0; a < seq.getAnnotation().length; a++) + { + AlignmentAnnotation tocopy = seq.getAnnotation()[a]; + if (alann != null) + { + boolean found = false; + for (int pos = 0; pos < alann.length; pos++) + { + if (alann[pos] == tocopy) + { + found = true; + break; + } + } + if (!found) + continue; + } + AlignmentAnnotation newannot = new AlignmentAnnotation(seq + .getAnnotation()[a]); + newannot.restrict(startRes, endRes); + newannot.setSequenceRef(seqs[ipos]); + newannot.adjustForAlignment(); + seqs[ipos].addAlignmentAnnotation(newannot); + } } + ipos++; + } + else + { + iSize--; } } - + if (iSize != inorder.length) + { + SequenceI[] nseqs = new SequenceI[iSize]; + System.arraycopy(seqs, 0, nseqs, 0, iSize); + seqs = nseqs; + } return seqs; } /** - * If sequence ends in gaps, the end residue can - * be correctly calculated here - * @param seq SequenceI + * If sequence ends in gaps, the end residue can be correctly calculated here + * + * @param seq + * SequenceI * @return int */ public int findEndRes(SequenceI seq) @@ -139,7 +259,7 @@ public class SequenceGroup for (int j = 0; j < endRes + 1 && j < seq.getLength(); j++) { ch = seq.getCharAt(j); - if (!jalview.util.Comparison.isGap( (ch))) + if (!jalview.util.Comparison.isGap((ch))) { eres++; } @@ -173,8 +293,7 @@ public class SequenceGroup for (int h = 0; h < hsg.getSize(); h++) { seq2 = hsg.getSequenceAt(h); - if (seq2 != seq - && !allSequences.contains(seq2)) + if (seq2 != seq && !allSequences.contains(seq2)) { allSequences.addElement(seq2); } @@ -204,9 +323,10 @@ public class SequenceGroup /** * DOCUMENT ME! - * - * @param col DOCUMENT ME! - * + * + * @param col + * DOCUMENT ME! + * * @return DOCUMENT ME! */ public boolean adjustForRemoveLeft(int col) @@ -237,9 +357,10 @@ public class SequenceGroup /** * DOCUMENT ME! - * - * @param col DOCUMENT ME! - * + * + * @param col + * DOCUMENT ME! + * * @return DOCUMENT ME! */ public boolean adjustForRemoveRight(int col) @@ -260,7 +381,7 @@ public class SequenceGroup /** * DOCUMENT ME! - * + * * @return DOCUMENT ME! */ public String getName() @@ -275,12 +396,14 @@ public class SequenceGroup /** * DOCUMENT ME! - * - * @param name DOCUMENT ME! + * + * @param name + * DOCUMENT ME! */ public void setName(String name) { groupName = name; + // TODO: URGENT: update dependent objects (annotation row) } public void setDescription(String desc) @@ -290,7 +413,7 @@ public class SequenceGroup /** * DOCUMENT ME! - * + * * @return DOCUMENT ME! */ public Conservation getConservation() @@ -300,8 +423,9 @@ public class SequenceGroup /** * DOCUMENT ME! - * - * @param c DOCUMENT ME! + * + * @param c + * DOCUMENT ME! */ public void setConservation(Conservation c) { @@ -309,10 +433,12 @@ public class SequenceGroup } /** - * DOCUMENT ME! - * - * @param s DOCUMENT ME! - * @param recalc DOCUMENT ME! + * Add s to this sequence group + * + * @param s + * alignment sequence to be added + * @param recalc + * true means Group's conservation should be recalculated */ public void addSequence(SequenceI s, boolean recalc) { @@ -328,54 +454,103 @@ public class SequenceGroup } /** - * DOCUMENT ME! + * Max Gaps Threshold for performing a conservation calculation + * TODO: make this a configurable property - or global to an alignment view + */ + private int consPercGaps=25; + /** + * calculate residue conservation for group - but only if necessary. */ public void recalcConservation() { - if (cs == null) + if (cs == null && consensus == null && conservation == null) { return; } - + try { - cs.setConsensus(AAFrequency.calculate(sequences, startRes, endRes + 1)); - + Hashtable cnsns[] = AAFrequency.calculate(sequences, startRes, endRes + 1, showConsensusProfile); + if (consensus != null) + { + _updateConsensusRow(cnsns); + } + if (cs!=null) + { + cs.setConsensus(cnsns); + if (cs instanceof ClustalxColourScheme) { - ( (ClustalxColourScheme) cs).resetClustalX(sequences, getWidth()); + ((ClustalxColourScheme) cs).resetClustalX(sequences, getWidth()); + } } - if (cs.conservationApplied()) + if ((conservation!=null) || (cs!=null && cs.conservationApplied())) { Conservation c = new Conservation(groupName, - ResidueProperties.propHash, 3, - sequences, - startRes, endRes + 1); + ResidueProperties.propHash, 3, sequences, startRes, + endRes + 1); c.calculate(); - c.verdict(false, 25); - - cs.setConservation(c); - + c.verdict(false, consPercGaps); + if (conservation!=null) + { + _updateConservationRow(c); + } + if (cs!=null) + { + cs.setConservation(c); + if (cs instanceof ClustalxColourScheme) { - ( (ClustalxColourScheme) cs).resetClustalX(sequences, - getWidth()); + ((ClustalxColourScheme) cs).resetClustalX(sequences, getWidth()); + } } } - } - catch (java.lang.OutOfMemoryError err) + } catch (java.lang.OutOfMemoryError err) { + // TODO: catch OOM System.out.println("Out of memory loading groups: " + err); } } + private void _updateConservationRow(Conservation c) + { + if (conservation==null) + { + getConservation(); + } + // update Labels + conservation.label = "Conservation for "+getName(); + conservation.description = "Conservation for group "+getName()+" less than " + consPercGaps + + "% gaps"; + // preserve width if already set + int aWidth = (conservation.annotations!=null) ? (endRes 0) { - width = ( (SequenceI) sequences.elementAt(0)).getLength(); + width = ((SequenceI) sequences.elementAt(0)).getLength(); } for (int i = 1; i < sequences.size(); i++) @@ -555,8 +738,9 @@ public class SequenceGroup /** * DOCUMENT ME! - * - * @param c DOCUMENT ME! + * + * @param c + * DOCUMENT ME! */ public void setOutlineColour(Color c) { @@ -565,7 +749,7 @@ public class SequenceGroup /** * DOCUMENT ME! - * + * * @return DOCUMENT ME! */ public Color getOutlineColour() @@ -574,11 +758,13 @@ public class SequenceGroup } /** - * - * returns the sequences in the group ordered by the ordering given by al - * - * @param al Alignment - * @return SequenceI[] + * + * returns the sequences in the group ordered by the ordering given by al. + * this used to return an array with null entries regardless, new behaviour is below. + * TODO: verify that this does not affect use in applet or application + * @param al + * Alignment + * @return SequenceI[] intersection of sequences in group with al, ordered by al, or null if group does not intersect with al */ public SequenceI[] getSequencesInOrder(AlignmentI al) { @@ -595,7 +781,282 @@ public class SequenceGroup seqs[index++] = al.getSequenceAt(i); } } - + if (index==0) + { + return null; + } + if (index=0) + { + seqs[index] = dummy[index]; + dummy[index] = null; + } + } return seqs; } -} + + /** + * @return the idColour + */ + public Color getIdColour() + { + return idColour; + } + + /** + * @param idColour + * the idColour to set + */ + public void setIdColour(Color idColour) + { + this.idColour = idColour; + } + + /** + * @return the representative sequence for this group + */ + public SequenceI getSeqrep() + { + return seqrep; + } + + /** + * set the representative sequence for this group. + * Note - this affects the interpretation of the Hidereps attribute. + * @param seqrep the seqrep to set (null means no sequence representative) + */ + public void setSeqrep(SequenceI seqrep) + { + this.seqrep = seqrep; + } + /** + * + * @return true if group has a sequence representative + */ + 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. + * @param visibility + */ + public void setHidereps(boolean visibility) + { + hidereps = visibility; + } + /** + * + * @return true if sequences represented (or covered) by this group should be hidden + */ + public boolean isHidereps() + { + return hidereps; + } + /** + * visibility of columns intersecting this group + */ + private boolean hidecols=false; + /** + * set intended visibility of columns covered by this group + * @param visibility + */ + public void setHideCols(boolean visibility) + { + hidecols = visibility; + } + /** + * + * @return true if columns covered by group should be hidden + */ + public boolean isHideCols() + { + return hidecols; + } + /** + * create a new sequence group from the intersection of this group + * with an alignment Hashtable of hidden representatives + * + * @param alignment (may not be null) + * @param hashtable (may be null) + * @return new group containing sequences common to this group and alignment + */ + public SequenceGroup intersect(AlignmentI alignment, Hashtable hashtable) + { + SequenceGroup sgroup = new SequenceGroup(this); + SequenceI[] insect=getSequencesInOrder(alignment); + sgroup.sequences = new Vector(); + for (int s=0;insect!=null && s