src/jalview/gui/FeatureRenderer.java

   1 /*\r
   2  * Jalview - A Sequence Alignment Editor and Viewer\r
   3  * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
   4  *\r
   5  * This program is free software; you can redistribute it and/or\r
   6  * modify it under the terms of the GNU General Public License\r
   7  * as published by the Free Software Foundation; either version 2\r
   8  * of the License, or (at your option) any later version.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  * You should have received a copy of the GNU General Public License\r
  16  * along with this program; if not, write to the Free Software\r
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
  18  */\r
  19 package jalview.gui;\r
  20 \r
  21 import jalview.datamodel.*;\r
  22 \r
  23 import java.awt.*;\r
  24 \r
  25 import java.util.*;\r
  26 \r
  27 import java.awt.image.*;\r
  28 \r
  29 \r
  30 /**\r
  31  * DOCUMENT ME!\r
  32  *\r
  33  * @author $author$\r
  34  * @version $Revision$\r
  35  */\r
  36 public class FeatureRenderer\r
  37 {\r
  38     AlignViewport av;\r
  39     Color resBoxColour;\r
  40     float transparency = 1.0f;\r
  41     FontMetrics fm;\r
  42     int charOffset;\r
  43 \r
  44     Hashtable featureColours = new Hashtable();\r
  45 \r
  46 \r
  47     // A higher level for grouping features of a\r
  48    // particular type\r
  49     Hashtable featureGroups = null;\r
  50 \r
  51     // This is actually an Integer held in the hashtable,\r
  52     // Retrieved using the key feature type\r
  53     Object currentColour;\r
  54 \r
  55     String [] renderOrder;\r
  56 \r
  57 \r
  58     /**\r
  59      * Creates a new FeatureRenderer object.\r
  60      *\r
  61      * @param av DOCUMENT ME!\r
  62      */\r
  63     public FeatureRenderer(AlignViewport av)\r
  64     {\r
  65         this.av = av;\r
  66     }\r
  67 \r
  68     public void transferSettings(FeatureRenderer fr)\r
  69     {\r
  70       renderOrder = fr.renderOrder;\r
  71       featureGroups = fr.featureGroups;\r
  72       featureColours = fr.featureColours;\r
  73       transparency =  fr.transparency;\r
  74     }\r
  75 \r
  76     BufferedImage offscreenImage;\r
  77     boolean offscreenRender = false;\r
  78     public Color findFeatureColour(Color initialCol, SequenceI seq, int res)\r
  79     {\r
  80       int seqindex = av.alignment.findIndex(seq);\r
  81 \r
  82       return new Color( findFeatureColour (initialCol.getRGB(),\r
  83                         seqindex, res ));\r
  84     }\r
  85 \r
  86     /**\r
  87      * This is used by the Molecule Viewer to get the accurate colour\r
  88      * of the rendered sequence\r
  89      */\r
  90     public int findFeatureColour(int initialCol, int seqIndex, int column)\r
  91     {\r
  92       if(!av.showSequenceFeatures)\r
  93         return initialCol;\r
  94 \r
  95       if(seqIndex!=lastSequenceIndex)\r
  96       {\r
  97         lastSequence = av.alignment.getSequenceAt(seqIndex);\r
  98         lastSequenceIndex = seqIndex;\r
  99         sequenceFeatures = lastSequence.getDatasetSequence().getSequenceFeatures();\r
 100         if(sequenceFeatures==null)\r
 101           return initialCol;\r
 102 \r
 103         sfSize = sequenceFeatures.length;\r
 104       }\r
 105 \r
 106       if(jalview.util.Comparison.isGap(lastSequence.getCharAt(column)))\r
 107         return Color.white.getRGB();\r
 108 \r
 109 \r
 110       //Only bother making an offscreen image if transparency is applied\r
 111       if(transparency!=1.0f && offscreenImage==null)\r
 112       {\r
 113         offscreenImage = new BufferedImage(1,1,BufferedImage.TYPE_INT_ARGB);\r
 114       }\r
 115 \r
 116       currentColour = null;\r
 117 \r
 118       offscreenRender = true;\r
 119 \r
 120       if(offscreenImage!=null)\r
 121       {\r
 122         offscreenImage.setRGB(0,0,initialCol);\r
 123         drawSequence(offscreenImage.getGraphics(),\r
 124                      lastSequence,\r
 125                      column,column,0);\r
 126 \r
 127         return offscreenImage.getRGB(0,0);\r
 128       }\r
 129       else\r
 130       {\r
 131         drawSequence(null,\r
 132                     lastSequence,\r
 133                     lastSequence.findPosition(column),\r
 134                     -1, -1);\r
 135 \r
 136         if (currentColour == null)\r
 137           return initialCol;\r
 138         else\r
 139           return  ((Integer)currentColour).intValue();\r
 140       }\r
 141 \r
 142 \r
 143     }\r
 144 \r
 145 \r
 146     /**\r
 147      * DOCUMENT ME!\r
 148      *\r
 149      * @param g DOCUMENT ME!\r
 150      * @param seq DOCUMENT ME!\r
 151      * @param sg DOCUMENT ME!\r
 152      * @param start DOCUMENT ME!\r
 153      * @param end DOCUMENT ME!\r
 154      * @param x1 DOCUMENT ME!\r
 155      * @param y1 DOCUMENT ME!\r
 156      * @param width DOCUMENT ME!\r
 157      * @param height DOCUMENT ME!\r
 158      */\r
 159    // String type;\r
 160    // SequenceFeature sf;\r
 161     int lastSequenceIndex=-1;\r
 162     SequenceI lastSequence;\r
 163     SequenceFeature [] sequenceFeatures;\r
 164     int sfSize, sfindex, spos, epos;\r
 165 \r
 166     public void drawSequence(Graphics g, SequenceI seq,\r
 167                              int start, int end, int y1)\r
 168     {\r
 169       if ( seq.getDatasetSequence().getSequenceFeatures() == null\r
 170           || seq.getDatasetSequence().getSequenceFeatures().length==0)\r
 171         return;\r
 172 \r
 173 \r
 174       if(g!=null)\r
 175         fm = g.getFontMetrics();\r
 176 \r
 177 \r
 178       if (av.featuresDisplayed == null || renderOrder==null)\r
 179        {\r
 180          findAllFeatures();\r
 181          if(av.featuresDisplayed.size()<1)\r
 182            return;\r
 183 \r
 184          sequenceFeatures = seq.getDatasetSequence().getSequenceFeatures();\r
 185          sfSize = sequenceFeatures.length;\r
 186        }\r
 187 \r
 188        if(lastSequence==null || seq!=lastSequence)\r
 189       {\r
 190         lastSequence = seq;\r
 191         sequenceFeatures = seq.getDatasetSequence().getSequenceFeatures();\r
 192         sfSize = sequenceFeatures.length;\r
 193       }\r
 194 \r
 195 \r
 196       if (transparency != 1 && g!=null)\r
 197       {\r
 198         Graphics2D g2 = (Graphics2D) g;\r
 199         g2.setComposite(\r
 200             AlphaComposite.getInstance(\r
 201                 AlphaComposite.SRC_OVER, transparency));\r
 202       }\r
 203 \r
 204       if(!offscreenRender)\r
 205       {\r
 206         spos = lastSequence.findPosition(start);\r
 207         epos = lastSequence.findPosition(end);\r
 208       }\r
 209 \r
 210 \r
 211       String type;\r
 212       for(int renderIndex=0; renderIndex<renderOrder.length; renderIndex++)\r
 213        {\r
 214         type =  renderOrder[renderIndex];\r
 215         if(!av.featuresDisplayed.containsKey(type))\r
 216           continue;\r
 217 \r
 218         // loop through all features in sequence to find\r
 219         // current feature to render\r
 220         for (sfindex = 0; sfindex < sfSize; sfindex++)\r
 221         {\r
 222           if(sequenceFeatures.length<=sfindex)\r
 223           {\r
 224             continue;\r
 225           }\r
 226           if (!sequenceFeatures[sfindex].type.equals(type))\r
 227             continue;\r
 228 \r
 229           if (featureGroups != null\r
 230               && sequenceFeatures[sfindex].featureGroup != null\r
 231               &&\r
 232               featureGroups.containsKey(sequenceFeatures[sfindex].featureGroup)\r
 233               &&\r
 234               ! ( (Boolean) featureGroups.get(sequenceFeatures[sfindex].featureGroup)).\r
 235               booleanValue())\r
 236           {\r
 237             continue;\r
 238           }\r
 239 \r
 240           if (!offscreenRender && (sequenceFeatures[sfindex].getBegin() > epos\r
 241                             || sequenceFeatures[sfindex].getEnd() < spos))\r
 242             continue;\r
 243 \r
 244           if (offscreenRender && offscreenImage==null)\r
 245           {\r
 246             if (sequenceFeatures[sfindex].begin <= start &&\r
 247                 sequenceFeatures[sfindex].end  >= start)\r
 248             {\r
 249               currentColour = av.featuresDisplayed.get(sequenceFeatures[sfindex].\r
 250                  type);\r
 251             }\r
 252           }\r
 253           else if (sequenceFeatures[sfindex].type.equals("disulfide bond"))\r
 254           {\r
 255 \r
 256             renderFeature(g, seq,\r
 257                           seq.findIndex(sequenceFeatures[sfindex].begin) - 1,\r
 258                           seq.findIndex(sequenceFeatures[sfindex].begin) - 1,\r
 259                           new Color( ( (Integer) av.featuresDisplayed.get(\r
 260                 sequenceFeatures[sfindex].type)).intValue()),\r
 261                           start, end, y1);\r
 262             renderFeature(g, seq,\r
 263                           seq.findIndex(sequenceFeatures[sfindex].end) - 1,\r
 264                           seq.findIndex(sequenceFeatures[sfindex].end) - 1,\r
 265                           new Color( ( (Integer) av.featuresDisplayed.get(\r
 266                 sequenceFeatures[sfindex].type)).intValue()),\r
 267                           start, end, y1);\r
 268 \r
 269           }\r
 270           else\r
 271             renderFeature(g, seq,\r
 272                           seq.findIndex(sequenceFeatures[sfindex].begin) - 1,\r
 273                           seq.findIndex(sequenceFeatures[sfindex].end) - 1,\r
 274                           getColour(sequenceFeatures[sfindex].type),\r
 275                           start, end, y1);\r
 276 \r
 277 \r
 278         }\r
 279 \r
 280       }\r
 281 \r
 282         if(transparency!=1.0f && g!=null)\r
 283         {\r
 284           Graphics2D g2 = (Graphics2D) g;\r
 285           g2.setComposite(\r
 286               AlphaComposite.getInstance(\r
 287                   AlphaComposite.SRC_OVER, 1.0f));\r
 288         }\r
 289     }\r
 290 \r
 291 \r
 292     char s;\r
 293     int i;\r
 294     void renderFeature(Graphics g, SequenceI seq,\r
 295                        int fstart, int fend, Color featureColour, int start, int end,  int y1)\r
 296     {\r
 297 \r
 298       if (((fstart <= end) && (fend >= start)))\r
 299       {\r
 300         if (fstart < start)\r
 301         { // fix for if the feature we have starts before the sequence start,\r
 302           fstart = start; // but the feature end is still valid!!\r
 303         }\r
 304 \r
 305         if (fend >= end)\r
 306         {\r
 307           fend = end;\r
 308         }\r
 309           int pady = (y1 + av.charHeight) - av.charHeight / 5;\r
 310           for (i = fstart; i <= fend; i++)\r
 311           {\r
 312             s = seq.getSequence().charAt(i);\r
 313 \r
 314             if (jalview.util.Comparison.isGap(s))\r
 315             {\r
 316               continue;\r
 317             }\r
 318 \r
 319             g.setColor(featureColour);\r
 320 \r
 321             g.fillRect( (i - start) * av.charWidth, y1, av.charWidth,av.charHeight);\r
 322 \r
 323             if(offscreenRender || !av.validCharWidth)\r
 324               continue;\r
 325 \r
 326             g.setColor(Color.white);\r
 327             charOffset = (av.charWidth - fm.charWidth(s)) / 2;\r
 328             g.drawString(String.valueOf(s),\r
 329                          charOffset + (av.charWidth * (i - start)),\r
 330                          pady);\r
 331 \r
 332           }\r
 333       }\r
 334     }\r
 335 \r
 336     synchronized void findAllFeatures()\r
 337     {\r
 338       jalview.schemes.UserColourScheme ucs = new\r
 339           jalview.schemes.UserColourScheme();\r
 340 \r
 341           av.featuresDisplayed = new Hashtable();\r
 342       Vector allfeatures = new Vector();\r
 343       for (int i = 0; i < av.alignment.getHeight(); i++)\r
 344       {\r
 345         SequenceFeature [] features\r
 346             = av.alignment.getSequenceAt(i).getDatasetSequence().getSequenceFeatures();\r
 347 \r
 348         if (features == null)\r
 349           continue;\r
 350 \r
 351         int index = 0;\r
 352         while (index < features.length)\r
 353         {\r
 354           if (!av.featuresDisplayed.containsKey(features[index].getType()))\r
 355           {\r
 356             if(!(features[index].begin == 0 && features[index].end ==0))\r
 357             {\r
 358               // If beginning and end are 0, the feature is for the whole sequence\r
 359               // and we don't want to render the feature in the normal way\r
 360 \r
 361               if (getColour(features[index].getType()) == null)\r
 362               {\r
 363                  featureColours.put(features[index].getType(),\r
 364                                    ucs.createColourFromName(features[index].\r
 365                     getType()));\r
 366               }\r
 367 \r
 368               av.featuresDisplayed.put(features[index].getType(),\r
 369                                        new Integer(getColour(features[index].\r
 370                   getType()).getRGB()));\r
 371               allfeatures.addElement(features[index].getType());\r
 372             }\r
 373           }\r
 374           index++;\r
 375         }\r
 376       }\r
 377 \r
 378       renderOrder = new String[allfeatures.size()];\r
 379       Enumeration en = allfeatures.elements();\r
 380       int i = allfeatures.size()-1;\r
 381       while(en.hasMoreElements())\r
 382       {\r
 383         renderOrder[i] = en.nextElement().toString();\r
 384         i--;\r
 385       }\r
 386     }\r
 387 \r
 388     public Color getColour(String featureType)\r
 389     {\r
 390       Color colour = (Color)featureColours.get(featureType);\r
 391       return colour;\r
 392     }\r
 393 \r
 394 \r
 395     public void addNewFeature(String name, Color col, String group)\r
 396     {\r
 397 \r
 398       setColour(name, col);\r
 399       if(av.featuresDisplayed==null)\r
 400         av.featuresDisplayed = new Hashtable();\r
 401 \r
 402       if(group == null)\r
 403         group = "NOGROUP";\r
 404 \r
 405       av.featuresDisplayed.put(name, new Integer(col.getRGB()));\r
 406     }\r
 407 \r
 408     public void setColour(String featureType, Color col)\r
 409     {\r
 410       featureColours.put(featureType, col);\r
 411     }\r
 412 \r
 413     public void setTransparency(float value)\r
 414     {\r
 415       transparency = value;\r
 416     }\r
 417 \r
 418     public float getTransparency()\r
 419     {\r
 420       return transparency;\r
 421     }\r
 422 \r
 423     public void setFeaturePriority(Object [][] data)\r
 424     {\r
 425       // The feature table will display high priority\r
 426       // features at the top, but theses are the ones\r
 427       // we need to render last, so invert the data\r
 428       if(av.featuresDisplayed!=null)\r
 429         av.featuresDisplayed.clear();\r
 430       else\r
 431         av.featuresDisplayed = new Hashtable();\r
 432 \r
 433       renderOrder = new String[data.length];\r
 434 \r
 435       if (data.length > 0)\r
 436         for (int i = 0; i < data.length; i++)\r
 437         {\r
 438           String type = data[i][0].toString();\r
 439           setColour(type, (Color) data[i][1]);\r
 440           if ( ( (Boolean) data[i][2]).booleanValue())\r
 441           {\r
 442             av.featuresDisplayed.put(type, new Integer(getColour(type).getRGB()));\r
 443           }\r
 444 \r
 445           renderOrder[data.length - i - 1] = type;\r
 446         }\r
 447 \r
 448     }\r
 449 \r
 450 \r
 451 \r
 452 \r
 453 }\r