X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignment.java;h=7c4b3c71c7693f8b717d72f9ce1e880a5013baac;hb=ab43013b7e357b84b4abade0dba949668dfb2a0e;hp=90a8b318e0fdd42a477c626f8d94c358ab671190;hpb=174230b4233d9ce80f94527768d2cd2f76da11ab;p=jalview.git diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java index 90a8b31..7c4b3c7 100755 --- a/src/jalview/datamodel/Alignment.java +++ b/src/jalview/datamodel/Alignment.java @@ -1,850 +1,1597 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer - * Copyright (C) 2006 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 + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2b1) + * Copyright (C) 2014 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. - * - * 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. - * + * + * 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 this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.datamodel; -import jalview.analysis.*; +import jalview.util.MessageManager; -import jalview.util.*; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.Hashtable; +import java.util.List; +import java.util.Map; +import java.util.Vector; -import java.util.*; - -/** Data structure to hold and manipulate a multiple sequence alignment +/** + * Data structure to hold and manipulate a multiple sequence alignment + */ +/** + * @author JimP + * */ public class Alignment implements AlignmentI { - protected Alignment dataset; - protected Vector sequences; - protected Vector groups = new Vector(); - protected char gapCharacter = '-'; - protected int type = NUCLEOTIDE; - public static final int PROTEIN = 0; - public static final int NUCLEOTIDE = 1; + protected Alignment dataset; - /** DOCUMENT ME!! */ - public AlignmentAnnotation[] annotations; + protected List sequences; - HiddenSequences hiddenSequences = new HiddenSequences(this); + protected List groups = java.util.Collections + .synchronizedList(new ArrayList()); - private void initAlignment(SequenceI[] seqs) { - int i=0; + protected char gapCharacter = '-'; - if( jalview.util.Comparison.isNucleotide(seqs)) - type = NUCLEOTIDE; - else - type = PROTEIN; + protected int type = NUCLEOTIDE; + + public static final int PROTEIN = 0; + + public static final int NUCLEOTIDE = 1; + + public boolean hasRNAStructure = false; - sequences = new Vector(); + /** DOCUMENT ME!! */ + public AlignmentAnnotation[] annotations; - for (i = 0; i < seqs.length; i++) + HiddenSequences hiddenSequences = new HiddenSequences(this); + + public Hashtable alignmentProperties; + + private void initAlignment(SequenceI[] seqs) + { + int i = 0; + + if (jalview.util.Comparison.isNucleotide(seqs)) + { + type = NUCLEOTIDE; + } + else + { + type = PROTEIN; + } + + sequences = java.util.Collections + .synchronizedList(new ArrayList()); + + for (i = 0; i < seqs.length; i++) + { + sequences.add(seqs[i]); + } + + } + + /** + * Make an alignment from an array of Sequences. + * + * @param sequences + */ + public Alignment(SequenceI[] seqs) + { + initAlignment(seqs); + } + + /** + * Make a new alignment from an array of SeqCigars + * + * @param seqs + * SeqCigar[] + */ + public Alignment(SeqCigar[] alseqs) + { + SequenceI[] seqs = SeqCigar.createAlignmentSequences(alseqs, + gapCharacter, new ColumnSelection(), null); + initAlignment(seqs); + } + + /** + * Make a new alignment from an CigarArray JBPNote - can only do this when + * compactAlignment does not contain hidden regions. JBPNote - must also check + * that compactAlignment resolves to a set of SeqCigars - or construct them + * appropriately. + * + * @param compactAlignment + * CigarArray + */ + public static AlignmentI createAlignment(CigarArray compactAlignment) + { + throw new Error(MessageManager.getString("error.alignment_cigararray_not_implemented")); + // this(compactAlignment.refCigars); + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + @Override + public List getSequences() + { + return sequences; + } + + @Override + public List getSequences( + Map hiddenReps) + { + // TODO: in jalview 2.8 we don't do anything with hiddenreps - fix design to + // work on this. + return sequences; + } + + @Override + public SequenceI[] getSequencesArray() + { + if (sequences == null) + { + return null; + } + synchronized (sequences) + { + return sequences.toArray(new SequenceI[sequences.size()]); + } + } + + /** + * DOCUMENT ME! + * + * @param i + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + @Override + public SequenceI getSequenceAt(int i) + { + synchronized (sequences) + { + if (i > -1 && i < sequences.size()) { - sequences.addElement(seqs[i]); + return sequences.get(i); } + } + return null; + } + /** + * Adds a sequence to the alignment. Recalculates maxLength and size. + * + * @param snew + */ + @Override + public void addSequence(SequenceI snew) + { + if (dataset != null) + { + // maintain dataset integrity + if (snew.getDatasetSequence() != null) + { + getDataset().addSequence(snew.getDatasetSequence()); + } + else + { + // derive new sequence + SequenceI adding = snew.deriveSequence(); + getDataset().addSequence(adding.getDatasetSequence()); + snew = adding; + } } - /** Make an alignment from an array of Sequences. - * - * @param sequences - */ - public Alignment(SequenceI[] seqs) + if (sequences == null) { - initAlignment(seqs); + initAlignment(new SequenceI[] + { snew }); } - /** - * Make a new alignment from an array of SeqCigars - * @param seqs SeqCigar[] - */ - public Alignment(SeqCigar[] alseqs) { - SequenceI[] seqs = SeqCigar.createAlignmentSequences(alseqs, gapCharacter, new ColumnSelection(), null); - initAlignment(seqs); + else + { + synchronized (sequences) + { + sequences.add(snew); + } } - /** - * Make a new alignment from an CigarArray - * JBPNote - can only do this when compactAlignment does not contain hidden regions. - * JBPNote - must also check that compactAlignment resolves to a set of SeqCigars - or construct them appropriately. - * @param compactAlignment CigarArray - */ - public static AlignmentI createAlignment(CigarArray compactAlignment) { - throw new Error("Alignment(CigarArray) not yet implemented"); - // this(compactAlignment.refCigars); + if (hiddenSequences != null) + { + hiddenSequences.adjustHeightSequenceAdded(); } + } - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public Vector getSequences() + /** + * Adds a sequence to the alignment. Recalculates maxLength and size. + * + * @param snew + */ + @Override + public void setSequenceAt(int i, SequenceI snew) + { + SequenceI oldseq = getSequenceAt(i); + deleteSequence(i); + synchronized (sequences) { - return sequences; + sequences.set(i, snew); } + } - public SequenceI [] getSequencesArray() + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + @Override + public List getGroups() + { + return groups; + } + + @Override + public void finalize() + { + if (getDataset() != null) { - SequenceI [] reply = new SequenceI[sequences.size()]; - for(int i=0; i -1 && i < getHeight()) + { + synchronized (sequences) { - reply[i] = (SequenceI)sequences.elementAt(i); + sequences.remove(i); } - return reply; + hiddenSequences.adjustHeightSequenceDeleted(i); } + } - /** - * DOCUMENT ME! - * - * @param i DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public SequenceI getSequenceAt(int i) + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#findGroup(jalview.datamodel.SequenceI) + */ + @Override + public SequenceGroup findGroup(SequenceI s) + { + synchronized (groups) { - if (i < sequences.size()) + for (int i = 0; i < this.groups.size(); i++) + { + SequenceGroup sg = groups.get(i); + + if (sg.getSequences(null).contains(s)) { - return (SequenceI) sequences.elementAt(i); + return sg; } + } + } + return null; + } + + /* + * (non-Javadoc) + * + * @see + * jalview.datamodel.AlignmentI#findAllGroups(jalview.datamodel.SequenceI) + */ + @Override + public SequenceGroup[] findAllGroups(SequenceI s) + { + ArrayList temp = new ArrayList(); - return null; + synchronized (groups) + { + int gSize = groups.size(); + for (int i = 0; i < gSize; i++) + { + SequenceGroup sg = groups.get(i); + if (sg == null || sg.getSequences(null) == null) + { + this.deleteGroup(sg); + gSize--; + continue; + } + + if (sg.getSequences(null).contains(s)) + { + temp.add(sg); + } + } } + SequenceGroup[] ret = new SequenceGroup[temp.size()]; + return temp.toArray(ret); + } - /** Adds a sequence to the alignment. Recalculates maxLength and size. - * - * @param snew - */ - public void addSequence(SequenceI snew) + /** */ + @Override + public void addGroup(SequenceGroup sg) + { + synchronized (groups) { - if(dataset!=null) + if (!groups.contains(sg)) { - if(snew.getDatasetSequence()!=null) + if (hiddenSequences.getSize() > 0) { - System.out.println(snew.getName()); - getDataset().addSequence(snew.getDatasetSequence()); + int i, iSize = sg.getSize(); + for (i = 0; i < iSize; i++) + { + if (!sequences.contains(sg.getSequenceAt(i))) + { + sg.deleteSequence(sg.getSequenceAt(i), false); + iSize--; + i--; + } + } + + if (sg.getSize() < 1) + { + return; + } + } + sg.setContext(this); + groups.add(sg); + } + } + } + + /** + * remove any annotation that references gp + * + * @param gp + * (if null, removes all group associated annotation) + */ + private void removeAnnotationForGroup(SequenceGroup gp) + { + if (annotations == null || annotations.length == 0) + { + return; + } + // remove annotation very quickly + AlignmentAnnotation[] t, todelete = new AlignmentAnnotation[annotations.length], tokeep = new AlignmentAnnotation[annotations.length]; + int i, p, k; + if (gp == null) + { + for (i = 0, p = 0, k = 0; i < annotations.length; i++) + { + if (annotations[i].groupRef != null) + { + todelete[p++] = annotations[i]; + } + else + { + tokeep[k++] = annotations[i]; + } + } + } + else + { + for (i = 0, p = 0, k = 0; i < annotations.length; i++) + { + if (annotations[i].groupRef == gp) + { + todelete[p++] = annotations[i]; } else { - Sequence ds = new Sequence(snew.getName(), - AlignSeq.extractGaps("-. ", - snew.getSequence()), - snew.getStart(), - snew.getEnd()); + tokeep[k++] = annotations[i]; + } + } + } + if (p > 0) + { + // clear out the group associated annotation. + for (i = 0; i < p; i++) + { + unhookAnnotation(todelete[i]); + todelete[i] = null; + } + t = new AlignmentAnnotation[k]; + for (i = 0; i < k; i++) + { + t[i] = tokeep[i]; + } + annotations = t; + } + } + + @Override + public void deleteAllGroups() + { + synchronized (groups) + { + if (annotations != null) + { + removeAnnotationForGroup(null); + } + for (SequenceGroup sg : groups) + { + sg.setContext(null); + } + groups.clear(); + } + } + + /** */ + @Override + public void deleteGroup(SequenceGroup g) + { + synchronized (groups) + { + if (groups.contains(g)) + { + removeAnnotationForGroup(g); + groups.remove(g); + g.setContext(null); + } + } + } + + /** */ + @Override + public SequenceI findName(String name) + { + return findName(name, false); + } + + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#findName(java.lang.String, boolean) + */ + @Override + public SequenceI findName(String token, boolean b) + { + return findName(null, token, b); + } + + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#findName(SequenceI, java.lang.String, + * boolean) + */ + @Override + public SequenceI findName(SequenceI startAfter, String token, boolean b) + { - snew.setDatasetSequence(ds); - getDataset().addSequence(ds); + int i = 0; + SequenceI sq = null; + String sqname = null; + if (startAfter != null) + { + // try to find the sequence in the alignment + boolean matched = false; + while (i < sequences.size()) + { + if (getSequenceAt(i++) == startAfter) + { + matched = true; + break; } } + if (!matched) + { + i = 0; + } + } + while (i < sequences.size()) + { + sq = getSequenceAt(i); + sqname = sq.getName(); + if (sqname.equals(token) // exact match + || (b && // allow imperfect matches - case varies + (sqname.equalsIgnoreCase(token)))) + { + return getSequenceAt(i); + } + + i++; + } + + return null; + } + + @Override + public SequenceI[] findSequenceMatch(String name) + { + Vector matches = new Vector(); + int i = 0; + + while (i < sequences.size()) + { + if (getSequenceAt(i).getName().equals(name)) + { + matches.addElement(getSequenceAt(i)); + } + i++; + } - sequences.addElement(snew); + SequenceI[] result = new SequenceI[matches.size()]; + for (i = 0; i < result.length; i++) + { + result[i] = (SequenceI) matches.elementAt(i); } + return result; + + } + + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SequenceI) + */ + @Override + public int findIndex(SequenceI s) + { + int i = 0; - /** Adds a sequence to the alignment. Recalculates maxLength and size. - * - * @param snew - */ - public void setSequenceAt(int i, SequenceI snew) + while (i < sequences.size()) { - SequenceI oldseq = getSequenceAt(i); - deleteSequence(oldseq); + if (s == getSequenceAt(i)) + { + return i; + } - sequences.setElementAt(snew, i); + i++; } - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public Vector getGroups() + return -1; + } + + /* + * (non-Javadoc) + * + * @see + * jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SearchResults) + */ + @Override + public int findIndex(SearchResults results) + { + int i = 0; + + while (i < sequences.size()) { - return groups; + if (results.involvesSequence(getSequenceAt(i))) + { + return i; + } + i++; } - /** Takes out columns consisting entirely of gaps (-,.," ") - */ - public void removeGaps() { - removeGaps((ShiftList)null); + return -1; + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + @Override + public int getHeight() + { + return sequences.size(); + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + @Override + public int getWidth() + { + int maxLength = -1; + + for (int i = 0; i < sequences.size(); i++) + { + if (getSequenceAt(i).getLength() > maxLength) + { + maxLength = getSequenceAt(i).getLength(); + } } - /** - * remove gaps in alignment - recording any frame shifts in shiftrecord - * intended to be passed to ColumnSelection.compensateForEdits(shiftrecord) - * @param shiftrecord - */ - public void removeGaps(ShiftList shiftrecord) { - SequenceI[] seqs = getVisibleAndRepresentedSeqs(); - int j, jSize = seqs.length; - int width = 0; - for (int i = 0; i < jSize; i++) + return maxLength; + } + + /** + * DOCUMENT ME! + * + * @param gc + * DOCUMENT ME! + */ + @Override + public void setGapCharacter(char gc) + { + gapCharacter = gc; + synchronized (sequences) + { + for (SequenceI seq : sequences) + { + seq.setSequence(seq.getSequenceAsString().replace('.', gc) + .replace('-', gc).replace(' ', gc)); + } + } + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + @Override + public char getGapCharacter() + { + return gapCharacter; + } + + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#isAligned() + */ + @Override + public boolean isAligned() + { + return isAligned(false); + } + + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#isAligned(boolean) + */ + @Override + public boolean isAligned(boolean includeHidden) + { + int width = getWidth(); + if (hiddenSequences == null || hiddenSequences.getSize() == 0) + { + includeHidden = true; // no hidden sequences to check against. + } + for (int i = 0; i < sequences.size(); i++) + { + if (includeHidden || !hiddenSequences.isHidden(getSequenceAt(i))) + { + if (getSequenceAt(i).getLength() != width) { - if (seqs[i].getLength() > width) - { - width = seqs[i].getLength(); - } + return false; } + } + } - int startCol = -1, endCol = -1; - boolean delete = true; - for (int i = 0; i < width; i++) - { - delete = true; + return true; + } - for (j = 0; j < jSize; j++) - { - if (seqs[j].getLength() > i) - { - if (!jalview.util.Comparison.isGap(seqs[j].getCharAt(i))) - { - if(delete) - endCol = i; - - delete = false; - break; - } - } - } + /* + * (non-Javadoc) + * + * @seejalview.datamodel.AlignmentI#deleteAnnotation(jalview.datamodel. + * AlignmentAnnotation) + */ + @Override + public boolean deleteAnnotation(AlignmentAnnotation aa) + { + return deleteAnnotation(aa, true); + } - if(delete && startCol==-1) - { - startCol = i; - } + @Override + public boolean deleteAnnotation(AlignmentAnnotation aa, boolean unhook) + { + int aSize = 1; + if (annotations != null) + { + aSize = annotations.length; + } - if (!delete && startCol > -1) - { - deleteColumns(seqs, startCol, endCol); - if (shiftrecord!=null) { - shiftrecord.addShift(startCol, 1+endCol-startCol); - } - width -= (endCol - startCol); - i -= (endCol - startCol); - startCol = -1; - endCol = -1; - } - } + if (aSize < 1) + { + return false; + } + + AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize - 1]; + + boolean swap = false; + int tIndex = 0; + + for (int i = 0; i < aSize; i++) + { + if (annotations[i] == aa) + { + swap = true; + continue; + } + if (tIndex < temp.length) + { + temp[tIndex++] = annotations[i]; + } + } + + if (swap) + { + annotations = temp; + if (unhook) + { + unhookAnnotation(aa); + } + } + return swap; + } + + /** + * remove any object references associated with this annotation + * + * @param aa + */ + private void unhookAnnotation(AlignmentAnnotation aa) + { + if (aa.sequenceRef != null) + { + aa.sequenceRef.removeAlignmentAnnotation(aa); + } + if (aa.groupRef != null) + { + // probably need to do more here in the future (post 2.5.0) + aa.groupRef = null; + } + } - if (delete && startCol > -1) + /* + * (non-Javadoc) + * + * @seejalview.datamodel.AlignmentI#addAnnotation(jalview.datamodel. + * AlignmentAnnotation) + */ + @Override + public void addAnnotation(AlignmentAnnotation aa) + { + addAnnotation(aa, -1); + } + + /* + * (non-Javadoc) + * + * @seejalview.datamodel.AlignmentI#addAnnotation(jalview.datamodel. + * AlignmentAnnotation, int) + */ + @Override + public void addAnnotation(AlignmentAnnotation aa, int pos) + { + if (aa.getRNAStruc() != null) + { + hasRNAStructure = true; + } + + int aSize = 1; + if (annotations != null) + { + aSize = annotations.length + 1; + } + + AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize]; + int i = 0; + if (pos == -1 || pos >= aSize) + { + temp[aSize - 1] = aa; + } + else + { + temp[pos] = aa; + } + if (aSize > 1) + { + int p = 0; + for (i = 0; i < (aSize - 1); i++, p++) + { + if (p == pos) { - deleteColumns(seqs, startCol, endCol); - if (shiftrecord!=null) { - shiftrecord.addShift(startCol, 1+endCol-startCol); - } + p++; } + if (p < temp.length) + { + temp[p] = annotations[i]; + } + } } - /** Removes a range of columns (start to end inclusive). - * - * @param seqs Sequences to remove columns from - * @param start Start column in the alignment - * @param end End column in the alignment - */ - public void deleteColumns(SequenceI [] seqs, int start, int end) + annotations = temp; + } + + @Override + public void setAnnotationIndex(AlignmentAnnotation aa, int index) + { + if (aa == null || annotations == null || annotations.length - 1 < index) { - for(int i=0; iseqs[j].getLength()) - { - sequences.removeElement(seqs[j]); - j--; - jSize--; - } - else - { - seqs[j].setStart(newstart); - seqs[j].setSequence(seqs[j].getSequence().substring(i)); - } + dataset = new Alignment(seqs); + } + else if (dataset == null && data != null) + { + dataset = data; + for (int i = 0; i < getHeight(); i++) + { + SequenceI currentSeq = getSequenceAt(i); + SequenceI dsq = currentSeq.getDatasetSequence(); + if (dsq == null) + { + dsq = currentSeq.createDatasetSequence(); + dataset.addSequence(dsq); + } + else + { + while (dsq.getDatasetSequence() != null) + { + dsq = dsq.getDatasetSequence(); + } + if (dataset.findIndex(dsq) == -1) + { + dataset.addSequence(dsq); + } } + } } + dataset.addAlignmentRef(); + } + + /** + * reference count for number of alignments referencing this one. + */ + int alignmentRefs = 0; + + /** + * increase reference count to this alignment. + */ + private void addAlignmentRef() + { + alignmentRefs++; + } + + @Override + public Alignment getDataset() + { + return dataset; + } - /** - * DOCUMENT ME! - * - * @param i DOCUMENT ME! - */ - public void trimRight(int i) - { - SequenceI[] seqs = getVisibleAndRepresentedSeqs(); - int j, jSize = seqs.length; - for (j = 0; j < jSize; j++) - { - int newend = seqs[j].findPosition(i); + @Override + public boolean padGaps() + { + boolean modified = false; - seqs[j].setEnd(newend); - if(seqs[j].getLength()>i) - seqs[j].setSequence(seqs[j].getSequence().substring(0, i + 1)); - } - } + // Remove excess gaps from the end of alignment + int maxLength = -1; - /** - * DOCUMENT ME! - * - * @param s DOCUMENT ME! - */ - public void deleteSequence(SequenceI s) + SequenceI current; + for (int i = 0; i < sequences.size(); i++) { - for (int i = 0; i < getHeight(); i++) + current = getSequenceAt(i); + for (int j = current.getLength(); j > maxLength; j--) + { + if (j > maxLength + && !jalview.util.Comparison.isGap(current.getCharAt(j))) { - if (getSequenceAt(i) == s) - { - deleteSequence(i); - } + maxLength = j; + break; } + } } - /** - * DOCUMENT ME! - * - * @param i DOCUMENT ME! - */ - public void deleteSequence(int i) + maxLength++; + + int cLength; + for (int i = 0; i < sequences.size(); i++) { - sequences.removeElementAt(i); + current = getSequenceAt(i); + cLength = current.getLength(); + + if (cLength < maxLength) + { + current.insertCharAt(cLength, maxLength - cLength, gapCharacter); + modified = true; + } + else if (current.getLength() > maxLength) + { + current.deleteChars(maxLength, current.getLength()); + } } + return modified; + } + /** + * Justify the sequences to the left or right by deleting and inserting gaps + * before the initial residue or after the terminal residue + * + * @param right + * true if alignment padded to right, false to justify to left + * @return true if alignment was changed + */ + @Override + public boolean justify(boolean right) + { + boolean modified = false; - /** */ - public SequenceGroup findGroup(SequenceI s) + // Remove excess gaps from the end of alignment + int maxLength = -1; + int ends[] = new int[sequences.size() * 2]; + SequenceI current; + for (int i = 0; i < sequences.size(); i++) { - for (int i = 0; i < this.groups.size(); i++) + current = getSequenceAt(i); + // This should really be a sequence method + ends[i * 2] = current.findIndex(current.getStart()); + ends[i * 2 + 1] = current.findIndex(current.getStart() + + current.getLength()); + boolean hitres = false; + for (int j = 0, rs = 0, ssiz = current.getLength(); j < ssiz; j++) + { + if (!jalview.util.Comparison.isGap(current.getCharAt(j))) { - SequenceGroup sg = (SequenceGroup) groups.elementAt(i); - - if (sg.getSequences(false).contains(s)) + if (!hitres) + { + ends[i * 2] = j; + hitres = true; + } + else + { + ends[i * 2 + 1] = j; + if (j - ends[i * 2] > maxLength) { - return sg; + maxLength = j - ends[i * 2]; } + } } - - return null; + } } - /** - * DOCUMENT ME! - * - * @param s DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public SequenceGroup[] findAllGroups(SequenceI s) + maxLength++; + // now edit the flanking gaps to justify to either left or right + int cLength, extent, diff; + for (int i = 0; i < sequences.size(); i++) { - Vector temp = new Vector(); + current = getSequenceAt(i); - int gSize = groups.size(); - for (int i = 0; i < gSize; i++) + cLength = 1 + ends[i * 2 + 1] - ends[i * 2]; + diff = maxLength - cLength; // number of gaps to indent + extent = current.getLength(); + if (right) + { + // right justify + if (extent > ends[i * 2 + 1]) { - SequenceGroup sg = (SequenceGroup) groups.elementAt(i); - if(sg==null || sg.getSequences(false)==null) - { - this.deleteGroup(sg); - gSize--; - continue; - } - - if (sg.getSequences(false).contains(s)) - { - temp.addElement(sg); - } + current.deleteChars(ends[i * 2 + 1] + 1, extent); + modified = true; } - - SequenceGroup[] ret = new SequenceGroup[temp.size()]; - - for (int i = 0; i < temp.size(); i++) + if (ends[i * 2] > diff) { - ret[i] = (SequenceGroup) temp.elementAt(i); + current.deleteChars(0, ends[i * 2] - diff); + modified = true; } - - return ret; - } - - - - /** */ - public void addGroup(SequenceGroup sg) - { - if (!groups.contains(sg)) + else { - groups.addElement(sg); + if (ends[i * 2] < diff) + { + current.insertCharAt(0, diff - ends[i * 2], gapCharacter); + modified = true; + } } - } - - /** - * DOCUMENT ME! - */ - public void deleteAllGroups() - { - groups.removeAllElements(); - - int i = 0; - - while (i < sequences.size()) + } + else + { + // left justify + if (ends[i * 2] > 0) { - SequenceI s = getSequenceAt(i); - s.setColor(java.awt.Color.white); - i++; + current.deleteChars(0, ends[i * 2]); + modified = true; + ends[i * 2 + 1] -= ends[i * 2]; + extent -= ends[i * 2]; } - } - - /** */ - public void deleteGroup(SequenceGroup g) - { - if (groups.contains(g)) + if (extent > maxLength) { - groups.removeElement(g); + current.deleteChars(maxLength + 1, extent); + modified = true; } - } - - /** */ - public SequenceI findName(String name) - { - int i = 0; - - while (i < sequences.size()) + else { - if (getSequenceAt(i).getName().equals(name)) - { - return getSequenceAt(i); - } - - i++; + if (extent < maxLength) + { + current.insertCharAt(extent, maxLength - extent, gapCharacter); + modified = true; + } } - - return null; + } } + return modified; + } + + @Override + public HiddenSequences getHiddenSequences() + { + return hiddenSequences; + } - public SequenceI [] findSequenceMatch(String name) + @Override + public CigarArray getCompactAlignment() + { + synchronized (sequences) { - Vector matches = new Vector(); + SeqCigar alseqs[] = new SeqCigar[sequences.size()]; int i = 0; - - while (i < sequences.size()) + for (SequenceI seq : sequences) { - if (getSequenceAt(i).getName().equals(name)) - { - matches.addElement(getSequenceAt(i)); - } - i++; + alseqs[i++] = new SeqCigar(seq); } - - SequenceI [] result = new SequenceI[matches.size()]; - for(i=0; i maxLength) - { - maxLength = getSequenceAt(i).getLength(); - } - } + @Override + public Hashtable getProperties() + { + return alignmentProperties; + } - return maxLength; + AlignedCodonFrame[] codonFrameList = null; + + /* + * (non-Javadoc) + * + * @see + * jalview.datamodel.AlignmentI#addCodonFrame(jalview.datamodel.AlignedCodonFrame + * ) + */ + @Override + public void addCodonFrame(AlignedCodonFrame codons) + { + if (codons == null) + { + return; } - - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public int getMaxIdLength() + if (codonFrameList == null) { - int max = 0; - int i = 0; - - while (i < sequences.size()) - { - SequenceI seq = getSequenceAt(i); - String tmp = seq.getName() + "/" + seq.getStart() + "-" + - seq.getEnd(); - - if (tmp.length() > max) - { - max = tmp.length(); - } + codonFrameList = new AlignedCodonFrame[] + { codons }; + return; + } + AlignedCodonFrame[] t = new AlignedCodonFrame[codonFrameList.length + 1]; + System.arraycopy(codonFrameList, 0, t, 0, codonFrameList.length); + t[codonFrameList.length] = codons; + codonFrameList = t; + } - i++; - } + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#getCodonFrame(int) + */ + @Override + public AlignedCodonFrame getCodonFrame(int index) + { + return codonFrameList[index]; + } - return max; + /* + * (non-Javadoc) + * + * @see + * jalview.datamodel.AlignmentI#getCodonFrame(jalview.datamodel.SequenceI) + */ + @Override + public AlignedCodonFrame[] getCodonFrame(SequenceI seq) + { + if (seq == null || codonFrameList == null) + { + return null; } - - /** - * DOCUMENT ME! - * - * @param gc DOCUMENT ME! - */ - public void setGapCharacter(char gc) + Vector cframes = new Vector(); + for (int f = 0; f < codonFrameList.length; f++) { - gapCharacter = gc; - - for (int i = 0; i < sequences.size(); i++) - { - Sequence seq = (Sequence) sequences.elementAt(i); - seq.setSequence( seq.getSequence().replace('.', gc) ); - seq.setSequence( seq.getSequence().replace('-', gc) ); - seq.setSequence( seq.getSequence().replace(' ', gc) ); - } + if (codonFrameList[f].involvesSequence(seq)) + { + cframes.addElement(codonFrameList[f]); + } } - - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public char getGapCharacter() + if (cframes.size() == 0) { - return gapCharacter; + return null; } + AlignedCodonFrame[] cfr = new AlignedCodonFrame[cframes.size()]; + cframes.copyInto(cfr); + return cfr; + } - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public Vector getAAFrequency() + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#getCodonFrames() + */ + @Override + public AlignedCodonFrame[] getCodonFrames() + { + return codonFrameList; + } + + /* + * (non-Javadoc) + * + * @seejalview.datamodel.AlignmentI#removeCodonFrame(jalview.datamodel. + * AlignedCodonFrame) + */ + @Override + public boolean removeCodonFrame(AlignedCodonFrame codons) + { + if (codons == null || codonFrameList == null) { - return AAFrequency.calculate(sequences, 0, getWidth()); + return false; } - - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public boolean isAligned() + boolean removed = false; + int i = 0, iSize = codonFrameList.length; + while (i < iSize) { - int width = getWidth(); - - for (int i = 0; i < sequences.size(); i++) + if (codonFrameList[i] == codons) + { + removed = true; + if (i + 1 < iSize) { - if (getSequenceAt(i).getLength() != width) - { - return false; - } + System.arraycopy(codonFrameList, i + 1, codonFrameList, i, iSize + - i - 1); } - - return true; + iSize--; + } + else + { + i++; + } } + return removed; + } - /** - * DOCUMENT ME! - * - * @param aa DOCUMENT ME! - */ - public void deleteAnnotation(AlignmentAnnotation aa) + @Override + public void append(AlignmentI toappend) + { + if (toappend == this) { - int aSize = 1; - - if (annotations != null) - { - aSize = annotations.length; - } - - AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize - 1]; - - int tIndex = 0; - - for (int i = 0; i < aSize; i++) + System.err.println("Self append may cause a deadlock."); + } + // TODO test this method for a future 2.5 release + // currently tested for use in jalview.gui.SequenceFetcher + boolean samegap = toappend.getGapCharacter() == getGapCharacter(); + char oldc = toappend.getGapCharacter(); + boolean hashidden = toappend.getHiddenSequences() != null + && toappend.getHiddenSequences().hiddenSequences != null; + // get all sequences including any hidden ones + List sqs = (hashidden) ? toappend.getHiddenSequences() + .getFullAlignment().getSequences() : toappend.getSequences(); + if (sqs != null) + { + synchronized (sqs) + { + for (SequenceI addedsq : sqs) { - if (annotations[i] == aa) + if (!samegap) + { + char[] oldseq = addedsq.getSequence(); + for (int c = 0; c < oldseq.length; c++) { - continue; + if (oldseq[c] == oldc) + { + oldseq[c] = gapCharacter; + } } - - temp[tIndex] = annotations[i]; - tIndex++; + } + addSequence(addedsq); } - - annotations = temp; + } } - - - public void adjustSequenceAnnotations() + AlignmentAnnotation[] alan = toappend.getAlignmentAnnotation(); + for (int a = 0; alan != null && a < alan.length; a++) + { + addAnnotation(alan[a]); + } + AlignedCodonFrame[] acod = toappend.getCodonFrames(); + for (int a = 0; acod != null && a < acod.length; a++) + { + this.addCodonFrame(acod[a]); + } + List sg = toappend.getGroups(); + if (sg != null) + { + for (SequenceGroup _sg : sg) + { + addGroup(_sg); + } + } + if (toappend.getHiddenSequences() != null) { - if(annotations!=null) + HiddenSequences hs = toappend.getHiddenSequences(); + if (hiddenSequences == null) + { + hiddenSequences = new HiddenSequences(this); + } + if (hs.hiddenSequences != null) { - for (int a = 0; a < annotations.length; a++) + for (int s = 0; s < hs.hiddenSequences.length; s++) { - if (annotations[a].sequenceRef != null) + // hide the newly appended sequence in the alignment + if (hs.hiddenSequences[s] != null) { - annotations[a].adjustForAlignment(); + hiddenSequences.hideSequence(hs.hiddenSequences[s]); } } } } - - /** - * DOCUMENT ME! - * - * @param aa DOCUMENT ME! - */ - public void addAnnotation(AlignmentAnnotation aa) + if (toappend.getProperties() != null) { - int aSize = 1; - if (annotations != null) - { - aSize = annotations.length + 1; - } - - AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize]; - - temp[aSize-1] = aa; - - int i = 0; - - if (aSize > 1) + // we really can't do very much here - just try to concatenate strings + // where property collisions occur. + Enumeration key = toappend.getProperties().keys(); + while (key.hasMoreElements()) + { + Object k = key.nextElement(); + Object ourval = this.getProperty(k); + Object toapprop = toappend.getProperty(k); + if (ourval != null) { - for (i = 0; i < (aSize-1); i++) + if (ourval.getClass().equals(toapprop.getClass()) + && !ourval.equals(toapprop)) + { + if (ourval instanceof String) { - temp[i] = annotations[i]; + // append strings + this.setProperty(k, ((String) ourval) + "; " + + ((String) toapprop)); } + else + { + if (ourval instanceof Vector) + { + // append vectors + Enumeration theirv = ((Vector) toapprop).elements(); + while (theirv.hasMoreElements()) + { + ((Vector) ourval).addElement(theirv); + } + } + } + } + } + else + { + // just add new property directly + setProperty(k, toapprop); } - annotations = temp; + } } + } - public void setAnnotationIndex(AlignmentAnnotation aa, int index) + @Override + public AlignmentAnnotation findOrCreateAnnotation(String name, + String calcId, boolean autoCalc, SequenceI seqRef, + SequenceGroup groupRef) + { + assert (name != null); + if (annotations != null) { - if(aa==null || annotations==null || annotations.length-1 findAnnotation(String calcId) + { + ArrayList aa = new ArrayList(); + for (AlignmentAnnotation a : getAlignmentAnnotation()) { - if(b) - type = NUCLEOTIDE; - else - type = PROTEIN; + if (a.getCalcId() == calcId + || (a.getCalcId() != null && calcId != null && a.getCalcId() + .equals(calcId))) + { + aa.add(a); + } } + return aa; + } - public boolean isNucleotide() + /** + * Returns an iterable collection of any annotations that match on given + * sequence ref, calcId and label (ignoring null values). + */ + @Override + public Iterable findAnnotations(SequenceI seq, + String calcId, String label) + { + ArrayList aa = new ArrayList(); + for (AlignmentAnnotation ann : getAlignmentAnnotation()) { - if(type==NUCLEOTIDE) - return true; - else - return false; + 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; + } - public void setDataset(Alignment data) + @Override + public void moveSelectedSequencesByOne(SequenceGroup sg, + Map map, boolean up) + { + synchronized (sequences) { - if(dataset==null && data==null) + if (up) { - // Create a new dataset for this alignment. - // Can only be done once, if dataset is not null - // This will not be performed - Sequence[] seqs = new Sequence[getHeight()]; - for (int i = 0; i < getHeight(); i++) + + for (int i = 1, iSize = sequences.size(); i < iSize; i++) { - if(getSequenceAt(i).getDatasetSequence()!=null) + SequenceI seq = sequences.get(i); + if (!sg.getSequences(map).contains(seq)) { - seqs[i] = (Sequence)getSequenceAt(i).getDatasetSequence(); + continue; } - else + + SequenceI temp = sequences.get(i - 1); + if (sg.getSequences(null).contains(temp)) { - seqs[i] = new Sequence(getSequenceAt(i).getName(), - AlignSeq.extractGaps( - jalview.util.Comparison.GapChars, - getSequenceAt(i).getSequence() - ), - getSequenceAt(i).getStart(), - getSequenceAt(i).getEnd()); - seqs[i].sequenceFeatures = getSequenceAt(i).getSequenceFeatures(); - getSequenceAt(i).setSequenceFeatures(null); - getSequenceAt(i).setDatasetSequence(seqs[i]); + continue; } - } - dataset = new Alignment(seqs); - } - else if(dataset==null && data!=null) - { - dataset = data; + sequences.set(i, temp); + sequences.set(i - 1, seq); + } } - } - - public Alignment getDataset() - { - return dataset; - } - - public boolean padGaps() { - boolean modified=false; - - //Remove excess gaps from the end of alignment - int maxLength = -1; - - SequenceI current; - for (int i = 0; i < sequences.size(); i++) + else { - current = getSequenceAt(i); - for (int j = current.getLength(); j > maxLength; j--) + for (int i = sequences.size() - 2; i > -1; i--) { - if (j > maxLength && !jalview.util.Comparison.isGap( - current.getCharAt(j))) + SequenceI seq = sequences.get(i); + if (!sg.getSequences(map).contains(seq)) { - maxLength = j; - break; + continue; } - } - } - - maxLength++; - for (int i = 0; i < sequences.size(); - i++) - { - current = getSequenceAt(i); + SequenceI temp = sequences.get(i + 1); + if (sg.getSequences(map).contains(temp)) + { + continue; + } - if (current.getLength() < maxLength) - { - current.insertCharAt(maxLength - 1, gapCharacter); - modified=true; - } - else if(current.getLength() > maxLength) - { - current.deleteChars(maxLength, current.getLength()); + sequences.set(i, temp); + sequences.set(i + 1, seq); } } - return modified; + } + } - public HiddenSequences getHiddenSequences() + @Override + public void validateAnnotation(AlignmentAnnotation alignmentAnnotation) + { + alignmentAnnotation.validateRangeAndDisplay(); + if (isNucleotide() && alignmentAnnotation.isValidStruc()) { - return hiddenSequences; + hasRNAStructure = true; } - SequenceI [] getVisibleAndRepresentedSeqs() - { - if(hiddenSequences==null || hiddenSequences.getSize()<1) - return getSequencesArray(); - - Vector seqs = new Vector(); - SequenceI seq; - SequenceGroup hidden; - for (int i = 0; i < sequences.size(); i++) - { - seq = (SequenceI) sequences.elementAt(i); - seqs.addElement(seq); - hidden = seq.getHiddenSequences(); - if(hidden!=null) - { - for(int j=0; j