src/jalview/renderer/AnnotationRenderer.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
   3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 package jalview.renderer;
  19
  20 import jalview.analysis.AAFrequency;
  21 import jalview.analysis.StructureFrequency;
  22 import jalview.api.AlignViewportI;
  23 import jalview.datamodel.AlignmentAnnotation;
  24 import jalview.datamodel.Annotation;
  25 import jalview.datamodel.ColumnSelection;
  26 import jalview.schemes.ColourSchemeI;
  27
  28 import java.awt.BasicStroke;
  29 import java.awt.Color;
  30 import java.awt.Font;
  31 import java.awt.FontMetrics;
  32 import java.awt.Graphics;
  33 import java.awt.Graphics2D;
  34 import java.awt.Image;
  35 import java.awt.font.LineMetrics;
  36 import java.awt.geom.AffineTransform;
  37 import java.awt.image.ImageObserver;
  38 import java.util.BitSet;
  39 import java.util.Hashtable;
  40
  41 import com.stevesoft.pat.Regex;
  42
  43 public class AnnotationRenderer
  44 {
  45   /**
  46    * flag indicating if timing and redraw parameter info should be output
  47    */
  48   private final boolean debugRedraw;
  49
  50   public AnnotationRenderer()
  51   {
  52     this(false);
  53   }
  54   /**
  55    * Create a new annotation Renderer
  56    * @param debugRedraw flag indicating if timing and redraw parameter info should be output
  57    */
  58   public AnnotationRenderer(boolean debugRedraw)
  59   {
  60     this.debugRedraw=debugRedraw;
  61   }
  62
  63   public void drawStemAnnot(Graphics g, Annotation[] row_annotations,
  64           int lastSSX, int x, int y, int iconOffset, int startRes,
  65           int column, boolean validRes, boolean validEnd)
  66   {
  67     g.setColor(STEM_COLOUR);
  68     int sCol = (lastSSX / charWidth) + startRes;
  69     int x1 = lastSSX;
  70     int x2 = (x * charWidth);
  71     Regex closeparen = new Regex("(\\))");
  72
  73     String dc = (column == 0 || row_annotations[column - 1] == null) ? ""
  74             : row_annotations[column - 1].displayCharacter;
  75
  76     boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
  77             || !dc.equals(row_annotations[sCol - 1].displayCharacter);
  78     boolean diffdownstream = !validRes || !validEnd
  79             || row_annotations[column] == null
  80             || !dc.equals(row_annotations[column].displayCharacter);
  81     // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream);
  82     // If a closing base pair half of the stem, display a backward arrow
  83     if (column > 0 && closeparen.search(dc))
  84     {
  85       if (diffupstream)
  86       // if (validRes && column>1 && row_annotations[column-2]!=null &&
  87       // dc.equals(row_annotations[column-2].displayCharacter))
  88       {
  89         g.fillPolygon(new int[]
  90         { lastSSX + 5, lastSSX + 5, lastSSX }, new int[]
  91         { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
  92         x1 += 5;
  93       }
  94       if (diffdownstream)
  95       {
  96         x2 -= 1;
  97       }
  98     }
  99     else
 100     {
 101       // display a forward arrow
 102       if (diffdownstream)
 103       {
 104         g.fillPolygon(new int[]
 105         { x2 - 5, x2 - 5, x2 }, new int[]
 106         { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
 107         x2 -= 5;
 108       }
 109       if (diffupstream)
 110       {
 111         x1 += 1;
 112       }
 113     }
 114     // draw arrow body
 115     g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
 116   }
 117
 118   private int charWidth, endRes, charHeight;
 119
 120   private boolean validCharWidth, hasHiddenColumns;
 121
 122   private FontMetrics fm;
 123
 124   private final boolean MAC = new jalview.util.Platform().isAMac();
 125
 126   boolean av_renderHistogram = true, av_renderProfile = true,
 127           av_normaliseProfile = false;
 128
 129   ColourSchemeI profcolour = null;
 130
 131   private ColumnSelection columnSelection;
 132
 133   private Hashtable[] hconsensus;
 134
 135   private Hashtable[] hStrucConsensus;
 136
 137   private boolean av_ignoreGapsConsensus;
 138
 139   /**
 140    * attributes set from AwtRenderPanelI
 141    */
 142   /**
 143    * old image used when data is currently being calculated and cannot be
 144    * rendered
 145    */
 146   private Image fadedImage;
 147
 148   /**
 149    * panel being rendered into
 150    */
 151   private ImageObserver annotationPanel;
 152
 153   /**
 154    * width of image to render in panel
 155    */
 156   private int imgWidth;
 157   /**
 158    * offset to beginning of visible area
 159    */
 160   private int sOffset;
 161   /**
 162    * offset to end of visible area
 163    */
 164   private int visHeight;
 165   /**
 166    * indicate if the renderer should only render the visible portion of the annotation given the current view settings
 167    */
 168   private boolean useClip=true;
 169   /**
 170    * master flag indicating if renderer should ever try to clip. not enabled for jalview 2.8.1
 171    */
 172   private boolean canClip=false;
 173
 174   // public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI
 175   // av)
 176   public void updateFromAwtRenderPanel(AwtRenderPanelI annotPanel,
 177           AlignViewportI av)
 178   {
 179     fm = annotPanel.getFontMetrics();
 180     annotationPanel = annotPanel;
 181     fadedImage = annotPanel.getFadedImage();
 182     imgWidth = annotPanel.getFadedImageWidth();
 183     // visible area for rendering
 184     int[] bounds=annotPanel.getVisibleVRange();
 185     if (bounds!=null)
 186     {
 187       sOffset = bounds[0];
 188       visHeight = bounds[1];
 189       if (visHeight==0)
 190       {
 191         useClip=false;
 192       } else {
 193         useClip=canClip;
 194       }
 195     } else {
 196       useClip=false;
 197     }
 198
 199     updateFromAlignViewport(av);
 200   }
 201
 202   public void updateFromAlignViewport(AlignViewportI av)
 203   {
 204     charWidth = av.getCharWidth();
 205     endRes = av.getEndRes();
 206     charHeight = av.getCharHeight();
 207     hasHiddenColumns = av.hasHiddenColumns();
 208     validCharWidth = av.isValidCharWidth();
 209     av_renderHistogram = av.isShowConsensusHistogram();
 210     av_renderProfile = av.isShowSequenceLogo();
 211     av_normaliseProfile = av.isNormaliseSequenceLogo();
 212     profcolour = av.getGlobalColourScheme();
 213     if (profcolour == null)
 214     {
 215       // Set the default colour for sequence logo if the alignnent has no
 216       // colourscheme set
 217       profcolour = av.getAlignment().isNucleotide() ? new jalview.schemes.NucleotideColourScheme()
 218               : new jalview.schemes.ZappoColourScheme();
 219     }
 220     columnSelection = av.getColumnSelection();
 221     hconsensus = av.getSequenceConsensusHash();// hconsensus;
 222     hStrucConsensus = av.getRnaStructureConsensusHash(); // hStrucConsensus;
 223     av_ignoreGapsConsensus = av.getIgnoreGapsConsensus();
 224   }
 225
 226   public int[] getProfileFor(AlignmentAnnotation aa, int column)
 227   {
 228     // TODO : consider refactoring the global alignment calculation
 229     // properties/rendering attributes as a global 'alignment group' which holds
 230     // all vis settings for the alignment as a whole rather than a subset
 231     //
 232     if (aa.autoCalculated && aa.label.startsWith("Consensus"))
 233     {
 234       if (aa.groupRef != null && aa.groupRef.consensusData != null
 235               && aa.groupRef.isShowSequenceLogo())
 236       {
 237         return AAFrequency.extractProfile(
 238                 aa.groupRef.consensusData[column],
 239                 aa.groupRef.getIgnoreGapsConsensus());
 240       }
 241       // TODO extend annotation row to enable dynamic and static profile data to
 242       // be stored
 243       if (aa.groupRef == null && aa.sequenceRef == null && av_renderProfile)
 244       {
 245         return AAFrequency.extractProfile(hconsensus[column],
 246                 av_ignoreGapsConsensus);
 247       }
 248     }
 249     else
 250     {
 251       if (aa.autoCalculated && aa.label.startsWith("StrucConsensus"))
 252       {
 253         // TODO implement group structure consensus
 254         /*
 255          * if (aa.groupRef != null && aa.groupRef.consensusData != null &&
 256          * aa.groupRef.isShowSequenceLogo()) { //TODO check what happens for
 257          * group selections return StructureFrequency.extractProfile(
 258          * aa.groupRef.consensusData[column], aa.groupRef
 259          * .getIgnoreGapsConsensus()); }
 260          */
 261         // TODO extend annotation row to enable dynamic and static profile data
 262         // to
 263         // be stored
 264         if (aa.groupRef == null && aa.sequenceRef == null
 265                 && av_renderProfile && hStrucConsensus != null
 266                 && hStrucConsensus.length > column)
 267         {
 268           return StructureFrequency.extractProfile(hStrucConsensus[column],
 269                   av_ignoreGapsConsensus);
 270         }
 271       }
 272     }
 273     return null;
 274   }
 275
 276   /**
 277    * Render the annotation rows associated with an alignment.
 278    *
 279    * @param annotPanel
 280    *          container frame
 281    * @param av
 282    *          data and view settings to render
 283    * @param g
 284    *          destination for graphics
 285    * @param activeRow
 286    *          row where a mouse event occured (or -1)
 287    * @param startRes
 288    *          first column that will be drawn
 289    * @param endRes
 290    *          last column that will be drawn
 291    * @return true if the fadedImage was used for any alignment annotation rows
 292    *         currently being calculated
 293    */
 294   public boolean drawComponent(AwtRenderPanelI annotPanel,
 295           AlignViewportI av, Graphics g, int activeRow, int startRes,
 296           int endRes)
 297   {
 298     long stime=System.currentTimeMillis();
 299     boolean usedFaded = false;
 300     // NOTES:
 301     // AnnotationPanel needs to implement: ImageObserver, access to
 302     // AlignViewport
 303     updateFromAwtRenderPanel(annotPanel, av);
 304     fm = g.getFontMetrics();
 305     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 306     if (aa==null)
 307     {
 308       return false;
 309     }
 310     int x = 0, y = 0;
 311     int column = 0;
 312     char lastSS;
 313     int lastSSX;
 314     int iconOffset = 0;
 315     boolean validRes = false;
 316     boolean validEnd = false;
 317     boolean labelAllCols = false;
 318     boolean centreColLabels, centreColLabelsDef = av
 319             .getCentreColumnLabels();
 320     boolean scaleColLabel = false;
 321
 322     BitSet graphGroupDrawn = new BitSet();
 323     int charOffset = 0; // offset for a label
 324     float fmWidth, fmScaling = 1f; // scaling for a label to fit it into a
 325     // column.
 326     Font ofont = g.getFont();
 327     // \u03B2 \u03B1
 328     // debug ints
 329     int yfrom=0,f_i=0,yto=0,f_to=0;
 330     boolean clipst=false,clipend=false;
 331     for (int i = 0; i < aa.length; i++)
 332     {
 333       AlignmentAnnotation row = aa[i];
 334       Annotation[] row_annotations = row.annotations;
 335       if (!row.visible)
 336       {
 337         continue;
 338       }
 339       centreColLabels = row.centreColLabels || centreColLabelsDef;
 340       labelAllCols = row.showAllColLabels;
 341       scaleColLabel = row.scaleColLabel;
 342       lastSS = ' ';
 343       lastSSX = 0;
 344
 345       if (!useClip || ((y-charHeight)<visHeight && (y+row.height+charHeight*2)>=sOffset))
 346       {// if_in_visible_region
 347         if (!clipst)
 348         {
 349           clipst=true;
 350           yfrom=y;
 351           f_i=i;
 352         }
 353         yto = y;
 354         f_to=i;
 355       if (row.graph > 0)
 356       {
 357         if (row.graphGroup > -1 && graphGroupDrawn.get(row.graphGroup)) {
 358           continue;
 359         }
 360
 361         // this is so that we draw the characters below the graph
 362         y += row.height;
 363
 364         if (row.hasText)
 365         {
 366           iconOffset = charHeight - fm.getDescent();
 367           y -= charHeight;
 368         }
 369       }
 370       else if (row.hasText)
 371       {
 372         iconOffset = charHeight - fm.getDescent();
 373
 374       }
 375       else
 376       {
 377         iconOffset = 0;
 378       }
 379
 380       if (row.autoCalculated && av.isCalculationInProgress(row))
 381       {
 382         y += charHeight;
 383         usedFaded = true;
 384         g.drawImage(fadedImage, 0, y - row.height, imgWidth, y, 0, y
 385                 - row.height, imgWidth, y, annotationPanel);
 386         g.setColor(Color.black);
 387         // g.drawString("Calculating "+aa[i].label+"....",20, y-row.height/2);
 388
 389         continue;
 390       }
 391
 392       /*
 393        * else if (annotationPanel.av.updatingConservation &&
 394        * aa[i].label.equals("Conservation")) {
 395        *
 396        * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y -
 397        * row.height, annotationPanel.imgWidth, y, 0, y - row.height,
 398        * annotationPanel.imgWidth, y, annotationPanel);
 399        *
 400        * g.setColor(Color.black); //
 401        * g.drawString("Calculating Conservation.....",20, y-row.height/2);
 402        *
 403        * continue; } else if (annotationPanel.av.updatingConservation &&
 404        * aa[i].label.equals("Quality")) {
 405        *
 406        * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y -
 407        * row.height, annotationPanel.imgWidth, y, 0, y - row.height,
 408        * annotationPanel.imgWidth, y, annotationPanel); g.setColor(Color.black);
 409        * // / g.drawString("Calculating Quality....",20, y-row.height/2);
 410        *
 411        * continue; }
 412        */
 413       // first pass sets up state for drawing continuation from left-hand column
 414       // of startRes
 415       x = (startRes == 0) ? 0 : -1;
 416       while (x < endRes - startRes)
 417       {
 418         if (hasHiddenColumns)
 419         {
 420           column = columnSelection.adjustForHiddenColumns(startRes + x);
 421           if (column > row_annotations.length - 1)
 422           {
 423             break;
 424           }
 425         }
 426         else
 427         {
 428           column = startRes + x;
 429         }
 430
 431         if ((row_annotations == null) || (row_annotations.length <= column)
 432                 || (row_annotations[column] == null))
 433         {
 434           validRes = false;
 435         }
 436         else
 437         {
 438           validRes = true;
 439         }
 440         if (x > -1)
 441         {
 442           if (activeRow == i)
 443           {
 444             g.setColor(Color.red);
 445
 446             if (columnSelection != null)
 447             {
 448               for (int n = 0; n < columnSelection.size(); n++)
 449               {
 450                 int v = columnSelection.columnAt(n);
 451
 452                 if (v == column)
 453                 {
 454                   g.fillRect(x * charWidth, y, charWidth, charHeight);
 455                 }
 456               }
 457             }
 458           }
 459           if (!row.isValidStruc())
 460           {
 461             g.setColor(Color.orange);
 462             g.fillRect((int) row.getInvalidStrucPos() * charWidth, y,
 463                     charWidth, charHeight);
 464           }
 465           if (validCharWidth
 466                   && validRes
 467                   && row_annotations[column].displayCharacter != null
 468                   && (row_annotations[column].displayCharacter.length() > 0))
 469           {
 470
 471             if (centreColLabels || scaleColLabel)
 472             {
 473               fmWidth = fm.charsWidth(
 474                       row_annotations[column].displayCharacter
 475                               .toCharArray(), 0,
 476                       row_annotations[column].displayCharacter.length());
 477
 478               if (scaleColLabel)
 479               {
 480                 // justify the label and scale to fit in column
 481                 if (fmWidth > charWidth)
 482                 {
 483                   // scale only if the current font isn't already small enough
 484                   fmScaling = charWidth;
 485                   fmScaling /= fmWidth;
 486                   g.setFont(ofont.deriveFont(AffineTransform
 487                           .getScaleInstance(fmScaling, 1.0)));
 488                   // and update the label's width to reflect the scaling.
 489                   fmWidth = charWidth;
 490                 }
 491               }
 492             }
 493             else
 494             {
 495               fmWidth = fm
 496                       .charWidth(row_annotations[column].displayCharacter
 497                               .charAt(0));
 498             }
 499             charOffset = (int) ((charWidth - fmWidth) / 2f);
 500
 501             if (row_annotations[column].colour == null)
 502               g.setColor(Color.black);
 503             else
 504               g.setColor(row_annotations[column].colour);
 505
 506             if (column == 0 || row.graph > 0)
 507             {
 508               g.drawString(row_annotations[column].displayCharacter,
 509                       (x * charWidth) + charOffset, y + iconOffset);
 510             }
 511             else if (row_annotations[column - 1] == null
 512                     || (labelAllCols
 513                             || !row_annotations[column].displayCharacter
 514                                     .equals(row_annotations[column - 1].displayCharacter) || (row_annotations[column].displayCharacter
 515                             .length() < 2 && row_annotations[column].secondaryStructure == ' ')))
 516             {
 517               g.drawString(row_annotations[column].displayCharacter, x
 518                       * charWidth + charOffset, y + iconOffset);
 519             }
 520             g.setFont(ofont);
 521           }
 522         }
 523         if (row.hasIcons)
 524         {
 525           char ss = validRes ? row_annotations[column].secondaryStructure
 526                   : ' ';
 527           if (ss == 'S')
 528           {
 529             // distinguish between forward/backward base-pairing
 530             if (row_annotations[column].displayCharacter.indexOf(')') > -1)
 531             {
 532               ss = 's';
 533             }
 534           }
 535           if (!validRes || (ss != lastSS))
 536           {
 537             if (x > -1)
 538             {
 539               switch (lastSS)
 540               {
 541               case 'H':
 542                 drawHelixAnnot(g, row_annotations, lastSSX, x, y,
 543                         iconOffset, startRes, column, validRes, validEnd);
 544                 break;
 545
 546               case 'E':
 547                 drawSheetAnnot(g, row_annotations, lastSSX, x, y,
 548                         iconOffset, startRes, column, validRes, validEnd);
 549                 break;
 550
 551               case 'S': // Stem case for RNA secondary structure
 552               case 's': // and opposite direction
 553                 drawStemAnnot(g, row_annotations, lastSSX, x, y,
 554                         iconOffset, startRes, column, validRes, validEnd);
 555                 break;
 556
 557               default:
 558                 g.setColor(Color.gray);
 559                 g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth)
 560                         - lastSSX, 2);
 561
 562                 break;
 563               }
 564             }
 565             if (validRes)
 566             {
 567               lastSS = ss;
 568             }
 569             else
 570             {
 571               lastSS = ' ';
 572             }
 573             if (x > -1)
 574             {
 575               lastSSX = (x * charWidth);
 576             }
 577           }
 578         }
 579         column++;
 580         x++;
 581       }
 582       if (column >= row_annotations.length)
 583       {
 584         column = row_annotations.length - 1;
 585         validEnd = false;
 586       }
 587       else
 588       {
 589         validEnd = true;
 590       }
 591       if ((row_annotations == null) || (row_annotations.length <= column)
 592               || (row_annotations[column] == null))
 593       {
 594         validRes = false;
 595       }
 596       else
 597       {
 598         validRes = true;
 599       }
 600
 601       // x ++;
 602
 603       if (row.hasIcons)
 604       {
 605         switch (lastSS)
 606         {
 607         case 'H':
 608           drawHelixAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
 609                   startRes, column, validRes, validEnd);
 610           break;
 611
 612         case 'E':
 613           drawSheetAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
 614                   startRes, column, validRes, validEnd);
 615           break;
 616         case 's':
 617         case 'S': // Stem case for RNA secondary structure
 618           drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
 619                   startRes, column, validRes, validEnd);
 620           break;
 621         default:
 622           drawGlyphLine(g, row_annotations, lastSSX, x, y, iconOffset,
 623                   startRes, column, validRes, validEnd);
 624           break;
 625         }
 626       }
 627
 628       if (row.graph > 0 && row.graphHeight > 0)
 629       {
 630         if (row.graph == AlignmentAnnotation.LINE_GRAPH)
 631         {
 632           if (row.graphGroup > -1 && !graphGroupDrawn.get(row.graphGroup))
 633           {
 634             // TODO: JAL-1291 revise rendering model so the graphGroup map is computed efficiently for all visible labels
 635             float groupmax = -999999, groupmin = 9999999;
 636             for (int gg = 0; gg < aa.length; gg++)
 637             {
 638               if (aa[gg].graphGroup != row.graphGroup)
 639               {
 640                 continue;
 641               }
 642
 643               if (aa[gg] != row)
 644               {
 645                 aa[gg].visible = false;
 646               }
 647               if (aa[gg].graphMax > groupmax)
 648               {
 649                 groupmax = aa[gg].graphMax;
 650               }
 651               if (aa[gg].graphMin < groupmin)
 652               {
 653                 groupmin = aa[gg].graphMin;
 654               }
 655             }
 656
 657             for (int gg = 0; gg < aa.length; gg++)
 658             {
 659               if (aa[gg].graphGroup == row.graphGroup)
 660               {
 661                 drawLineGraph(g, aa[gg], aa[gg].annotations, startRes,
 662                         endRes, y, groupmin, groupmax, row.graphHeight);
 663               }
 664             }
 665
 666             graphGroupDrawn.set(row.graphGroup);
 667           }
 668           else
 669           {
 670             drawLineGraph(g, row, row_annotations, startRes, endRes, y,
 671                     row.graphMin, row.graphMax, row.graphHeight);
 672           }
 673         }
 674         else if (row.graph == AlignmentAnnotation.BAR_GRAPH)
 675         {
 676           drawBarGraph(g, row, row_annotations, startRes, endRes,
 677                   row.graphMin, row.graphMax, y);
 678         }
 679       }
 680     } else {
 681       if (clipst && !clipend)
 682       {
 683         clipend = true;
 684       }
 685     }// end if_in_visible_region
 686       if (row.graph > 0 && row.hasText)
 687       {
 688         y += charHeight;
 689       }
 690
 691       if (row.graph == 0)
 692       {
 693         y += aa[i].height;
 694       }
 695     }
 696     if (debugRedraw)
 697     {
 698       if (canClip)
 699       {
 700         if (clipst)
 701         {
 702           System.err.println("Start clip at : " + yfrom + " (index " + f_i
 703                   + ")");
 704         }
 705         if (clipend)
 706         {
 707           System.err.println("End clip at : " + yto + " (index " + f_to
 708                   + ")");
 709         }
 710       }
 711       ;
 712       System.err.println("Annotation Rendering time:"
 713               + (System.currentTimeMillis() - stime));
 714     }
 715     ;
 716
 717     return !usedFaded;
 718   }
 719
 720   private final Color GLYPHLINE_COLOR = Color.gray;
 721
 722   private final Color SHEET_COLOUR = Color.green;
 723
 724   private final Color HELIX_COLOUR = Color.red;
 725
 726   private final Color STEM_COLOUR = Color.blue;
 727
 728   public void drawGlyphLine(Graphics g, Annotation[] row, int lastSSX,
 729           int x, int y, int iconOffset, int startRes, int column,
 730           boolean validRes, boolean validEnd)
 731   {
 732     g.setColor(GLYPHLINE_COLOR);
 733     g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2);
 734   }
 735
 736   public void drawSheetAnnot(Graphics g, Annotation[] row, int lastSSX,
 737           int x, int y, int iconOffset, int startRes, int column,
 738           boolean validRes, boolean validEnd)
 739   {
 740     g.setColor(SHEET_COLOUR);
 741
 742     if (!validEnd || !validRes || row == null || row[column] == null
 743             || row[column].secondaryStructure != 'E')
 744     {
 745       g.fillRect(lastSSX, y + 4 + iconOffset,
 746               (x * charWidth) - lastSSX - 4, 7);
 747       g.fillPolygon(new int[]
 748       { (x * charWidth) - 4, (x * charWidth) - 4, (x * charWidth) },
 749               new int[]
 750               { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset },
 751               3);
 752     }
 753     else
 754     {
 755       g.fillRect(lastSSX, y + 4 + iconOffset,
 756               (x + 1) * charWidth - lastSSX, 7);
 757     }
 758
 759   }
 760
 761   public void drawHelixAnnot(Graphics g, Annotation[] row, int lastSSX,
 762           int x, int y, int iconOffset, int startRes, int column,
 763           boolean validRes, boolean validEnd)
 764   {
 765     g.setColor(HELIX_COLOUR);
 766
 767     int sCol = (lastSSX / charWidth) + startRes;
 768     int x1 = lastSSX;
 769     int x2 = (x * charWidth);
 770
 771     if (MAC)
 772     {
 773       int ofs = charWidth / 2;
 774       // Off by 1 offset when drawing rects and ovals
 775       // to offscreen image on the MAC
 776       g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1, 8, 8, 8);
 777       if (sCol == 0 || row[sCol - 1] == null
 778               || row[sCol - 1].secondaryStructure != 'H')
 779       {
 780       }
 781       else
 782       {
 783         // g.setColor(Color.orange);
 784         g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1 - ofs + 1, 8,
 785                 0, 0);
 786       }
 787       if (!validRes || row[column] == null
 788               || row[column].secondaryStructure != 'H')
 789       {
 790
 791       }
 792       else
 793       {
 794         // g.setColor(Color.magenta);
 795         g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset, x2 - x1 - ofs
 796                 + 1, 8, 0, 0);
 797
 798       }
 799
 800       return;
 801     }
 802
 803     if (sCol == 0 || row[sCol - 1] == null
 804             || row[sCol - 1].secondaryStructure != 'H')
 805     {
 806       g.fillArc(lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180);
 807       x1 += charWidth / 2;
 808     }
 809
 810     if (!validRes || row[column] == null
 811             || row[column].secondaryStructure != 'H')
 812     {
 813       g.fillArc((x * charWidth) - charWidth, y + 4 + iconOffset, charWidth,
 814               8, 270, 180);
 815       x2 -= charWidth / 2;
 816     }
 817
 818     g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
 819   }
 820
 821   public void drawLineGraph(Graphics g, AlignmentAnnotation _aa,
 822           Annotation[] aa_annotations, int sRes, int eRes, int y,
 823           float min, float max, int graphHeight)
 824   {
 825     if (sRes > aa_annotations.length)
 826     {
 827       return;
 828     }
 829
 830     int x = 0;
 831
 832     // Adjustment for fastpaint to left
 833     if (eRes < endRes)
 834     {
 835       eRes++;
 836     }
 837
 838     eRes = Math.min(eRes, aa_annotations.length);
 839
 840     if (sRes == 0)
 841     {
 842       x++;
 843     }
 844
 845     int y1 = y, y2 = y;
 846     float range = max - min;
 847
 848     // //Draw origin
 849     if (min < 0)
 850     {
 851       y2 = y - (int) ((0 - min / range) * graphHeight);
 852     }
 853
 854     g.setColor(Color.gray);
 855     g.drawLine(x - charWidth, y2, (eRes - sRes + 1) * charWidth, y2);
 856
 857     eRes = Math.min(eRes, aa_annotations.length);
 858
 859     int column;
 860     int aaMax = aa_annotations.length - 1;
 861
 862     while (x < eRes - sRes)
 863     {
 864       column = sRes + x;
 865       if (hasHiddenColumns)
 866       {
 867         column = columnSelection.adjustForHiddenColumns(column);
 868       }
 869
 870       if (column > aaMax)
 871       {
 872         break;
 873       }
 874
 875       if (aa_annotations[column] == null
 876               || aa_annotations[column - 1] == null)
 877       {
 878         x++;
 879         continue;
 880       }
 881
 882       if (aa_annotations[column].colour == null)
 883         g.setColor(Color.black);
 884       else
 885         g.setColor(aa_annotations[column].colour);
 886
 887       y1 = y
 888               - (int) (((aa_annotations[column - 1].value - min) / range) * graphHeight);
 889       y2 = y
 890               - (int) (((aa_annotations[column].value - min) / range) * graphHeight);
 891
 892       g.drawLine(x * charWidth - charWidth / 2, y1, x * charWidth
 893               + charWidth / 2, y2);
 894       x++;
 895     }
 896
 897     if (_aa.threshold != null)
 898     {
 899       g.setColor(_aa.threshold.colour);
 900       Graphics2D g2 = (Graphics2D) g;
 901       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
 902               BasicStroke.JOIN_ROUND, 3f, new float[]
 903               { 5f, 3f }, 0f));
 904
 905       y2 = (int) (y - ((_aa.threshold.value - min) / range) * graphHeight);
 906       g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
 907       g2.setStroke(new BasicStroke());
 908     }
 909   }
 910
 911   public void drawBarGraph(Graphics g, AlignmentAnnotation _aa,
 912           Annotation[] aa_annotations, int sRes, int eRes, float min,
 913           float max, int y)
 914   {
 915     if (sRes > aa_annotations.length)
 916     {
 917       return;
 918     }
 919     Font ofont = g.getFont();
 920     eRes = Math.min(eRes, aa_annotations.length);
 921
 922     int x = 0, y1 = y, y2 = y;
 923
 924     float range = max - min;
 925
 926     if (min < 0)
 927     {
 928       y2 = y - (int) ((0 - min / (range)) * _aa.graphHeight);
 929     }
 930
 931     g.setColor(Color.gray);
 932
 933     g.drawLine(x, y2, (eRes - sRes) * charWidth, y2);
 934
 935     int column;
 936     int aaMax = aa_annotations.length - 1;
 937     boolean renderHistogram = true, renderProfile = true, normaliseProfile = false;
 938     // if (aa.autoCalculated && aa.label.startsWith("Consensus"))
 939     {
 940       // TODO: generalise this to have render styles for consensus/profile data
 941       if (_aa.groupRef != null)
 942       {
 943         renderHistogram = _aa.groupRef.isShowConsensusHistogram();
 944         renderProfile = _aa.groupRef.isShowSequenceLogo();
 945         normaliseProfile = _aa.groupRef.isNormaliseSequenceLogo();
 946       }
 947       else
 948       {
 949         renderHistogram = av_renderHistogram;
 950         renderProfile = av_renderProfile;
 951         normaliseProfile = av_normaliseProfile;
 952       }
 953     }
 954     while (x < eRes - sRes)
 955     {
 956       column = sRes + x;
 957       if (hasHiddenColumns)
 958       {
 959         column = columnSelection.adjustForHiddenColumns(column);
 960       }
 961
 962       if (column > aaMax)
 963       {
 964         break;
 965       }
 966
 967       if (aa_annotations[column] == null)
 968       {
 969         x++;
 970         continue;
 971       }
 972       if (aa_annotations[column].colour == null)
 973         g.setColor(Color.black);
 974       else
 975         g.setColor(aa_annotations[column].colour);
 976
 977       y1 = y
 978               - (int) (((aa_annotations[column].value - min) / (range)) * _aa.graphHeight);
 979
 980       if (renderHistogram)
 981       {
 982         if (y1 - y2 > 0)
 983         {
 984           g.fillRect(x * charWidth, y2, charWidth, y1 - y2);
 985         }
 986         else
 987         {
 988           g.fillRect(x * charWidth, y1, charWidth, y2 - y1);
 989         }
 990       }
 991       // draw profile if available
 992       if (renderProfile)
 993       {
 994
 995         int profl[] = getProfileFor(_aa, column);
 996         // just try to draw the logo if profl is not null
 997         if (profl != null && profl[1] != 0)
 998         {
 999           float ht = normaliseProfile ? y - _aa.graphHeight : y1;
1000           double htn = normaliseProfile ? _aa.graphHeight : (y2 - y1);// aa.graphHeight;
1001           double hght;
1002           float wdth;
1003           double ht2 = 0;
1004           char[] dc;
1005
1006           /**
1007            * profl.length == 74 indicates that the profile of a secondary
1008            * structure conservation row was accesed. Therefore dc gets length 2,
1009            * to have space for a basepair instead of just a single nucleotide
1010            */
1011           if (profl.length == 74)
1012           {
1013             dc = new char[2];
1014           }
1015           else
1016           {
1017             dc = new char[1];
1018           }
1019           LineMetrics lm = g.getFontMetrics(ofont).getLineMetrics("Q", g);
1020           double scale = 1f / (normaliseProfile ? profl[1] : 100f);
1021           float ofontHeight = 1f / lm.getAscent();// magnify to fill box
1022           double scl = 0.0;
1023           for (int c = 2; c < profl[0];)
1024           {
1025             dc[0] = (char) profl[c++];
1026
1027             if (_aa.label.startsWith("StrucConsensus"))
1028             {
1029               dc[1] = (char) profl[c++];
1030             }
1031
1032             wdth = charWidth;
1033             wdth /= fm.charsWidth(dc, 0, dc.length);
1034
1035             ht += scl;
1036             {
1037               scl = htn * scale * profl[c++];
1038               lm = ofont.getLineMetrics(dc, 0, 1, g.getFontMetrics()
1039                       .getFontRenderContext());
1040               g.setFont(ofont.deriveFont(AffineTransform.getScaleInstance(
1041                       wdth, scl / lm.getAscent())));
1042               lm = g.getFontMetrics().getLineMetrics(dc, 0, 1, g);
1043
1044               // Debug - render boxes around characters
1045               // g.setColor(Color.red);
1046               // g.drawRect(x*av.charWidth, (int)ht, av.charWidth,
1047               // (int)(scl));
1048               // g.setColor(profcolour.findColour(dc[0]).darker());
1049               g.setColor(profcolour.findColour(dc[0], column, null));
1050
1051               hght = (ht + (scl - lm.getDescent() - lm.getBaselineOffsets()[lm
1052                       .getBaselineIndex()]));
1053
1054               g.drawChars(dc, 0, dc.length, x * charWidth, (int) hght);
1055             }
1056           }
1057           g.setFont(ofont);
1058         }
1059       }
1060       x++;
1061     }
1062     if (_aa.threshold != null)
1063     {
1064       g.setColor(_aa.threshold.colour);
1065       Graphics2D g2 = (Graphics2D) g;
1066       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
1067               BasicStroke.JOIN_ROUND, 3f, new float[]
1068               { 5f, 3f }, 0f));
1069
1070       y2 = (int) (y - ((_aa.threshold.value - min) / range)
1071               * _aa.graphHeight);
1072       g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
1073       g2.setStroke(new BasicStroke());
1074     }
1075   }
1076
1077   // used by overview window
1078   public void drawGraph(Graphics g, AlignmentAnnotation _aa,
1079           Annotation[] aa_annotations, int width, int y, int sRes, int eRes)
1080   {
1081     eRes = Math.min(eRes, aa_annotations.length);
1082     g.setColor(Color.white);
1083     g.fillRect(0, 0, width, y);
1084     g.setColor(new Color(0, 0, 180));
1085
1086     int x = 0, height;
1087
1088     for (int j = sRes; j < eRes; j++)
1089     {
1090       if (aa_annotations[j] != null)
1091       {
1092         if (aa_annotations[j].colour == null)
1093           g.setColor(Color.black);
1094         else
1095           g.setColor(aa_annotations[j].colour);
1096
1097         height = (int) ((aa_annotations[j].value / _aa.graphMax) * y);
1098         if (height > y)
1099         {
1100           height = y;
1101         }
1102
1103         g.fillRect(x, y - height, charWidth, height);
1104       }
1105       x += charWidth;
1106     }
1107   }
1108 }