X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignedCodonFrame.java;h=627f0a6a6ba112e3178ed909e80432ca8a551b10;hb=4d7f98a6dd54d9863ba449ec79dcd95d25ed863d;hp=48b334681ee70d2187747ac94e621e4f5d87dfe1;hpb=59d682209891099d46b960509907c79e3fb276fe;p=jalview.git

diff --git a/src/jalview/datamodel/AlignedCodonFrame.java b/src/jalview/datamodel/AlignedCodonFrame.java
index 48b3346..627f0a6 100644
--- a/src/jalview/datamodel/AlignedCodonFrame.java
+++ b/src/jalview/datamodel/AlignedCodonFrame.java
@@ -1,149 +1,59 @@
 /*
- * 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 <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
  */
 package jalview.datamodel;
 
-import java.util.Enumeration;
-import java.util.Vector;
-
 import jalview.util.MapList;
+import jalview.util.MappingUtils;
+
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Stores mapping between the columns of a protein alignment and a DNA alignment
  * and a list of individual codon to amino acid mappings between sequences.
  */
-
 public class AlignedCodonFrame
 {
-  /**
-   * array of nucleotide positions for aligned codons at column of aligned
-   * proteins.
-   */
-  public int[][] codons = null;
-
-  /**
-   * width of protein sequence alignement implicit assertion that codons.length
-   * >= aaWidth
-   */
-  public int aaWidth = 0;
-
-  /**
-   * initialise codon frame with a nominal alignment width
-   * 
-   * @param aWidth
-   */
-  public AlignedCodonFrame(int aWidth)
-  {
-    if (aWidth <= 0)
-    {
-      codons = null;
-      return;
-    }
-    codons = new int[aWidth][];
-    for (int res = 0; res < aWidth; res++)
-      codons[res] = null;
-  }
-
-  /**
-   * ensure that codons array is at least as wide as aslen residues
-   * 
-   * @param aslen
-   * @return (possibly newly expanded) codon array
-   */
-  public int[][] checkCodonFrameWidth(int aslen)
-  {
-    if (codons.length <= aslen + 1)
-    {
-      // probably never have to do this ?
-      int[][] c = new int[codons.length + 10][];
-      for (int i = 0; i < codons.length; i++)
-      {
-        c[i] = codons[i];
-        codons[i] = null;
-      }
-      codons = c;
-    }
-    return codons;
-  }
 
   /**
-   * @return width of aligned translated amino acid residues
+   * tied array of na Sequence objects.
    */
-  public int getaaWidth()
-  {
-    return aaWidth;
-  }
+  private SequenceI[] dnaSeqs = null;
 
   /**
-   * TODO: not an ideal solution - we reference the aligned amino acid sequences
-   * in order to make insertions on them Better would be dnaAlignment and
-   * aaAlignment reference....
+   * tied array of Mappings to protein sequence Objects and SequenceI[]
+   * aaSeqs=null; MapLists where each maps from the corresponding dnaSeqs
+   * element to corresponding aaSeqs element
    */
-  Vector a_aaSeqs = new Vector();
+  private Mapping[] dnaToProt = null;
 
   /**
-   * increase aaWidth by one and insert a new aligned codon position space at
-   * aspos.
-   * 
-   * @param aspos
+   * Constructor
    */
-  public void insertAAGap(int aspos, char gapCharacter)
-  {
-    // this aa appears before the aligned codons at aspos - so shift them in
-    // each pair of mapped sequences
-    aaWidth++;
-    if (a_aaSeqs != null)
-    {
-      // we actually have to modify the aligned sequences here, so use the
-      // a_aaSeqs vector
-      Enumeration sq = a_aaSeqs.elements();
-      while (sq.hasMoreElements())
-      {
-        ((SequenceI) sq.nextElement()).insertCharAt(aspos, gapCharacter);
-      }
-    }
-    checkCodonFrameWidth(aspos);
-    if (aspos < aaWidth)
-    {
-      aaWidth++;
-      System.arraycopy(codons, aspos, codons, aspos + 1, aaWidth - aspos);
-      codons[aspos] = null; // clear so new codon position can be marked.
-    }
-  }
-
-  public void setAaWidth(int aapos)
+  public AlignedCodonFrame()
   {
-    aaWidth = aapos;
   }
 
   /**
-   * tied array of na Sequence objects.
-   */
-  SequenceI[] dnaSeqs = null;
-
-  /**
-   * tied array of Mappings to protein sequence Objects and SequenceI[]
-   * aaSeqs=null; MapLists where eac maps from the corresponding dnaSeqs element
-   * to corresponding aaSeqs element
-   */
-  Mapping[] dnaToProt = null;
-
-  /**
-   * add a mapping between the dataset sequences for the associated dna and
+   * Adds a mapping between the dataset sequences for the associated dna and
    * protein sequence objects
    * 
    * @param dnaseq
@@ -175,7 +85,6 @@ public class AlignedCodonFrame
     // aaseq.transferAnnotation(dnaseq, new Mapping(map.getInverse()));
     mp.to = (aaseq.getDatasetSequence() == null) ? aaseq : aaseq
             .getDatasetSequence();
-    a_aaSeqs.addElement(aaseq);
     dnaToProt[nlen] = mp;
   }
 
@@ -187,7 +96,9 @@ public class AlignedCodonFrame
   public SequenceI[] getAaSeqs()
   {
     if (dnaToProt == null)
+    {
       return null;
+    }
     SequenceI[] sqs = new SequenceI[dnaToProt.length];
     for (int sz = 0; sz < dnaToProt.length; sz++)
     {
@@ -199,7 +110,9 @@ public class AlignedCodonFrame
   public MapList[] getdnaToProt()
   {
     if (dnaToProt == null)
+    {
       return null;
+    }
     MapList[] sqs = new MapList[dnaToProt.length];
     for (int sz = 0; sz < dnaToProt.length; sz++)
     {
@@ -214,9 +127,37 @@ public class AlignedCodonFrame
   }
 
   /**
+   * Returns the first mapping found which is to or from the given sequence, or
+   * null.
+   * 
+   * @param seq
+   * @return
+   */
+  public Mapping getMappingForSequence(SequenceI seq)
+  {
+    if (dnaSeqs == null)
+    {
+      return null;
+    }
+    SequenceI seqDs = seq.getDatasetSequence();
+    seqDs = seqDs != null ? seqDs : seq;
+
+    for (int ds = 0; ds < dnaSeqs.length; ds++)
+    {
+      if (dnaSeqs[ds] == seqDs || dnaToProt[ds].to == seqDs)
+      {
+        return dnaToProt[ds];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the corresponding aligned or dataset aa sequence for given dna
+   * sequence, null if not found.
    * 
    * @param sequenceRef
-   * @return null or corresponding aaSeq entry for dnaSeq entry
+   * @return
    */
   public SequenceI getAaForDnaSeq(SequenceI dnaSeqRef)
   {
@@ -228,7 +169,9 @@ public class AlignedCodonFrame
     for (int ds = 0; ds < dnaSeqs.length; ds++)
     {
       if (dnaSeqs[ds] == dnaSeqRef || dnaSeqs[ds] == dnads)
+      {
         return dnaToProt[ds].to;
+      }
     }
     return null;
   }
@@ -248,7 +191,9 @@ public class AlignedCodonFrame
     for (int as = 0; as < dnaToProt.length; as++)
     {
       if (dnaToProt[as].to == aaSeqRef || dnaToProt[as].to == aads)
+      {
         return dnaSeqs[as];
+      }
     }
     return null;
   }
@@ -315,4 +260,203 @@ public class AlignedCodonFrame
       }
     }
   }
+
+  /**
+   * Returns the DNA codon positions (base 1) for the given position (base 1) in
+   * a mapped protein sequence, or null if no mapping is found.
+   * 
+   * Intended for use in aligning cDNA to match aligned protein. Only the first
+   * mapping found is returned, so not suitable for use if multiple protein
+   * sequences are mapped to the same cDNA (but aligning cDNA as protein is
+   * ill-defined for this case anyway).
+   * 
+   * @param seq
+   *          the DNA dataset sequence
+   * @param aaPos
+   *          residue position (base 1) in a protein sequence
+   * @return
+   */
+  public int[] getDnaPosition(SequenceI seq, int aaPos)
+  {
+    /*
+     * Adapted from markMappedRegion().
+     */
+    MapList ml = null;
+    for (int i = 0; i < dnaToProt.length; i++)
+    {
+      if (dnaSeqs[i] == seq)
+      {
+        ml = getdnaToProt()[i];
+        break;
+      }
+    }
+    return ml == null ? null : ml.locateInFrom(aaPos, aaPos);
+  }
+
+  /**
+   * Convenience method to return the first aligned sequence in the given
+   * alignment whose dataset has a mapping with the given dataset sequence.
+   * 
+   * @param seq
+   * 
+   * @param al
+   * @return
+   */
+  public SequenceI findAlignedSequence(SequenceI seq, AlignmentI al)
+  {
+    /*
+     * Search mapped protein ('to') sequences first.
+     */
+    if (this.dnaToProt != null)
+    {
+      for (int i = 0; i < dnaToProt.length; i++)
+      {
+        if (this.dnaSeqs[i] == seq)
+        {
+          for (SequenceI sourceAligned : al.getSequences())
+          {
+            if (this.dnaToProt[i].to == sourceAligned.getDatasetSequence())
+            {
+              return sourceAligned;
+            }
+          }
+        }
+      }
+    }
+
+    /*
+     * Then try mapped dna sequences.
+     */
+    if (this.dnaToProt != null)
+    {
+      for (int i = 0; i < dnaToProt.length; i++)
+      {
+        if (this.dnaToProt[i].to == seq)
+        {
+          for (SequenceI sourceAligned : al.getSequences())
+          {
+            if (this.dnaSeqs[i] == sourceAligned.getDatasetSequence())
+            {
+              return sourceAligned;
+            }
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Returns the region in the 'mappedFrom' sequence's dataset that is mapped to
+   * position 'pos' (base 1) in the 'mappedTo' sequence's dataset. The region is
+   * a set of start/end position pairs.
+   * 
+   * @param mappedFrom
+   * @param mappedTo
+   * @param pos
+   * @return
+   */
+  public int[] getMappedRegion(SequenceI mappedFrom, SequenceI mappedTo,
+          int pos)
+  {
+    SequenceI targetDs = mappedFrom.getDatasetSequence() == null ? mappedFrom
+            : mappedFrom.getDatasetSequence();
+    SequenceI sourceDs = mappedTo.getDatasetSequence() == null ? mappedTo
+            : mappedTo.getDatasetSequence();
+    if (targetDs == null || sourceDs == null || dnaToProt == null)
+    {
+      return null;
+    }
+    for (int mi = 0; mi < dnaToProt.length; mi++)
+    {
+      if (dnaSeqs[mi] == targetDs && dnaToProt[mi].to == sourceDs)
+      {
+        int[] codon = dnaToProt[mi].map.locateInFrom(pos, pos);
+        if (codon != null)
+        {
+          return codon;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Returns the DNA codon for the given position (base 1) in a mapped protein
+   * sequence, or null if no mapping is found.
+   * 
+   * @param protein
+   *          the peptide dataset sequence
+   * @param aaPos
+   *          residue position (base 1) in the peptide sequence
+   * @return
+   */
+  public char[] getMappedCodon(SequenceI protein, int aaPos)
+  {
+    if (dnaToProt == null)
+    {
+      return null;
+    }
+    MapList ml = null;
+    char[] dnaSeq = null;
+    for (int i = 0; i < dnaToProt.length; i++)
+    {
+      if (dnaToProt[i].to == protein)
+      {
+        ml = getdnaToProt()[i];
+        dnaSeq = dnaSeqs[i].getSequence();
+        break;
+      }
+    }
+    if (ml == null)
+    {
+      return null;
+    }
+    int[] codonPos = ml.locateInFrom(aaPos, aaPos);
+    if (codonPos == null)
+    {
+      return null;
+    }
+
+    /*
+     * Read off the mapped nucleotides (converting to position base 0)
+     */
+    codonPos = MappingUtils.flattenRanges(codonPos);
+    return new char[] { dnaSeq[codonPos[0] - 1], dnaSeq[codonPos[1] - 1],
+        dnaSeq[codonPos[2] - 1] };
+  }
+
+  /**
+   * Returns any mappings found which are to (or from) the given sequence, and
+   * to distinct sequences.
+   * 
+   * @param seq
+   * @return
+   */
+  public List<Mapping> getMappingsForSequence(SequenceI seq)
+  {
+    List<Mapping> result = new ArrayList<Mapping>();
+    if (dnaSeqs == null)
+    {
+      return result;
+    }
+    List<SequenceI> related = new ArrayList<SequenceI>();
+    SequenceI seqDs = seq.getDatasetSequence();
+    seqDs = seqDs != null ? seqDs : seq;
+
+    for (int ds = 0; ds < dnaSeqs.length; ds++)
+    {
+      final Mapping mapping = dnaToProt[ds];
+      if (dnaSeqs[ds] == seqDs || mapping.to == seqDs)
+      {
+        if (!related.contains(mapping.to))
+        {
+          result.add(mapping);
+          related.add(mapping.to);
+        }
+      }
+    }
+    return result;
+  }
 }