X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FColumnSelection.java;h=d0fc9277f5c5bbda923b5b7f0acc4d695c5f11de;hb=797df64fa2a0a30773d0f48f5494d4155e5a8be3;hp=4371994e0d3593a5594b07d2bd89e86895aee9a9;hpb=d423f22792e47dbc800ae220a58677f988971d06;p=jalview.git

diff --git a/src/jalview/datamodel/ColumnSelection.java b/src/jalview/datamodel/ColumnSelection.java
index 4371994..d0fc927 100644
--- a/src/jalview/datamodel/ColumnSelection.java
+++ b/src/jalview/datamodel/ColumnSelection.java
@@ -1,6 +1,6 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.5)
- * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
+ * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
  * 
  * This file is part of Jalview.
  * 
@@ -508,8 +508,9 @@ public class ColumnSelection
   }
 
   /**
-   * Use this method to find out where a visible column is in the alignment when
-   * hidden columns exist
+   * Use this method to find out where a column will appear in the visible
+   * alignment when hidden columns exist. If the column is not visible, then the
+   * left-most visible column will always be returned.
    * 
    * @param hiddenColumn
    *          int
@@ -521,21 +522,21 @@ public class ColumnSelection
     if (hiddenColumns != null)
     {
       int index = 0;
-      int gaps = 0;
+      int[] region;
       do
       {
-        int[] region = (int[]) hiddenColumns.elementAt(index);
+        region = (int[]) hiddenColumns.elementAt(index++);
         if (hiddenColumn > region[1])
         {
           result -= region[1] + 1 - region[0];
         }
-        index++;
-      } while (index < hiddenColumns.size());
-
-      result -= gaps;
+      } while ((hiddenColumn > region[1]) && (index < hiddenColumns.size()));
+      if (hiddenColumn > region[0] && hiddenColumn < region[1])
+      {
+        return region[0] + hiddenColumn - result;
+      }
     }
-
-    return result;
+    return result; // return the shifted position after removing hidden columns.
   }
 
   /**
@@ -1111,4 +1112,134 @@ public class ColumnSelection
       }
     }
   }
+
+  /**
+   * Add gaps into the sequences aligned to profileseq under the given
+   * AlignmentView
+   * 
+   * @param profileseq
+   * @param al - alignment to have gaps inserted into it
+   * @param input - alignment view where sequence corresponding to profileseq is first entry
+   * @return new Column selection for new alignment view, with insertions into profileseq marked as hidden.
+   */
+  public static ColumnSelection propagateInsertions(SequenceI profileseq,
+          Alignment al, AlignmentView input)
+  {
+    int profsqpos=0;
+    
+//    return propagateInsertions(profileseq, al, )
+    char gc = al.getGapCharacter();
+    Object[] alandcolsel = input.getAlignmentAndColumnSelection(gc);
+    ColumnSelection nview = (ColumnSelection) alandcolsel[1];
+    SequenceI origseq = ((SequenceI[]) alandcolsel[0])[profsqpos];
+    nview.propagateInsertions(profileseq,
+            al, origseq);
+    return nview;
+  }
+  /**
+   * 
+   * @param profileseq - sequence in al which corresponds to origseq 
+   * @param al - alignment which is to have gaps inserted into it
+   * @param origseq - sequence corresponding to profileseq which defines gap map for modifying al
+   */
+  public void propagateInsertions(SequenceI profileseq, AlignmentI al, SequenceI origseq)
+  {
+    char gc = al.getGapCharacter();
+    // recover mapping between sequence's non-gap positions and positions 
+    // mapping to view.
+    pruneDeletions(ShiftList
+            .parseMap(origseq
+                    .gapMap())); 
+    int[] viscontigs = getVisibleContigs(0, profileseq.getLength());
+    int spos = 0;
+    int offset = 0;
+    // input.pruneDeletions(ShiftList.parseMap(((SequenceI[])
+    // alandcolsel[0])[0].gapMap()))
+    // add profile to visible contigs
+    for (int v = 0; v < viscontigs.length; v += 2)
+    {
+      if (viscontigs[v] > spos)
+      {
+        StringBuffer sb = new StringBuffer();
+        for (int s = 0, ns = viscontigs[v] - spos; s < ns; s++)
+        {
+          sb.append(gc);
+        }
+        for (int s = 0, ns = al.getHeight(); s < ns; s++)
+        {
+          SequenceI sqobj = al.getSequenceAt(s);
+          if (sqobj != profileseq)
+          {
+            String sq = al.getSequenceAt(s).getSequenceAsString();
+            if (sq.length() <= spos + offset)
+            {
+              // pad sequence
+              int diff = spos + offset - sq.length() - 1;
+              if (diff > 0)
+              {
+                // pad gaps
+                sq = sq + sb;
+                while ((diff = spos + offset - sq.length() - 1) > 0)
+                {
+                  //sq = sq
+                  //        + ((diff >= sb.length()) ? sb.toString() : sb
+                  //                .substring(0, diff));
+                  if (diff>=sb.length()) {
+                    sq+=sb.toString();
+                  } else {
+                    char[] buf = new char[diff];
+                    sb.getChars(0, diff, buf, 0);
+                    sq+=buf.toString();
+                  }
+                }
+              }
+              sq += sb.toString();
+            }
+            else
+            {
+              al.getSequenceAt(s).setSequence(
+                      sq.substring(0, spos + offset) + sb.toString()
+                              + sq.substring(spos + offset));
+            }
+          }
+        }
+        // offset+=sb.length();
+      }
+      spos = viscontigs[v + 1] + 1;
+    }
+    if ((offset + spos) < profileseq.getLength())
+    {
+      // pad the final region with gaps.
+      StringBuffer sb = new StringBuffer();
+      for (int s = 0, ns = profileseq.getLength() - spos - offset; s < ns; s++)
+      {
+        sb.append(gc);
+      }
+      for (int s = 0, ns = al.getHeight(); s < ns; s++)
+      {
+        SequenceI sqobj = al.getSequenceAt(s);
+        if (sqobj==profileseq)
+        {
+          continue;
+        }
+        String sq = sqobj.getSequenceAsString();
+        // pad sequence
+        int diff = origseq.getLength() - sq.length();
+        while (diff > 0)
+        {
+          //sq = sq
+          //        + ((diff >= sb.length()) ? sb.toString() : sb
+          //                .substring(0, diff));
+          if (diff>=sb.length()) {
+            sq+=sb.toString();
+          } else {
+            char[] buf = new char[diff];
+            sb.getChars(0, diff, buf, 0);
+            sq+=buf.toString();
+          }
+          diff = origseq.getLength() - sq.length();
+        }
+      }
+    }
+  }
 }