X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FCigarArray.java;h=78d34edd07f0435c43ce9b1f541c0678ec35d5eb;hb=a45774ee31d9f35d4eff46d54d7deab719afb092;hp=8961425031ee64d06dfc87116c4b0234f95f1798;hpb=7570956d4b58f313d402cdd0507737c0628f1544;p=jalview.git

diff --git a/src/jalview/datamodel/CigarArray.java b/src/jalview/datamodel/CigarArray.java
index 8961425..78d34ed 100644
--- a/src/jalview/datamodel/CigarArray.java
+++ b/src/jalview/datamodel/CigarArray.java
@@ -1,174 +1,379 @@
-package jalview.datamodel;
-
-public class CigarArray extends CigarBase
-{
-    /**
-     * Do CIGAR operations on a set of sequences from many other cigars
-     * BAD THINGS WILL HAPPEN IF A CIGARARRAY IS PASSED TO A CIGARARRAY
-     * or a CIGARCIGAR is given a CIGARARRAY to insert gaps into.
-     */
-    /**
-     * array of subject cigars
-     */
-    public CigarSimple refCigars[]=null;
-    private boolean seqcigararray=false;
-  private CigarArray() {
-    super();
-  }
-
-  /**
-   * isSeqCigarArray()
-   * @return boolean true if all refCigars resolve to a SeqCigar or a CigarCigar
-   */
-  public boolean isSeqCigarArray()
-  {
-    return seqcigararray;
-  }
-  /**
-   * Apply CIGAR operations to several cigars in parallel
-   * will throw an error if any of cigar are actually CigarArrays.
-   * @param cigar Cigar[]
-   */
-  public CigarArray(CigarSimple[] cigars) {
-    super();
-    seqcigararray = true;
-    if (cigars != null && cigars.length > 0)
-    {
-      refCigars = new CigarSimple[cigars.length];
-      for (int c = 0; c < cigars.length; c++)
-      {
-        refCigars[c] = cigars[c];
-        if (! ( (cigars[c] instanceof SeqCigar)
-               || cigars[c] instanceof CigarCigar))
-        {
-          seqcigararray = false;
-        }
-      }
-    }
-  }
-  /**
-   * @see Cigar.getSequenceAndDeletions
-   * @param GapChar char
-   * @return Object[][]
-   */
-  protected Object[][] getArrayofSequenceAndDeletions(char GapChar) {
-      if (refCigars == null || refCigars.length == 0 || length == 0) {
-        return null;
-      }
-      Object[][] sqanddels = new Object[refCigars.length][];
-      for (int c=0; c<refCigars.length; c++) {
-        String refString = refCigars[c].getSequenceString(GapChar);
-        if (refString != null)
-        {
-          sqanddels[c] = getSequenceAndDeletions(refString, GapChar);
-        } else {
-          sqanddels[c] = null;
-        }
-      }
-      return sqanddels;
-    }
-  /**
-   * NOTE: this is an improper sequence string function
-   * @return String formed by newline concatenated results of applying CIGAR operations to each reference object in turn.
-   * @param GapChar char
-   * @return '\n' separated strings (empty results included as \n\n)
-   */
-  public String getSequenceString(char GapChar)
-  {
-    if (length==0 || refCigars==null)
-      return "";
-    StringBuffer seqStrings = new StringBuffer();
-    Object[][] sqanddels = getArrayofSequenceAndDeletions(GapChar);
-    for (int c=0; c<refCigars.length; c++) {
-      if (sqanddels[c]!=null) {
-        seqStrings.append( (String) sqanddels[c][0]);
-        sqanddels[c][0] = null;
-      }
-      seqStrings.append('\n');
-    }
-    return seqStrings.toString();
-  }
-  /**
-   * return string results of applying cigar string to all reference cigars
-   * @param GapChar char
-   * @return String[]
-   */
-  public String[] getSequenceStrings(char GapChar) {
-
-    if (length==0 || refCigars==null || refCigars.length==0)
-      return null;
-    Object[][] sqanddels = getArrayofSequenceAndDeletions(GapChar);
-    String[] seqs = new String[sqanddels.length];
-    for (int c=0; c<refCigars.length; c++) {
-      seqs[c] = (String) sqanddels[c][0];
-    }
-    return seqs;
-  }
-  /**
-   * Combines the CigarArray cigar operations with the operations in each
-   * reference cigar - creating a new reference cigar
-   * @return Cigar[]
-
-  public CigarBase[] getEditedCigars() {
-
-    return new CigarBase[] {};
-  }
-*/
-  /**
-   * applyDeletions
-   * edits underlying refCigars to propagate deleted regions, and removes deletion
-   * operations from CigarArray operation list.
-   * @return int[] position where deletion occured in cigarArray or null if none occured
-   */
-  public int[] applyDeletions()
-  {
-    java.util.Vector delpos=null;
-    if (length==0)
-      return null;
-    int cursor=0; // range counter for deletions
-    int vcursor=0; // visible column index
-    for (int i=0; i<length; i++) {
-      if (operation[i]!=D) {
-        if (operation[i]==M)
-          cursor+=range[i];
-        vcursor+=range[i];
-      }
-      else
-      {
-        if (delpos==null)
-          delpos=new java.util.Vector();
-        int delstart=cursor, delend=cursor+range[i]-1; // inclusive
-        delpos.add(new Integer(vcursor-1)); // index of left hand column of hidden region boundary
-        System.arraycopy(operation, i+1, operation, i, length-i);
-        System.arraycopy(range, i+1, range, i, length-i);
-        length--;
-        for (int s=0; s<refCigars.length; s++) {
-          refCigars[s].deleteRange(delstart, delend);
-        }
-      }
-    }
-    if (delpos!=null)
-    {
-      int[] pos=new int[delpos.size()];
-      for (int k = 0, l = delpos.size(); k < l; k++) {
-        pos[k] = ((Integer) delpos.get(k)).intValue();
-        delpos.set(k,null);
-      }
-      delpos=null;
-      return pos;
-    }
-    return null;
-  }
-  /**
-   *
-   * @return SeqCigar[] or null if CigarArray is not a SeqCigarArray (ie it does not resolve to set of seqCigars)
-   */
-  public SeqCigar[] getSeqCigarArray() {
-    if (!isSeqCigarArray())
-      return null;
-    SeqCigar[] sa = new SeqCigar[refCigars.length];
-    for (int i=0; i<refCigars.length; i++)
-      sa[i] = (SeqCigar) refCigars[i];
-    return sa;
-  }
-}
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
+ * Copyright (C) 2011 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
+ * 
+ * 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.
+ * 
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+package jalview.datamodel;
+
+import java.util.Vector;
+
+public class CigarArray extends CigarBase
+{
+  /**
+   * Do CIGAR operations on a set of sequences from many other cigars BAD THINGS
+   * WILL HAPPEN IF A CIGARARRAY IS PASSED TO A CIGARARRAY or a CIGARCIGAR is
+   * given a CIGARARRAY to insert gaps into.
+   */
+  /**
+   * array of subject cigars
+   */
+  public CigarSimple refCigars[] = null;
+
+  private boolean seqcigararray = false;
+
+  private CigarArray()
+  {
+    super();
+  }
+
+  /**
+   * isSeqCigarArray()
+   * 
+   * @return boolean true if all refCigars resolve to a SeqCigar or a CigarCigar
+   */
+  public boolean isSeqCigarArray()
+  {
+    return seqcigararray;
+  }
+
+  /**
+   * Apply CIGAR operations to several cigars in parallel will throw an error if
+   * any of cigar are actually CigarArrays.
+   * 
+   * @param cigar
+   *          Cigar[]
+   */
+  public CigarArray(CigarSimple[] cigars)
+  {
+    super();
+    seqcigararray = true;
+    if (cigars != null && cigars.length > 0)
+    {
+      refCigars = new CigarSimple[cigars.length];
+      for (int c = 0; c < cigars.length; c++)
+      {
+        refCigars[c] = cigars[c];
+        if (!((cigars[c] instanceof SeqCigar) || cigars[c] instanceof CigarCigar))
+        {
+          seqcigararray = false;
+        }
+      }
+    }
+  }
+
+  /**
+   * construct a cigar array from the current alignment, or just the subset of the current alignment specified by selectionGroup. Any columns marked as hidden in columnSelection will be marked as deleted in the array.
+   * @param alignment
+   * @param columnSelection 
+   * @param selectionGroup
+   */
+  public CigarArray(AlignmentI alignment, ColumnSelection columnSelection, SequenceGroup selectionGroup)
+  {
+    this(constructSeqCigarArray(alignment, selectionGroup));
+    constructFromAlignment(alignment, columnSelection!=null ? columnSelection.getHiddenColumns() : null, selectionGroup);
+  }
+  private static int[] _calcStartEndBounds(AlignmentI alignment, SequenceGroup selectionGroup)
+  {
+    int[] startend = new int[] { 0,0,0};
+    if (selectionGroup != null)
+    {
+      startend[0] = selectionGroup.getSize();
+      startend[1] = selectionGroup.getStartRes();
+      startend[2] = selectionGroup.getEndRes(); // inclusive for start and end in
+      // SeqCigar constructor
+    }
+    else
+    {
+      startend[0] = alignment.getHeight();
+      startend[2] = alignment.getWidth() - 1;
+    }
+    return startend;
+  }
+  public static SeqCigar[] constructSeqCigarArray(AlignmentI alignment, SequenceGroup selectionGroup)
+  {
+    SequenceI[] seqs = null;
+    int i, iSize;
+    int _startend[] = _calcStartEndBounds(alignment, selectionGroup);
+    int start = _startend[1],end=_startend[2];
+    if (selectionGroup != null)
+    {
+      iSize = selectionGroup.getSize();
+      seqs = selectionGroup.getSequencesInOrder(alignment);
+      start = selectionGroup.getStartRes();
+      end = selectionGroup.getEndRes(); // inclusive for start and end in
+      // SeqCigar constructor
+    }
+    else
+    {
+      iSize = alignment.getHeight();
+      seqs = alignment.getSequencesArray();
+      end = alignment.getWidth() - 1;
+    }
+    SeqCigar[] selseqs = new SeqCigar[iSize];
+    for (i = 0; i < iSize; i++)
+    {
+      selseqs[i] = new SeqCigar(seqs[i], start, end);
+    }
+    return selseqs;
+  }
+  /**
+   * internal constructor function - called by CigarArray(AlignmentI, ...);
+   * @param alignment
+   * @param columnSelection - vector of visible regions as returned from columnSelection.getHiddenColumns() 
+   * @param selectionGroup
+   */
+  private void constructFromAlignment(AlignmentI alignment, Vector columnSelection, SequenceGroup selectionGroup)
+  {
+    int[] _startend = _calcStartEndBounds(alignment, selectionGroup);
+    int start = _startend[1],end=_startend[2];
+    // now construct the CigarArray operations
+    if (columnSelection!=null)
+    {
+      int[] region;
+      int hideStart, hideEnd;
+      int last = start;
+      for (int j = 0; last < end & j < columnSelection.size(); j++)
+      {
+        region = (int[]) columnSelection.elementAt(j);
+        hideStart = region[0];
+        hideEnd = region[1];
+        // edit hidden regions to selection range
+        if (hideStart < last)
+        {
+          if (hideEnd > last)
+          {
+            hideStart = last;
+          }
+          else
+          {
+            continue;
+          }
+        }
+
+        if (hideStart > end)
+        {
+          break;
+        }
+
+        if (hideEnd > end)
+        {
+          hideEnd = end;
+        }
+
+        if (hideStart > hideEnd)
+        {
+          break;
+        }
+        /**
+         * form operations...
+         */
+        if (last < hideStart)
+        {
+          addOperation(CigarArray.M, hideStart - last);
+        }
+        addOperation(CigarArray.D, 1 + hideEnd - hideStart);
+        last = hideEnd + 1;
+      }
+      // Final match if necessary.
+      if (last < end)
+      {
+        addOperation(CigarArray.M, end - last + 1);
+      }
+    }
+    else
+    {
+      addOperation(CigarArray.M, end - start + 1);
+    }
+  }
+
+  /**
+   * @see Cigar.getSequenceAndDeletions
+   * @param GapChar
+   *          char
+   * @return Object[][]
+   */
+  protected Object[][] getArrayofSequenceAndDeletions(char GapChar)
+  {
+    if (refCigars == null || refCigars.length == 0 || length == 0)
+    {
+      return null;
+    }
+    Object[][] sqanddels = new Object[refCigars.length][];
+    for (int c = 0; c < refCigars.length; c++)
+    {
+      String refString = refCigars[c].getSequenceString(GapChar);
+      if (refString != null)
+      {
+        sqanddels[c] = getSequenceAndDeletions(refString, GapChar);
+      }
+      else
+      {
+        sqanddels[c] = null;
+      }
+    }
+    return sqanddels;
+  }
+
+  /**
+   * NOTE: this is an improper sequence string function
+   * 
+   * @return String formed by newline concatenated results of applying CIGAR
+   *         operations to each reference object in turn.
+   * @param GapChar
+   *          char
+   * @return '\n' separated strings (empty results included as \n\n)
+   */
+  public String getSequenceString(char GapChar)
+  {
+    if (length == 0 || refCigars == null)
+    {
+      return "";
+    }
+    StringBuffer seqStrings = new StringBuffer();
+    Object[][] sqanddels = getArrayofSequenceAndDeletions(GapChar);
+    for (int c = 0; c < refCigars.length; c++)
+    {
+      if (sqanddels[c] != null)
+      {
+        seqStrings.append((String) sqanddels[c][0]);
+        sqanddels[c][0] = null;
+      }
+      seqStrings.append('\n');
+    }
+    return seqStrings.toString();
+  }
+
+  /**
+   * return string results of applying cigar string to all reference cigars
+   * 
+   * @param GapChar
+   *          char
+   * @return String[]
+   */
+  public String[] getSequenceStrings(char GapChar)
+  {
+
+    if (length == 0 || refCigars == null || refCigars.length == 0)
+    {
+      return null;
+    }
+    Object[][] sqanddels = getArrayofSequenceAndDeletions(GapChar);
+    String[] seqs = new String[sqanddels.length];
+    for (int c = 0; c < refCigars.length; c++)
+    {
+      seqs[c] = (String) sqanddels[c][0];
+    }
+    return seqs;
+  }
+
+  /**
+   * Combines the CigarArray cigar operations with the operations in each
+   * reference cigar - creating a new reference cigar
+   * 
+   * @return Cigar[]
+   * 
+   *         public CigarBase[] getEditedCigars() {
+   * 
+   *         return new CigarBase[] {}; }
+   */
+  /**
+   * applyDeletions edits underlying refCigars to propagate deleted regions, and
+   * removes deletion operations from CigarArray operation list.
+   * 
+   * @return int[] position after deletion occured and range of deletion in
+   *         cigarArray or null if none occured
+   */
+  public int[] applyDeletions()
+  {
+    java.util.Vector delpos = null;
+    if (length == 0)
+    {
+      return null;
+    }
+    int cursor = 0; // range counter for deletions
+    int vcursor = 0; // visible column index
+    int offset = 0; // shift in visible column index as deletions are made
+    int i = 0;
+    while (i < length)
+    {
+      if (operation[i] != D)
+      {
+        if (operation[i] == M)
+        {
+          cursor += range[i];
+        }
+        vcursor += range[i++];
+      }
+      else
+      {
+        if (delpos == null)
+        {
+          delpos = new java.util.Vector();
+        }
+        int delstart = cursor, delend = cursor + range[i] - 1; // inclusive
+        delpos.addElement(new int[]
+        { vcursor + offset, range[i] }); // index of right hand column after
+        // hidden region boundary
+        offset += range[i] - 1; // shift in visible column coordinates
+        System.arraycopy(operation, i + 1, operation, i, length - i);
+        System.arraycopy(range, i + 1, range, i, length - i);
+        length--;
+        /*
+         * int dmax=0; for (int s=0; s<refCigars.length; s++) { int d =
+         * refCigars[s].deleteRange(delstart, delend); if (d>dmax) dmax=d; }
+         * offset+=dmax; // shift in visible column coordinates
+         */
+        for (int s = 0; s < refCigars.length; s++)
+        {
+          int d = refCigars[s].deleteRange(delstart, delend);
+        }
+
+      }
+    }
+    if (delpos != null)
+    {
+      int[] pos = new int[delpos.size() * 2];
+      for (int k = 0, l = delpos.size(); k < l; k++)
+      {
+        int[] dr = ((int[]) delpos.elementAt(k));
+        pos[k * 2] = dr[0];
+        pos[k * 2 + 1] = dr[1];
+        delpos.setElementAt(null, k);
+      }
+      delpos = null;
+      return pos;
+    }
+    return null;
+  }
+
+  /**
+   * 
+   * @return SeqCigar[] or null if CigarArray is not a SeqCigarArray (ie it does
+   *         not resolve to set of seqCigars)
+   */
+  public SeqCigar[] getSeqCigarArray()
+  {
+    if (!isSeqCigarArray())
+    {
+      return null;
+    }
+    SeqCigar[] sa = new SeqCigar[refCigars.length];
+    for (int i = 0; i < refCigars.length; i++)
+    {
+      sa[i] = (SeqCigar) refCigars[i];
+    }
+    return sa;
+  }
+}