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     boolean newFeatureAdded = false;\r
  58 \r
  59 \r
  60     /**\r
  61      * Creates a new FeatureRenderer object.\r
  62      *\r
  63      * @param av DOCUMENT ME!\r
  64      */\r
  65     public FeatureRenderer(AlignViewport av)\r
  66     {\r
  67         this.av = av;\r
  68     }\r
  69 \r
  70     public void transferSettings(FeatureRenderer fr)\r
  71     {\r
  72       renderOrder = fr.renderOrder;\r
  73       featureGroups = fr.featureGroups;\r
  74       featureColours = fr.featureColours;\r
  75       transparency =  fr.transparency;\r
  76     }\r
  77 \r
  78     BufferedImage offscreenImage;\r
  79     boolean offscreenRender = false;\r
  80     public Color findFeatureColour(Color initialCol, SequenceI seq, int res)\r
  81     {\r
  82       return new Color( findFeatureColour (initialCol.getRGB(),\r
  83                         seq, res ));\r
  84     }\r
  85 \r
  86     /**\r
  87      * This is used by the Molecule Viewer and Overview to\r
  88      * get the accurate colourof the rendered sequence\r
  89      */\r
  90     public int findFeatureColour(int initialCol, SequenceI seq, int column)\r
  91     {\r
  92       if(!av.showSequenceFeatures)\r
  93         return initialCol;\r
  94 \r
  95       if(seq!=lastSeq)\r
  96       {\r
  97         lastSeq = seq;\r
  98         sequenceFeatures = lastSeq.getDatasetSequence().getSequenceFeatures();\r
  99         if(sequenceFeatures==null)\r
 100           return initialCol;\r
 101 \r
 102         sfSize = sequenceFeatures.length;\r
 103       }\r
 104 \r
 105       if(jalview.util.Comparison.isGap(lastSeq.getCharAt(column)))\r
 106         return Color.white.getRGB();\r
 107 \r
 108 \r
 109       //Only bother making an offscreen image if transparency is applied\r
 110       if(transparency!=1.0f && offscreenImage==null)\r
 111       {\r
 112         offscreenImage = new BufferedImage(1,1,BufferedImage.TYPE_INT_ARGB);\r
 113       }\r
 114 \r
 115       currentColour = null;\r
 116 \r
 117       offscreenRender = true;\r
 118 \r
 119       if(offscreenImage!=null)\r
 120       {\r
 121         offscreenImage.setRGB(0,0,initialCol);\r
 122         drawSequence(offscreenImage.getGraphics(),\r
 123                      lastSeq,\r
 124                      column,column,0);\r
 125 \r
 126         return offscreenImage.getRGB(0,0);\r
 127       }\r
 128       else\r
 129       {\r
 130         drawSequence(null,\r
 131                     lastSeq,\r
 132                     lastSeq.findPosition(column),\r
 133                     -1, -1);\r
 134 \r
 135         if (currentColour == null)\r
 136           return initialCol;\r
 137         else\r
 138           return  ((Integer)currentColour).intValue();\r
 139       }\r
 140 \r
 141 \r
 142     }\r
 143 \r
 144 \r
 145     /**\r
 146      * DOCUMENT ME!\r
 147      *\r
 148      * @param g DOCUMENT ME!\r
 149      * @param seq DOCUMENT ME!\r
 150      * @param sg DOCUMENT ME!\r
 151      * @param start DOCUMENT ME!\r
 152      * @param end DOCUMENT ME!\r
 153      * @param x1 DOCUMENT ME!\r
 154      * @param y1 DOCUMENT ME!\r
 155      * @param width DOCUMENT ME!\r
 156      * @param height DOCUMENT ME!\r
 157      */\r
 158    // String type;\r
 159    // SequenceFeature sf;\r
 160     SequenceI lastSeq;\r
 161     SequenceFeature [] sequenceFeatures;\r
 162     int sfSize, sfindex, spos, epos;\r
 163 \r
 164     public void drawSequence(Graphics g, SequenceI seq,\r
 165                              int start, int end, int y1)\r
 166     {\r
 167       if ( seq.getDatasetSequence().getSequenceFeatures() == null\r
 168           || seq.getDatasetSequence().getSequenceFeatures().length==0)\r
 169         return;\r
 170 \r
 171       if(g!=null)\r
 172         fm = g.getFontMetrics();\r
 173 \r
 174 \r
 175       if (av.featuresDisplayed == null\r
 176           || renderOrder==null\r
 177           || newFeatureAdded)\r
 178        {\r
 179          findAllFeatures();\r
 180          if(av.featuresDisplayed.size()<1)\r
 181            return;\r
 182 \r
 183          sequenceFeatures = seq.getDatasetSequence().getSequenceFeatures();\r
 184          sfSize = sequenceFeatures.length;\r
 185        }\r
 186 \r
 187        if(lastSeq==null || seq!=lastSeq)\r
 188       {\r
 189         lastSeq = seq;\r
 190         sequenceFeatures = seq.getDatasetSequence().getSequenceFeatures();\r
 191         sfSize = sequenceFeatures.length;\r
 192       }\r
 193 \r
 194 \r
 195       if (transparency != 1 && g!=null)\r
 196       {\r
 197         Graphics2D g2 = (Graphics2D) g;\r
 198         g2.setComposite(\r
 199             AlphaComposite.getInstance(\r
 200                 AlphaComposite.SRC_OVER, transparency));\r
 201       }\r
 202 \r
 203       if(!offscreenRender)\r
 204       {\r
 205         spos = lastSeq.findPosition(start);\r
 206         epos = lastSeq.findPosition(end);\r
 207       }\r
 208 \r
 209 \r
 210       String type;\r
 211       for(int renderIndex=0; renderIndex<renderOrder.length; renderIndex++)\r
 212        {\r
 213         type =  renderOrder[renderIndex];\r
 214 \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 public void featuresAdded()\r
 337     {\r
 338       newFeatureAdded = true;\r
 339       findAllFeatures();\r
 340       newFeatureAdded = false;\r
 341     }\r
 342 \r
 343    synchronized void findAllFeatures()\r
 344    {\r
 345       jalview.schemes.UserColourScheme ucs = new\r
 346           jalview.schemes.UserColourScheme();\r
 347 \r
 348       if(av.featuresDisplayed==null)\r
 349         av.featuresDisplayed = new Hashtable();\r
 350 \r
 351       av.featuresDisplayed.clear();\r
 352 \r
 353       Vector allfeatures = new Vector();\r
 354       for (int i = 0; i < av.alignment.getHeight(); i++)\r
 355       {\r
 356         SequenceFeature [] features\r
 357             = av.alignment.getSequenceAt(i).getDatasetSequence().getSequenceFeatures();\r
 358 \r
 359         if (features == null)\r
 360           continue;\r
 361 \r
 362         int index = 0;\r
 363         while (index < features.length)\r
 364         {\r
 365           if (!av.featuresDisplayed.containsKey(features[index].getType()))\r
 366           {\r
 367             if(!(features[index].begin == 0 && features[index].end ==0))\r
 368             {\r
 369               // If beginning and end are 0, the feature is for the whole sequence\r
 370               // and we don't want to render the feature in the normal way\r
 371 \r
 372               if (getColour(features[index].getType()) == null)\r
 373               {\r
 374                  featureColours.put(features[index].getType(),\r
 375                                    ucs.createColourFromName(features[index].\r
 376                     getType()));\r
 377               }\r
 378 \r
 379               av.featuresDisplayed.put(features[index].getType(),\r
 380                                        new Integer(getColour(features[index].\r
 381                   getType()).getRGB()));\r
 382               allfeatures.addElement(features[index].getType());\r
 383             }\r
 384           }\r
 385           index++;\r
 386         }\r
 387       }\r
 388 \r
 389       renderOrder = new String[allfeatures.size()];\r
 390       Enumeration en = allfeatures.elements();\r
 391       int i = allfeatures.size()-1;\r
 392       while(en.hasMoreElements())\r
 393       {\r
 394         renderOrder[i] = en.nextElement().toString();\r
 395         i--;\r
 396       }\r
 397     }\r
 398 \r
 399     public Color getColour(String featureType)\r
 400     {\r
 401       Color colour = (Color)featureColours.get(featureType);\r
 402       return colour;\r
 403     }\r
 404 \r
 405 \r
 406     public void addNewFeature(String name, Color col, String group)\r
 407     {\r
 408 \r
 409       setColour(name, col);\r
 410       if(av.featuresDisplayed==null)\r
 411         av.featuresDisplayed = new Hashtable();\r
 412 \r
 413       if(group == null)\r
 414         group = "NOGROUP";\r
 415 \r
 416       av.featuresDisplayed.put(name, new Integer(col.getRGB()));\r
 417     }\r
 418 \r
 419     public void setColour(String featureType, Color col)\r
 420     {\r
 421       featureColours.put(featureType, col);\r
 422     }\r
 423 \r
 424     public void setTransparency(float value)\r
 425     {\r
 426       transparency = value;\r
 427     }\r
 428 \r
 429     public float getTransparency()\r
 430     {\r
 431       return transparency;\r
 432     }\r
 433 \r
 434     public void setFeaturePriority(Object [][] data)\r
 435     {\r
 436       // The feature table will display high priority\r
 437       // features at the top, but theses are the ones\r
 438       // we need to render last, so invert the data\r
 439       if(av.featuresDisplayed!=null)\r
 440         av.featuresDisplayed.clear();\r
 441       else\r
 442         av.featuresDisplayed = new Hashtable();\r
 443 \r
 444       renderOrder = new String[data.length];\r
 445 \r
 446       if (data.length > 0)\r
 447         for (int i = 0; i < data.length; i++)\r
 448         {\r
 449           String type = data[i][0].toString();\r
 450           setColour(type, (Color) data[i][1]);\r
 451           if ( ( (Boolean) data[i][2]).booleanValue())\r
 452           {\r
 453             av.featuresDisplayed.put(type, new Integer(getColour(type).getRGB()));\r
 454           }\r
 455 \r
 456           renderOrder[data.length - i - 1] = type;\r
 457         }\r
 458 \r
 459     }\r
 460 \r
 461 \r
 462 \r
 463 \r
 464 }\r