X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAlignSeq.java;h=bd4cc223152a38191ca5fccff936147c4f68744e;hb=ba2f5105391c4421c9d74e5f63505e2a291035b0;hp=832f5198781b804b055ee48f596c5bd6fc570b1c;hpb=3889d8cc311503f8d40d9618acec1b0f4baf2aec;p=jalview.git
diff --git a/src/jalview/analysis/AlignSeq.java b/src/jalview/analysis/AlignSeq.java
index 832f519..bd4cc22 100755
--- a/src/jalview/analysis/AlignSeq.java
+++ b/src/jalview/analysis/AlignSeq.java
@@ -1,28 +1,43 @@
/*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
- * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ 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.
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
*
* 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 Jalview. If not, see .
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview. If not, see .
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
*/
package jalview.analysis;
-import java.util.*;
-import java.awt.*;
-
-import jalview.datamodel.*;
-import jalview.schemes.*;
-import jalview.util.*;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.Mapping;
+import jalview.datamodel.Sequence;
+import jalview.datamodel.SequenceI;
+import jalview.schemes.ResidueProperties;
+import jalview.schemes.ScoreMatrix;
+import jalview.util.Comparison;
+import jalview.util.Format;
+import jalview.util.MapList;
+import jalview.util.MessageManager;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.StringTokenizer;
/**
*
@@ -266,11 +281,44 @@ public class AlignSeq
}
/**
+ *
+ * @return aligned instance of Seq 1
+ */
+ public SequenceI getAlignedSeq1()
+ {
+ SequenceI alSeq1 = new Sequence(s1.getName(), getAStr1());
+ alSeq1.setStart(s1.getStart() + getSeq1Start() - 1);
+ alSeq1.setEnd(s1.getStart() + getSeq1End() - 1);
+ alSeq1.setDatasetSequence(s1.getDatasetSequence() == null ? s1 : s1
+ .getDatasetSequence());
+ return alSeq1;
+ }
+
+ /**
+ *
+ * @return aligned instance of Seq 2
+ */
+ public SequenceI getAlignedSeq2()
+ {
+ SequenceI alSeq2 = new Sequence(s2.getName(), getAStr2());
+ alSeq2.setStart(s2.getStart() + getSeq2Start() - 1);
+ alSeq2.setEnd(s2.getStart() + getSeq2End() - 1);
+ alSeq2.setDatasetSequence(s2.getDatasetSequence() == null ? s2 : s2
+ .getDatasetSequence());
+ return alSeq2;
+ }
+
+ /**
* Construct score matrix for sequences with standard DNA or PEPTIDE matrix
- * @param s1 - sequence 1
- * @param string1 - string to use for s1
- * @param s2 - sequence 2
- * @param string2 - string to use for s2
+ *
+ * @param s1
+ * - sequence 1
+ * @param string1
+ * - string to use for s1
+ * @param s2
+ * - sequence 2
+ * @param string2
+ * - string to use for s2
* @param type
* DNA or PEPTIDE
*/
@@ -285,11 +333,17 @@ public class AlignSeq
/**
* Construct score matrix for sequences with custom substitution matrix
- * @param s1 - sequence 1
- * @param string1 - string to use for s1
- * @param s2 - sequence 2
- * @param string2 - string to use for s2
- * @param scoreMatrix - substitution matrix to use for alignment
+ *
+ * @param s1
+ * - sequence 1
+ * @param string1
+ * - string to use for s1
+ * @param s2
+ * - sequence 2
+ * @param string2
+ * - string to use for s2
+ * @param scoreMatrix
+ * - substitution matrix to use for alignment
*/
public void SeqInit(SequenceI s1, String string1, SequenceI s2,
String string2, ScoreMatrix scoreMatrix)
@@ -304,7 +358,7 @@ public class AlignSeq
* construct score matrix for string1 and string2 (after removing any existing
* gaps
*
- * @param string1
+ * @param string1
* @param string2
*/
private void SeqInit(String string1, String string2)
@@ -395,8 +449,7 @@ public class AlignSeq
else
{
output.append("Wrong type = dna or pep only");
- throw new Error("Unknown Type " + type2
- + " - dna or pep are the only allowed values.");
+ throw new Error(MessageManager.formatMessage("error.unknown_type_dna_or_pep", new String[]{type2}));
}
}
@@ -600,7 +653,7 @@ public class AlignSeq
output = output.append("\n\n");
}
- pid = pid / (float) (aseq1.length - count) * 100;
+ pid = pid / (aseq1.length - count) * 100;
output = output.append(new Format("Percentage ID = %2.2f\n\n")
.form(pid));
@@ -751,19 +804,23 @@ public class AlignSeq
}
/**
- * DOCUMENT ME!
+ * Returns the given sequence with all of the given gap characters removed.
*
- * @param gapChar
- * DOCUMENT ME!
+ * @param gapChars
+ * a string of characters to be treated as gaps
* @param seq
- * DOCUMENT ME!
+ * the input sequence
*
- * @return DOCUMENT ME!
+ * @return
*/
- public static String extractGaps(String gapChar, String seq)
+ public static String extractGaps(String gapChars, String seq)
{
- StringTokenizer str = new StringTokenizer(seq, gapChar);
- StringBuffer newString = new StringBuffer();
+ if (gapChars == null || seq == null)
+ {
+ return null;
+ }
+ StringTokenizer str = new StringTokenizer(seq, gapChars);
+ StringBuilder newString = new StringBuilder(seq.length());
while (str.hasMoreTokens())
{
@@ -967,26 +1024,29 @@ public class AlignSeq
if (allowmismatch || c1 == c2)
{
- lastmatch = true;
- // extend mapping interval.
- if (lp1 + 1 != alignpos)
+ // extend mapping interval
+ if (lp1 + 1 != alignpos || lp2 + 1 != pdbpos)
{
as1.add(Integer.valueOf(alignpos));
- lp1 = alignpos;
- }
-
- if (lp2 + 1 != pdbpos)
- {
as2.add(Integer.valueOf(pdbpos));
- lp2 = pdbpos;
}
+ lastmatch = true;
+ lp1 = alignpos;
+ lp2 = pdbpos;
}
else
{
+ // extend mapping interval
+ if (lastmatch)
+ {
+ as1.add(Integer.valueOf(lp1));
+ as2.add(Integer.valueOf(lp2));
+ }
lastmatch = false;
}
}
// construct range pairs
+
int[] mapseq1 = new int[as1.size() + (lastmatch ? 1 : 0)], mapseq2 = new int[as2
.size() + (lastmatch ? 1 : 0)];
int i = 0;
@@ -1014,6 +1074,101 @@ public class AlignSeq
}
/**
+ * matches ochains against al and populates seqs with the best match between
+ * each ochain and the set in al
+ *
+ * @param ochains
+ * @param al
+ * @param dnaOrProtein
+ * @param removeOldAnnots
+ * when true, old annotation is cleared before new annotation
+ * transferred
+ * @return List originals, List replacement,
+ * List alignment between each>
+ */
+ public static List> replaceMatchingSeqsWith(
+ List seqs, List annotations,
+ List ochains,
+ AlignmentI al, String dnaOrProtein, boolean removeOldAnnots)
+ {
+ List orig = new ArrayList(), repl = new ArrayList();
+ List aligs = new ArrayList();
+ if (al != null && al.getHeight() > 0)
+ {
+ ArrayList matches = new ArrayList();
+ ArrayList aligns = new ArrayList();
+
+ for (SequenceI sq : ochains)
+ {
+ SequenceI bestm = null;
+ AlignSeq bestaseq = null;
+ int bestscore = 0;
+ for (SequenceI msq : al.getSequences())
+ {
+ AlignSeq aseq = doGlobalNWAlignment(msq, sq,
+ dnaOrProtein);
+ if (bestm == null || aseq.getMaxScore() > bestscore)
+ {
+ bestscore = aseq.getMaxScore();
+ bestaseq = aseq;
+ bestm = msq;
+ }
+ }
+ System.out.println("Best Score for " + (matches.size() + 1) + " :"
+ + bestscore);
+ matches.add(bestm);
+ aligns.add(bestaseq);
+ al.deleteSequence(bestm);
+ }
+ for (int p = 0, pSize = seqs.size(); p < pSize; p++)
+ {
+ SequenceI sq, sp = seqs.get(p);
+ int q;
+ if ((q = ochains.indexOf(sp)) > -1)
+ {
+ seqs.set(p, sq = matches.get(q));
+ orig.add(sp);
+ repl.add(sq);
+ sq.setName(sp.getName());
+ sq.setDescription(sp.getDescription());
+ Mapping sp2sq;
+ sq.transferAnnotation(sp, sp2sq = aligns.get(q).getMappingFromS1(false));
+ aligs.add(aligns.get(q));
+ int inspos = -1;
+ for (int ap = 0; ap < annotations.size();)
+ {
+ if (annotations.get(ap).sequenceRef == sp)
+ {
+ if (inspos == -1)
+ {
+ inspos = ap;
+ }
+ if (removeOldAnnots) {
+ annotations.remove(ap);
+ } else {
+ AlignmentAnnotation alan = annotations.remove(ap);
+ alan.liftOver(sq, sp2sq);
+ alan.setSequenceRef(sq);
+ sq.addAlignmentAnnotation(alan);
+ }
+ }
+ else
+ {
+ ap++;
+ }
+ }
+ if (sq.getAnnotation() != null && sq.getAnnotation().length > 0)
+ {
+ annotations.addAll(inspos == -1 ? annotations.size() : inspos,
+ Arrays.asList(sq.getAnnotation()));
+ }
+ }
+ }
+ }
+ return Arrays.asList(orig, repl, aligs);
+ }
+
+ /**
* compute the PID vector used by the redundancy filter.
*
* @param originalSequences