src/jalview/datamodel/SequenceGroup.java

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