src/jalview/io/FeaturesFile.java

   1 /*\r
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)\r
   3  * Copyright (C) 2008 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.io;\r
  20 \r
  21 import java.io.*;\r
  22 import java.util.*;\r
  23 \r
  24 import jalview.datamodel.*;\r
  25 import jalview.schemes.*;\r
  26 \r
  27 /**\r
  28  * Parse and create Jalview Features files Detects GFF format features files and\r
  29  * parses. Does not implement standard print() - call specific printFeatures or\r
  30  * printGFF. Uses AlignmentI.findSequence(String id) to find the sequence object\r
  31  * for the features annotation - this normally works on an exact match.\r
  32  * \r
  33  * @author AMW\r
  34  * @version $Revision$\r
  35  */\r
  36 public class FeaturesFile extends AlignFile\r
  37 {\r
  38   /**\r
  39    * work around for GFF interpretation bug where source string becomes description rather than a group\r
  40    */\r
  41   private boolean doGffSource = true;\r
  42 \r
  43   /**\r
  44    * Creates a new FeaturesFile object.\r
  45    */\r
  46   public FeaturesFile()\r
  47   {\r
  48   }\r
  49 \r
  50   /**\r
  51    * Creates a new FeaturesFile object.\r
  52    * \r
  53    * @param inFile\r
  54    *                DOCUMENT ME!\r
  55    * @param type\r
  56    *                DOCUMENT ME!\r
  57    * \r
  58    * @throws IOException\r
  59    *                 DOCUMENT ME!\r
  60    */\r
  61   public FeaturesFile(String inFile, String type) throws IOException\r
  62   {\r
  63     super(inFile, type);\r
  64   }\r
  65 \r
  66   public FeaturesFile(FileParse source) throws IOException\r
  67   {\r
  68     super(source);\r
  69   }\r
  70 \r
  71   /**\r
  72    * The Application can render HTML, but the applet will remove HTML tags and\r
  73    * replace links with %LINK% Both need to read links in HTML however\r
  74    * \r
  75    * @throws IOException\r
  76    *                 DOCUMENT ME!\r
  77    */\r
  78   public boolean parse(AlignmentI align, Hashtable colours,\r
  79           boolean removeHTML)\r
  80   {\r
  81     return parse(align, colours, null, removeHTML);\r
  82   }\r
  83 \r
  84   /**\r
  85    * The Application can render HTML, but the applet will remove HTML tags and\r
  86    * replace links with %LINK% Both need to read links in HTML however\r
  87    * \r
  88    * @throws IOException\r
  89    *                 DOCUMENT ME!\r
  90    */\r
  91   public boolean parse(AlignmentI align, Hashtable colours,\r
  92           Hashtable featureLink, boolean removeHTML)\r
  93   {\r
  94     String line = null;\r
  95     try\r
  96     {\r
  97       SequenceI seq = null;\r
  98       String type, desc, token = null;\r
  99 \r
 100       int index, start, end;\r
 101       float score;\r
 102       StringTokenizer st;\r
 103       SequenceFeature sf;\r
 104       String featureGroup = null, groupLink = null;\r
 105       Hashtable typeLink = new Hashtable();\r
 106 \r
 107       boolean GFFFile = true;\r
 108 \r
 109       while ((line = nextLine()) != null)\r
 110       {\r
 111         if (line.startsWith("#"))\r
 112         {\r
 113           continue;\r
 114         }\r
 115 \r
 116         st = new StringTokenizer(line, "\t");\r
 117         if (st.countTokens() > 1 && st.countTokens() < 4)\r
 118         {\r
 119           GFFFile = false;\r
 120           type = st.nextToken();\r
 121           if (type.equalsIgnoreCase("startgroup"))\r
 122           {\r
 123             featureGroup = st.nextToken();\r
 124             if (st.hasMoreElements())\r
 125             {\r
 126               groupLink = st.nextToken();\r
 127               featureLink.put(featureGroup, groupLink);\r
 128             }\r
 129           }\r
 130           else if (type.equalsIgnoreCase("endgroup"))\r
 131           {\r
 132             // We should check whether this is the current group,\r
 133             // but at present theres no way of showing more than 1 group\r
 134             st.nextToken();\r
 135             featureGroup = null;\r
 136             groupLink = null;\r
 137           }\r
 138           else\r
 139           {\r
 140             UserColourScheme ucs = new UserColourScheme(st.nextToken());\r
 141             colours.put(type, ucs.findColour('A'));\r
 142             if (st.hasMoreElements())\r
 143             {\r
 144               String link = st.nextToken();\r
 145               typeLink.put(type, link);\r
 146               if (featureLink == null)\r
 147               {\r
 148                 featureLink = new Hashtable();\r
 149               }\r
 150               featureLink.put(type, link);\r
 151             }\r
 152 \r
 153           }\r
 154           continue;\r
 155         }\r
 156         String seqId = "";\r
 157         while (st.hasMoreElements())\r
 158         {\r
 159 \r
 160           if (GFFFile)\r
 161           {\r
 162             // Still possible this is an old Jalview file,\r
 163             // which does not have type colours at the beginning\r
 164             seqId = token = st.nextToken();\r
 165             seq = align.findName(seqId, true);\r
 166             if (seq != null)\r
 167             {\r
 168               desc = st.nextToken();\r
 169               String group=null;\r
 170               if (doGffSource && desc.indexOf(' ')==-1) {\r
 171                 // could also be a source term rather than description line\r
 172                 group = new String(desc);\r
 173               }\r
 174               type = st.nextToken();\r
 175               try\r
 176               {\r
 177                 String stt = st.nextToken();\r
 178                 if (stt.length()==0 || stt.equals("-"))\r
 179                 {\r
 180                   start = 0;\r
 181                 } else {\r
 182                 start = Integer.parseInt(stt);\r
 183                 }\r
 184               } catch (NumberFormatException ex)\r
 185               {\r
 186                 start = 0;\r
 187               }\r
 188               try\r
 189               {\r
 190                 String stt = st.nextToken();\r
 191                 if (stt.length()==0 || stt.equals("-"))\r
 192                 {\r
 193                   end = 0;\r
 194                 } else {\r
 195                   end = Integer.parseInt(stt);\r
 196                 }\r
 197               } catch (NumberFormatException ex)\r
 198               {\r
 199                 end = 0;\r
 200               }\r
 201               // TODO: decide if non positional feature assertion for input data where end==0 is generally valid\r
 202               if (end==0)\r
 203               {\r
 204                 // treat as non-positional feature, regardless.\r
 205                 start=0;\r
 206               }\r
 207               try\r
 208               {\r
 209                 score = new Float(st.nextToken()).floatValue();\r
 210               } catch (NumberFormatException ex)\r
 211               {\r
 212                 score = 0;\r
 213               }\r
 214 \r
 215               sf = new SequenceFeature(type, desc, start, end, score, group);\r
 216 \r
 217               try\r
 218               {\r
 219                 sf.setValue("STRAND", st.nextToken());\r
 220                 sf.setValue("FRAME", st.nextToken());\r
 221               } catch (Exception ex)\r
 222               {\r
 223               }\r
 224 \r
 225               if (st.hasMoreTokens())\r
 226               {\r
 227                 StringBuffer attributes = new StringBuffer();\r
 228                 while (st.hasMoreTokens())\r
 229                 {\r
 230                   attributes.append("\t" + st.nextElement());\r
 231                 }\r
 232                 // TODO validate and split GFF2 attributes field ? parse out ([A-Za-z][A-Za-z0-9_]*) <value> ; and add as sf.setValue(attrib, val); \r
 233                 sf.setValue("ATTRIBUTES", attributes.toString());\r
 234               }\r
 235 \r
 236               seq.addSequenceFeature(sf);\r
 237               while ((seq = align.findName(seq, seqId, true)) != null)\r
 238               {\r
 239                 seq.addSequenceFeature(new SequenceFeature(sf));\r
 240               }\r
 241               break;\r
 242             }\r
 243           }\r
 244 \r
 245           if (GFFFile && seq == null)\r
 246           {\r
 247             desc = token;\r
 248           }\r
 249           else\r
 250           {\r
 251             desc = st.nextToken();\r
 252           }\r
 253           if (!st.hasMoreTokens())\r
 254           {\r
 255             System.err\r
 256                     .println("DEBUG: Run out of tokens when trying to identify the destination for the feature.. giving up.");\r
 257             // in all probability, this isn't a file we understand, so bail\r
 258             // quietly.\r
 259             return false;\r
 260           }\r
 261 \r
 262           token = st.nextToken();\r
 263 \r
 264           if (!token.equals("ID_NOT_SPECIFIED"))\r
 265           {\r
 266             seq = align.findName(seqId = token, true);\r
 267             st.nextToken();\r
 268           }\r
 269           else\r
 270           {\r
 271             seqId = null;\r
 272             try\r
 273             {\r
 274               index = Integer.parseInt(st.nextToken());\r
 275               seq = align.getSequenceAt(index);\r
 276             } catch (NumberFormatException ex)\r
 277             {\r
 278               seq = null;\r
 279             }\r
 280           }\r
 281 \r
 282           if (seq == null)\r
 283           {\r
 284             System.out.println("Sequence not found: " + line);\r
 285             break;\r
 286           }\r
 287 \r
 288           start = Integer.parseInt(st.nextToken());\r
 289           end = Integer.parseInt(st.nextToken());\r
 290 \r
 291           type = st.nextToken();\r
 292 \r
 293           if (!colours.containsKey(type))\r
 294           {\r
 295             // Probably the old style groups file\r
 296             UserColourScheme ucs = new UserColourScheme(type);\r
 297             colours.put(type, ucs.findColour('A'));\r
 298           }\r
 299 \r
 300           sf = new SequenceFeature(type, desc, "", start, end, featureGroup);\r
 301 \r
 302           if (groupLink != null && removeHTML)\r
 303           {\r
 304             sf.addLink(groupLink);\r
 305             sf.description += "%LINK%";\r
 306           }\r
 307           if (typeLink.containsKey(type) && removeHTML)\r
 308           {\r
 309             sf.addLink(typeLink.get(type).toString());\r
 310             sf.description += "%LINK%";\r
 311           }\r
 312 \r
 313           parseDescriptionHTML(sf, removeHTML);\r
 314 \r
 315           seq.addSequenceFeature(sf);\r
 316 \r
 317           while (seqId != null\r
 318                   && (seq = align.findName(seq, seqId, false)) != null)\r
 319           {\r
 320             seq.addSequenceFeature(new SequenceFeature(sf));\r
 321           }\r
 322           // If we got here, its not a GFFFile\r
 323           GFFFile = false;\r
 324         }\r
 325       }\r
 326     } catch (Exception ex)\r
 327     {\r
 328       System.out.println(line);\r
 329       System.out.println("Error parsing feature file: " + ex + "\n" + line);\r
 330       ex.printStackTrace(System.err);\r
 331       return false;\r
 332     }\r
 333 \r
 334     return true;\r
 335   }\r
 336 \r
 337   public void parseDescriptionHTML(SequenceFeature sf, boolean removeHTML)\r
 338   {\r
 339     if (sf.getDescription() == null)\r
 340     {\r
 341       return;\r
 342     }\r
 343 \r
 344     if (removeHTML\r
 345             && sf.getDescription().toUpperCase().indexOf("<HTML>") == -1)\r
 346     {\r
 347       removeHTML = false;\r
 348     }\r
 349 \r
 350     StringBuffer sb = new StringBuffer();\r
 351     StringTokenizer st = new StringTokenizer(sf.getDescription(), "<");\r
 352     String token, link;\r
 353     int startTag;\r
 354     String tag = null;\r
 355     while (st.hasMoreElements())\r
 356     {\r
 357       token = st.nextToken("&>");\r
 358       if (token.equalsIgnoreCase("html") || token.startsWith("/"))\r
 359       {\r
 360         continue;\r
 361       }\r
 362 \r
 363       tag = null;\r
 364       startTag = token.indexOf("<");\r
 365 \r
 366       if (startTag > -1)\r
 367       {\r
 368         tag = token.substring(startTag + 1);\r
 369         token = token.substring(0, startTag);\r
 370       }\r
 371 \r
 372       if (tag != null && tag.toUpperCase().startsWith("A HREF="))\r
 373       {\r
 374         if (token.length() > 0)\r
 375         {\r
 376           sb.append(token);\r
 377         }\r
 378         link = tag.substring(tag.indexOf("\"") + 1, tag.length() - 1);\r
 379         String label = st.nextToken("<>");\r
 380         sf.addLink(label + "|" + link);\r
 381         sb.append(label + "%LINK%");\r
 382       }\r
 383       else if (tag != null && tag.equalsIgnoreCase("br"))\r
 384       {\r
 385         sb.append("\n");\r
 386       }\r
 387       else if (token.startsWith("lt;"))\r
 388       {\r
 389         sb.append("<" + token.substring(3));\r
 390       }\r
 391       else if (token.startsWith("gt;"))\r
 392       {\r
 393         sb.append(">" + token.substring(3));\r
 394       }\r
 395       else if (token.startsWith("amp;"))\r
 396       {\r
 397         sb.append("&" + token.substring(4));\r
 398       }\r
 399       else\r
 400       {\r
 401         sb.append(token);\r
 402       }\r
 403     }\r
 404 \r
 405     if (removeHTML)\r
 406     {\r
 407       sf.description = sb.toString();\r
 408     }\r
 409 \r
 410   }\r
 411 \r
 412   /**\r
 413    * generate a features file for seqs\r
 414    * \r
 415    * @param seqs\r
 416    *                source of sequence features\r
 417    * @param visible\r
 418    *                hash of feature types and colours\r
 419    * @return features file contents\r
 420    */\r
 421   public String printJalviewFormat(SequenceI[] seqs, Hashtable visible)\r
 422   {\r
 423     return printJalviewFormat(seqs, visible, true);\r
 424   }\r
 425 \r
 426   /**\r
 427    * generate a features file for seqs with colours from visible (if any)\r
 428    * \r
 429    * @param seqs\r
 430    *                source of features\r
 431    * @param visible\r
 432    *                hash of Colours for each feature type\r
 433    * @param visOnly\r
 434    *                when true only feature types in 'visible' will be output\r
 435    * @return features file contents\r
 436    */\r
 437   public String printJalviewFormat(SequenceI[] seqs, Hashtable visible,\r
 438           boolean visOnly)\r
 439   {\r
 440     StringBuffer out = new StringBuffer();\r
 441     SequenceFeature[] next;\r
 442 \r
 443     if (visOnly && (visible == null || visible.size() < 1))\r
 444     {\r
 445       return "No Features Visible";\r
 446     }\r
 447     if (visible != null && visOnly)\r
 448     {\r
 449       // write feature colours only if we're given them and we are generating\r
 450       // viewed features\r
 451       Enumeration en = visible.keys();\r
 452       String type;\r
 453       int color;\r
 454       while (en.hasMoreElements())\r
 455       {\r
 456         type = en.nextElement().toString();\r
 457         color = Integer.parseInt(visible.get(type).toString());\r
 458         out.append(type\r
 459                 + "\t"\r
 460                 + jalview.util.Format\r
 461                         .getHexString(new java.awt.Color(color)) + "\n");\r
 462       }\r
 463     }\r
 464     // Work out which groups are both present and visible\r
 465     Vector groups = new Vector();\r
 466     int groupIndex = 0;\r
 467 \r
 468     for (int i = 0; i < seqs.length; i++)\r
 469     {\r
 470       next = seqs[i].getSequenceFeatures();\r
 471       if (next != null)\r
 472       {\r
 473         for (int j = 0; j < next.length; j++)\r
 474         {\r
 475           if (visOnly && !visible.containsKey(next[j].type))\r
 476           {\r
 477             continue;\r
 478           }\r
 479 \r
 480           if (next[j].featureGroup != null\r
 481                   && !groups.contains(next[j].featureGroup))\r
 482           {\r
 483             groups.addElement(next[j].featureGroup);\r
 484           }\r
 485         }\r
 486       }\r
 487     }\r
 488 \r
 489     String group = null;\r
 490 \r
 491     do\r
 492     {\r
 493 \r
 494       if (groups.size() > 0 && groupIndex < groups.size())\r
 495       {\r
 496         group = groups.elementAt(groupIndex).toString();\r
 497         out.append("\nSTARTGROUP\t" + group + "\n");\r
 498       }\r
 499       else\r
 500       {\r
 501         group = null;\r
 502       }\r
 503 \r
 504       for (int i = 0; i < seqs.length; i++)\r
 505       {\r
 506         next = seqs[i].getSequenceFeatures();\r
 507         if (next != null)\r
 508         {\r
 509           for (int j = 0; j < next.length; j++)\r
 510           {\r
 511             if (visOnly && !visible.containsKey(next[j].type))\r
 512             {\r
 513               continue;\r
 514             }\r
 515 \r
 516             if (group != null\r
 517                     && (next[j].featureGroup == null || !next[j].featureGroup\r
 518                             .equals(group)))\r
 519             {\r
 520               continue;\r
 521             }\r
 522 \r
 523             if (group == null && next[j].featureGroup != null)\r
 524             {\r
 525               continue;\r
 526             }\r
 527 \r
 528             if (next[j].description == null\r
 529                     || next[j].description.equals(""))\r
 530             {\r
 531               out.append(next[j].type + "\t");\r
 532             }\r
 533             else\r
 534             {\r
 535               if (next[j].links != null\r
 536                       && next[j].getDescription().indexOf("<html>") == -1)\r
 537               {\r
 538                 out.append("<html>");\r
 539               }\r
 540 \r
 541               out.append(next[j].description + " ");\r
 542               if (next[j].links != null)\r
 543               {\r
 544                 for (int l = 0; l < next[j].links.size(); l++)\r
 545                 {\r
 546                   String label = next[j].links.elementAt(l).toString();\r
 547                   String href = label.substring(label.indexOf("|") + 1);\r
 548                   label = label.substring(0, label.indexOf("|"));\r
 549 \r
 550                   if (next[j].description.indexOf(href) == -1)\r
 551                   {\r
 552                     out\r
 553                             .append("<a href=\"" + href + "\">" + label\r
 554                                     + "</a>");\r
 555                   }\r
 556                 }\r
 557 \r
 558                 if (next[j].getDescription().indexOf("</html>") == -1)\r
 559                 {\r
 560                   out.append("</html>");\r
 561                 }\r
 562               }\r
 563 \r
 564               out.append("\t");\r
 565             }\r
 566 \r
 567             out.append(seqs[i].getName() + "\t-1\t" + next[j].begin + "\t"\r
 568                     + next[j].end + "\t" + next[j].type + "\n");\r
 569           }\r
 570         }\r
 571       }\r
 572 \r
 573       if (group != null)\r
 574       {\r
 575         out.append("ENDGROUP\t" + group + "\n");\r
 576         groupIndex++;\r
 577       }\r
 578       else\r
 579       {\r
 580         break;\r
 581       }\r
 582 \r
 583     } while (groupIndex < groups.size() + 1);\r
 584 \r
 585     return out.toString();\r
 586   }\r
 587 \r
 588   public String printGFFFormat(SequenceI[] seqs, Hashtable visible)\r
 589   {\r
 590     return printGFFFormat(seqs, visible, true);\r
 591   }\r
 592 \r
 593   public String printGFFFormat(SequenceI[] seqs, Hashtable visible,\r
 594           boolean visOnly)\r
 595   {\r
 596     StringBuffer out = new StringBuffer();\r
 597     SequenceFeature[] next;\r
 598     String source;\r
 599 \r
 600     for (int i = 0; i < seqs.length; i++)\r
 601     {\r
 602       if (seqs[i].getSequenceFeatures() != null)\r
 603       {\r
 604         next = seqs[i].getSequenceFeatures();\r
 605         for (int j = 0; j < next.length; j++)\r
 606         {\r
 607           if (visOnly && visible!=null && !visible.containsKey(next[j].type))\r
 608           {\r
 609             continue;\r
 610           }\r
 611 \r
 612           source = next[j].featureGroup;\r
 613           if (source == null)\r
 614           {\r
 615             source = next[j].getDescription();\r
 616           }\r
 617 \r
 618           out.append(seqs[i].getName() + "\t" + source + "\t"\r
 619                   + next[j].type + "\t" + next[j].begin + "\t"\r
 620                   + next[j].end + "\t" + next[j].score + "\t");\r
 621 \r
 622           if (next[j].getValue("STRAND") != null)\r
 623           {\r
 624             out.append(next[j].getValue("STRAND") + "\t");\r
 625           }\r
 626           else\r
 627           {\r
 628             out.append(".\t");\r
 629           }\r
 630 \r
 631           if (next[j].getValue("FRAME") != null)\r
 632           {\r
 633             out.append(next[j].getValue("FRAME"));\r
 634           }\r
 635           else\r
 636           {\r
 637             out.append(".");\r
 638           }\r
 639 \r
 640           if (next[j].getValue("ATTRIBUTES") != null)\r
 641           {\r
 642             out.append(next[j].getValue("ATTRIBUTES"));\r
 643           }\r
 644 \r
 645           out.append("\n");\r
 646 \r
 647         }\r
 648       }\r
 649     }\r
 650 \r
 651     return out.toString();\r
 652   }\r
 653 \r
 654   /**\r
 655    * this is only for the benefit of object polymorphism - method does nothing.\r
 656    */\r
 657   public void parse()\r
 658   {\r
 659     // IGNORED\r
 660   }\r
 661 \r
 662   /**\r
 663    * this is only for the benefit of object polymorphism - method does nothing.\r
 664    * \r
 665    * @return error message\r
 666    */\r
 667   public String print()\r
 668   {\r
 669     return "USE printGFFFormat() or printJalviewFormat()";\r
 670   }\r
 671 }\r