X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fappletgui%2FAlignViewport.java;h=5eb5e468db783321f31f20ac0e477474511fd3dc;hb=32a72d077d2371f4566688fbd103103d8505b27f;hp=998a4a43055e7d9a2ca010d44859f126217aeb01;hpb=d69ea8f1997771890b44e4b332a7ca84fe6f0893;p=jalview.git

diff --git a/src/jalview/appletgui/AlignViewport.java b/src/jalview/appletgui/AlignViewport.java
index 998a4a4..5eb5e46 100755
--- a/src/jalview/appletgui/AlignViewport.java
+++ b/src/jalview/appletgui/AlignViewport.java
@@ -102,8 +102,15 @@ public class AlignViewport
 
   jalview.bin.JalviewLite applet;
 
+  Hashtable sequenceColours;
+
   boolean MAC = false;
 
+  Stack historyList = new Stack();
+  Stack redoList = new Stack();
+
+  String sequenceSetID;
+
   public AlignViewport(AlignmentI al, JalviewLite applet)
   {
     this.applet = applet;
@@ -157,11 +164,6 @@ public class AlignViewport
       }
 
     }
-    // We must set conservation and consensus before setting colour,
-    // as Blosum and Clustal require this to be done
-    updateConservation();
-    updateConsensus();
-
 
     if (applet != null)
     {
@@ -189,7 +191,48 @@ public class AlignViewport
             applet.getParameter("userDefinedColour"));
       }
 
+      if(hconsensus==null)
+      {
+        if(!alignment.isNucleotide())
+        {
+          conservation = new AlignmentAnnotation("Conservation",
+              "Conservation of total alignment less than " +
+              ConsPercGaps + "% gaps",
+              new Annotation[1], 0f,
+              11f,
+              AlignmentAnnotation.BAR_GRAPH);
+          conservation.hasText = true;
+
+
+          if (showConservation)
+          {
+            alignment.addAnnotation(conservation);
+          }
+
+          if (showQuality)
+          {
+            quality = new AlignmentAnnotation("Quality",
+                                              "Alignment Quality based on Blosum62 scores",
+                                              new Annotation[1],
+                                              0f,
+                                              11f,
+                                              AlignmentAnnotation.BAR_GRAPH);
+            quality.hasText = true;
+
+            alignment.addAnnotation(quality);
+          }
+        }
 
+        consensus = new AlignmentAnnotation("Consensus", "PID",
+                                             new Annotation[1], 0f, 100f,
+                                             AlignmentAnnotation.BAR_GRAPH);
+        consensus.hasText = true;
+
+         if (showConsensus)
+         {
+           alignment.addAnnotation(consensus);
+         }
+      }
     }
   }
 
@@ -204,159 +247,271 @@ public class AlignViewport
   }
 
 
-  public void updateConservation()
+  class ConservationThread extends Thread
   {
-    if(alignment.isNucleotide())
-          return;
+    AlignmentPanel ap;
+    public ConservationThread(AlignmentPanel ap)
+    {
+      this.ap = ap;
+    }
 
-    Conservation cons = new jalview.analysis.Conservation("All",
-        jalview.schemes.ResidueProperties.propHash, 3,
-        alignment.getSequences(), 0,
-        alignment.getWidth() - 1);
-    cons.calculate();
-    cons.verdict(false, ConsPercGaps);
-    cons.findQuality();
-    int alWidth = alignment.getWidth();
-    Annotation[] annotations = new Annotation[alWidth];
-    Annotation[] qannotations = new Annotation[alWidth];
-    String sequence = cons.getConsSequence().getSequence();
-    float minR, minG, minB, maxR, maxG, maxB;
-    minR = 0.3f;
-    minG = 0.0f;
-    minB = 0f;
-    maxR = 1.0f - minR;
-    maxG = 0.9f - minG;
-    maxB = 0f - minB; // scalable range for colouring both Conservation and Quality
-    float min = 0f;
-    float max = 11f;
-    float qmin = cons.qualityRange[0].floatValue();
-    float qmax = cons.qualityRange[1].floatValue();
-
-    for (int i = 0; i < alWidth; i++)
+    public void run()
     {
-      float value = 0;
       try
       {
-        value = Integer.parseInt(sequence.charAt(i) + "");
-      }
-      catch (Exception ex)
-      {
-        if (sequence.charAt(i) == '*')
+        updatingConservation = true;
+
+        while (UPDATING_CONSERVATION)
         {
-          value = 11;
+          try
+          {
+            if (ap != null)
+            {
+              ap.repaint();
+            }
+            Thread.sleep(200);
+          }
+          catch (Exception ex)
+          {
+            ex.printStackTrace();
+          }
         }
-        if (sequence.charAt(i) == '+')
+
+        UPDATING_CONSERVATION = true;
+
+
+        int alWidth = alignment.getWidth();
+        if(alWidth<0)
+          return;
+
+        Conservation cons = new jalview.analysis.Conservation("All",
+            jalview.schemes.ResidueProperties.propHash, 3,
+            alignment.getSequences(), 0, alWidth -1);
+
+        cons.calculate();
+        cons.verdict(false, ConsPercGaps);
+
+        if (quality!=null)
         {
-          value = 10;
+          cons.findQuality();
         }
-      }
-      float vprop = value - min;
-      vprop /= max;
-
-      annotations[i] = new Annotation(sequence.charAt(i) + "",
-                                      "", ' ', value,
-                                      new Color(minR + maxR * vprop,
-                                                minG + maxG * vprop,
-                                                minB + maxB * vprop));
-      // Quality calc
-      value = ( (Double) cons.quality.elementAt(i)).floatValue();
-      vprop = value - qmin;
-      vprop /= qmax;
-      qannotations[i] = new Annotation(" ",
-                                       String.valueOf(value), ' ', value,
-                                       new
-                                       Color(minR + maxR * vprop,
-                                             minG + maxG * vprop,
-                                             minB + maxB * vprop));
-    }
 
-    if (conservation == null)
-    {
-      conservation = new AlignmentAnnotation("Conservation",
-                                             "Conservation of total alignment less than " +
-                                             ConsPercGaps + "% gaps",
-                                             annotations,
-                                             0f, // cons.qualityRange[0].floatValue(),
-                                             11f, // cons.qualityRange[1].floatValue()
-                                             AlignmentAnnotation.BAR_GRAPH);
-      if (showConservation)
+        String sequence = cons.getConsSequence().getSequence();
+        float minR;
+        float minG;
+        float minB;
+        float maxR;
+        float maxG;
+        float maxB;
+        minR = 0.3f;
+        minG = 0.0f;
+        minB = 0f;
+        maxR = 1.0f - minR;
+        maxG = 0.9f - minG;
+        maxB = 0f - minB; // scalable range for colouring both Conservation and Quality
+
+        float min = 0f;
+        float max = 11f;
+        float qmin = 0f;
+        float qmax = 0f;
+
+        char c;
+
+        conservation.annotations = new Annotation[alWidth];
+
+        if (quality!=null)
+        {
+          quality.graphMax = cons.qualityRange[1].floatValue();
+          quality.annotations = new Annotation[alWidth];
+          qmin = cons.qualityRange[0].floatValue();
+          qmax = cons.qualityRange[1].floatValue();
+        }
+
+        for (int i = 0; i < alWidth; i++)
+        {
+          float value = 0;
+
+          c = sequence.charAt(i);
+
+          if (Character.isDigit(c))
+            value = (int) (c - '0');
+          else if (c == '*')
+            value = 11;
+          else if (c == '+')
+            value = 10;
+
+          float vprop = value - min;
+          vprop /= max;
+          conservation.annotations[i] =
+              new Annotation(String.valueOf(c),
+                             String.valueOf(value), ' ', value,
+                             new Color(minR + (maxR * vprop),
+                                       minG + (maxG * vprop),
+                                       minB + (maxB * vprop)));
+
+          // Quality calc
+          if (quality!=null)
+          {
+            value = ( (Double) cons.quality.elementAt(i)).floatValue();
+            vprop = value - qmin;
+            vprop /= qmax;
+            quality.annotations[i] = new Annotation(" ", String.valueOf(value), ' ',
+                                             value,
+                                             new Color(minR + (maxR * vprop),
+                minG + (maxG * vprop),
+                minB + (maxB * vprop)));
+          }
+        }
+      }
+      catch (OutOfMemoryError error)
       {
-        alignment.addAnnotation(conservation);
+        System.out.println("Out of memory calculating conservation!!");
+        conservation = null;
+        quality = null;
+        System.gc();
       }
-      quality = new AlignmentAnnotation("Quality",
-                                        "Alignment Quality based on Blosum62 scores",
-                                        qannotations,
-                                        cons.qualityRange[0].floatValue(),
-                                        cons.qualityRange[1].floatValue(),
-                                        AlignmentAnnotation.BAR_GRAPH);
-      if (showQuality)
+
+      UPDATING_CONSERVATION = false;
+      updatingConservation = false;
+
+      if(ap!=null)
       {
-        alignment.addAnnotation(quality);
+        ap.repaint();
       }
-    }
-    else
-    {
-      conservation.annotations = annotations;
-      quality.annotations = qannotations;
-      quality.graphMax = cons.qualityRange[1].floatValue();
-    }
 
+    }
   }
 
-  public void updateConsensus()
-  {
-    // this routine prevents vconsensus becoming a new object each time
-    // consenus is calculated. Important for speed of Blosum62
-    // and PID colouring of alignment
-    int aWidth = alignment.getWidth();
 
-    Annotation[] annotations = new Annotation[aWidth];
+  ConservationThread conservationThread;
 
-    hconsensus = new Hashtable[aWidth];
-    AAFrequency.calculate(alignment.getSequencesArray(),
-                          0, aWidth,
-                          hconsensus);
+  ConsensusThread consensusThread;
 
-    for (int i = 0; i < aWidth; i++)
-    {
-      float value = 0;
-      if(ignoreGapsInConsensusCalculation)
-        value = ((Float)hconsensus[i].get("pid_nogaps")).floatValue();
-      else
-        value = ((Float)hconsensus[i].get("pid_gaps")).floatValue();
+  boolean consUpdateNeeded = false;
 
-      String maxRes = hconsensus[i].get("maxResidue").toString();
-      String mouseOver = hconsensus[i].get("maxResidue") + " ";
-      if (maxRes.length() > 1)
-      {
-        mouseOver = "[" + maxRes + "] ";
-        maxRes = "+";
-      }
+  static boolean UPDATING_CONSENSUS = false;
 
+  static boolean UPDATING_CONSERVATION = false;
 
-      mouseOver += (int) value + "%";
-      annotations[i] = new Annotation(maxRes, mouseOver, ' ', value);
+  boolean updatingConsensus = false;
 
-    }
+  boolean updatingConservation = false;
+
+  /**
+   * DOCUMENT ME!
+   */
+  public void updateConservation(final AlignmentPanel ap)
+  {
+    if (alignment.isNucleotide() || conservation==null)
+      return;
+
+    conservationThread = new ConservationThread(ap);
+    conservationThread.start();
+  }
 
-    if (consensus == null)
+  /**
+   * DOCUMENT ME!
+   */
+  public void updateConsensus(final AlignmentPanel ap)
+  {
+    consensusThread = new ConsensusThread(ap);
+    consensusThread.start();
+  }
+
+
+  class ConsensusThread extends Thread
+  {
+    AlignmentPanel ap;
+    public ConsensusThread(AlignmentPanel ap)
     {
-      consensus = new AlignmentAnnotation("Consensus",
-                                          "PID", annotations, 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
-      if (showConsensus)
-      {
-        alignment.addAnnotation(consensus);
-      }
+      this.ap = ap;
     }
-    else
+    public void run()
     {
-      consensus.annotations = annotations;
-    }
+      updatingConsensus = true;
+      while (UPDATING_CONSENSUS)
+      {
+        try
+        {
+          if (ap != null)
+          {
+            ap.repaint();
+          }
+
+          Thread.sleep(200);
+        }
+        catch (Exception ex)
+        {
+          ex.printStackTrace();
+        }
+      }
+
+
+      UPDATING_CONSENSUS = true;
+
+      try
+      {
+        int aWidth = alignment.getWidth();
+        if(aWidth<0)
+          return;
+
+        consensus.annotations = null;
+        consensus.annotations = new Annotation[aWidth];
+
+
+        hconsensus = new Hashtable[aWidth];
+        AAFrequency.calculate(alignment.getSequencesArray(),
+                              0,
+                              alignment.getWidth(),
+                              hconsensus);
+
+        for (int i = 0; i < aWidth; i++)
+        {
+          float value = 0;
+          if (ignoreGapsInConsensusCalculation)
+            value = ( (Float) hconsensus[i].get(AAFrequency.PID_NOGAPS)).
+                floatValue();
+          else
+            value = ( (Float) hconsensus[i].get(AAFrequency.PID_GAPS)).
+                floatValue();
+
+          String maxRes = hconsensus[i].get(AAFrequency.MAXRESIDUE).toString();
+          String mouseOver = hconsensus[i].get(AAFrequency.MAXRESIDUE) + " ";
+
+          if (maxRes.length() > 1)
+          {
+            mouseOver = "[" + maxRes + "] ";
+            maxRes = "+";
+          }
+
+          mouseOver += ( (int) value + "%");
+          consensus.annotations[i] = new Annotation(maxRes, mouseOver, ' ', value);
+        }
 
-    if(globalColourScheme!=null)
+
+        if (globalColourScheme != null)
           globalColourScheme.setConsensus(hconsensus);
 
+      }
+      catch (OutOfMemoryError error)
+      {
+        alignment.deleteAnnotation(consensus);
+
+        consensus = null;
+        hconsensus = null;
+        System.out.println("Out of memory calculating consensus!!");
+        System.gc();
+      }
+      UPDATING_CONSENSUS = false;
+      updatingConsensus = false;
+
+      if (ap != null)
+      {
+        ap.repaint();
+      }
+    }
   }
+
   /**
    * get the consensus sequence as displayed under the PID consensus annotation row.
    * @return consensus sequence as a new sequence object
@@ -365,9 +520,8 @@ public class AlignViewport
    * get the consensus sequence as displayed under the PID consensus annotation row.
    * @return consensus sequence as a new sequence object
    */
-  public SequenceI getConsensusSeq() {
-    if (consensus==null)
-      updateConsensus();
+  public SequenceI getConsensusSeq()
+  {
     if (consensus==null)
       return null;
     StringBuffer seqs=new StringBuffer();
@@ -710,7 +864,7 @@ public class AlignViewport
   public void setIgnoreGapsConsensus(boolean b)
   {
     ignoreGapsInConsensusCalculation = b;
-    updateConsensus();
+    updateConsensus(null);
     if (globalColourScheme!=null)
     {
       globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
@@ -965,8 +1119,10 @@ public class AlignViewport
     // object. Refactoring of Cigar and alignment view representation should
     // be done to remove redundancy.
     CigarArray aligview = getViewAsCigars(selectedOnly);
-    if (aligview!=null)
-      return new AlignmentView(aligview);
+    if (aligview!=null) {
+      return new AlignmentView(aligview,
+          (selectedOnly && selectionGroup!=null) ? selectionGroup.getStartRes() : 0);
+    }
     return null;
   }
   /**
@@ -1061,5 +1217,103 @@ public class AlignViewport
     showHiddenMarkers = show;
   }
 
+  public Color getSequenceColour(SequenceI seq)
+  {
+    if (sequenceColours == null || !sequenceColours.containsKey(seq))
+      return Color.white;
+    else
+      return (Color) sequenceColours.get(seq);
+  }
+
+  public void setSequenceColour(SequenceI seq, Color col)
+  {
+    if (sequenceColours == null)
+      sequenceColours = new Hashtable();
+
+    if (col == null)
+      sequenceColours.remove(seq);
+    else
+      sequenceColours.put(seq, col);
+  }
+
+  public String getSequenceSetId()
+  {
+    if (sequenceSetID == null)
+      sequenceSetID = alignment.hashCode() + "";
+
+    return sequenceSetID;
+  }
+
+  public void alignmentChanged(AlignmentPanel ap)
+  {
+    alignment.padGaps();
+
+    if (hconsensus != null && autocalculateConsensus)
+    {
+      updateConsensus(ap);
+      updateConservation(ap);
+    }
+
+    //Reset endRes of groups if beyond alignment width
+    int alWidth = alignment.getWidth();
+    Vector groups = alignment.getGroups();
+    if(groups!=null)
+    {
+      for(int i=0; i<groups.size(); i++)
+      {
+        SequenceGroup sg = (SequenceGroup)groups.elementAt(i);
+        if(sg.getEndRes()>alWidth)
+          sg.setEndRes(alWidth-1);
+      }
+    }
+
+    if(selectionGroup!=null && selectionGroup.getEndRes()>alWidth)
+      selectionGroup.setEndRes(alWidth-1);
+
+    resetAllColourSchemes();
+
+    alignment.adjustSequenceAnnotations();
+  }
+
+  void resetAllColourSchemes()
+  {
+    ColourSchemeI cs = globalColourScheme;
+    if(cs!=null)
+    {
+      if (cs instanceof ClustalxColourScheme)
+      {
+        ( (ClustalxColourScheme) cs).
+            resetClustalX(alignment.getSequences(),
+                          alignment.getWidth());
+      }
+
+      cs.setConsensus(hconsensus);
+      if (cs.conservationApplied())
+      {
+        Alignment al = (Alignment) alignment;
+        Conservation c = new Conservation("All",
+                                          ResidueProperties.propHash, 3,
+                                          al.getSequences(), 0,
+                                          al.getWidth() - 1);
+        c.calculate();
+        c.verdict(false, ConsPercGaps);
+
+        cs.setConservation(c);
+      }
+    }
+
+    int s, sSize = alignment.getGroups().size();
+    for(s=0; s<sSize; s++)
+    {
+      SequenceGroup sg = (SequenceGroup)alignment.getGroups().elementAt(s);
+      if(sg.cs!=null && sg.cs instanceof ClustalxColourScheme)
+      {
+        ((ClustalxColourScheme)sg.cs).resetClustalX(
+            sg.getSequences(true), sg.getWidth());
+      }
+      sg.recalcConservation();
+    }
+  }
+
 
 }