JAL-1632 add score model params to PCAModel and PCA constructors
[jalview.git] / src / jalview / gui / SequenceRenderer.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.gui;
22
23 import jalview.api.FeatureRenderer;
24 import jalview.datamodel.SequenceGroup;
25 import jalview.datamodel.SequenceI;
26 import jalview.renderer.ResidueShaderI;
27 import jalview.util.Comparison;
28
29 import java.awt.Color;
30 import java.awt.FontMetrics;
31 import java.awt.Graphics;
32
33 public class SequenceRenderer implements jalview.api.SequenceRenderer
34 {
35   final static int CHAR_TO_UPPER = 'A' - 'a';
36
37   AlignViewport av;
38
39   FontMetrics fm;
40
41   boolean renderGaps = true;
42
43   SequenceGroup currentSequenceGroup = null;
44
45   SequenceGroup[] allGroups = null;
46
47   Color resBoxColour;
48
49   Graphics graphics;
50
51   boolean monospacedFont;
52
53   boolean forOverview = false;
54
55   /**
56    * Creates a new SequenceRenderer object.
57    * 
58    * @param av
59    *          DOCUMENT ME!
60    */
61   public SequenceRenderer(AlignViewport av)
62   {
63     this.av = av;
64   }
65
66   /**
67    * DOCUMENT ME!
68    * 
69    * @param b
70    *          DOCUMENT ME!
71    */
72   public void prepare(Graphics g, boolean renderGaps)
73   {
74     graphics = g;
75     fm = g.getFontMetrics();
76
77     // If EPS graphics, stringWidth will be a double, not an int
78     double dwidth = fm.getStringBounds("M", g).getWidth();
79
80     monospacedFont = (dwidth == fm.getStringBounds("|", g).getWidth() && av
81             .getCharWidth() == dwidth);
82
83     this.renderGaps = renderGaps;
84   }
85
86   @Override
87   public Color getResidueBoxColour(SequenceI seq, int i)
88   {
89     // rate limiting step when rendering overview for lots of groups
90     allGroups = av.getAlignment().findAllGroups(seq);
91
92     if (inCurrentSequenceGroup(i))
93     {
94       if (currentSequenceGroup.getDisplayBoxes())
95       {
96         getBoxColour(currentSequenceGroup.getGroupColourScheme(), seq, i);
97       }
98     }
99     else if (av.getShowBoxes())
100     {
101       getBoxColour(av.getResidueShading(), seq, i);
102     }
103
104     return resBoxColour;
105   }
106
107   /**
108    * Get the residue colour at the given sequence position - as determined by
109    * the sequence group colour (if any), else the colour scheme, possibly
110    * overridden by a feature colour.
111    * 
112    * @param seq
113    * @param position
114    * @param fr
115    * @return
116    */
117   @Override
118   public Color getResidueColour(final SequenceI seq, int position,
119           FeatureRenderer fr)
120   {
121     // TODO replace 8 or so code duplications with calls to this method
122     // (refactored as needed)
123     Color col = getResidueBoxColour(seq, position);
124
125     if (fr != null)
126     {
127       col = fr.findFeatureColour(col, seq, position);
128     }
129     return col;
130   }
131
132   /**
133    * DOCUMENT ME!
134    * 
135    * @param shader
136    *          DOCUMENT ME!
137    * @param seq
138    *          DOCUMENT ME!
139    * @param i
140    *          DOCUMENT ME!
141    */
142   void getBoxColour(ResidueShaderI shader, SequenceI seq, int i)
143   {
144     if (shader != null)
145     {
146       resBoxColour = shader.findColour(seq.getCharAt(i),
147               i, seq);
148     }
149     else if (forOverview && !Comparison.isGap(seq.getCharAt(i)))
150     {
151       resBoxColour = Color.lightGray;
152     }
153     else
154     {
155       resBoxColour = Color.white;
156     }
157   }
158
159   /**
160    * DOCUMENT ME!
161    * 
162    * @param g
163    *          DOCUMENT ME!
164    * @param seq
165    *          DOCUMENT ME!
166    * @param sg
167    *          DOCUMENT ME!
168    * @param start
169    *          DOCUMENT ME!
170    * @param end
171    *          DOCUMENT ME!
172    * @param x1
173    *          DOCUMENT ME!
174    * @param y1
175    *          DOCUMENT ME!
176    * @param width
177    *          DOCUMENT ME!
178    * @param height
179    *          DOCUMENT ME!
180    */
181   public void drawSequence(SequenceI seq, SequenceGroup[] sg, int start,
182           int end, int y1)
183   {
184     allGroups = sg;
185
186     drawBoxes(seq, start, end, y1);
187
188     if (av.validCharWidth)
189     {
190       drawText(seq, start, end, y1);
191     }
192   }
193
194   /**
195    * DOCUMENT ME!
196    * 
197    * @param seq
198    *          DOCUMENT ME!
199    * @param start
200    *          DOCUMENT ME!
201    * @param end
202    *          DOCUMENT ME!
203    * @param x1
204    *          DOCUMENT ME!
205    * @param y1
206    *          DOCUMENT ME!
207    * @param width
208    *          DOCUMENT ME!
209    * @param height
210    *          DOCUMENT ME!
211    */
212   public synchronized void drawBoxes(SequenceI seq, int start, int end,
213           int y1)
214   {
215     if (seq == null)
216     {
217       return; // fix for racecondition
218     }
219     int i = start;
220     int length = seq.getLength();
221
222     int curStart = -1;
223     int curWidth = av.getCharWidth(), avWidth = av.getCharWidth(), avHeight = av
224             .getCharHeight();
225
226     Color tempColour = null;
227
228     while (i <= end)
229     {
230       resBoxColour = Color.white;
231
232       if (i < length)
233       {
234         if (inCurrentSequenceGroup(i))
235         {
236           if (currentSequenceGroup.getDisplayBoxes())
237           {
238             getBoxColour(currentSequenceGroup.getGroupColourScheme(), seq,
239                     i);
240           }
241         }
242         else if (av.getShowBoxes())
243         {
244           getBoxColour(av.getResidueShading(), seq, i);
245         }
246       }
247
248       if (resBoxColour != tempColour)
249       {
250         if (tempColour != null)
251         {
252           graphics.fillRect(avWidth * (curStart - start), y1, curWidth,
253                   avHeight);
254         }
255
256         graphics.setColor(resBoxColour);
257
258         curStart = i;
259         curWidth = avWidth;
260         tempColour = resBoxColour;
261       }
262       else
263       {
264         curWidth += avWidth;
265       }
266
267       i++;
268     }
269
270     graphics.fillRect(avWidth * (curStart - start), y1, curWidth, avHeight);
271
272   }
273
274   /**
275    * DOCUMENT ME!
276    * 
277    * @param seq
278    *          DOCUMENT ME!
279    * @param start
280    *          DOCUMENT ME!
281    * @param end
282    *          DOCUMENT ME!
283    * @param x1
284    *          DOCUMENT ME!
285    * @param y1
286    *          DOCUMENT ME!
287    * @param width
288    *          DOCUMENT ME!
289    * @param height
290    *          DOCUMENT ME!
291    */
292   public void drawText(SequenceI seq, int start, int end, int y1)
293   {
294     y1 += av.getCharHeight() - av.getCharHeight() / 5; // height/5 replaces pady
295     int charOffset = 0;
296     char s;
297
298     if (end + 1 >= seq.getLength())
299     {
300       end = seq.getLength() - 1;
301     }
302     graphics.setColor(av.getTextColour());
303
304     if (monospacedFont && av.getShowText() && allGroups.length == 0
305             && !av.getColourText() && av.getThresholdTextColour() == 0)
306     {
307       if (av.isRenderGaps())
308       {
309         graphics.drawString(seq.getSequenceAsString(start, end + 1), 0, y1);
310       }
311       else
312       {
313         char gap = av.getGapCharacter();
314         graphics.drawString(seq.getSequenceAsString(start, end + 1)
315                 .replace(gap, ' '), 0, y1);
316       }
317     }
318     else
319     {
320       boolean srep = av.isDisplayReferenceSeq();
321       boolean getboxColour = false;
322       boolean isarep = av.getAlignment().getSeqrep() == seq;
323       boolean isgrep = currentSequenceGroup != null ? currentSequenceGroup
324               .getSeqrep() == seq : false;
325       char sr_c;
326       for (int i = start; i <= end; i++)
327       {
328
329         graphics.setColor(av.getTextColour());
330         getboxColour = false;
331         s = seq.getCharAt(i);
332
333         if (!renderGaps && jalview.util.Comparison.isGap(s))
334         {
335           continue;
336         }
337
338         if (inCurrentSequenceGroup(i))
339         {
340           if (!currentSequenceGroup.getDisplayText())
341           {
342             continue;
343           }
344
345           if (currentSequenceGroup.thresholdTextColour > 0
346                   || currentSequenceGroup.getColourText())
347           {
348             getboxColour = true;
349             getBoxColour(currentSequenceGroup.getGroupColourScheme(), seq,
350                     i);
351
352             if (currentSequenceGroup.getColourText())
353             {
354               graphics.setColor(resBoxColour.darker());
355             }
356
357             if (currentSequenceGroup.thresholdTextColour > 0)
358             {
359               if (resBoxColour.getRed() + resBoxColour.getBlue()
360                       + resBoxColour.getGreen() < currentSequenceGroup.thresholdTextColour)
361               {
362                 graphics.setColor(currentSequenceGroup.textColour2);
363               }
364             }
365           }
366           else
367           {
368             graphics.setColor(currentSequenceGroup.textColour);
369           }
370           if (!isarep && !isgrep
371                   && currentSequenceGroup.getShowNonconserved()) // todo
372                                                                  // optimize
373           {
374             // todo - use sequence group consensus
375             s = getDisplayChar(srep, i, s, '.', currentSequenceGroup);
376
377           }
378
379         }
380         else
381         {
382           if (!av.getShowText())
383           {
384             continue;
385           }
386
387           if (av.getColourText())
388           {
389             getboxColour = true;
390             getBoxColour(av.getResidueShading(), seq, i);
391
392             if (av.getShowBoxes())
393             {
394               graphics.setColor(resBoxColour.darker());
395             }
396             else
397             {
398               graphics.setColor(resBoxColour);
399             }
400           }
401
402           if (av.getThresholdTextColour() > 0)
403           {
404             if (!getboxColour)
405             {
406               getBoxColour(av.getResidueShading(), seq, i);
407             }
408
409             if (resBoxColour.getRed() + resBoxColour.getBlue()
410                     + resBoxColour.getGreen() < av.getThresholdTextColour())
411             {
412               graphics.setColor(av.getTextColour2());
413             }
414           }
415           if (!isarep && av.getShowUnconserved())
416           {
417             s = getDisplayChar(srep, i, s, '.', null);
418
419           }
420
421         }
422
423         charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
424         graphics.drawString(String.valueOf(s),
425                 charOffset + av.getCharWidth() * (i - start), y1);
426
427       }
428     }
429   }
430
431   /**
432    * Returns 'conservedChar' to represent the given position if the sequence
433    * character at that position is equal to the consensus (ignoring case), else
434    * returns the sequence character
435    * 
436    * @param usesrep
437    * @param position
438    * @param sequenceChar
439    * @param conservedChar
440    * @return
441    */
442   private char getDisplayChar(final boolean usesrep, int position,
443           char sequenceChar, char conservedChar, SequenceGroup currentGroup)
444   {
445     // TODO - use currentSequenceGroup rather than alignment
446     // currentSequenceGroup.getConsensus()
447     char conschar = (usesrep) ? (currentGroup == null
448             || position < currentGroup.getStartRes()
449             || position > currentGroup.getEndRes() ? av.getAlignment()
450             .getSeqrep().getCharAt(position)
451             : (currentGroup.getSeqrep() != null ? currentGroup.getSeqrep()
452                     .getCharAt(position) : av.getAlignment().getSeqrep()
453                     .getCharAt(position)))
454             : (currentGroup != null && currentGroup.getConsensus() != null
455                     && position >= currentGroup.getStartRes()
456                     && position <= currentGroup.getEndRes() && currentGroup
457                     .getConsensus().annotations.length > position) ? currentGroup
458                     .getConsensus().annotations[position].displayCharacter
459                     .charAt(0)
460                     : av.getAlignmentConsensusAnnotation().annotations[position].displayCharacter
461                             .charAt(0);
462     if (!jalview.util.Comparison.isGap(conschar)
463             && (sequenceChar == conschar || sequenceChar + CHAR_TO_UPPER == conschar))
464     {
465       sequenceChar = conservedChar;
466     }
467     return sequenceChar;
468   }
469
470   /**
471    * DOCUMENT ME!
472    * 
473    * @param res
474    *          DOCUMENT ME!
475    * 
476    * @return DOCUMENT ME!
477    */
478   boolean inCurrentSequenceGroup(int res)
479   {
480     if (allGroups == null)
481     {
482       return false;
483     }
484
485     for (int i = 0; i < allGroups.length; i++)
486     {
487       if ((allGroups[i].getStartRes() <= res)
488               && (allGroups[i].getEndRes() >= res))
489       {
490         currentSequenceGroup = allGroups[i];
491
492         return true;
493       }
494     }
495
496     return false;
497   }
498
499   /**
500    * DOCUMENT ME!
501    * 
502    * @param seq
503    *          DOCUMENT ME!
504    * @param start
505    *          DOCUMENT ME!
506    * @param end
507    *          DOCUMENT ME!
508    * @param x1
509    *          DOCUMENT ME!
510    * @param y1
511    *          DOCUMENT ME!
512    * @param width
513    *          DOCUMENT ME!
514    * @param height
515    *          DOCUMENT ME!
516    */
517   public void drawHighlightedText(SequenceI seq, int start, int end,
518           int x1, int y1)
519   {
520     int pady = av.getCharHeight() / 5;
521     int charOffset = 0;
522     graphics.setColor(Color.BLACK);
523     graphics.fillRect(x1, y1, av.getCharWidth() * (end - start + 1),
524             av.getCharHeight());
525     graphics.setColor(Color.white);
526
527     char s = '~';
528
529     // Need to find the sequence position here.
530     if (av.isValidCharWidth())
531     {
532       for (int i = start; i <= end; i++)
533       {
534         if (i < seq.getLength())
535         {
536           s = seq.getCharAt(i);
537         }
538
539         charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
540         graphics.drawString(String.valueOf(s),
541                 charOffset + x1 + (av.getCharWidth() * (i - start)),
542                 (y1 + av.getCharHeight()) - pady);
543       }
544     }
545   }
546
547   public void drawCursor(SequenceI seq, int res, int x1, int y1)
548   {
549     int pady = av.getCharHeight() / 5;
550     int charOffset = 0;
551     graphics.setColor(Color.black);
552     graphics.fillRect(x1, y1, av.getCharWidth(), av.getCharHeight());
553
554     if (av.isValidCharWidth())
555     {
556       graphics.setColor(Color.white);
557
558       char s = seq.getCharAt(res);
559
560       charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
561       graphics.drawString(String.valueOf(s), charOffset + x1,
562               (y1 + av.getCharHeight()) - pady);
563     }
564
565   }
566 }