X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignment.java;h=0ee03445558468a9896249320ecda8c689e886d9;hb=375e9f7d622c89e41fc7831fd517e23d1ea52fbd;hp=7ea9985ecb03eaa2da3cd7671b9facd74d0f4ff4;hpb=4d7f98a6dd54d9863ba449ec79dcd95d25ed863d;p=jalview.git diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java index 7ea9985..0ee0344 100755 --- a/src/jalview/datamodel/Alignment.java +++ b/src/jalview/datamodel/Alignment.java @@ -22,13 +22,14 @@ package jalview.datamodel; import jalview.analysis.AlignmentUtils; import jalview.io.FastaFile; +import jalview.util.Comparison; import jalview.util.MessageManager; import java.util.ArrayList; +import java.util.Collections; import java.util.Enumeration; import java.util.HashSet; import java.util.Hashtable; -import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -43,12 +44,11 @@ import java.util.Vector; */ public class Alignment implements AlignmentI { - protected Alignment dataset; + private Alignment dataset; protected List sequences; - protected List groups = java.util.Collections - .synchronizedList(new ArrayList()); + protected List groups; protected char gapCharacter = '-'; @@ -60,20 +60,21 @@ public class Alignment implements AlignmentI public boolean hasRNAStructure = false; - /** DOCUMENT ME!! */ public AlignmentAnnotation[] annotations; - HiddenSequences hiddenSequences = new HiddenSequences(this); + HiddenSequences hiddenSequences; public Hashtable alignmentProperties; - private Set codonFrameList = new LinkedHashSet(); + private List codonFrameList; private void initAlignment(SequenceI[] seqs) { - int i = 0; + groups = Collections.synchronizedList(new ArrayList()); + hiddenSequences = new HiddenSequences(this); + codonFrameList = new ArrayList(); - if (jalview.util.Comparison.isNucleotide(seqs)) + if (Comparison.isNucleotide(seqs)) { type = NUCLEOTIDE; } @@ -82,10 +83,9 @@ public class Alignment implements AlignmentI type = PROTEIN; } - sequences = java.util.Collections - .synchronizedList(new ArrayList()); + sequences = Collections.synchronizedList(new ArrayList()); - for (i = 0; i < seqs.length; i++) + for (int i = 0; i < seqs.length; i++) { sequences.add(seqs[i]); } @@ -104,13 +104,15 @@ public class Alignment implements AlignmentI seqs[i] = new Sequence(seqs[i]); } + initAlignment(seqs); + /* - * Share the same dataset sequence mappings (if any). TODO: find a better - * place for these to live (alignment dataset?). + * Share the same dataset sequence mappings (if any). */ - this.codonFrameList = ((Alignment) al).codonFrameList; - - initAlignment(seqs); + if (dataset == null && al.getDataset() == null) + { + this.setCodonFrames(al.getCodonFrames()); + } } /** @@ -987,33 +989,20 @@ public class Alignment implements AlignmentI } @Override - public void setDataset(Alignment data) + public void setDataset(AlignmentI data) { if (dataset == null && data == null) { - // Create a new dataset for this alignment. - // Can only be done once, if dataset is not null - // This will not be performed - SequenceI[] seqs = new SequenceI[getHeight()]; - SequenceI currentSeq; - for (int i = 0; i < getHeight(); i++) - { - currentSeq = getSequenceAt(i); - if (currentSeq.getDatasetSequence() != null) - { - seqs[i] = currentSeq.getDatasetSequence(); - } - else - { - seqs[i] = currentSeq.createDatasetSequence(); - } - } - - dataset = new Alignment(seqs); + createDatasetAlignment(); } else if (dataset == null && data != null) { - dataset = data; + if (!(data instanceof Alignment)) + { + throw new Error( + "Implementation Error: jalview.datamodel.Alignment does not yet support other implementations of AlignmentI as its dataset reference"); + } + dataset = (Alignment) data; for (int i = 0; i < getHeight(); i++) { SequenceI currentSeq = getSequenceAt(i); @@ -1040,6 +1029,37 @@ public class Alignment implements AlignmentI } /** + * Creates a new dataset for this alignment. Can only be done once - if + * dataset is not null this will not be performed. + */ + public void createDatasetAlignment() + { + if (dataset != null) + { + return; + } + SequenceI[] seqs = new SequenceI[getHeight()]; + SequenceI currentSeq; + for (int i = 0; i < getHeight(); i++) + { + currentSeq = getSequenceAt(i); + if (currentSeq.getDatasetSequence() != null) + { + seqs[i] = currentSeq.getDatasetSequence(); + } + else + { + seqs[i] = currentSeq.createDatasetSequence(); + } + } + + dataset = new Alignment(seqs); + // move mappings to the dataset alignment + dataset.codonFrameList = this.codonFrameList; + this.codonFrameList = null; + } + + /** * reference count for number of alignments referencing this one. */ int alignmentRefs = 0; @@ -1261,19 +1281,17 @@ public class Alignment implements AlignmentI return alignmentProperties; } - /* - * (non-Javadoc) - * - * @see - * jalview.datamodel.AlignmentI#addCodonFrame(jalview.datamodel.AlignedCodonFrame - * ) + /** + * Adds the given mapping to the stored set. Note this may be held on the + * dataset alignment. */ @Override public void addCodonFrame(AlignedCodonFrame codons) { - if (codons != null) + List acfs = getCodonFrames(); + if (codons != null && acfs != null && !acfs.contains(codons)) { - codonFrameList.add(codons); + acfs.add(codons); } } @@ -1291,7 +1309,7 @@ public class Alignment implements AlignmentI return null; } List cframes = new ArrayList(); - for (AlignedCodonFrame acf : codonFrameList) + for (AlignedCodonFrame acf : getCodonFrames()) { if (acf.involvesSequence(seq)) { @@ -1302,42 +1320,54 @@ public class Alignment implements AlignmentI } /** - * Sets the codon frame mappings (replacing any existing mappings). + * Sets the codon frame mappings (replacing any existing mappings). Note the + * mappings are set on the dataset alignment instead if there is one. * * @see jalview.datamodel.AlignmentI#setCodonFrames() */ @Override - public void setCodonFrames(Set acfs) + public void setCodonFrames(List acfs) { - this.codonFrameList = acfs; + if (dataset != null) + { + dataset.setCodonFrames(acfs); + } + else + { + this.codonFrameList = acfs; + } } /** * Returns the set of codon frame mappings. Any changes to the returned set - * will affect the alignment. + * will affect the alignment. The mappings are held on (and read from) the + * dataset alignment if there is one. * * @see jalview.datamodel.AlignmentI#getCodonFrames() */ @Override - public Set getCodonFrames() + public List getCodonFrames() { - return codonFrameList; + // TODO: Fix this method to fix failing AlignedCodonFrame tests + // this behaviour is currently incorrect. method should return codon frames + // for just the alignment, + // selected from dataset + return dataset != null ? dataset.getCodonFrames() : codonFrameList; } - /* - * (non-Javadoc) - * - * @seejalview.datamodel.AlignmentI#removeCodonFrame(jalview.datamodel. - * AlignedCodonFrame) + /** + * Removes the given mapping from the stored set. Note that the mappings are + * held on the dataset alignment if there is one. */ @Override public boolean removeCodonFrame(AlignedCodonFrame codons) { - if (codons == null || codonFrameList == null) + List acfs = getCodonFrames(); + if (codons == null || acfs == null) { return false; } - return codonFrameList.remove(codons); + return acfs.remove(codons); } @Override @@ -1347,7 +1377,7 @@ public class Alignment implements AlignmentI { System.err.println("Self append may cause a deadlock."); } - // TODO test this method for a future 2.5 release + // TODO JAL-1270 needs test coverage // currently tested for use in jalview.gui.SequenceFetcher boolean samegap = toappend.getGapCharacter() == getGapCharacter(); char oldc = toappend.getGapCharacter(); @@ -1383,7 +1413,8 @@ public class Alignment implements AlignmentI addAnnotation(alan[a]); } - this.codonFrameList.addAll(toappend.getCodonFrames()); + // use add method + getCodonFrames().addAll(toappend.getCodonFrames()); List sg = toappend.getGroups(); if (sg != null) @@ -1595,6 +1626,7 @@ public class Alignment implements AlignmentI * * @return the representative sequence for this group */ + @Override public SequenceI getSeqrep() { return seqrep; @@ -1607,6 +1639,7 @@ public class Alignment implements AlignmentI * @param seqrep * the seqrep to set (null means no sequence representative) */ + @Override public void setSeqrep(SequenceI seqrep) { this.seqrep = seqrep; @@ -1616,6 +1649,7 @@ public class Alignment implements AlignmentI * * @return true if group has a sequence representative */ + @Override public boolean hasSeqrep() { return seqrep != null; @@ -1670,9 +1704,11 @@ public class Alignment implements AlignmentI * Parameters control whether gaps in exon (mapped) and intron (unmapped) * regions are preserved. Gaps that connect introns to exons are treated * conservatively, i.e. only preserved if both intron and exon gaps are - * preserved. + * preserved. TODO: check caveats below where the implementation fails * * @param al + * - must have same dataset, and sequences in al must have equivalent + * dataset sequence and start/end bounds under given mapping * @param preserveMappedGaps * if true, gaps within and between mapped codons are preserved * @param preserveUnmappedGaps @@ -1683,31 +1719,17 @@ public class Alignment implements AlignmentI boolean preserveUnmappedGaps) { // TODO should this method signature be the one in the interface? - int count = 0; boolean thisIsNucleotide = this.isNucleotide(); boolean thatIsProtein = !al.isNucleotide(); if (!thatIsProtein && !thisIsNucleotide) { return AlignmentUtils.alignProteinAsDna(this, al); } - - char thisGapChar = this.getGapCharacter(); - String gap = thisIsNucleotide && thatIsProtein ? String - .valueOf(new char[] { thisGapChar, thisGapChar, thisGapChar }) - : String.valueOf(thisGapChar); - - // TODO handle intron regions? Needs a 'holistic' alignment of dna, - // not just sequence by sequence. But how to 'gap' intron regions? - - /* - * Get mappings from 'that' alignment's sequences to this. - */ - for (SequenceI alignTo : getSequences()) + else if (thatIsProtein && thisIsNucleotide) { - count += AlignmentUtils.alignSequenceAs(alignTo, al, gap, - preserveMappedGaps, preserveUnmappedGaps) ? 1 : 0; + return AlignmentUtils.alignCdsAsProtein(this, al); } - return count; + return AlignmentUtils.alignAs(this, al); } /** @@ -1748,4 +1770,82 @@ public class Alignment implements AlignmentI } return hasValidSeq; } + + /** + * Update any mappings to 'virtual' sequences to compatible real ones, if + * present in the added sequences. Returns a count of mappings updated. + * + * @param seqs + * @return + */ + @Override + public int realiseMappings(List seqs) + { + int count = 0; + for (SequenceI seq : seqs) + { + for (AlignedCodonFrame mapping : getCodonFrames()) + { + count += mapping.realiseWith(seq); + } + } + return count; + } + + /** + * Returns the first AlignedCodonFrame that has a mapping between the given + * dataset sequences + * + * @param mapFrom + * @param mapTo + * @return + */ + @Override + public AlignedCodonFrame getMapping(SequenceI mapFrom, SequenceI mapTo) + { + for (AlignedCodonFrame acf : getCodonFrames()) + { + if (acf.getAaForDnaSeq(mapFrom) == mapTo) + { + return acf; + } + } + return null; + } + + @Override + public int[] getVisibleStartAndEndIndex(List hiddenCols) + { + int[] alignmentStartEnd = new int[] { 0, getWidth() - 1 }; + int startPos = alignmentStartEnd[0]; + int endPos = alignmentStartEnd[1]; + + int[] lowestRange = new int[] { -1, -1 }; + int[] higestRange = new int[] { -1, -1 }; + + for (int[] hiddenCol : hiddenCols) + { + lowestRange = (hiddenCol[0] <= startPos) ? hiddenCol : lowestRange; + higestRange = (hiddenCol[1] >= endPos) ? hiddenCol : higestRange; + } + + if (lowestRange[0] == -1 && lowestRange[1] == -1) + { + startPos = alignmentStartEnd[0]; + } + else + { + startPos = lowestRange[1] + 1; + } + + if (higestRange[0] == -1 && higestRange[1] == -1) + { + endPos = alignmentStartEnd[1]; + } + else + { + endPos = higestRange[0] - 1; + } + return new int[] { startPos, endPos }; + } }