src/jalview/renderer/AnnotationRenderer.java

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