X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignment.java;h=3a1b44a6ef095fba286bf110f71a41acc3f4b0dd;hb=32ce9ddb7ce1a68add53dd81785ae428ca136a83;hp=b3cf89031438729d5bf6972a7814b7fac02bbc4d;hpb=588042b69abf8e60bcc950b24c283933c7dd422f;p=jalview.git diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java index b3cf890..3a1b44a 100755 --- a/src/jalview/datamodel/Alignment.java +++ b/src/jalview/datamodel/Alignment.java @@ -1,21 +1,21 @@ /* -* Jalview - A Sequence Alignment Editor and Viewer -* Copyright (C) 2005 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 -*/ + * Jalview - A Sequence Alignment Editor and Viewer + * Copyright (C) 2005 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 + */ package jalview.datamodel; import jalview.analysis.*; @@ -27,33 +27,68 @@ import java.util.*; /** Data structure to hold and manipulate a multiple sequence alignment */ -public class Alignment implements AlignmentI { +public class Alignment implements AlignmentI +{ + protected Alignment dataset; protected Vector sequences; protected Vector groups = new Vector(); protected Vector superGroup = new Vector(); protected char gapCharacter = '-'; + protected Provenance provenance; + protected int type = NUCLEOTIDE; + public static final int PROTEIN = 0; + public static final int NUCLEOTIDE = 1; + + /** DOCUMENT ME!! */ public AlignmentAnnotation[] annotations; + + /** DOCUMENT ME!! */ public boolean featuresAdded = false; /** Make an alignment from an array of Sequences. - * - * @param sequences - */ - public Alignment(SequenceI[] seqs) { + * + * @param sequences + */ + public Alignment(SequenceI[] seqs) + { + int i=0; + + if( jalview.util.Comparison.isNucleotide(seqs)) + type = NUCLEOTIDE; + else + type = PROTEIN; + sequences = new Vector(); - for (int i = 0; i < seqs.length; i++) + for (i = 0; i < seqs.length; i++) + { sequences.addElement(seqs[i]); + } getWidth(); } - public Vector getSequences() { + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public Vector getSequences() + { return sequences; } - public SequenceI getSequenceAt(int i) { - if (i < sequences.size()) { + /** + * DOCUMENT ME! + * + * @param i DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public SequenceI getSequenceAt(int i) + { + if (i < sequences.size()) + { return (SequenceI) sequences.elementAt(i); } @@ -64,75 +99,73 @@ public class Alignment implements AlignmentI { * * @param snew */ - public void addSequence(SequenceI snew) { + public void addSequence(SequenceI snew) + { sequences.addElement(snew); } - public void addSequence(SequenceI[] seq) { - for (int i = 0; i < seq.length; i++) { + /** + * DOCUMENT ME! + * + * @param seq DOCUMENT ME! + */ + public void addSequence(SequenceI[] seq) + { + for (int i = 0; i < seq.length; i++) + { addSequence(seq[i]); } } /** Adds a sequence to the alignment. Recalculates maxLength and size. - * + * * @param snew */ - public void setSequenceAt(int i, SequenceI snew) { + public void setSequenceAt(int i, SequenceI snew) + { SequenceI oldseq = getSequenceAt(i); deleteSequence(oldseq); sequences.setElementAt(snew, i); } - public Vector getGroups() { - return groups; - } - - /** Sorts the sequences by sequence group size - largest to smallest. - * Uses QuickSort. + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! */ - public void sortGroups() { - float[] arr = new float[groups.size()]; - Object[] s = new Object[groups.size()]; - - for (int i = 0; i < groups.size(); i++) { - arr[i] = ((SequenceGroup) groups.elementAt(i)).sequences.size(); - s[i] = groups.elementAt(i); - } - - QuickSort.sort(arr, s); - - Vector newg = new Vector(groups.size()); - - for (int i = groups.size() - 1; i >= 0; i--) { - newg.addElement(s[i]); - } - - groups = newg; + public Vector getGroups() + { + return groups; } /** Takes out columns consisting entirely of gaps (-,.," ") */ - public void removeGaps() { + public void removeGaps() + { SequenceI current; int iSize = getWidth(); - for (int i = 0; i < iSize; i++) { + for (int i = 0; i < iSize; i++) + { boolean delete = true; - for (int j = 0; j < getHeight(); j++) { + for (int j = 0; j < getHeight(); j++) + { current = getSequenceAt(j); - if (current.getLength() > i) { + if (current.getLength() > i) + { /* MC Should move this to a method somewhere */ - if (!jalview.util.Comparison.isGap(current.getCharAt(i))) { + if (!jalview.util.Comparison.isGap(current.getCharAt(i))) + { delete = false; } } } - if (delete) { + if (delete) + { deleteColumns(i, i); iSize--; i--; @@ -140,59 +173,44 @@ public class Alignment implements AlignmentI { } } - /** Returns an array of Sequences containing columns - * start to end (inclusive) only. - * - * @param start start column to fetch - * @param end end column to fetch - * @return Array of Sequences, ready to put into a new Alignment - */ - public SequenceI[] getColumns(int start, int end) { - return getColumns(0, getHeight() - 1, start, end); - } - /** Removes a range of columns (start to end inclusive). * * @param start Start column in the alignment * @param end End column in the alignment */ - public void deleteColumns(int start, int end) { + public void deleteColumns(int start, int end) + { deleteColumns(0, getHeight() - 1, start, end); } - public void deleteColumns(int seq1, int seq2, int start, int end) { - for (int i = 0; i <= (end - start); i++) { - for (int j = seq1; j <= seq2; j++) { + /** + * DOCUMENT ME! + * + * @param seq1 DOCUMENT ME! + * @param seq2 DOCUMENT ME! + * @param start DOCUMENT ME! + * @param end DOCUMENT ME! + */ + public void deleteColumns(int seq1, int seq2, int start, int end) + { + for (int i = 0; i <= (end - start); i++) + { + for (int j = seq1; j <= seq2; j++) + { getSequenceAt(j).deleteCharAt(start); } } } - public void insertColumns(SequenceI[] seqs, int pos) { - if (seqs.length == getHeight()) { - for (int i = 0; i < getHeight(); i++) { - String tmp = new String(getSequenceAt(i).getSequence()); - getSequenceAt(i).setSequence(tmp.substring(0, pos) + - seqs[i].getSequence() + tmp.substring(pos)); - } - } - } - - public SequenceI[] getColumns(int seq1, int seq2, int start, int end) { - SequenceI[] seqs = new Sequence[(seq2 - seq1) + 1]; - - for (int i = seq1; i <= seq2; i++) { - seqs[i] = new Sequence(getSequenceAt(i).getName(), - getSequenceAt(i).getSequence().substring(start, end), - getSequenceAt(i).findPosition(start), - getSequenceAt(i).findPosition(end)); - } - - return seqs; - } - - public void trimLeft(int i) { - for (int j = 0; j < getHeight(); j++) { + /** + * DOCUMENT ME! + * + * @param i DOCUMENT ME! + */ + public void trimLeft(int i) + { + for (int j = 0; j < getHeight(); j++) + { SequenceI s = getSequenceAt(j); int newstart = s.findPosition(i); @@ -201,8 +219,15 @@ public class Alignment implements AlignmentI { } } - public void trimRight(int i) { - for (int j = 0; j < getHeight(); j++) { + /** + * DOCUMENT ME! + * + * @param i DOCUMENT ME! + */ + public void trimRight(int i) + { + for (int j = 0; j < getHeight(); j++) + { SequenceI s = getSequenceAt(j); int newend = s.findPosition(i); @@ -211,36 +236,67 @@ public class Alignment implements AlignmentI { } } - public void deleteSequence(SequenceI s) { + /** + * DOCUMENT ME! + * + * @param s DOCUMENT ME! + */ + public void deleteSequence(SequenceI s) + { for (int i = 0; i < getHeight(); i++) - if (getSequenceAt(i) == s) { + { + if (getSequenceAt(i) == s) + { deleteSequence(i); } + } } - public void deleteSequence(int i) { + /** + * DOCUMENT ME! + * + * @param i DOCUMENT ME! + */ + public void deleteSequence(int i) + { sequences.removeElementAt(i); } - public Vector removeRedundancy(float threshold, Vector sel) { + /** + * DOCUMENT ME! + * + * @param threshold DOCUMENT ME! + * @param sel DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public Vector removeRedundancy(float threshold, Vector sel) + { Vector del = new Vector(); - for (int i = 1; i < sel.size(); i++) { - for (int j = 0; j < i; j++) { + for (int i = 1; i < sel.size(); i++) + { + for (int j = 0; j < i; j++) + { // Only do the comparison if either have not been deleted if (!del.contains((SequenceI) sel.elementAt(i)) || - !del.contains((SequenceI) sel.elementAt(j))) { + !del.contains((SequenceI) sel.elementAt(j))) + { // use PID instead of Comparison (which is really not pleasant) float pid = Comparison.PID((SequenceI) sel.elementAt(j), (SequenceI) sel.elementAt(i)); - if (pid >= threshold) { + if (pid >= threshold) + { // Delete the shortest one if (((SequenceI) sel.elementAt(j)).getSequence().length() > ((SequenceI) sel .elementAt( - i)).getSequence().length()) { + i)).getSequence().length()) + { del.addElement(sel.elementAt(i)); - } else { + } + else + { del.addElement(sel.elementAt(i)); } } @@ -250,78 +306,28 @@ public class Alignment implements AlignmentI { // Now delete the sequences for (int i = 0; i < del.size(); i++) + { deleteSequence((SequenceI) del.elementAt(i)); - - return del; - } - - public void sortByPID(SequenceI s) { - float[] scores = new float[getHeight()]; - SequenceI[] seqs = new SequenceI[getHeight()]; - - for (int i = 0; i < getHeight(); i++) { - scores[i] = Comparison.compare(getSequenceAt(i), s); - seqs[i] = getSequenceAt(i); - } - - QuickSort.sort(scores, 0, scores.length - 1, seqs); - - int len = 0; - - if ((getHeight() % 2) == 0) { - len = getHeight() / 2; - } else { - len = (getHeight() + 1) / 2; - } - - for (int i = 0; i < len; i++) { - SequenceI tmp = seqs[i]; - sequences.setElementAt(seqs[getHeight() - i - 1], i); - sequences.setElementAt(tmp, getHeight() - i - 1); } - } - - public void sortByID() { - String[] ids = new String[getHeight()]; - SequenceI[] seqs = new SequenceI[getHeight()]; - for (int i = 0; i < getHeight(); i++) { - ids[i] = getSequenceAt(i).getName(); - seqs[i] = getSequenceAt(i); - } - - QuickSort.sort(ids, seqs); - - int len = 0; - - if ((getHeight() % 2) == 0) { - len = getHeight() / 2; - } else { - len = (getHeight() + 1) / 2; - System.out.println("DEBUG:Sort len is odd = " + len); // log. - } - - for (int i = 0; i < len; i++) { - System.out.println("DEBUG:Swapping " + seqs[i].getName() + " and " + - seqs[getHeight() - i - 1].getName()); // log. - - SequenceI tmp = seqs[i]; - sequences.setElementAt(seqs[getHeight() - i - 1], i); - sequences.setElementAt(tmp, getHeight() - i - 1); - } + return del; } /** */ - public SequenceGroup findGroup(int i) { + public SequenceGroup findGroup(int i) + { return findGroup(getSequenceAt(i)); } /** */ - public SequenceGroup findGroup(SequenceI s) { - for (int i = 0; i < this.groups.size(); i++) { + public SequenceGroup findGroup(SequenceI s) + { + for (int i = 0; i < this.groups.size(); i++) + { SequenceGroup sg = (SequenceGroup) groups.elementAt(i); - if (sg.sequences.contains(s)) { + if (sg.sequences.contains(s)) + { return sg; } } @@ -329,13 +335,30 @@ public class Alignment implements AlignmentI { return null; } - public SequenceGroup[] findAllGroups(SequenceI s) { + /** + * DOCUMENT ME! + * + * @param s DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public SequenceGroup[] findAllGroups(SequenceI s) + { Vector temp = new Vector(); - for (int i = 0; i < this.groups.size(); i++) { + int gSize = groups.size(); + for (int i = 0; i < gSize; i++) + { SequenceGroup sg = (SequenceGroup) groups.elementAt(i); + if(sg==null || sg.sequences==null) + { + this.deleteGroup(sg); + gSize--; + continue; + } - if (sg.sequences.contains(s)) { + if (sg.sequences.contains(s)) + { temp.addElement(sg); } } @@ -343,44 +366,48 @@ public class Alignment implements AlignmentI { SequenceGroup[] ret = new SequenceGroup[temp.size()]; for (int i = 0; i < temp.size(); i++) + { ret[i] = (SequenceGroup) temp.elementAt(i); - - return ret; - } - - /** */ - public void addToGroup(SequenceGroup g, SequenceI s) { - if (!(g.sequences.contains(s))) { - g.sequences.addElement(s); } - } - /** */ - public void removeFromGroup(SequenceGroup g, SequenceI s) { - if ((g != null) && (g.sequences != null)) { - if (g.sequences.contains(s)) { - g.sequences.removeElement(s); - - if (g.sequences.size() == 0) { - groups.removeElement(g); - } - } - } + return ret; } - public void addSuperGroup(SuperGroup sg) { + /** + * DOCUMENT ME! + * + * @param sg DOCUMENT ME! + */ + public void addSuperGroup(SuperGroup sg) + { superGroup.addElement(sg); } - public void removeSuperGroup(SuperGroup sg) { + /** + * DOCUMENT ME! + * + * @param sg DOCUMENT ME! + */ + public void removeSuperGroup(SuperGroup sg) + { superGroup.removeElement(sg); } - public SuperGroup getSuperGroup(SequenceGroup sg) { - for (int i = 0; i < this.superGroup.size(); i++) { + /** + * DOCUMENT ME! + * + * @param sg DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public SuperGroup getSuperGroup(SequenceGroup sg) + { + for (int i = 0; i < this.superGroup.size(); i++) + { SuperGroup temp = (SuperGroup) superGroup.elementAt(i); - if (temp.sequenceGroups.contains(sg)) { + if (temp.sequenceGroups.contains(sg)) + { return temp; } } @@ -389,19 +416,26 @@ public class Alignment implements AlignmentI { } /** */ - public void addGroup(SequenceGroup sg) { - if (!groups.contains(sg)) { + public void addGroup(SequenceGroup sg) + { + if (!groups.contains(sg)) + { groups.addElement(sg); } } - public void deleteAllGroups() { + /** + * DOCUMENT ME! + */ + public void deleteAllGroups() + { groups.removeAllElements(); superGroup.removeAllElements(); int i = 0; - while (i < sequences.size()) { + while (i < sequences.size()) + { SequenceI s = getSequenceAt(i); s.setColor(java.awt.Color.white); i++; @@ -409,21 +443,24 @@ public class Alignment implements AlignmentI { } /** */ - public void deleteGroup(SequenceGroup g) { - if (groups.contains(g)) { + public void deleteGroup(SequenceGroup g) + { + if (groups.contains(g)) + { groups.removeElement(g); } } /** */ - public SequenceI findName(String name) { + public SequenceI findName(String name) + { int i = 0; - while (i < sequences.size()) { - SequenceI s = getSequenceAt(i); - - if (s.getName().equals(name)) { - return s; + while (i < sequences.size()) + { + if (getSequenceAt(i).getName().equals(name)) + { + return getSequenceAt(i); } i++; @@ -432,29 +469,16 @@ public class Alignment implements AlignmentI { return null; } - /** */ - public SequenceI findbyDisplayId(String name) { - int i = 0; - - while (i < sequences.size()) { - SequenceI s = getSequenceAt(i); - - if (s.getDisplayId().equals(name)) { - return s; - } - - i++; - } - - return null; - } /** */ - public int findIndex(SequenceI s) { + public int findIndex(SequenceI s) + { int i = 0; - while (i < sequences.size()) { - if (s == getSequenceAt(i)) { + while (i < sequences.size()) + { + if (s == getSequenceAt(i)) + { return i; } @@ -464,15 +488,29 @@ public class Alignment implements AlignmentI { return -1; } - public int getHeight() { + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public int getHeight() + { return sequences.size(); } - public int getWidth() { + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public int getWidth() + { int maxLength = -1; - for (int i = 0; i < sequences.size(); i++) { - if (getSequenceAt(i).getLength() > maxLength) { + for (int i = 0; i < sequences.size(); i++) + { + if (getSequenceAt(i).getLength() > maxLength) + { maxLength = getSequenceAt(i).getLength(); } } @@ -480,16 +518,24 @@ public class Alignment implements AlignmentI { return maxLength; } - public int getMaxIdLength() { + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public int getMaxIdLength() + { int max = 0; int i = 0; - while (i < sequences.size()) { + while (i < sequences.size()) + { SequenceI seq = getSequenceAt(i); String tmp = seq.getName() + "/" + seq.getStart() + "-" + seq.getEnd(); - if (tmp.length() > max) { + if (tmp.length() > max) + { max = tmp.length(); } @@ -499,39 +545,75 @@ public class Alignment implements AlignmentI { return max; } - public void setGapCharacter(char gc) { + /** + * DOCUMENT ME! + * + * @param gc DOCUMENT ME! + */ + public void setGapCharacter(char gc) + { gapCharacter = gc; - for (int i = 0; i < sequences.size(); i++) { + for (int i = 0; i < sequences.size(); i++) + { Sequence seq = (Sequence) sequences.elementAt(i); seq.sequence = seq.sequence.replace('.', gc); seq.sequence = seq.sequence.replace('-', gc); + seq.sequence = seq.sequence.replace(' ', gc); } } - public char getGapCharacter() { + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public char getGapCharacter() + { return gapCharacter; } - public Vector getAAFrequency() { + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public Vector getAAFrequency() + { return AAFrequency.calculate(sequences, 0, getWidth()); } - public boolean isAligned() { + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public boolean isAligned() + { int width = getWidth(); for (int i = 0; i < sequences.size(); i++) - if (getSequenceAt(i).getLength() != width) { + { + if (getSequenceAt(i).getLength() != width) + { return false; } + } return true; } - public void deleteAnnotation(AlignmentAnnotation aa) { + /** + * DOCUMENT ME! + * + * @param aa DOCUMENT ME! + */ + public void deleteAnnotation(AlignmentAnnotation aa) + { int aSize = 1; - if (annotations != null) { + if (annotations != null) + { aSize = annotations.length; } @@ -539,8 +621,10 @@ public class Alignment implements AlignmentI { int tIndex = 0; - for (int i = 0; i < aSize; i++) { - if (annotations[i] == aa) { + for (int i = 0; i < aSize; i++) + { + if (annotations[i] == aa) + { continue; } @@ -551,19 +635,30 @@ public class Alignment implements AlignmentI { annotations = temp; } - public void addAnnotation(AlignmentAnnotation aa) { + /** + * DOCUMENT ME! + * + * @param aa DOCUMENT ME! + */ + public void addAnnotation(AlignmentAnnotation aa) + { int aSize = 1; - if (annotations != null) { + if (annotations != null) + { aSize = annotations.length + 1; } + AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize]; int i = 0; - if (aSize > 1) { + if (aSize > 1) + { for (i = 0; i < (aSize - 1); i++) + { temp[i] = annotations[i]; + } } temp[i] = aa; @@ -571,7 +666,73 @@ public class Alignment implements AlignmentI { annotations = temp; } - public AlignmentAnnotation[] getAlignmentAnnotation() { + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public AlignmentAnnotation[] getAlignmentAnnotation() + { return annotations; } + + public void setNucleotide(boolean b) + { + if(b) + type = NUCLEOTIDE; + else + type = PROTEIN; + } + + public boolean isNucleotide() + { + if(type==NUCLEOTIDE) + return true; + else + return false; + } + + public void setDataset(Alignment 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 + Sequence[] seqs = new Sequence[getHeight()]; + for (int i = 0; i < getHeight(); i++) + { + + seqs[i] = new Sequence(getSequenceAt(i).getDisplayId(true), + AlignSeq.extractGaps( + jalview.util.Comparison.GapChars, + getSequenceAt(i).getSequence() + ), + getSequenceAt(i).getStart(), + getSequenceAt(i).getEnd()); + + getSequenceAt(i).setDatasetSequence(seqs[i]); + } + + dataset = new Alignment(seqs); + } + else if(dataset==null && data!=null) + { + dataset = data; + } + } + + public Alignment getDataset() + { + return dataset; + } + + public void setProvenance(Provenance prov) + { + provenance = prov; + } + public Provenance getProvenance() + { + return provenance; + } }