X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAlignSeq.java;h=eacceb0bcc42b891dd16f600bd8706724ae68618;hb=ab43013b7e357b84b4abade0dba949668dfb2a0e;hp=b9119ed2187946080b4b2eef9dceeb7832915430;hpb=47168f025aefdaa044802bd5f8f510ffe43a4808;p=jalview.git

diff --git a/src/jalview/analysis/AlignSeq.java b/src/jalview/analysis/AlignSeq.java
index b9119ed..eacceb0 100755
--- a/src/jalview/analysis/AlignSeq.java
+++ b/src/jalview/analysis/AlignSeq.java
@@ -1,5 +1,5 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2b1)
  * Copyright (C) 2014 The Jalview Authors
  * 
  * This file is part of Jalview.
@@ -19,13 +19,25 @@
  * 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;
 
 /**
  * 
@@ -269,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
    */
@@ -288,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)
@@ -307,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)
@@ -398,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}));
     }
   }
 
@@ -603,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));
 
@@ -970,22 +1020,29 @@ public class AlignSeq
 
       if (allowmismatch || c1 == c2)
       {
-        lastmatch = true;
-        // extend mapping interval.
-        if (lp1 + 1 != alignpos || lp2+1 !=pdbpos)
+        // extend mapping interval
+        if (lp1 + 1 != alignpos || lp2 + 1 != pdbpos)
         {
           as1.add(Integer.valueOf(alignpos));
           as2.add(Integer.valueOf(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;
@@ -1013,6 +1070,100 @@ 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<List<SequenceI> originals, List<SequenceI> replacement,
+   *         List<AlignSeq> alignment between each>
+   */
+  public static List<List<? extends Object>> replaceMatchingSeqsWith(
+          List<SequenceI> seqs, List<AlignmentAnnotation> annotations,
+          List<SequenceI> ochains,
+          AlignmentI al, String dnaOrProtein, boolean removeOldAnnots)
+  {
+    List<SequenceI> orig = new ArrayList<SequenceI>(), repl = new ArrayList<SequenceI>();
+    List<AlignSeq> aligs = new ArrayList<AlignSeq>();
+    if (al != null && al.getHeight() > 0)
+    {
+      ArrayList<SequenceI> matches = new ArrayList<SequenceI>();
+      ArrayList<AlignSeq> aligns = new ArrayList<AlignSeq>();
+  
+      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, Arrays.asList(sq.getAnnotation()));
+          }
+        }
+      }
+    }
+    return Arrays.asList(orig, repl, aligs);
+  }
+
+  /**
    * compute the PID vector used by the redundancy filter.
    * 
    * @param originalSequences