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
 444    *
 445    * @param s
 446    *          alignment sequence to be added
 447    * @param recalc
 448    *          true means Group's conservation should be recalculated
 449    */
 450   public void addSequence(SequenceI s, boolean recalc)
 451   {
 452     if (s != null && !sequences.contains(s))
 453     {
 454       sequences.addElement(s);
 455     }
 456
 457     if (recalc)
 458     {
 459       recalcConservation();
 460     }
 461   }
 462
 463   /**
 464    * Max Gaps Threshold for performing a conservation calculation TODO: make
 465    * this a configurable property - or global to an alignment view
 466    */
 467   private int consPercGaps = 25;
 468
 469   /**
 470    * calculate residue conservation for group - but only if necessary.
 471    */
 472   public void recalcConservation()
 473   {
 474     if (cs == null && consensus == null && conservation == null)
 475     {
 476       return;
 477     }
 478
 479     try
 480     {
 481       Hashtable cnsns[] = AAFrequency.calculate(sequences, startRes,
 482               endRes + 1, showSequenceLogo);
 483       if (consensus != null)
 484       {
 485         _updateConsensusRow(cnsns);
 486       }
 487       if (cs != null)
 488       {
 489         cs.setConsensus(cnsns);
 490
 491         if (cs instanceof ClustalxColourScheme)
 492         {
 493           ((ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());
 494         }
 495       }
 496
 497       if ((conservation != null)
 498               || (cs != null && cs.conservationApplied()))
 499       {
 500         Conservation c = new Conservation(groupName,
 501                 ResidueProperties.propHash, 3, sequences, startRes,
 502                 endRes + 1);
 503         c.calculate();
 504         c.verdict(false, consPercGaps);
 505         if (conservation != null)
 506         {
 507           _updateConservationRow(c);
 508         }
 509         if (cs != null)
 510         {
 511           cs.setConservation(c);
 512
 513           if (cs instanceof ClustalxColourScheme)
 514           {
 515             ((ClustalxColourScheme) cs)
 516                     .resetClustalX(sequences, getWidth());
 517           }
 518         }
 519       }
 520     } catch (java.lang.OutOfMemoryError err)
 521     {
 522       // TODO: catch OOM
 523       System.out.println("Out of memory loading groups: " + err);
 524     }
 525
 526   }
 527
 528   private void _updateConservationRow(Conservation c)
 529   {
 530     if (conservation == null)
 531     {
 532       getConservation();
 533     }
 534     // update Labels
 535     conservation.label = "Conservation for " + getName();
 536     conservation.description = "Conservation for group " + getName()
 537             + " less than " + consPercGaps + "% gaps";
 538     // preserve width if already set
 539     int aWidth = (conservation.annotations != null) ? (endRes < conservation.annotations.length ? conservation.annotations.length
 540             : endRes + 1)
 541             : endRes + 1;
 542     conservation.annotations = null;
 543     conservation.annotations = new Annotation[aWidth]; // should be alignment
 544                                                        // width
 545     c.completeAnnotations(conservation, null, startRes, endRes + 1);
 546   }
 547
 548   public Hashtable[] consensusData = null;
 549
 550   private void _updateConsensusRow(Hashtable[] cnsns)
 551   {
 552     if (consensus == null)
 553     {
 554       getConsensus();
 555     }
 556     consensus.label = "Consensus for " + getName();
 557     consensus.description = "Percent Identity";
 558     consensusData = cnsns;
 559     // preserve width if already set
 560     int aWidth = (consensus.annotations != null) ? (endRes < consensus.annotations.length ? consensus.annotations.length
 561             : endRes + 1)
 562             : endRes + 1;
 563     consensus.annotations = null;
 564     consensus.annotations = new Annotation[aWidth]; // should be alignment width
 565
 566     AAFrequency.completeConsensus(consensus, cnsns, startRes, endRes + 1,
 567             ignoreGapsInConsensus, showSequenceLogo); // TODO: setting container
 568                                                       // for
 569                                                       // ignoreGapsInConsensusCalculation);
 570   }
 571
 572   /**
 573    * @param s
 574    *          sequence to either add or remove from group
 575    * @param recalc
 576    *          flag passed to delete/addSequence to indicate if group properties
 577    *          should be recalculated
 578    */
 579   public void addOrRemove(SequenceI s, boolean recalc)
 580   {
 581     if (sequences.contains(s))
 582     {
 583       deleteSequence(s, recalc);
 584     }
 585     else
 586     {
 587       addSequence(s, recalc);
 588     }
 589   }
 590
 591   /**
 592    * DOCUMENT ME!
 593    *
 594    * @param s
 595    *          DOCUMENT ME!
 596    * @param recalc
 597    *          DOCUMENT ME!
 598    */
 599   public void deleteSequence(SequenceI s, boolean recalc)
 600   {
 601     sequences.removeElement(s);
 602
 603     if (recalc)
 604     {
 605       recalcConservation();
 606     }
 607   }
 608
 609   /**
 610    * DOCUMENT ME!
 611    *
 612    * @return DOCUMENT ME!
 613    */
 614   public int getStartRes()
 615   {
 616     return startRes;
 617   }
 618
 619   /**
 620    * DOCUMENT ME!
 621    *
 622    * @return DOCUMENT ME!
 623    */
 624   public int getEndRes()
 625   {
 626     return endRes;
 627   }
 628
 629   /**
 630    * Set the first column selected by this group. Runs from 0<=i<N_cols
 631    *
 632    * @param i
 633    */
 634   public void setStartRes(int i)
 635   {
 636     startRes = i;
 637   }
 638
 639   /**
 640    * Set the groups last selected column. Runs from 0<=i<N_cols
 641    *
 642    * @param i
 643    */
 644   public void setEndRes(int i)
 645   {
 646     endRes = i;
 647   }
 648
 649   /**
 650    * DOCUMENT ME!
 651    *
 652    * @return DOCUMENT ME!
 653    */
 654   public int getSize()
 655   {
 656     return sequences.size();
 657   }
 658
 659   /**
 660    * DOCUMENT ME!
 661    *
 662    * @param i
 663    *          DOCUMENT ME!
 664    *
 665    * @return DOCUMENT ME!
 666    */
 667   public SequenceI getSequenceAt(int i)
 668   {
 669     return (SequenceI) sequences.elementAt(i);
 670   }
 671
 672   /**
 673    * DOCUMENT ME!
 674    *
 675    * @param state
 676    *          DOCUMENT ME!
 677    */
 678   public void setColourText(boolean state)
 679   {
 680     colourText = state;
 681   }
 682
 683   /**
 684    * DOCUMENT ME!
 685    *
 686    * @return DOCUMENT ME!
 687    */
 688   public boolean getColourText()
 689   {
 690     return colourText;
 691   }
 692
 693   /**
 694    * DOCUMENT ME!
 695    *
 696    * @param state
 697    *          DOCUMENT ME!
 698    */
 699   public void setDisplayText(boolean state)
 700   {
 701     displayText = state;
 702   }
 703
 704   /**
 705    * DOCUMENT ME!
 706    *
 707    * @return DOCUMENT ME!
 708    */
 709   public boolean getDisplayText()
 710   {
 711     return displayText;
 712   }
 713
 714   /**
 715    * DOCUMENT ME!
 716    *
 717    * @param state
 718    *          DOCUMENT ME!
 719    */
 720   public void setDisplayBoxes(boolean state)
 721   {
 722     displayBoxes = state;
 723   }
 724
 725   /**
 726    * DOCUMENT ME!
 727    *
 728    * @return DOCUMENT ME!
 729    */
 730   public boolean getDisplayBoxes()
 731   {
 732     return displayBoxes;
 733   }
 734
 735   /**
 736    * DOCUMENT ME!
 737    *
 738    * @return DOCUMENT ME!
 739    */
 740   public int getWidth()
 741   {
 742     // MC This needs to get reset when characters are inserted and deleted
 743     if (sequences.size() > 0)
 744     {
 745       width = ((SequenceI) sequences.elementAt(0)).getLength();
 746     }
 747
 748     for (int i = 1; i < sequences.size(); i++)
 749     {
 750       SequenceI seq = (SequenceI) sequences.elementAt(i);
 751
 752       if (seq.getLength() > width)
 753       {
 754         width = seq.getLength();
 755       }
 756     }
 757
 758     return width;
 759   }
 760
 761   /**
 762    * DOCUMENT ME!
 763    *
 764    * @param c
 765    *          DOCUMENT ME!
 766    */
 767   public void setOutlineColour(Color c)
 768   {
 769     outlineColour = c;
 770   }
 771
 772   /**
 773    * DOCUMENT ME!
 774    *
 775    * @return DOCUMENT ME!
 776    */
 777   public Color getOutlineColour()
 778   {
 779     return outlineColour;
 780   }
 781
 782   /**
 783    *
 784    * returns the sequences in the group ordered by the ordering given by al.
 785    * this used to return an array with null entries regardless, new behaviour is
 786    * below. TODO: verify that this does not affect use in applet or application
 787    *
 788    * @param al
 789    *          Alignment
 790    * @return SequenceI[] intersection of sequences in group with al, ordered by
 791    *         al, or null if group does not intersect with al
 792    */
 793   public SequenceI[] getSequencesInOrder(AlignmentI al)
 794   {
 795     return getSequencesInOrder(al, true);
 796   }
 797   /**
 798    * return an array representing the intersection of the group with al, optionally returning an array the size of al.getHeight()
 799    * where nulls mark the non-intersected sequences
 800    * @param al
 801    * @param trim
 802    * @return null or array
 803    */
 804   public SequenceI[] getSequencesInOrder(AlignmentI al, boolean trim)
 805   {
 806     int sSize = sequences.size();
 807     int alHeight = al.getHeight();
 808
 809     SequenceI[] seqs = new SequenceI[(trim) ? sSize : alHeight];
 810
 811     int index = 0;
 812     for (int i = 0; i < alHeight && index < sSize; i++)
 813     {
 814       if (sequences.contains(al.getSequenceAt(i)))
 815       {
 816         seqs[(trim) ? index : i] = al.getSequenceAt(i);
 817         index++;
 818       }
 819     }
 820     if (index == 0)
 821     {
 822       return null;
 823     }
 824     if (!trim)
 825     {
 826       return seqs;
 827     }
 828     if (index < seqs.length)
 829     {
 830       SequenceI[] dummy = seqs;
 831       seqs = new SequenceI[index];
 832       while (--index >= 0)
 833       {
 834         seqs[index] = dummy[index];
 835         dummy[index] = null;
 836       }
 837     }
 838     return seqs;
 839   }
 840
 841   /**
 842    * @return the idColour
 843    */
 844   public Color getIdColour()
 845   {
 846     return idColour;
 847   }
 848
 849   /**
 850    * @param idColour
 851    *          the idColour to set
 852    */
 853   public void setIdColour(Color idColour)
 854   {
 855     this.idColour = idColour;
 856   }
 857
 858   /**
 859    * @return the representative sequence for this group
 860    */
 861   public SequenceI getSeqrep()
 862   {
 863     return seqrep;
 864   }
 865
 866   /**
 867    * set the representative sequence for this group. Note - this affects the
 868    * interpretation of the Hidereps attribute.
 869    *
 870    * @param seqrep
 871    *          the seqrep to set (null means no sequence representative)
 872    */
 873   public void setSeqrep(SequenceI seqrep)
 874   {
 875     this.seqrep = seqrep;
 876   }
 877
 878   /**
 879    *
 880    * @return true if group has a sequence representative
 881    */
 882   public boolean hasSeqrep()
 883   {
 884     return seqrep != null;
 885   }
 886
 887   /**
 888    * visibility of rows or represented rows covered by group
 889    */
 890   private boolean hidereps = false;
 891
 892   /**
 893    * set visibility of sequences covered by (if no sequence representative is
 894    * defined) or represented by this group.
 895    *
 896    * @param visibility
 897    */
 898   public void setHidereps(boolean visibility)
 899   {
 900     hidereps = visibility;
 901   }
 902
 903   /**
 904    *
 905    * @return true if sequences represented (or covered) by this group should be
 906    *         hidden
 907    */
 908   public boolean isHidereps()
 909   {
 910     return hidereps;
 911   }
 912
 913   /**
 914    * visibility of columns intersecting this group
 915    */
 916   private boolean hidecols = false;
 917
 918   /**
 919    * set intended visibility of columns covered by this group
 920    *
 921    * @param visibility
 922    */
 923   public void setHideCols(boolean visibility)
 924   {
 925     hidecols = visibility;
 926   }
 927
 928   /**
 929    *
 930    * @return true if columns covered by group should be hidden
 931    */
 932   public boolean isHideCols()
 933   {
 934     return hidecols;
 935   }
 936
 937   /**
 938    * create a new sequence group from the intersection of this group with an
 939    * alignment Hashtable of hidden representatives
 940    *
 941    * @param alignment
 942    *          (may not be null)
 943    * @param hashtable
 944    *          (may be null)
 945    * @return new group containing sequences common to this group and alignment
 946    */
 947   public SequenceGroup intersect(AlignmentI alignment, Hashtable hashtable)
 948   {
 949     SequenceGroup sgroup = new SequenceGroup(this);
 950     SequenceI[] insect = getSequencesInOrder(alignment);
 951     sgroup.sequences = new Vector();
 952     for (int s = 0; insect != null && s < insect.length; s++)
 953     {
 954       if (hashtable == null || hashtable.containsKey(insect[s]))
 955       {
 956         sgroup.sequences.addElement(insect[s]);
 957       }
 958     }
 959     // Enumeration en =getSequences(hashtable).elements();
 960     // while (en.hasMoreElements())
 961     // {
 962     // SequenceI elem = (SequenceI) en.nextElement();
 963     // if (alignment.getSequences().contains(elem))
 964     // {
 965     // sgroup.addSequence(elem, false);
 966     // }
 967     // }
 968     return sgroup;
 969   }
 970
 971   /**
 972    * @return the showUnconserved
 973    */
 974   public boolean getShowNonconserved()
 975   {
 976     return showNonconserved;
 977   }
 978
 979   /**
 980    * @param showNonconserved
 981    *          the showUnconserved to set
 982    */
 983   public void setShowNonconserved(boolean displayNonconserved)
 984   {
 985     this.showNonconserved = displayNonconserved;
 986   }
 987
 988   AlignmentAnnotation consensus = null, conservation = null;
 989
 990   /**
 991    * flag indicating if consensus histogram should be rendered
 992    */
 993   private boolean showConsensusHistogram;
 994
 995   /**
 996    *
 997    * @return automatically calculated consensus row
 998    */
 999   public AlignmentAnnotation getConsensus()
1000   {
1001     // TODO get or calculate and get consensus annotation row for this group
1002     int aWidth = this.getWidth();
1003     // pointer
1004     // possibility
1005     // here.
1006     if (aWidth < 0)
1007     {
1008       return null;
1009     }
1010     if (consensus == null)
1011     {
1012       consensus = new AlignmentAnnotation("", "", new Annotation[1], 0f,
1013               100f, AlignmentAnnotation.BAR_GRAPH);
1014     }
1015     consensus.hasText = true;
1016     consensus.autoCalculated = true;
1017     consensus.groupRef = this;
1018     consensus.label = "Consensus for " + getName();
1019     consensus.description = "Percent Identity";
1020     return consensus;
1021   }
1022
1023   /**
1024    * get the conservation annotation row for this group
1025    *
1026    * @return autoCalculated annotation row
1027    */
1028   public AlignmentAnnotation getConservationRow()
1029   {
1030     if (conservation == null)
1031     {
1032       conservation = new AlignmentAnnotation("", "", new Annotation[1], 0f,
1033               11f, AlignmentAnnotation.BAR_GRAPH);
1034     }
1035
1036     conservation.hasText = true;
1037     conservation.autoCalculated = true;
1038     conservation.groupRef = this;
1039     conservation.label = "Conservation for " + getName();
1040     conservation.description = "Conservation for group " + getName()
1041             + " less than " + consPercGaps + "% gaps";
1042     return conservation;
1043   }
1044
1045   /**
1046    *
1047    * @return true if annotation rows have been instantiated for this group
1048    */
1049   public boolean hasAnnotationRows()
1050   {
1051     return consensus != null || conservation != null;
1052   }
1053
1054   public SequenceI getConsensusSeq()
1055   {
1056     getConsensus();
1057     StringBuffer seqs = new StringBuffer();
1058     for (int i = 0; i < consensus.annotations.length; i++)
1059     {
1060       if (consensus.annotations[i] != null)
1061       {
1062         if (consensus.annotations[i].description.charAt(0) == '[')
1063         {
1064           seqs.append(consensus.annotations[i].description.charAt(1));
1065         }
1066         else
1067         {
1068           seqs.append(consensus.annotations[i].displayCharacter);
1069         }
1070       }
1071     }
1072
1073     SequenceI sq = new Sequence("Group" + getName() + " Consensus",
1074             seqs.toString());
1075     sq.setDescription("Percentage Identity Consensus "
1076             + ((ignoreGapsInConsensus) ? " without gaps" : ""));
1077     return sq;
1078   }
1079
1080   public void setIgnoreGapsConsensus(boolean state)
1081   {
1082     if (this.ignoreGapsInConsensus != state && consensus != null)
1083     {
1084       ignoreGapsInConsensus = state;
1085       recalcConservation();
1086     }
1087     ignoreGapsInConsensus = state;
1088   }
1089
1090   public boolean getIgnoreGapsConsensus()
1091   {
1092     return ignoreGapsInConsensus;
1093   }
1094
1095   /**
1096    * @param showSequenceLogo
1097    *          indicates if a sequence logo is shown for consensus annotation
1098    */
1099   public void setshowSequenceLogo(boolean showSequenceLogo)
1100   {
1101     // TODO: decouple calculation from settings update
1102     if (this.showSequenceLogo != showSequenceLogo && consensus != null)
1103     {
1104       this.showSequenceLogo = showSequenceLogo;
1105       recalcConservation();
1106     }
1107     this.showSequenceLogo = showSequenceLogo;
1108   }
1109
1110   /**
1111    *
1112    * @param showConsHist
1113    *          flag indicating if the consensus histogram for this group should
1114    *          be rendered
1115    */
1116   public void setShowConsensusHistogram(boolean showConsHist)
1117   {
1118
1119     if (showConsensusHistogram != showConsHist && consensus != null)
1120     {
1121       this.showConsensusHistogram = showConsHist;
1122       recalcConservation();
1123     }
1124     this.showConsensusHistogram = showConsHist;
1125   }
1126
1127   /**
1128    * @return the showConsensusHistogram
1129    */
1130   public boolean isShowConsensusHistogram()
1131   {
1132     return showConsensusHistogram;
1133   }
1134 }