X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequenceGroup.java;h=871e4cf5d9410603870e2020da3ad3388deb3dca;hb=1dabf099b7c77fb0a80039f72cef34669df9b2e1;hp=dd842ea5a13209b81bc4c7def3a9a9341a53bd38;hpb=506d60f0e188723ddc91c26824b41ac7034df3fe;p=jalview.git

diff --git a/src/jalview/datamodel/SequenceGroup.java b/src/jalview/datamodel/SequenceGroup.java
index dd842ea..871e4cf 100755
--- a/src/jalview/datamodel/SequenceGroup.java
+++ b/src/jalview/datamodel/SequenceGroup.java
@@ -1,6 +1,6 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
- * Copyright (C) 2008 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1)
+ * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -46,12 +46,23 @@ public class SequenceGroup
   boolean displayText = true;
 
   boolean colourText = false;
-
+  /**
+   * after Olivier's non-conserved only character display
+   */
+  boolean showUnconserved = false;
+  
+  /**
+   * group members
+   */
   private Vector sequences = new Vector();
-
+  /**
+   * representative sequence for this group (if any)
+   */
+  private SequenceI seqrep = null;
   int width = -1;
 
-  /** DOCUMENT ME!! */
+  /**
+   * Colourscheme applied to group if any */
   public ColourSchemeI cs;
 
   int startRes = 0;
@@ -69,6 +80,24 @@ public class SequenceGroup
   public Color textColour2 = Color.white;
 
   /**
+   * consensus calculation property
+   */
+  private boolean ignoreGapsInConsensus=true;
+  /**
+   * consensus calculation property
+   */
+  private boolean showConsensusProfile=false;
+
+  /**
+   * @return the includeAllConsSymbols
+   */
+  public boolean isIncludeAllConsSymbols()
+  {
+    return showConsensusProfile;
+  }
+
+
+  /**
    * Creates a new SequenceGroup object.
    */
   public SequenceGroup()
@@ -104,6 +133,48 @@ public class SequenceGroup
     endRes = end;
     recalcConservation();
   }
+  /**
+   * copy constructor
+   * @param seqsel
+   */
+  public SequenceGroup(SequenceGroup seqsel)
+  {
+    if (seqsel!=null)
+    {
+      sequences=new Vector();
+      Enumeration sq = seqsel.sequences.elements();
+      while (sq.hasMoreElements()) { 
+        sequences.addElement(sq.nextElement()); 
+      };
+      if (seqsel.groupName!=null)
+      {
+        groupName = new String(seqsel.groupName);
+      }
+      displayBoxes = seqsel.displayBoxes;
+      displayText = seqsel.displayText;
+      colourText = seqsel.colourText;
+      startRes = seqsel.startRes;
+      endRes = seqsel.endRes;
+      cs =seqsel.cs;
+      if (seqsel.description!=null)
+        description = new String(seqsel.description);
+      hidecols = seqsel.hidecols;
+      hidereps = seqsel.hidereps;
+      idColour = seqsel.idColour;
+      outlineColour = seqsel.outlineColour;
+      seqrep = seqsel.seqrep;
+      textColour = seqsel.textColour;
+      textColour2 = seqsel.textColour2;
+      thresholdTextColour = seqsel.thresholdTextColour;
+      width = seqsel.width;
+      ignoreGapsInConsensus = seqsel.ignoreGapsInConsensus;
+      if (seqsel.conserve!=null)
+      {
+        recalcConservation(); // safer than 
+        // aaFrequency = (Vector) seqsel.aaFrequency.clone(); // ??
+      }
+    }
+  }
 
   public SequenceI[] getSelectionAsNewSequences(AlignmentI align)
   {
@@ -332,6 +403,7 @@ public class SequenceGroup
   public void setName(String name)
   {
     groupName = name;
+    // TODO: URGENT: update dependent objects (annotation row)
   }
 
   public void setDescription(String desc)
@@ -382,39 +454,57 @@ public class SequenceGroup
   }
 
   /**
-   * calculate residue conservation for group
+   * Max Gaps Threshold for performing a conservation calculation
+   * TODO: make this a configurable property - or global to an alignment view 
+   */
+  private int consPercGaps=25;
+  /**
+   * calculate residue conservation for group - but only if necessary.
    */
   public void recalcConservation()
   {
-    if (cs == null)
+    if (cs == null && consensus == null && conservation == null)
     {
       return;
     }
-
+    
     try
     {
-      cs.setConsensus(AAFrequency
-              .calculate(sequences, startRes, endRes + 1));
-
+      Hashtable cnsns[] = AAFrequency.calculate(sequences, startRes, endRes + 1, showConsensusProfile);
+      if (consensus != null)
+      {
+        _updateConsensusRow(cnsns);
+      }
+      if (cs!=null)
+      {
+        cs.setConsensus(cnsns);
+      
       if (cs instanceof ClustalxColourScheme)
       {
         ((ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());
       }
+      }
 
-      if (cs.conservationApplied())
+      if ((conservation!=null) || (cs!=null && cs.conservationApplied()))
       {
         Conservation c = new Conservation(groupName,
                 ResidueProperties.propHash, 3, sequences, startRes,
                 endRes + 1);
         c.calculate();
-        c.verdict(false, 25);
-
-        cs.setConservation(c);
-
+        c.verdict(false, consPercGaps);
+        if (conservation!=null)
+        {
+          _updateConservationRow(c);
+        }
+        if (cs!=null)
+        {
+          cs.setConservation(c);
+        
         if (cs instanceof ClustalxColourScheme)
         {
           ((ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());
         }
+        }
       }
     } catch (java.lang.OutOfMemoryError err)
     {
@@ -424,13 +514,43 @@ public class SequenceGroup
 
   }
 
+  private void _updateConservationRow(Conservation c)
+  {
+    if (conservation==null)
+    {
+      getConservation();
+    }
+    // update Labels
+    conservation.label = "Conservation for "+getName();
+    conservation.description = "Conservation for group "+getName()+" less than " + consPercGaps
+            + "% gaps";
+    // preserve width if already set
+    int aWidth = (conservation.annotations!=null) ? (endRes<conservation.annotations.length ? conservation.annotations.length : endRes+1) : endRes+1;
+    conservation.annotations = null;
+    conservation.annotations = new Annotation[aWidth]; // should be alignment width
+    c.completeAnnotations(conservation,null, startRes, endRes+1);
+  }
+  public Hashtable[] consensusData = null;
+  private void _updateConsensusRow(Hashtable[] cnsns)
+  {
+    if (consensus==null)
+    {
+      getConsensus();
+    }
+    consensus.label = "Consensus for "+getName();
+    consensus.description = "Percent Identity";
+    consensusData = cnsns;
+    // preserve width if already set
+    int aWidth = (consensus.annotations!=null) ? (endRes<consensus.annotations.length ? consensus.annotations.length : endRes+1) : endRes+1;
+    consensus.annotations = null;
+    consensus.annotations = new Annotation[aWidth]; // should be alignment width
+
+    AAFrequency.completeConsensus(consensus,cnsns,startRes,endRes+1,ignoreGapsInConsensus, showConsensusProfile); // TODO: setting container for ignoreGapsInConsensusCalculation);
+  }
+
   /**
-   * DOCUMENT ME!
-   * 
-   * @param s
-   *                DOCUMENT ME!
-   * @param recalc
-   *                DOCUMENT ME!
+   * @param s sequence to either add or remove from group
+   * @param recalc flag passed to delete/addSequence to indicate if group properties should be recalculated
    */
   public void addOrRemove(SequenceI s, boolean recalc)
   {
@@ -639,11 +759,12 @@ public class SequenceGroup
 
   /**
    * 
-   * returns the sequences in the group ordered by the ordering given by al
-   * 
+   * returns the sequences in the group ordered by the ordering given by al.
+   * this used to return an array with null entries regardless, new behaviour is below.
+   * TODO: verify that this does not affect use in applet or application
    * @param al
    *                Alignment
-   * @return SequenceI[]
+   * @return SequenceI[] intersection of sequences in group with al, ordered by al, or null if group does not intersect with al
    */
   public SequenceI[] getSequencesInOrder(AlignmentI al)
   {
@@ -660,7 +781,20 @@ public class SequenceGroup
         seqs[index++] = al.getSequenceAt(i);
       }
     }
-
+    if (index==0)
+    {
+      return null;
+    }
+    if (index<seqs.length)
+    {
+      SequenceI[] dummy = seqs;
+      seqs = new SequenceI[index];
+      while (--index>=0)
+      {
+        seqs[index] = dummy[index];
+        dummy[index] = null;
+      }
+    }
     return seqs;
   }
 
@@ -680,4 +814,249 @@ public class SequenceGroup
   {
     this.idColour = idColour;
   }
-}
+
+  /**
+   * @return the representative sequence for this group
+   */
+  public SequenceI getSeqrep()
+  {
+    return seqrep;
+  }
+
+  /**
+   * set the representative sequence for this group.
+   * Note - this affects the interpretation of the Hidereps attribute.
+   * @param seqrep the seqrep to set (null means no sequence representative)
+   */
+  public void setSeqrep(SequenceI seqrep)
+  {
+    this.seqrep = seqrep;
+  }
+  /**
+   * 
+   * @return true if group has a sequence representative
+   */
+  public boolean hasSeqrep()
+  {
+    return seqrep != null;
+  }
+  /**
+   * visibility of rows or represented rows covered by group
+   */
+  private boolean hidereps=false;
+  /**
+   * set visibility of sequences covered by (if no sequence representative is defined) 
+   * or represented by this group.
+   * @param visibility
+   */
+  public void setHidereps(boolean visibility)
+  {
+    hidereps = visibility;
+  }
+  /**
+   * 
+   * @return true if sequences represented (or covered) by this group should be hidden
+   */
+  public boolean isHidereps()
+  {
+    return hidereps;
+  }
+  /**
+   * visibility of columns intersecting this group
+   */
+  private boolean hidecols=false;
+  /**
+   * set intended visibility of columns covered by this group
+   * @param visibility
+   */
+  public void setHideCols(boolean visibility)
+  {
+    hidecols = visibility;
+  }
+  /**
+   * 
+   * @return true if columns covered by group should be hidden
+   */
+  public boolean isHideCols()
+  {
+    return hidecols;
+  }
+  /**
+   * create a new sequence group from the intersection of this group
+   * with an alignment Hashtable of hidden representatives
+   * 
+   * @param alignment (may not be null)
+   * @param hashtable (may be null)
+   * @return new group containing sequences common to this group and alignment
+   */
+  public SequenceGroup intersect(AlignmentI alignment, Hashtable hashtable)
+  {
+    SequenceGroup sgroup = new SequenceGroup(this);
+    SequenceI[] insect=getSequencesInOrder(alignment);
+    sgroup.sequences = new Vector();
+    for (int s=0;insect!=null && s<insect.length;s++) { 
+      if (hashtable==null || hashtable.containsKey(insect[s]))
+              {
+      sgroup.sequences.addElement(insect[s]); }
+    }
+    //Enumeration en =getSequences(hashtable).elements();
+    //while (en.hasMoreElements())
+   // {
+   //   SequenceI elem = (SequenceI) en.nextElement();
+   //   if (alignment.getSequences().contains(elem))
+   //   {
+   //     sgroup.addSequence(elem, false);
+   //   }
+   // }
+    return sgroup;
+  }
+
+  /**
+   * @return the showUnconserved
+   */
+  public boolean getShowunconserved()
+  {
+    return showUnconserved;
+  }
+
+  /**
+   * @param showUnconserved the showUnconserved to set
+   */
+  public void setShowunconserved(boolean displayNonconserved)
+  {
+    this.showUnconserved = displayNonconserved;
+  }
+  AlignmentAnnotation consensus=null,conservation=null;
+
+  /**
+   * flag indicating if consensus histogram should be rendered
+   */
+  private boolean showConsensusHistogram;
+ 
+
+  /**
+   * 
+   * @return automatically calculated consensus row
+   */
+  public AlignmentAnnotation getConsensus()
+  {
+    // TODO get or calculate and get consensus annotation row for this group
+    int aWidth = this.getWidth();
+    // pointer
+    // possibility
+    // here.
+    if (aWidth < 0)
+    {
+      return null;
+    }
+    if (consensus==null)
+    {
+       consensus = new AlignmentAnnotation("","",
+              new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
+      consensus.hasText = true;
+      consensus.autoCalculated = true;
+      consensus.groupRef = this;
+    }
+    consensus.label = "Consensus for "+getName();
+    consensus.description = "Percent Identity";
+    return consensus;
+  }
+    /**
+   * get the conservation annotation row for this group
+   * @return autoCalculated annotation row
+   */
+  public AlignmentAnnotation getConservationRow() {
+    if (conservation == null) {
+      conservation = new AlignmentAnnotation("","", new Annotation[1], 0f, 11f,
+            AlignmentAnnotation.BAR_GRAPH);
+    conservation.hasText = true;
+    conservation.autoCalculated = true;
+    conservation.groupRef = this;
+    }
+    conservation.label = "Conservation for "+getName();
+    conservation.description = "Conservation for group "+getName()+" less than " + consPercGaps
+            + "% gaps";
+    return conservation;
+  }
+
+  /**
+   * 
+   * @return true if annotation rows have been instantiated for this group
+   */
+    public boolean hasAnnotationRows()
+    {
+      return consensus!=null || conservation!=null;
+    }
+
+  public SequenceI getConsensusSeq()
+  {
+    getConsensus();
+    StringBuffer seqs = new StringBuffer();
+    for (int i = 0; i < consensus.annotations.length; i++)
+    {
+      if (consensus.annotations[i] != null)
+      {
+        if (consensus.annotations[i].description.charAt(0) == '[')
+        {
+          seqs.append(consensus.annotations[i].description.charAt(1));
+        }
+        else
+        {
+          seqs.append(consensus.annotations[i].displayCharacter);
+        }
+      }
+    }
+
+    SequenceI sq = new Sequence("Group"+getName()+" Consensus", seqs.toString());
+    sq.setDescription("Percentage Identity Consensus "
+            + ((ignoreGapsInConsensus) ? " without gaps" : ""));
+    return sq;    
+  }
+
+  public void setIgnoreGapsConsensus(boolean state)
+  {
+    if (this.ignoreGapsInConsensus!=state && consensus!=null)
+    {
+      ignoreGapsInConsensus = state;
+      recalcConservation();
+    }
+    ignoreGapsInConsensus = state;
+  }
+  public boolean getIgnoreGapsConsensus()
+  {
+    return ignoreGapsInConsensus;
+  }
+  /**
+   * @param includeAllConsSymbols the includeAllConsSymbols to set
+   */
+  public void setIncludeAllConsSymbols(boolean includeAllConsSymbols)
+  {
+    if (this.showConsensusProfile!=includeAllConsSymbols && consensus!=null) {
+      this.showConsensusProfile = includeAllConsSymbols;
+      recalcConservation();
+    }
+    this.showConsensusProfile = includeAllConsSymbols;
+  }
+
+
+  /**
+   * 
+   * @param showConsHist flag indicating if the consensus histogram for this group should be rendered
+   */
+  public void setShowConsensusHistogram(boolean showConsHist)
+  {
+    
+    if (showConsensusHistogram!=showConsHist && consensus!=null) {
+      this.showConsensusHistogram = showConsHist;
+      recalcConservation();
+    }
+    this.showConsensusHistogram = showConsHist;
+  }
+  /**
+   * @return the showConsensusHistogram
+   */
+  public boolean isShowConsensusHistogram()
+  {
+    return showConsensusHistogram;
+  }
+  }