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             // TODO: graduated feature colour needs to be parsed here\r
 141             UserColourScheme ucs = new UserColourScheme(st.nextToken());\r
 142             colours.put(type, ucs.findColour('A'));\r
 143             if (st.hasMoreElements())\r
 144             {\r
 145               String link = st.nextToken();\r
 146               typeLink.put(type, link);\r
 147               if (featureLink == null)\r
 148               {\r
 149                 featureLink = new Hashtable();\r
 150               }\r
 151               featureLink.put(type, link);\r
 152             }\r
 153 \r
 154           }\r
 155           continue;\r
 156         }\r
 157         String seqId = "";\r
 158         while (st.hasMoreElements())\r
 159         {\r
 160 \r
 161           if (GFFFile)\r
 162           {\r
 163             // Still possible this is an old Jalview file,\r
 164             // which does not have type colours at the beginning\r
 165             seqId = token = st.nextToken();\r
 166             seq = align.findName(seqId, true);\r
 167             if (seq != null)\r
 168             {\r
 169               desc = st.nextToken();\r
 170               String group=null;\r
 171               if (doGffSource && desc.indexOf(' ')==-1) {\r
 172                 // could also be a source term rather than description line\r
 173                 group = new String(desc);\r
 174               }\r
 175               type = st.nextToken();\r
 176               try\r
 177               {\r
 178                 String stt = st.nextToken();\r
 179                 if (stt.length()==0 || stt.equals("-"))\r
 180                 {\r
 181                   start = 0;\r
 182                 } else {\r
 183                 start = Integer.parseInt(stt);\r
 184                 }\r
 185               } catch (NumberFormatException ex)\r
 186               {\r
 187                 start = 0;\r
 188               }\r
 189               try\r
 190               {\r
 191                 String stt = st.nextToken();\r
 192                 if (stt.length()==0 || stt.equals("-"))\r
 193                 {\r
 194                   end = 0;\r
 195                 } else {\r
 196                   end = Integer.parseInt(stt);\r
 197                 }\r
 198               } catch (NumberFormatException ex)\r
 199               {\r
 200                 end = 0;\r
 201               }\r
 202               // TODO: decide if non positional feature assertion for input data where end==0 is generally valid\r
 203               if (end==0)\r
 204               {\r
 205                 // treat as non-positional feature, regardless.\r
 206                 start=0;\r
 207               }\r
 208               try\r
 209               {\r
 210                 score = new Float(st.nextToken()).floatValue();\r
 211               } catch (NumberFormatException ex)\r
 212               {\r
 213                 score = 0;\r
 214               }\r
 215 \r
 216               sf = new SequenceFeature(type, desc, start, end, score, group);\r
 217 \r
 218               try\r
 219               {\r
 220                 sf.setValue("STRAND", st.nextToken());\r
 221                 sf.setValue("FRAME", st.nextToken());\r
 222               } catch (Exception ex)\r
 223               {\r
 224               }\r
 225 \r
 226               if (st.hasMoreTokens())\r
 227               {\r
 228                 StringBuffer attributes = new StringBuffer();\r
 229                 while (st.hasMoreTokens())\r
 230                 {\r
 231                   attributes.append("\t" + st.nextElement());\r
 232                 }\r
 233                 // 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
 234                 sf.setValue("ATTRIBUTES", attributes.toString());\r
 235               }\r
 236 \r
 237               seq.addSequenceFeature(sf);\r
 238               while ((seq = align.findName(seq, seqId, true)) != null)\r
 239               {\r
 240                 seq.addSequenceFeature(new SequenceFeature(sf));\r
 241               }\r
 242               break;\r
 243             }\r
 244           }\r
 245 \r
 246           if (GFFFile && seq == null)\r
 247           {\r
 248             desc = token;\r
 249           }\r
 250           else\r
 251           {\r
 252             desc = st.nextToken();\r
 253           }\r
 254           if (!st.hasMoreTokens())\r
 255           {\r
 256             System.err\r
 257                     .println("DEBUG: Run out of tokens when trying to identify the destination for the feature.. giving up.");\r
 258             // in all probability, this isn't a file we understand, so bail\r
 259             // quietly.\r
 260             return false;\r
 261           }\r
 262 \r
 263           token = st.nextToken();\r
 264 \r
 265           if (!token.equals("ID_NOT_SPECIFIED"))\r
 266           {\r
 267             seq = align.findName(seqId = token, true);\r
 268             st.nextToken();\r
 269           }\r
 270           else\r
 271           {\r
 272             seqId = null;\r
 273             try\r
 274             {\r
 275               index = Integer.parseInt(st.nextToken());\r
 276               seq = align.getSequenceAt(index);\r
 277             } catch (NumberFormatException ex)\r
 278             {\r
 279               seq = null;\r
 280             }\r
 281           }\r
 282 \r
 283           if (seq == null)\r
 284           {\r
 285             System.out.println("Sequence not found: " + line);\r
 286             break;\r
 287           }\r
 288 \r
 289           start = Integer.parseInt(st.nextToken());\r
 290           end = Integer.parseInt(st.nextToken());\r
 291 \r
 292           type = st.nextToken();\r
 293 \r
 294           if (!colours.containsKey(type))\r
 295           {\r
 296             // Probably the old style groups file\r
 297             UserColourScheme ucs = new UserColourScheme(type);\r
 298             colours.put(type, ucs.findColour('A'));\r
 299           }\r
 300 \r
 301           sf = new SequenceFeature(type, desc, "", start, end, featureGroup);\r
 302 \r
 303           if (groupLink != null && removeHTML)\r
 304           {\r
 305             sf.addLink(groupLink);\r
 306             sf.description += "%LINK%";\r
 307           }\r
 308           if (typeLink.containsKey(type) && removeHTML)\r
 309           {\r
 310             sf.addLink(typeLink.get(type).toString());\r
 311             sf.description += "%LINK%";\r
 312           }\r
 313 \r
 314           parseDescriptionHTML(sf, removeHTML);\r
 315 \r
 316           seq.addSequenceFeature(sf);\r
 317 \r
 318           while (seqId != null\r
 319                   && (seq = align.findName(seq, seqId, false)) != null)\r
 320           {\r
 321             seq.addSequenceFeature(new SequenceFeature(sf));\r
 322           }\r
 323           // If we got here, its not a GFFFile\r
 324           GFFFile = false;\r
 325         }\r
 326       }\r
 327     } catch (Exception ex)\r
 328     {\r
 329       System.out.println(line);\r
 330       System.out.println("Error parsing feature file: " + ex + "\n" + line);\r
 331       ex.printStackTrace(System.err);\r
 332       return false;\r
 333     }\r
 334 \r
 335     return true;\r
 336   }\r
 337 \r
 338   public void parseDescriptionHTML(SequenceFeature sf, boolean removeHTML)\r
 339   {\r
 340     if (sf.getDescription() == null)\r
 341     {\r
 342       return;\r
 343     }\r
 344 \r
 345     if (removeHTML\r
 346             && sf.getDescription().toUpperCase().indexOf("<HTML>") == -1)\r
 347     {\r
 348       removeHTML = false;\r
 349     }\r
 350 \r
 351     StringBuffer sb = new StringBuffer();\r
 352     StringTokenizer st = new StringTokenizer(sf.getDescription(), "<");\r
 353     String token, link;\r
 354     int startTag;\r
 355     String tag = null;\r
 356     while (st.hasMoreElements())\r
 357     {\r
 358       token = st.nextToken("&>");\r
 359       if (token.equalsIgnoreCase("html") || token.startsWith("/"))\r
 360       {\r
 361         continue;\r
 362       }\r
 363 \r
 364       tag = null;\r
 365       startTag = token.indexOf("<");\r
 366 \r
 367       if (startTag > -1)\r
 368       {\r
 369         tag = token.substring(startTag + 1);\r
 370         token = token.substring(0, startTag);\r
 371       }\r
 372 \r
 373       if (tag != null && tag.toUpperCase().startsWith("A HREF="))\r
 374       {\r
 375         if (token.length() > 0)\r
 376         {\r
 377           sb.append(token);\r
 378         }\r
 379         link = tag.substring(tag.indexOf("\"") + 1, tag.length() - 1);\r
 380         String label = st.nextToken("<>");\r
 381         sf.addLink(label + "|" + link);\r
 382         sb.append(label + "%LINK%");\r
 383       }\r
 384       else if (tag != null && tag.equalsIgnoreCase("br"))\r
 385       {\r
 386         sb.append("\n");\r
 387       }\r
 388       else if (token.startsWith("lt;"))\r
 389       {\r
 390         sb.append("<" + token.substring(3));\r
 391       }\r
 392       else if (token.startsWith("gt;"))\r
 393       {\r
 394         sb.append(">" + token.substring(3));\r
 395       }\r
 396       else if (token.startsWith("amp;"))\r
 397       {\r
 398         sb.append("&" + token.substring(4));\r
 399       }\r
 400       else\r
 401       {\r
 402         sb.append(token);\r
 403       }\r
 404     }\r
 405 \r
 406     if (removeHTML)\r
 407     {\r
 408       sf.description = sb.toString();\r
 409     }\r
 410 \r
 411   }\r
 412 \r
 413   /**\r
 414    * generate a features file for seqs\r
 415    * \r
 416    * @param seqs\r
 417    *                source of sequence features\r
 418    * @param visible\r
 419    *                hash of feature types and colours\r
 420    * @return features file contents\r
 421    */\r
 422   public String printJalviewFormat(SequenceI[] seqs, Hashtable visible)\r
 423   {\r
 424     return printJalviewFormat(seqs, visible, true);\r
 425   }\r
 426 \r
 427   /**\r
 428    * generate a features file for seqs with colours from visible (if any)\r
 429    * \r
 430    * @param seqs\r
 431    *                source of features\r
 432    * @param visible\r
 433    *                hash of Colours for each feature type\r
 434    * @param visOnly\r
 435    *                when true only feature types in 'visible' will be output\r
 436    * @return features file contents\r
 437    */\r
 438   public String printJalviewFormat(SequenceI[] seqs, Hashtable visible,\r
 439           boolean visOnly)\r
 440   {\r
 441     StringBuffer out = new StringBuffer();\r
 442     SequenceFeature[] next;\r
 443 \r
 444     if (visOnly && (visible == null || visible.size() < 1))\r
 445     {\r
 446       return "No Features Visible";\r
 447     }\r
 448     if (visible != null && visOnly)\r
 449     {\r
 450       // write feature colours only if we're given them and we are generating\r
 451       // viewed features\r
 452       Enumeration en = visible.keys();\r
 453       String type;\r
 454       int color;\r
 455       while (en.hasMoreElements())\r
 456       {\r
 457         type = en.nextElement().toString();\r
 458         // TODO: Extend to output graduated feature colour details\r
 459         \r
 460         color = Integer.parseInt(visible.get(type).toString());\r
 461         out.append(type\r
 462                 + "\t"\r
 463                 + jalview.util.Format\r
 464                         .getHexString(new java.awt.Color(color)) + "\n");\r
 465       }\r
 466     }\r
 467     // Work out which groups are both present and visible\r
 468     Vector groups = new Vector();\r
 469     int groupIndex = 0;\r
 470 \r
 471     for (int i = 0; i < seqs.length; i++)\r
 472     {\r
 473       next = seqs[i].getSequenceFeatures();\r
 474       if (next != null)\r
 475       {\r
 476         for (int j = 0; j < next.length; j++)\r
 477         {\r
 478           if (visOnly && !visible.containsKey(next[j].type))\r
 479           {\r
 480             continue;\r
 481           }\r
 482 \r
 483           if (next[j].featureGroup != null\r
 484                   && !groups.contains(next[j].featureGroup))\r
 485           {\r
 486             groups.addElement(next[j].featureGroup);\r
 487           }\r
 488         }\r
 489       }\r
 490     }\r
 491 \r
 492     String group = null;\r
 493 \r
 494     do\r
 495     {\r
 496 \r
 497       if (groups.size() > 0 && groupIndex < groups.size())\r
 498       {\r
 499         group = groups.elementAt(groupIndex).toString();\r
 500         out.append("\nSTARTGROUP\t" + group + "\n");\r
 501       }\r
 502       else\r
 503       {\r
 504         group = null;\r
 505       }\r
 506 \r
 507       for (int i = 0; i < seqs.length; i++)\r
 508       {\r
 509         next = seqs[i].getSequenceFeatures();\r
 510         if (next != null)\r
 511         {\r
 512           for (int j = 0; j < next.length; j++)\r
 513           {\r
 514             if (visOnly && !visible.containsKey(next[j].type))\r
 515             {\r
 516               continue;\r
 517             }\r
 518 \r
 519             if (group != null\r
 520                     && (next[j].featureGroup == null || !next[j].featureGroup\r
 521                             .equals(group)))\r
 522             {\r
 523               continue;\r
 524             }\r
 525 \r
 526             if (group == null && next[j].featureGroup != null)\r
 527             {\r
 528               continue;\r
 529             }\r
 530 \r
 531             if (next[j].description == null\r
 532                     || next[j].description.equals(""))\r
 533             {\r
 534               out.append(next[j].type + "\t");\r
 535             }\r
 536             else\r
 537             {\r
 538               if (next[j].links != null\r
 539                       && next[j].getDescription().indexOf("<html>") == -1)\r
 540               {\r
 541                 out.append("<html>");\r
 542               }\r
 543 \r
 544               out.append(next[j].description + " ");\r
 545               if (next[j].links != null)\r
 546               {\r
 547                 for (int l = 0; l < next[j].links.size(); l++)\r
 548                 {\r
 549                   String label = next[j].links.elementAt(l).toString();\r
 550                   String href = label.substring(label.indexOf("|") + 1);\r
 551                   label = label.substring(0, label.indexOf("|"));\r
 552 \r
 553                   if (next[j].description.indexOf(href) == -1)\r
 554                   {\r
 555                     out\r
 556                             .append("<a href=\"" + href + "\">" + label\r
 557                                     + "</a>");\r
 558                   }\r
 559                 }\r
 560 \r
 561                 if (next[j].getDescription().indexOf("</html>") == -1)\r
 562                 {\r
 563                   out.append("</html>");\r
 564                 }\r
 565               }\r
 566 \r
 567               out.append("\t");\r
 568             }\r
 569 \r
 570             out.append(seqs[i].getName() + "\t-1\t" + next[j].begin + "\t"\r
 571                     + next[j].end + "\t" + next[j].type + "\n");\r
 572           }\r
 573         }\r
 574       }\r
 575 \r
 576       if (group != null)\r
 577       {\r
 578         out.append("ENDGROUP\t" + group + "\n");\r
 579         groupIndex++;\r
 580       }\r
 581       else\r
 582       {\r
 583         break;\r
 584       }\r
 585 \r
 586     } while (groupIndex < groups.size() + 1);\r
 587 \r
 588     return out.toString();\r
 589   }\r
 590 \r
 591   public String printGFFFormat(SequenceI[] seqs, Hashtable visible)\r
 592   {\r
 593     return printGFFFormat(seqs, visible, true);\r
 594   }\r
 595 \r
 596   public String printGFFFormat(SequenceI[] seqs, Hashtable visible,\r
 597           boolean visOnly)\r
 598   {\r
 599     StringBuffer out = new StringBuffer();\r
 600     SequenceFeature[] next;\r
 601     String source;\r
 602 \r
 603     for (int i = 0; i < seqs.length; i++)\r
 604     {\r
 605       if (seqs[i].getSequenceFeatures() != null)\r
 606       {\r
 607         next = seqs[i].getSequenceFeatures();\r
 608         for (int j = 0; j < next.length; j++)\r
 609         {\r
 610           if (visOnly && visible!=null && !visible.containsKey(next[j].type))\r
 611           {\r
 612             continue;\r
 613           }\r
 614 \r
 615           source = next[j].featureGroup;\r
 616           if (source == null)\r
 617           {\r
 618             source = next[j].getDescription();\r
 619           }\r
 620 \r
 621           out.append(seqs[i].getName() + "\t" + source + "\t"\r
 622                   + next[j].type + "\t" + next[j].begin + "\t"\r
 623                   + next[j].end + "\t" + next[j].score + "\t");\r
 624 \r
 625           if (next[j].getValue("STRAND") != null)\r
 626           {\r
 627             out.append(next[j].getValue("STRAND") + "\t");\r
 628           }\r
 629           else\r
 630           {\r
 631             out.append(".\t");\r
 632           }\r
 633 \r
 634           if (next[j].getValue("FRAME") != null)\r
 635           {\r
 636             out.append(next[j].getValue("FRAME"));\r
 637           }\r
 638           else\r
 639           {\r
 640             out.append(".");\r
 641           }\r
 642 \r
 643           if (next[j].getValue("ATTRIBUTES") != null)\r
 644           {\r
 645             out.append(next[j].getValue("ATTRIBUTES"));\r
 646           }\r
 647 \r
 648           out.append("\n");\r
 649 \r
 650         }\r
 651       }\r
 652     }\r
 653 \r
 654     return out.toString();\r
 655   }\r
 656 \r
 657   /**\r
 658    * this is only for the benefit of object polymorphism - method does nothing.\r
 659    */\r
 660   public void parse()\r
 661   {\r
 662     // IGNORED\r
 663   }\r
 664 \r
 665   /**\r
 666    * this is only for the benefit of object polymorphism - method does nothing.\r
 667    * \r
 668    * @return error message\r
 669    */\r
 670   public String print()\r
 671   {\r
 672     return "USE printGFFFormat() or printJalviewFormat()";\r
 673   }\r
 674 }\r