src/jalview/datamodel/SequenceGroup.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6)
   3  * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 package jalview.datamodel;
  19
  20 import java.util.*;
  21
  22 import java.awt.*;
  23
  24 import jalview.analysis.*;
  25 import jalview.schemes.*;
  26
  27 /**
  28  * Collects a set contiguous ranges on a set of sequences
  29  *
  30  * @author $author$
  31  * @version $Revision$
  32  */
  33 public class SequenceGroup
  34 {
  35   String groupName;
  36
  37   String description;
  38
  39   Conservation conserve;
  40
  41   Vector aaFrequency;
  42
  43   boolean displayBoxes = true;
  44
  45   boolean displayText = true;
  46
  47   boolean colourText = false;
  48
  49   /**
  50    * after Olivier's non-conserved only character display
  51    */
  52   boolean showNonconserved = false;
  53
  54   /**
  55    * group members
  56    */
  57   private Vector sequences = new Vector();
  58
  59   /**
  60    * representative sequence for this group (if any)
  61    */
  62   private SequenceI seqrep = null;
  63
  64   int width = -1;
  65
  66   /**
  67    * Colourscheme applied to group if any
  68    */
  69   public ColourSchemeI cs;
  70
  71   int startRes = 0;
  72
  73   int endRes = 0;
  74
  75   public Color outlineColour = Color.black;
  76
  77   public Color idColour = null;
  78
  79   public int thresholdTextColour = 0;
  80
  81   public Color textColour = Color.black;
  82
  83   public Color textColour2 = Color.white;
  84
  85   /**
  86    * consensus calculation property
  87    */
  88   private boolean ignoreGapsInConsensus = true;
  89
  90   /**
  91    * consensus calculation property
  92    */
  93   private boolean showSequenceLogo = false;
  94
  95   /**
  96    * @return the includeAllConsSymbols
  97    */
  98   public boolean isShowSequenceLogo()
  99   {
 100     return showSequenceLogo;
 101   }
 102
 103   /**
 104    * Creates a new SequenceGroup object.
 105    */
 106   public SequenceGroup()
 107   {
 108     groupName = "JGroup:" + this.hashCode();
 109   }
 110
 111   /**
 112    * Creates a new SequenceGroup object.
 113    *
 114    * @param sequences
 115    * @param groupName
 116    * @param scheme
 117    * @param displayBoxes
 118    * @param displayText
 119    * @param colourText
 120    * @param start
 121    *          first column of group
 122    * @param end
 123    *          last column of group
 124    */
 125   public SequenceGroup(Vector sequences, String groupName,
 126           ColourSchemeI scheme, boolean displayBoxes, boolean displayText,
 127           boolean colourText, int start, int end)
 128   {
 129     this.sequences = sequences;
 130     this.groupName = groupName;
 131     this.displayBoxes = displayBoxes;
 132     this.displayText = displayText;
 133     this.colourText = colourText;
 134     this.cs = scheme;
 135     startRes = start;
 136     endRes = end;
 137     recalcConservation();
 138   }
 139
 140   /**
 141    * copy constructor
 142    *
 143    * @param seqsel
 144    */
 145   public SequenceGroup(SequenceGroup seqsel)
 146   {
 147     if (seqsel != null)
 148     {
 149       sequences = new Vector();
 150       Enumeration sq = seqsel.sequences.elements();
 151       while (sq.hasMoreElements())
 152       {
 153         sequences.addElement(sq.nextElement());
 154       }
 155       ;
 156       if (seqsel.groupName != null)
 157       {
 158         groupName = new String(seqsel.groupName);
 159       }
 160       displayBoxes = seqsel.displayBoxes;
 161       displayText = seqsel.displayText;
 162       colourText = seqsel.colourText;
 163       startRes = seqsel.startRes;
 164       endRes = seqsel.endRes;
 165       cs = seqsel.cs;
 166       if (seqsel.description != null)
 167         description = new String(seqsel.description);
 168       hidecols = seqsel.hidecols;
 169       hidereps = seqsel.hidereps;
 170       idColour = seqsel.idColour;
 171       outlineColour = seqsel.outlineColour;
 172       seqrep = seqsel.seqrep;
 173       textColour = seqsel.textColour;
 174       textColour2 = seqsel.textColour2;
 175       thresholdTextColour = seqsel.thresholdTextColour;
 176       width = seqsel.width;
 177       ignoreGapsInConsensus = seqsel.ignoreGapsInConsensus;
 178       if (seqsel.conserve != null)
 179       {
 180         recalcConservation(); // safer than
 181         // aaFrequency = (Vector) seqsel.aaFrequency.clone(); // ??
 182       }
 183     }
 184   }
 185
 186   public SequenceI[] getSelectionAsNewSequences(AlignmentI align)
 187   {
 188     int iSize = sequences.size();
 189     SequenceI[] seqs = new SequenceI[iSize];
 190     SequenceI[] inorder = getSequencesInOrder(align);
 191
 192     for (int i = 0, ipos = 0; i < inorder.length; i++)
 193     {
 194       SequenceI seq = inorder[i];
 195
 196       seqs[ipos] = seq.getSubSequence(startRes, endRes + 1);
 197       if (seqs[ipos] != null)
 198       {
 199         seqs[ipos].setDescription(seq.getDescription());
 200         seqs[ipos].setDBRef(seq.getDBRef());
 201         seqs[ipos].setSequenceFeatures(seq.getSequenceFeatures());
 202         if (seq.getDatasetSequence() != null)
 203         {
 204           seqs[ipos].setDatasetSequence(seq.getDatasetSequence());
 205         }
 206
 207         if (seq.getAnnotation() != null)
 208         {
 209           AlignmentAnnotation[] alann = align.getAlignmentAnnotation();
 210           // Only copy annotation that is either a score or referenced by the
 211           // alignment's annotation vector
 212           for (int a = 0; a < seq.getAnnotation().length; a++)
 213           {
 214             AlignmentAnnotation tocopy = seq.getAnnotation()[a];
 215             if (alann != null)
 216             {
 217               boolean found = false;
 218               for (int pos = 0; pos < alann.length; pos++)
 219               {
 220                 if (alann[pos] == tocopy)
 221                 {
 222                   found = true;
 223                   break;
 224                 }
 225               }
 226               if (!found)
 227                 continue;
 228             }
 229             AlignmentAnnotation newannot = new AlignmentAnnotation(
 230                     seq.getAnnotation()[a]);
 231             newannot.restrict(startRes, endRes);
 232             newannot.setSequenceRef(seqs[ipos]);
 233             newannot.adjustForAlignment();
 234             seqs[ipos].addAlignmentAnnotation(newannot);
 235           }
 236         }
 237         ipos++;
 238       }
 239       else
 240       {
 241         iSize--;
 242       }
 243     }
 244     if (iSize != inorder.length)
 245     {
 246       SequenceI[] nseqs = new SequenceI[iSize];
 247       System.arraycopy(seqs, 0, nseqs, 0, iSize);
 248       seqs = nseqs;
 249     }
 250     return seqs;
 251
 252   }
 253
 254   /**
 255    * If sequence ends in gaps, the end residue can be correctly calculated here
 256    *
 257    * @param seq
 258    *          SequenceI
 259    * @return int
 260    */
 261   public int findEndRes(SequenceI seq)
 262   {
 263     int eres = 0;
 264     char ch;
 265
 266     for (int j = 0; j < endRes + 1 && j < seq.getLength(); j++)
 267     {
 268       ch = seq.getCharAt(j);
 269       if (!jalview.util.Comparison.isGap((ch)))
 270       {
 271         eres++;
 272       }
 273     }
 274
 275     if (eres > 0)
 276     {
 277       eres += seq.getStart() - 1;
 278     }
 279
 280     return eres;
 281   }
 282
 283   public Vector getSequences(Hashtable hiddenReps)
 284   {
 285     if (hiddenReps == null)
 286     {
 287       return sequences;
 288     }
 289     else
 290     {
 291       Vector allSequences = new Vector();
 292       SequenceI seq, seq2;
 293       for (int i = 0; i < sequences.size(); i++)
 294       {
 295         seq = (SequenceI) sequences.elementAt(i);
 296         allSequences.addElement(seq);
 297         if (hiddenReps.containsKey(seq))
 298         {
 299           SequenceGroup hsg = (SequenceGroup) hiddenReps.get(seq);
 300           for (int h = 0; h < hsg.getSize(); h++)
 301           {
 302             seq2 = hsg.getSequenceAt(h);
 303             if (seq2 != seq && !allSequences.contains(seq2))
 304             {
 305               allSequences.addElement(seq2);
 306             }
 307           }
 308         }
 309       }
 310
 311       return allSequences;
 312     }
 313   }
 314
 315   public SequenceI[] getSequencesAsArray(Hashtable hiddenReps)
 316   {
 317     Vector tmp = getSequences(hiddenReps);
 318     if (tmp == null)
 319     {
 320       return null;
 321     }
 322     SequenceI[] result = new SequenceI[tmp.size()];
 323     for (int i = 0; i < result.length; i++)
 324     {
 325       result[i] = (SequenceI) tmp.elementAt(i);
 326     }
 327
 328     return result;
 329   }
 330
 331   /**
 332    * DOCUMENT ME!
 333    *
 334    * @param col
 335    *          DOCUMENT ME!
 336    *
 337    * @return DOCUMENT ME!
 338    */
 339   public boolean adjustForRemoveLeft(int col)
 340   {
 341     // return value is true if the group still exists
 342     if (startRes >= col)
 343     {
 344       startRes = startRes - col;
 345     }
 346
 347     if (endRes >= col)
 348     {
 349       endRes = endRes - col;
 350
 351       if (startRes > endRes)
 352       {
 353         startRes = 0;
 354       }
 355     }
 356     else
 357     {
 358       // must delete this group!!
 359       return false;
 360     }
 361
 362     return true;
 363   }
 364
 365   /**
 366    * DOCUMENT ME!
 367    *
 368    * @param col
 369    *          DOCUMENT ME!
 370    *
 371    * @return DOCUMENT ME!
 372    */
 373   public boolean adjustForRemoveRight(int col)
 374   {
 375     if (startRes > col)
 376     {
 377       // delete this group
 378       return false;
 379     }
 380
 381     if (endRes >= col)
 382     {
 383       endRes = col;
 384     }
 385
 386     return true;
 387   }
 388
 389   /**
 390    * DOCUMENT ME!
 391    *
 392    * @return DOCUMENT ME!
 393    */
 394   public String getName()
 395   {
 396     return groupName;
 397   }
 398
 399   public String getDescription()
 400   {
 401     return description;
 402   }
 403
 404   /**
 405    * DOCUMENT ME!
 406    *
 407    * @param name
 408    *          DOCUMENT ME!
 409    */
 410   public void setName(String name)
 411   {
 412     groupName = name;
 413     // TODO: URGENT: update dependent objects (annotation row)
 414   }
 415
 416   public void setDescription(String desc)
 417   {
 418     description = desc;
 419   }
 420
 421   /**
 422    * DOCUMENT ME!
 423    *
 424    * @return DOCUMENT ME!
 425    */
 426   public Conservation getConservation()
 427   {
 428     return conserve;
 429   }
 430
 431   /**
 432    * DOCUMENT ME!
 433    *
 434    * @param c
 435    *          DOCUMENT ME!
 436    */
 437   public void setConservation(Conservation c)
 438   {
 439     conserve = c;
 440   }
 441
 442   /**
 443    * Add s to this sequence group. If aligment sequence is already contained in
 444    * group, it will not be added again, but recalculation may happen if the flag
 445    * is set.
 446    *
 447    * @param s
 448    *          alignment sequence to be added
 449    * @param recalc
 450    *          true means Group's conservation should be recalculated
 451    */
 452   public void addSequence(SequenceI s, boolean recalc)
 453   {
 454     if (s != null && !sequences.contains(s))
 455     {
 456       sequences.addElement(s);
 457     }
 458
 459     if (recalc)
 460     {
 461       recalcConservation();
 462     }
 463   }
 464
 465   /**
 466    * Max Gaps Threshold for performing a conservation calculation TODO: make
 467    * this a configurable property - or global to an alignment view
 468    */
 469   private int consPercGaps = 25;
 470
 471   /**
 472    * calculate residue conservation for group - but only if necessary.
 473    */
 474   public void recalcConservation()
 475   {
 476     if (cs == null && consensus == null && conservation == null)
 477     {
 478       return;
 479     }
 480
 481     try
 482     {
 483       Hashtable cnsns[] = AAFrequency.calculate(sequences, startRes,
 484               endRes + 1, showSequenceLogo);
 485       if (consensus != null)
 486       {
 487         _updateConsensusRow(cnsns);
 488       }
 489       if (cs != null)
 490       {
 491         cs.setConsensus(cnsns);
 492
 493         if (cs instanceof ClustalxColourScheme)
 494         {
 495           ((ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());
 496         }
 497       }
 498
 499       if ((conservation != null)
 500               || (cs != null && cs.conservationApplied()))
 501       {
 502         Conservation c = new Conservation(groupName,
 503                 ResidueProperties.propHash, 3, sequences, startRes,
 504                 endRes + 1);
 505         c.calculate();
 506         c.verdict(false, consPercGaps);
 507         if (conservation != null)
 508         {
 509           _updateConservationRow(c);
 510         }
 511         if (cs != null)
 512         {
 513           cs.setConservation(c);
 514
 515           if (cs instanceof ClustalxColourScheme)
 516           {
 517             ((ClustalxColourScheme) cs)
 518                     .resetClustalX(sequences, getWidth());
 519           }
 520         }
 521       }
 522     } catch (java.lang.OutOfMemoryError err)
 523     {
 524       // TODO: catch OOM
 525       System.out.println("Out of memory loading groups: " + err);
 526     }
 527
 528   }
 529
 530   private void _updateConservationRow(Conservation c)
 531   {
 532     if (conservation == null)
 533     {
 534       getConservation();
 535     }
 536     // update Labels
 537     conservation.label = "Conservation for " + getName();
 538     conservation.description = "Conservation for group " + getName()
 539             + " less than " + consPercGaps + "% gaps";
 540     // preserve width if already set
 541     int aWidth = (conservation.annotations != null) ? (endRes < conservation.annotations.length ? conservation.annotations.length
 542             : endRes + 1)
 543             : endRes + 1;
 544     conservation.annotations = null;
 545     conservation.annotations = new Annotation[aWidth]; // should be alignment
 546                                                        // width
 547     c.completeAnnotations(conservation, null, startRes, endRes + 1);
 548   }
 549
 550   public Hashtable[] consensusData = null;
 551
 552   private void _updateConsensusRow(Hashtable[] cnsns)
 553   {
 554     if (consensus == null)
 555     {
 556       getConsensus();
 557     }
 558     consensus.label = "Consensus for " + getName();
 559     consensus.description = "Percent Identity";
 560     consensusData = cnsns;
 561     // preserve width if already set
 562     int aWidth = (consensus.annotations != null) ? (endRes < consensus.annotations.length ? consensus.annotations.length
 563             : endRes + 1)
 564             : endRes + 1;
 565     consensus.annotations = null;
 566     consensus.annotations = new Annotation[aWidth]; // should be alignment width
 567
 568     AAFrequency.completeConsensus(consensus, cnsns, startRes, endRes + 1,
 569             ignoreGapsInConsensus, showSequenceLogo); // TODO: setting container
 570                                                       // for
 571                                                       // ignoreGapsInConsensusCalculation);
 572   }
 573
 574   /**
 575    * @param s
 576    *          sequence to either add or remove from group
 577    * @param recalc
 578    *          flag passed to delete/addSequence to indicate if group properties
 579    *          should be recalculated
 580    */
 581   public void addOrRemove(SequenceI s, boolean recalc)
 582   {
 583     if (sequences.contains(s))
 584     {
 585       deleteSequence(s, recalc);
 586     }
 587     else
 588     {
 589       addSequence(s, recalc);
 590     }
 591   }
 592
 593   /**
 594    * DOCUMENT ME!
 595    *
 596    * @param s
 597    *          DOCUMENT ME!
 598    * @param recalc
 599    *          DOCUMENT ME!
 600    */
 601   public void deleteSequence(SequenceI s, boolean recalc)
 602   {
 603     sequences.removeElement(s);
 604
 605     if (recalc)
 606     {
 607       recalcConservation();
 608     }
 609   }
 610
 611   /**
 612    * DOCUMENT ME!
 613    *
 614    * @return DOCUMENT ME!
 615    */
 616   public int getStartRes()
 617   {
 618     return startRes;
 619   }
 620
 621   /**
 622    * DOCUMENT ME!
 623    *
 624    * @return DOCUMENT ME!
 625    */
 626   public int getEndRes()
 627   {
 628     return endRes;
 629   }
 630
 631   /**
 632    * Set the first column selected by this group. Runs from 0<=i<N_cols
 633    *
 634    * @param i
 635    */
 636   public void setStartRes(int i)
 637   {
 638     startRes = i;
 639   }
 640
 641   /**
 642    * Set the groups last selected column. Runs from 0<=i<N_cols
 643    *
 644    * @param i
 645    */
 646   public void setEndRes(int i)
 647   {
 648     endRes = i;
 649   }
 650
 651   /**
 652    * DOCUMENT ME!
 653    *
 654    * @return DOCUMENT ME!
 655    */
 656   public int getSize()
 657   {
 658     return sequences.size();
 659   }
 660
 661   /**
 662    * DOCUMENT ME!
 663    *
 664    * @param i
 665    *          DOCUMENT ME!
 666    *
 667    * @return DOCUMENT ME!
 668    */
 669   public SequenceI getSequenceAt(int i)
 670   {
 671     return (SequenceI) sequences.elementAt(i);
 672   }
 673
 674   /**
 675    * DOCUMENT ME!
 676    *
 677    * @param state
 678    *          DOCUMENT ME!
 679    */
 680   public void setColourText(boolean state)
 681   {
 682     colourText = state;
 683   }
 684
 685   /**
 686    * DOCUMENT ME!
 687    *
 688    * @return DOCUMENT ME!
 689    */
 690   public boolean getColourText()
 691   {
 692     return colourText;
 693   }
 694
 695   /**
 696    * DOCUMENT ME!
 697    *
 698    * @param state
 699    *          DOCUMENT ME!
 700    */
 701   public void setDisplayText(boolean state)
 702   {
 703     displayText = state;
 704   }
 705
 706   /**
 707    * DOCUMENT ME!
 708    *
 709    * @return DOCUMENT ME!
 710    */
 711   public boolean getDisplayText()
 712   {
 713     return displayText;
 714   }
 715
 716   /**
 717    * DOCUMENT ME!
 718    *
 719    * @param state
 720    *          DOCUMENT ME!
 721    */
 722   public void setDisplayBoxes(boolean state)
 723   {
 724     displayBoxes = state;
 725   }
 726
 727   /**
 728    * DOCUMENT ME!
 729    *
 730    * @return DOCUMENT ME!
 731    */
 732   public boolean getDisplayBoxes()
 733   {
 734     return displayBoxes;
 735   }
 736
 737   /**
 738    * DOCUMENT ME!
 739    *
 740    * @return DOCUMENT ME!
 741    */
 742   public int getWidth()
 743   {
 744     // MC This needs to get reset when characters are inserted and deleted
 745     if (sequences.size() > 0)
 746     {
 747       width = ((SequenceI) sequences.elementAt(0)).getLength();
 748     }
 749
 750     for (int i = 1; i < sequences.size(); i++)
 751     {
 752       SequenceI seq = (SequenceI) sequences.elementAt(i);
 753
 754       if (seq.getLength() > width)
 755       {
 756         width = seq.getLength();
 757       }
 758     }
 759
 760     return width;
 761   }
 762
 763   /**
 764    * DOCUMENT ME!
 765    *
 766    * @param c
 767    *          DOCUMENT ME!
 768    */
 769   public void setOutlineColour(Color c)
 770   {
 771     outlineColour = c;
 772   }
 773
 774   /**
 775    * DOCUMENT ME!
 776    *
 777    * @return DOCUMENT ME!
 778    */
 779   public Color getOutlineColour()
 780   {
 781     return outlineColour;
 782   }
 783
 784   /**
 785    *
 786    * returns the sequences in the group ordered by the ordering given by al.
 787    * this used to return an array with null entries regardless, new behaviour is
 788    * below. TODO: verify that this does not affect use in applet or application
 789    *
 790    * @param al
 791    *          Alignment
 792    * @return SequenceI[] intersection of sequences in group with al, ordered by
 793    *         al, or null if group does not intersect with al
 794    */
 795   public SequenceI[] getSequencesInOrder(AlignmentI al)
 796   {
 797     return getSequencesInOrder(al, true);
 798   }
 799
 800   /**
 801    * return an array representing the intersection of the group with al,
 802    * optionally returning an array the size of al.getHeight() where nulls mark
 803    * the non-intersected sequences
 804    *
 805    * @param al
 806    * @param trim
 807    * @return null or array
 808    */
 809   public SequenceI[] getSequencesInOrder(AlignmentI al, boolean trim)
 810   {
 811     int sSize = sequences.size();
 812     int alHeight = al.getHeight();
 813
 814     SequenceI[] seqs = new SequenceI[(trim) ? sSize : alHeight];
 815
 816     int index = 0;
 817     for (int i = 0; i < alHeight && index < sSize; i++)
 818     {
 819       if (sequences.contains(al.getSequenceAt(i)))
 820       {
 821         seqs[(trim) ? index : i] = al.getSequenceAt(i);
 822         index++;
 823       }
 824     }
 825     if (index == 0)
 826     {
 827       return null;
 828     }
 829     if (!trim)
 830     {
 831       return seqs;
 832     }
 833     if (index < seqs.length)
 834     {
 835       SequenceI[] dummy = seqs;
 836       seqs = new SequenceI[index];
 837       while (--index >= 0)
 838       {
 839         seqs[index] = dummy[index];
 840         dummy[index] = null;
 841       }
 842     }
 843     return seqs;
 844   }
 845
 846   /**
 847    * @return the idColour
 848    */
 849   public Color getIdColour()
 850   {
 851     return idColour;
 852   }
 853
 854   /**
 855    * @param idColour
 856    *          the idColour to set
 857    */
 858   public void setIdColour(Color idColour)
 859   {
 860     this.idColour = idColour;
 861   }
 862
 863   /**
 864    * @return the representative sequence for this group
 865    */
 866   public SequenceI getSeqrep()
 867   {
 868     return seqrep;
 869   }
 870
 871   /**
 872    * set the representative sequence for this group. Note - this affects the
 873    * interpretation of the Hidereps attribute.
 874    *
 875    * @param seqrep
 876    *          the seqrep to set (null means no sequence representative)
 877    */
 878   public void setSeqrep(SequenceI seqrep)
 879   {
 880     this.seqrep = seqrep;
 881   }
 882
 883   /**
 884    *
 885    * @return true if group has a sequence representative
 886    */
 887   public boolean hasSeqrep()
 888   {
 889     return seqrep != null;
 890   }
 891
 892   /**
 893    * visibility of rows or represented rows covered by group
 894    */
 895   private boolean hidereps = false;
 896
 897   /**
 898    * set visibility of sequences covered by (if no sequence representative is
 899    * defined) or represented by this group.
 900    *
 901    * @param visibility
 902    */
 903   public void setHidereps(boolean visibility)
 904   {
 905     hidereps = visibility;
 906   }
 907
 908   /**
 909    *
 910    * @return true if sequences represented (or covered) by this group should be
 911    *         hidden
 912    */
 913   public boolean isHidereps()
 914   {
 915     return hidereps;
 916   }
 917
 918   /**
 919    * visibility of columns intersecting this group
 920    */
 921   private boolean hidecols = false;
 922
 923   /**
 924    * set intended visibility of columns covered by this group
 925    *
 926    * @param visibility
 927    */
 928   public void setHideCols(boolean visibility)
 929   {
 930     hidecols = visibility;
 931   }
 932
 933   /**
 934    *
 935    * @return true if columns covered by group should be hidden
 936    */
 937   public boolean isHideCols()
 938   {
 939     return hidecols;
 940   }
 941
 942   /**
 943    * create a new sequence group from the intersection of this group with an
 944    * alignment Hashtable of hidden representatives
 945    *
 946    * @param alignment
 947    *          (may not be null)
 948    * @param hashtable
 949    *          (may be null)
 950    * @return new group containing sequences common to this group and alignment
 951    */
 952   public SequenceGroup intersect(AlignmentI alignment, Hashtable hashtable)
 953   {
 954     SequenceGroup sgroup = new SequenceGroup(this);
 955     SequenceI[] insect = getSequencesInOrder(alignment);
 956     sgroup.sequences = new Vector();
 957     for (int s = 0; insect != null && s < insect.length; s++)
 958     {
 959       if (hashtable == null || hashtable.containsKey(insect[s]))
 960       {
 961         sgroup.sequences.addElement(insect[s]);
 962       }
 963     }
 964     // Enumeration en =getSequences(hashtable).elements();
 965     // while (en.hasMoreElements())
 966     // {
 967     // SequenceI elem = (SequenceI) en.nextElement();
 968     // if (alignment.getSequences().contains(elem))
 969     // {
 970     // sgroup.addSequence(elem, false);
 971     // }
 972     // }
 973     return sgroup;
 974   }
 975
 976   /**
 977    * @return the showUnconserved
 978    */
 979   public boolean getShowNonconserved()
 980   {
 981     return showNonconserved;
 982   }
 983
 984   /**
 985    * @param showNonconserved
 986    *          the showUnconserved to set
 987    */
 988   public void setShowNonconserved(boolean displayNonconserved)
 989   {
 990     this.showNonconserved = displayNonconserved;
 991   }
 992
 993   AlignmentAnnotation consensus = null, conservation = null;
 994
 995   /**
 996    * flag indicating if consensus histogram should be rendered
 997    */
 998   private boolean showConsensusHistogram;
 999
1000   /**
1001    * set this alignmentAnnotation object as the one used to render consensus annotation
1002    * @param aan
1003    */
1004   public void setConsensus(AlignmentAnnotation aan)
1005   {
1006     if (consensus==null)
1007     {
1008       consensus=aan;
1009     }
1010   }
1011
1012   /**
1013    *
1014    * @return automatically calculated consensus row
1015    */
1016   public AlignmentAnnotation getConsensus()
1017   {
1018     // TODO get or calculate and get consensus annotation row for this group
1019     int aWidth = this.getWidth();
1020     // pointer
1021     // possibility
1022     // here.
1023     if (aWidth < 0)
1024     {
1025       return null;
1026     }
1027     if (consensus == null)
1028     {
1029       consensus = new AlignmentAnnotation("", "", new Annotation[1], 0f,
1030               100f, AlignmentAnnotation.BAR_GRAPH);
1031     }
1032     consensus.hasText = true;
1033     consensus.autoCalculated = true;
1034     consensus.groupRef = this;
1035     consensus.label = "Consensus for " + getName();
1036     consensus.description = "Percent Identity";
1037     return consensus;
1038   }
1039
1040   /**
1041    * set this alignmentAnnotation object as the one used to render consensus annotation
1042    * @param aan
1043    */
1044   public void setConservationRow(AlignmentAnnotation aan)
1045   {
1046     if (conservation==null)
1047     {
1048       conservation=aan;
1049     }
1050   }
1051   /**
1052    * get the conservation annotation row for this group
1053    *
1054    * @return autoCalculated annotation row
1055    */
1056   public AlignmentAnnotation getConservationRow()
1057   {
1058     if (conservation == null)
1059     {
1060       conservation = new AlignmentAnnotation("", "", new Annotation[1], 0f,
1061               11f, AlignmentAnnotation.BAR_GRAPH);
1062     }
1063
1064     conservation.hasText = true;
1065     conservation.autoCalculated = true;
1066     conservation.groupRef = this;
1067     conservation.label = "Conservation for " + getName();
1068     conservation.description = "Conservation for group " + getName()
1069             + " less than " + consPercGaps + "% gaps";
1070     return conservation;
1071   }
1072
1073   /**
1074    *
1075    * @return true if annotation rows have been instantiated for this group
1076    */
1077   public boolean hasAnnotationRows()
1078   {
1079     return consensus != null || conservation != null;
1080   }
1081
1082   public SequenceI getConsensusSeq()
1083   {
1084     getConsensus();
1085     StringBuffer seqs = new StringBuffer();
1086     for (int i = 0; i < consensus.annotations.length; i++)
1087     {
1088       if (consensus.annotations[i] != null)
1089       {
1090         if (consensus.annotations[i].description.charAt(0) == '[')
1091         {
1092           seqs.append(consensus.annotations[i].description.charAt(1));
1093         }
1094         else
1095         {
1096           seqs.append(consensus.annotations[i].displayCharacter);
1097         }
1098       }
1099     }
1100
1101     SequenceI sq = new Sequence("Group" + getName() + " Consensus",
1102             seqs.toString());
1103     sq.setDescription("Percentage Identity Consensus "
1104             + ((ignoreGapsInConsensus) ? " without gaps" : ""));
1105     return sq;
1106   }
1107
1108   public void setIgnoreGapsConsensus(boolean state)
1109   {
1110     if (this.ignoreGapsInConsensus != state && consensus != null)
1111     {
1112       ignoreGapsInConsensus = state;
1113       recalcConservation();
1114     }
1115     ignoreGapsInConsensus = state;
1116   }
1117
1118   public boolean getIgnoreGapsConsensus()
1119   {
1120     return ignoreGapsInConsensus;
1121   }
1122
1123   /**
1124    * @param showSequenceLogo
1125    *          indicates if a sequence logo is shown for consensus annotation
1126    */
1127   public void setshowSequenceLogo(boolean showSequenceLogo)
1128   {
1129     // TODO: decouple calculation from settings update
1130     if (this.showSequenceLogo != showSequenceLogo && consensus != null)
1131     {
1132       this.showSequenceLogo = showSequenceLogo;
1133       recalcConservation();
1134     }
1135     this.showSequenceLogo = showSequenceLogo;
1136   }
1137
1138   /**
1139    *
1140    * @param showConsHist
1141    *          flag indicating if the consensus histogram for this group should
1142    *          be rendered
1143    */
1144   public void setShowConsensusHistogram(boolean showConsHist)
1145   {
1146
1147     if (showConsensusHistogram != showConsHist && consensus != null)
1148     {
1149       this.showConsensusHistogram = showConsHist;
1150       recalcConservation();
1151     }
1152     this.showConsensusHistogram = showConsHist;
1153   }
1154
1155   /**
1156    * @return the showConsensusHistogram
1157    */
1158   public boolean isShowConsensusHistogram()
1159   {
1160     return showConsensusHistogram;
1161   }
1162 }