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