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) ? (endRes < conservation.annotations.length ? conservation.annotations.length
 648             : endRes + 1)
 649             : endRes + 1;
 650     conservation.annotations = null;
 651     conservation.annotations = new Annotation[aWidth]; // should be alignment
 652                                                        // width
 653     c.completeAnnotations(conservation, null, startRes, endRes + 1);
 654   }
 655
 656   public ProfilesI consensusData = null;
 657
 658   private void _updateConsensusRow(ProfilesI cnsns, long nseq)
 659   {
 660     if (consensus == null)
 661     {
 662       getConsensus();
 663     }
 664     consensus.label = "Consensus for " + getName();
 665     consensus.description = "Percent Identity";
 666     consensusData = cnsns;
 667     // preserve width if already set
 668     int aWidth = (consensus.annotations != null) ? (endRes < consensus.annotations.length ? consensus.annotations.length
 669             : endRes + 1)
 670             : endRes + 1;
 671     consensus.annotations = null;
 672     consensus.annotations = new Annotation[aWidth]; // should be alignment width
 673
 674     AAFrequency.completeConsensus(consensus, cnsns, startRes, endRes + 1,
 675             ignoreGapsInConsensus, showSequenceLogo, nseq); // TODO: setting
 676                                                             // container
 677     // for
 678     // ignoreGapsInConsensusCalculation);
 679   }
 680
 681   /**
 682    * @param s
 683    *          sequence to either add or remove from group
 684    * @param recalc
 685    *          flag passed to delete/addSequence to indicate if group properties
 686    *          should be recalculated
 687    */
 688   public void addOrRemove(SequenceI s, boolean recalc)
 689   {
 690     synchronized (sequences)
 691     {
 692       if (sequences.contains(s))
 693       {
 694         deleteSequence(s, recalc);
 695       }
 696       else
 697       {
 698         addSequence(s, recalc);
 699       }
 700     }
 701   }
 702
 703   /**
 704    * remove
 705    *
 706    * @param s
 707    *          to be removed
 708    * @param recalc
 709    *          true means recalculate conservation
 710    */
 711   public void deleteSequence(SequenceI s, boolean recalc)
 712   {
 713     synchronized (sequences)
 714     {
 715       List<SequenceI> before = sequences;
 716       sequences.remove(s);
 717       changeSupport.firePropertyChange(SEQ_GROUP_CHANGED,
 718               sequences.size() + 1, sequences.size());
 719
 720       if (recalc)
 721       {
 722         recalcConservation();
 723       }
 724     }
 725   }
 726
 727   /**
 728    *
 729    *
 730    * @return the first column selected by this group. Runs from 0<=i<N_cols
 731    */
 732   @Override
 733   public int getStartRes()
 734   {
 735     return startRes;
 736   }
 737
 738   /**
 739    *
 740    * @return the groups last selected column. Runs from 0<=i<N_cols
 741    */
 742   @Override
 743   public int getEndRes()
 744   {
 745     return endRes;
 746   }
 747
 748   /**
 749    * Set the first column selected by this group. Runs from 0<=i<N_cols
 750    *
 751    * @param i
 752    */
 753   public void setStartRes(int i)
 754   {
 755     int before = startRes;
 756     startRes = i;
 757     changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, before, startRes);
 758   }
 759
 760   /**
 761    * Set the groups last selected column. Runs from 0<=i<N_cols
 762    *
 763    * @param i
 764    */
 765   public void setEndRes(int i)
 766   {
 767     int before = endRes;
 768     endRes = i;
 769     changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, before, endRes);
 770   }
 771
 772   /**
 773    * @return number of sequences in group
 774    */
 775   public int getSize()
 776   {
 777     return sequences.size();
 778   }
 779
 780   /**
 781    * @param i
 782    * @return the ith sequence
 783    */
 784   public SequenceI getSequenceAt(int i)
 785   {
 786     return sequences.get(i);
 787   }
 788
 789   /**
 790    * @param state
 791    *          colourText
 792    */
 793   public void setColourText(boolean state)
 794   {
 795     colourText = state;
 796   }
 797
 798   /**
 799    * DOCUMENT ME!
 800    *
 801    * @return DOCUMENT ME!
 802    */
 803   public boolean getColourText()
 804   {
 805     return colourText;
 806   }
 807
 808   /**
 809    * DOCUMENT ME!
 810    *
 811    * @param state
 812    *          DOCUMENT ME!
 813    */
 814   public void setDisplayText(boolean state)
 815   {
 816     displayText = state;
 817   }
 818
 819   /**
 820    * DOCUMENT ME!
 821    *
 822    * @return DOCUMENT ME!
 823    */
 824   public boolean getDisplayText()
 825   {
 826     return displayText;
 827   }
 828
 829   /**
 830    * DOCUMENT ME!
 831    *
 832    * @param state
 833    *          DOCUMENT ME!
 834    */
 835   public void setDisplayBoxes(boolean state)
 836   {
 837     displayBoxes = state;
 838   }
 839
 840   /**
 841    * DOCUMENT ME!
 842    *
 843    * @return DOCUMENT ME!
 844    */
 845   public boolean getDisplayBoxes()
 846   {
 847     return displayBoxes;
 848   }
 849
 850   /**
 851    * computes the width of current set of sequences and returns it
 852    *
 853    * @return DOCUMENT ME!
 854    */
 855   @Override
 856   public int getWidth()
 857   {
 858     synchronized (sequences)
 859     {
 860       // MC This needs to get reset when characters are inserted and deleted
 861       boolean first = true;
 862       for (SequenceI seq : sequences)
 863       {
 864         if (first || seq.getLength() > width)
 865         {
 866           width = seq.getLength();
 867           first = false;
 868         }
 869       }
 870       return width;
 871     }
 872   }
 873
 874   /**
 875    * DOCUMENT ME!
 876    *
 877    * @param c
 878    *          DOCUMENT ME!
 879    */
 880   public void setOutlineColour(Color c)
 881   {
 882     outlineColour = c;
 883   }
 884
 885   /**
 886    * DOCUMENT ME!
 887    *
 888    * @return DOCUMENT ME!
 889    */
 890   public Color getOutlineColour()
 891   {
 892     return outlineColour;
 893   }
 894
 895   /**
 896    *
 897    * returns the sequences in the group ordered by the ordering given by al.
 898    * this used to return an array with null entries regardless, new behaviour is
 899    * below. TODO: verify that this does not affect use in applet or application
 900    *
 901    * @param al
 902    *          Alignment
 903    * @return SequenceI[] intersection of sequences in group with al, ordered by
 904    *         al, or null if group does not intersect with al
 905    */
 906   public SequenceI[] getSequencesInOrder(AlignmentI al)
 907   {
 908     return getSequencesInOrder(al, true);
 909   }
 910
 911   /**
 912    * return an array representing the intersection of the group with al,
 913    * optionally returning an array the size of al.getHeight() where nulls mark
 914    * the non-intersected sequences
 915    *
 916    * @param al
 917    * @param trim
 918    * @return null or array
 919    */
 920   public SequenceI[] getSequencesInOrder(AlignmentI al, boolean trim)
 921   {
 922     synchronized (sequences)
 923     {
 924       int sSize = sequences.size();
 925       int alHeight = al.getHeight();
 926
 927       SequenceI[] seqs = new SequenceI[(trim) ? sSize : alHeight];
 928
 929       int index = 0;
 930       for (int i = 0; i < alHeight && index < sSize; i++)
 931       {
 932         if (sequences.contains(al.getSequenceAt(i)))
 933         {
 934           seqs[(trim) ? index : i] = al.getSequenceAt(i);
 935           index++;
 936         }
 937       }
 938       if (index == 0)
 939       {
 940         return null;
 941       }
 942       if (!trim)
 943       {
 944         return seqs;
 945       }
 946       if (index < seqs.length)
 947       {
 948         SequenceI[] dummy = seqs;
 949         seqs = new SequenceI[index];
 950         while (--index >= 0)
 951         {
 952           seqs[index] = dummy[index];
 953           dummy[index] = null;
 954         }
 955       }
 956       return seqs;
 957     }
 958   }
 959
 960   /**
 961    * @return the idColour
 962    */
 963   public Color getIdColour()
 964   {
 965     return idColour;
 966   }
 967
 968   /**
 969    * @param idColour
 970    *          the idColour to set
 971    */
 972   public void setIdColour(Color idColour)
 973   {
 974     this.idColour = idColour;
 975   }
 976
 977   /**
 978    * @return the representative sequence for this group
 979    */
 980   @Override
 981   public SequenceI getSeqrep()
 982   {
 983     return seqrep;
 984   }
 985
 986   /**
 987    * set the representative sequence for this group. Note - this affects the
 988    * interpretation of the Hidereps attribute.
 989    *
 990    * @param seqrep
 991    *          the seqrep to set (null means no sequence representative)
 992    */
 993   @Override
 994   public void setSeqrep(SequenceI seqrep)
 995   {
 996     this.seqrep = seqrep;
 997   }
 998
 999   /**
1000    *
1001    * @return true if group has a sequence representative
1002    */
1003   @Override
1004   public boolean hasSeqrep()
1005   {
1006     return seqrep != null;
1007   }
1008
1009   /**
1010    * set visibility of sequences covered by (if no sequence representative is
1011    * defined) or represented by this group.
1012    *
1013    * @param visibility
1014    */
1015   public void setHidereps(boolean visibility)
1016   {
1017     hidereps = visibility;
1018   }
1019
1020   /**
1021    *
1022    * @return true if sequences represented (or covered) by this group should be
1023    *         hidden
1024    */
1025   public boolean isHidereps()
1026   {
1027     return hidereps;
1028   }
1029
1030   /**
1031    * set intended visibility of columns covered by this group
1032    *
1033    * @param visibility
1034    */
1035   public void setHideCols(boolean visibility)
1036   {
1037     hidecols = visibility;
1038   }
1039
1040   /**
1041    *
1042    * @return true if columns covered by group should be hidden
1043    */
1044   public boolean isHideCols()
1045   {
1046     return hidecols;
1047   }
1048
1049   /**
1050    * create a new sequence group from the intersection of this group with an
1051    * alignment Hashtable of hidden representatives
1052    *
1053    * @param alignment
1054    *          (may not be null)
1055    * @param map
1056    *          (may be null)
1057    * @return new group containing sequences common to this group and alignment
1058    */
1059   public SequenceGroup intersect(AlignmentI alignment,
1060           Map<SequenceI, SequenceCollectionI> map)
1061   {
1062     SequenceGroup sgroup = new SequenceGroup(this);
1063     SequenceI[] insect = getSequencesInOrder(alignment);
1064     sgroup.sequences = new ArrayList<>();
1065     for (int s = 0; insect != null && s < insect.length; s++)
1066     {
1067       if (map == null || map.containsKey(insect[s]))
1068       {
1069         sgroup.sequences.add(insect[s]);
1070       }
1071     }
1072     return sgroup;
1073   }
1074
1075   /**
1076    * @return the showUnconserved
1077    */
1078   public boolean getShowNonconserved()
1079   {
1080     return showNonconserved;
1081   }
1082
1083   /**
1084    * @param showNonconserved
1085    *          the showUnconserved to set
1086    */
1087   public void setShowNonconserved(boolean displayNonconserved)
1088   {
1089     this.showNonconserved = displayNonconserved;
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 setConsensus(AlignmentAnnotation aan)
1099   {
1100     if (consensus == null)
1101     {
1102       consensus = aan;
1103     }
1104   }
1105
1106   /**
1107    *
1108    * @return automatically calculated consensus row note: the row is a stub if a
1109    *         consensus calculation has not yet been performed on the group
1110    */
1111   public AlignmentAnnotation getConsensus()
1112   {
1113     // TODO get or calculate and get consensus annotation row for this group
1114     int aWidth = this.getWidth();
1115     // pointer
1116     // possibility
1117     // here.
1118     if (aWidth < 0)
1119     {
1120       return null;
1121     }
1122     if (consensus == null)
1123     {
1124       consensus = new AlignmentAnnotation("", "", new Annotation[1], 0f,
1125               100f, AlignmentAnnotation.BAR_GRAPH);
1126       consensus.hasText = true;
1127       consensus.autoCalculated = true;
1128       consensus.groupRef = this;
1129       consensus.label = "Consensus for " + getName();
1130       consensus.description = "Percent Identity";
1131     }
1132     return consensus;
1133   }
1134
1135   /**
1136    * set this alignmentAnnotation object as the one used to render consensus
1137    * annotation
1138    *
1139    * @param aan
1140    */
1141   public void setConservationRow(AlignmentAnnotation aan)
1142   {
1143     if (conservation == null)
1144     {
1145       conservation = aan;
1146     }
1147   }
1148
1149   /**
1150    * get the conservation annotation row for this group
1151    *
1152    * @return autoCalculated annotation row
1153    */
1154   public AlignmentAnnotation getConservationRow()
1155   {
1156     if (conservation == null)
1157     {
1158       conservation = new AlignmentAnnotation("", "", new Annotation[1], 0f,
1159               11f, AlignmentAnnotation.BAR_GRAPH);
1160     }
1161
1162     conservation.hasText = true;
1163     conservation.autoCalculated = true;
1164     conservation.groupRef = this;
1165     conservation.label = "Conservation for " + getName();
1166     conservation.description = "Conservation for group " + getName()
1167             + " less than " + consPercGaps + "% gaps";
1168     return conservation;
1169   }
1170
1171   /**
1172    *
1173    * @return true if annotation rows have been instantiated for this group
1174    */
1175   public boolean hasAnnotationRows()
1176   {
1177     return consensus != null || conservation != null;
1178   }
1179
1180   public SequenceI getConsensusSeq()
1181   {
1182     getConsensus();
1183     StringBuffer seqs = new StringBuffer();
1184     for (int i = 0; i < consensus.annotations.length; i++)
1185     {
1186       if (consensus.annotations[i] != null)
1187       {
1188         if (consensus.annotations[i].description.charAt(0) == '[')
1189         {
1190           seqs.append(consensus.annotations[i].description.charAt(1));
1191         }
1192         else
1193         {
1194           seqs.append(consensus.annotations[i].displayCharacter);
1195         }
1196       }
1197     }
1198
1199     SequenceI sq = new Sequence("Group" + getName() + " Consensus",
1200             seqs.toString());
1201     sq.setDescription("Percentage Identity Consensus "
1202             + ((ignoreGapsInConsensus) ? " without gaps" : ""));
1203     return sq;
1204   }
1205
1206   public void setIgnoreGapsConsensus(boolean state)
1207   {
1208     if (this.ignoreGapsInConsensus != state && consensus != null)
1209     {
1210       ignoreGapsInConsensus = state;
1211       recalcConservation();
1212     }
1213     ignoreGapsInConsensus = state;
1214   }
1215
1216   public boolean getIgnoreGapsConsensus()
1217   {
1218     return ignoreGapsInConsensus;
1219   }
1220
1221   /**
1222    * @param showSequenceLogo
1223    *          indicates if a sequence logo is shown for consensus annotation
1224    */
1225   public void setshowSequenceLogo(boolean showSequenceLogo)
1226   {
1227     // TODO: decouple calculation from settings update
1228     if (this.showSequenceLogo != showSequenceLogo && consensus != null)
1229     {
1230       this.showSequenceLogo = showSequenceLogo;
1231       recalcConservation();
1232     }
1233     this.showSequenceLogo = showSequenceLogo;
1234   }
1235
1236   /**
1237    *
1238    * @param showConsHist
1239    *          flag indicating if the consensus histogram for this group should
1240    *          be rendered
1241    */
1242   public void setShowConsensusHistogram(boolean showConsHist)
1243   {
1244
1245     if (showConsensusHistogram != showConsHist && consensus != null)
1246     {
1247       this.showConsensusHistogram = showConsHist;
1248       recalcConservation();
1249     }
1250     this.showConsensusHistogram = showConsHist;
1251   }
1252
1253   /**
1254    * @return the showConsensusHistogram
1255    */
1256   public boolean isShowConsensusHistogram()
1257   {
1258     return showConsensusHistogram;
1259   }
1260
1261   /**
1262    * set flag indicating if logo should be normalised when rendered
1263    *
1264    * @param norm
1265    */
1266   public void setNormaliseSequenceLogo(boolean norm)
1267   {
1268     normaliseSequenceLogo = norm;
1269   }
1270
1271   public boolean isNormaliseSequenceLogo()
1272   {
1273     return normaliseSequenceLogo;
1274   }
1275
1276   @Override
1277   /**
1278    * returns a new array with all annotation involving this group
1279    */
1280   public AlignmentAnnotation[] getAlignmentAnnotation()
1281   {
1282     // TODO add in other methods like 'getAlignmentAnnotation(String label),
1283     // etc'
1284     ArrayList<AlignmentAnnotation> annot = new ArrayList<>();
1285     synchronized (sequences)
1286     {
1287       for (SequenceI seq : sequences)
1288       {
1289         AlignmentAnnotation[] aa = seq.getAnnotation();
1290         if (aa != null)
1291         {
1292           for (AlignmentAnnotation al : aa)
1293           {
1294             if (al.groupRef == this)
1295             {
1296               annot.add(al);
1297             }
1298           }
1299         }
1300       }
1301       if (consensus != null)
1302       {
1303         annot.add(consensus);
1304       }
1305       if (conservation != null)
1306       {
1307         annot.add(conservation);
1308       }
1309     }
1310     return annot.toArray(new AlignmentAnnotation[0]);
1311   }
1312
1313   @Override
1314   public Iterable<AlignmentAnnotation> findAnnotation(String calcId)
1315   {
1316     List<AlignmentAnnotation> aa = new ArrayList<>();
1317     if (calcId == null)
1318     {
1319       return aa;
1320     }
1321     for (AlignmentAnnotation a : getAlignmentAnnotation())
1322     {
1323       if (calcId.equals(a.getCalcId()))
1324       {
1325         aa.add(a);
1326       }
1327     }
1328     return aa;
1329   }
1330
1331   @Override
1332   public Iterable<AlignmentAnnotation> findAnnotations(SequenceI seq,
1333           String calcId, String label)
1334   {
1335     ArrayList<AlignmentAnnotation> aa = new ArrayList<>();
1336     for (AlignmentAnnotation ann : getAlignmentAnnotation())
1337     {
1338       if ((calcId == null || (ann.getCalcId() != null && ann.getCalcId()
1339               .equals(calcId)))
1340               && (seq == null || (ann.sequenceRef != null && ann.sequenceRef == seq))
1341               && (label == null || (ann.label != null && ann.label
1342                       .equals(label))))
1343       {
1344         aa.add(ann);
1345       }
1346     }
1347     return aa;
1348   }
1349
1350   /**
1351    * Answer true if any annotation matches the calcId passed in (if not null).
1352    *
1353    * @param calcId
1354    * @return
1355    */
1356   public boolean hasAnnotation(String calcId)
1357   {
1358     if (calcId != null && !"".equals(calcId))
1359     {
1360       for (AlignmentAnnotation a : getAlignmentAnnotation())
1361       {
1362         if (a.getCalcId() == calcId)
1363         {
1364           return true;
1365         }
1366       }
1367     }
1368     return false;
1369   }
1370
1371   /**
1372    * Remove all sequences from the group (leaving other properties unchanged).
1373    */
1374   public void clear()
1375   {
1376     synchronized (sequences)
1377     {
1378       List<SequenceI> before = sequences;
1379       sequences.clear();
1380       changeSupport.firePropertyChange(SEQ_GROUP_CHANGED, before,
1381               sequences);
1382     }
1383   }
1384
1385   /**
1386    * Sets the alignment or group context for this group, and whether it is
1387    * defined as a group
1388    *
1389    * @param ctx
1390    *          the context for the group
1391    * @param defined
1392    *          whether the group is defined on the alignment or is just a
1393    *          selection
1394    * @throws IllegalArgumentException
1395    *           if setting the context would result in a circular reference chain
1396    */
1397   public void setContext(AnnotatedCollectionI ctx, boolean defined)
1398   {
1399     setContext(ctx);
1400     this.isDefined = defined;
1401   }
1402
1403   /**
1404    * Sets the alignment or group context for this group
1405    *
1406    * @param ctx
1407    *          the context for the group
1408    * @throws IllegalArgumentException
1409    *           if setting the context would result in a circular reference chain
1410    */
1411   public void setContext(AnnotatedCollectionI ctx)
1412   {
1413     AnnotatedCollectionI ref = ctx;
1414     while (ref != null)
1415     {
1416       if (ref == this || ref.getContext() == ctx)
1417       {
1418         throw new IllegalArgumentException(
1419                 "Circular reference in SequenceGroup.context");
1420       }
1421       ref = ref.getContext();
1422     }
1423     this.context = ctx;
1424   }
1425
1426   /*
1427    * (non-Javadoc)
1428    *
1429    * @see jalview.datamodel.AnnotatedCollectionI#getContext()
1430    */
1431   @Override
1432   public AnnotatedCollectionI getContext()
1433   {
1434     return context;
1435   }
1436
1437   public boolean isDefined()
1438   {
1439     return isDefined;
1440   }
1441
1442   public void setColourScheme(ColourSchemeI scheme)
1443   {
1444     if (cs == null)
1445     {
1446       cs = new ResidueShader();
1447     }
1448     cs.setColourScheme(scheme);
1449   }
1450
1451   public void setGroupColourScheme(ResidueShaderI scheme)
1452   {
1453     cs = scheme;
1454   }
1455
1456   public ColourSchemeI getColourScheme()
1457   {
1458     return cs == null ? null : cs.getColourScheme();
1459   }
1460
1461   public ResidueShaderI getGroupColourScheme()
1462   {
1463     return cs;
1464   }
1465
1466   @Override
1467   public boolean isNucleotide()
1468   {
1469     if (context != null) {
1470       return context.isNucleotide();
1471     }
1472     return false;
1473   }
1474
1475   /**
1476    * @param seq
1477    * @return true if seq is a member of the group
1478    */
1479
1480   public boolean contains(SequenceI seq1)
1481   {
1482     return sequences.contains(seq1);
1483   }
1484
1485   /**
1486    * @param seq
1487    * @param apos
1488    * @return true if startRes<=apos and endRes>=apos and seq is in the group
1489    */
1490   public boolean contains(SequenceI seq, int apos)
1491   {
1492     return (startRes <= apos && endRes >= apos) && sequences.contains(seq);
1493   }
1494 }