/*
* Jalview - A Sequence Alignment Editor and Viewer (Version 2.5)
* Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
*
* This file is part of Jalview.
*
* Jalview is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
*
* Jalview is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with Jalview. If not, see .
*/
package jalview.io;
import java.io.*;
import java.util.*;
import jalview.datamodel.*;
import jalview.schemes.*;
import jalview.util.Format;
/**
* Parse and create Jalview Features files Detects GFF format features files and
* parses. Does not implement standard print() - call specific printFeatures or
* printGFF. Uses AlignmentI.findSequence(String id) to find the sequence object
* for the features annotation - this normally works on an exact match.
*
* @author AMW
* @version $Revision$
*/
public class FeaturesFile extends AlignFile
{
/**
* work around for GFF interpretation bug where source string becomes
* description rather than a group
*/
private boolean doGffSource = true;
/**
* Creates a new FeaturesFile object.
*/
public FeaturesFile()
{
}
/**
* Creates a new FeaturesFile object.
*
* @param inFile
* DOCUMENT ME!
* @param type
* DOCUMENT ME!
*
* @throws IOException
* DOCUMENT ME!
*/
public FeaturesFile(String inFile, String type) throws IOException
{
super(inFile, type);
}
public FeaturesFile(FileParse source) throws IOException
{
super(source);
}
/**
* The Application can render HTML, but the applet will remove HTML tags and
* replace links with %LINK% Both need to read links in HTML however
*
* @throws IOException
* DOCUMENT ME!
*/
public boolean parse(AlignmentI align, Hashtable colours,
boolean removeHTML)
{
return parse(align, colours, null, removeHTML);
}
/**
* The Application can render HTML, but the applet will remove HTML tags and
* replace links with %LINK% Both need to read links in HTML however
*
* @throws IOException
* DOCUMENT ME!
*/
public boolean parse(AlignmentI align, Hashtable colours,
Hashtable featureLink, boolean removeHTML)
{
String line = null;
try
{
SequenceI seq = null;
String type, desc, token = null;
int index, start, end;
float score;
StringTokenizer st;
SequenceFeature sf;
String featureGroup = null, groupLink = null;
Hashtable typeLink = new Hashtable();
boolean GFFFile = true;
while ((line = nextLine()) != null)
{
if (line.startsWith("#"))
{
continue;
}
st = new StringTokenizer(line, "\t");
if (st.countTokens() > 1 && st.countTokens() < 4)
{
GFFFile = false;
type = st.nextToken();
if (type.equalsIgnoreCase("startgroup"))
{
featureGroup = st.nextToken();
if (st.hasMoreElements())
{
groupLink = st.nextToken();
featureLink.put(featureGroup, groupLink);
}
}
else if (type.equalsIgnoreCase("endgroup"))
{
// We should check whether this is the current group,
// but at present theres no way of showing more than 1 group
st.nextToken();
featureGroup = null;
groupLink = null;
}
else
{
Object colour = null;
String colscheme = st.nextToken();
if (colscheme.indexOf("|") > -1)
{
// Parse '|' separated graduated colourscheme fields:
// mincolour|maxcolour|[absolute|]minvalue|maxvalue|thresholdtype|thresholdvalue
// first four are required.
// first two are hexadecimal or word equivalent colours.
// second two are values parsed as floats.
// fifth is either 'above','below', or 'none'.
// sixth is a float value and only required when fifth is either
// 'above' or 'below'.
StringTokenizer gcol = new StringTokenizer(colscheme, "|");
String mincol = gcol.nextToken(), maxcol = gcol.nextToken();
String abso = gcol.nextToken(), minval, maxval;
if (abso.toLowerCase().indexOf("abso") != 0)
{
minval = abso;
abso = null;
}
else
{
minval = gcol.nextToken();
}
maxval = gcol.nextToken();
// set defaults
int threshtype = AnnotationColourGradient.NO_THRESHOLD;
float min = Float.MIN_VALUE, max = Float.MAX_VALUE, threshval = Float.NaN;
try
{
if (minval.length() > 0)
{
min = new Float(minval).floatValue();
}
} catch (Exception e)
{
System.err
.println("Couldn't parse the minimum value for graduated colour for type ("
+ colscheme
+ ") - did you misspell 'auto' for the optional automatic colour switch ?");
e.printStackTrace();
}
try
{
if (maxval.length() > 0)
{
max = new Float(maxval).floatValue();
}
} catch (Exception e)
{
System.err
.println("Couldn't parse the maximum value for graduated colour for type ("
+ colscheme + ")");
e.printStackTrace();
}
try
{
colour = new jalview.schemes.GraduatedColor(
new UserColourScheme(mincol).findColour('A'),
new UserColourScheme(maxcol).findColour('A'), min,
max);
} catch (Exception e)
{
System.err
.println("Couldn't parse the graduated colour scheme ("
+ colscheme + ")");
e.printStackTrace();
}
if (colour != null)
{
((jalview.schemes.GraduatedColor) colour)
.setAutoScaled(abso == null);
// add in any additional parameters
String ttype = null, tval = null;
if (gcol.hasMoreTokens())
{
// threshold type and possibly a threshold value
ttype = gcol.nextToken();
if (ttype.toLowerCase().startsWith("below"))
{
((jalview.schemes.GraduatedColor) colour)
.setThreshType(AnnotationColourGradient.BELOW_THRESHOLD);
}
else if (ttype.toLowerCase().startsWith("above"))
{
((jalview.schemes.GraduatedColor) colour)
.setThreshType(AnnotationColourGradient.ABOVE_THRESHOLD);
}
else
{
((jalview.schemes.GraduatedColor) colour)
.setThreshType(AnnotationColourGradient.NO_THRESHOLD);
if (!ttype.toLowerCase().startsWith("no"))
{
System.err
.println("Ignoring unrecognised threshold type : "
+ ttype);
}
}
}
if (((GraduatedColor) colour).getThreshType() != AnnotationColourGradient.NO_THRESHOLD)
{
tval = gcol.nextToken();
try
{
((jalview.schemes.GraduatedColor) colour)
.setThresh(new Float(tval).floatValue());
} catch (Exception e)
{
System.err
.println("Couldn't parse threshold value as a float: ("
+ tval + ")");
e.printStackTrace();
}
}
// parse the thresh-is-min token ?
if (gcol.hasMoreTokens())
{
System.err
.println("Ignoring additional tokens in parameters in graduated colour specification\n");
while (gcol.hasMoreTokens())
{
System.err.println("|" + gcol);
}
System.err.println("\n");
}
}
}
else
{
UserColourScheme ucs = new UserColourScheme(colscheme);
colour = ucs.findColour('A');
}
if (colour != null)
{
colours.put(type, colour);
}
if (st.hasMoreElements())
{
String link = st.nextToken();
typeLink.put(type, link);
if (featureLink == null)
{
featureLink = new Hashtable();
}
featureLink.put(type, link);
}
}
continue;
}
String seqId = "";
while (st.hasMoreElements())
{
if (GFFFile)
{
// Still possible this is an old Jalview file,
// which does not have type colours at the beginning
seqId = token = st.nextToken();
seq = align.findName(seqId, true);
if (seq != null)
{
desc = st.nextToken();
String group = null;
if (doGffSource && desc.indexOf(' ') == -1)
{
// could also be a source term rather than description line
group = new String(desc);
}
type = st.nextToken();
try
{
String stt = st.nextToken();
if (stt.length() == 0 || stt.equals("-"))
{
start = 0;
}
else
{
start = Integer.parseInt(stt);
}
} catch (NumberFormatException ex)
{
start = 0;
}
try
{
String stt = st.nextToken();
if (stt.length() == 0 || stt.equals("-"))
{
end = 0;
}
else
{
end = Integer.parseInt(stt);
}
} catch (NumberFormatException ex)
{
end = 0;
}
// TODO: decide if non positional feature assertion for input data
// where end==0 is generally valid
if (end == 0)
{
// treat as non-positional feature, regardless.
start = 0;
}
try
{
score = new Float(st.nextToken()).floatValue();
} catch (NumberFormatException ex)
{
score = 0;
}
sf = new SequenceFeature(type, desc, start, end, score, group);
try
{
sf.setValue("STRAND", st.nextToken());
sf.setValue("FRAME", st.nextToken());
} catch (Exception ex)
{
}
if (st.hasMoreTokens())
{
StringBuffer attributes = new StringBuffer();
while (st.hasMoreTokens())
{
attributes.append("\t" + st.nextElement());
}
// TODO validate and split GFF2 attributes field ? parse out
// ([A-Za-z][A-Za-z0-9_]*) ; and add as
// sf.setValue(attrib, val);
sf.setValue("ATTRIBUTES", attributes.toString());
}
seq.addSequenceFeature(sf);
while ((seq = align.findName(seq, seqId, true)) != null)
{
seq.addSequenceFeature(new SequenceFeature(sf));
}
break;
}
}
if (GFFFile && seq == null)
{
desc = token;
}
else
{
desc = st.nextToken();
}
if (!st.hasMoreTokens())
{
System.err
.println("DEBUG: Run out of tokens when trying to identify the destination for the feature.. giving up.");
// in all probability, this isn't a file we understand, so bail
// quietly.
return false;
}
token = st.nextToken();
if (!token.equals("ID_NOT_SPECIFIED"))
{
seq = align.findName(seqId = token, true);
st.nextToken();
}
else
{
seqId = null;
try
{
index = Integer.parseInt(st.nextToken());
seq = align.getSequenceAt(index);
} catch (NumberFormatException ex)
{
seq = null;
}
}
if (seq == null)
{
System.out.println("Sequence not found: " + line);
break;
}
start = Integer.parseInt(st.nextToken());
end = Integer.parseInt(st.nextToken());
type = st.nextToken();
if (!colours.containsKey(type))
{
// Probably the old style groups file
UserColourScheme ucs = new UserColourScheme(type);
colours.put(type, ucs.findColour('A'));
}
sf = new SequenceFeature(type, desc, "", start, end, featureGroup);
if (st.hasMoreTokens())
{
try
{
score = new Float(st.nextToken()).floatValue();
// update colourgradient bounds if allowed to
} catch (NumberFormatException ex)
{
score = 0;
}
sf.setScore(score);
}
if (groupLink != null && removeHTML)
{
sf.addLink(groupLink);
sf.description += "%LINK%";
}
if (typeLink.containsKey(type) && removeHTML)
{
sf.addLink(typeLink.get(type).toString());
sf.description += "%LINK%";
}
parseDescriptionHTML(sf, removeHTML);
seq.addSequenceFeature(sf);
while (seqId != null
&& (seq = align.findName(seq, seqId, false)) != null)
{
seq.addSequenceFeature(new SequenceFeature(sf));
}
// If we got here, its not a GFFFile
GFFFile = false;
}
}
} catch (Exception ex)
{
System.out.println(line);
System.out.println("Error parsing feature file: " + ex + "\n" + line);
ex.printStackTrace(System.err);
return false;
}
return true;
}
public void parseDescriptionHTML(SequenceFeature sf, boolean removeHTML)
{
if (sf.getDescription() == null)
{
return;
}
if (removeHTML
&& sf.getDescription().toUpperCase().indexOf("") == -1)
{
removeHTML = false;
}
StringBuffer sb = new StringBuffer();
StringTokenizer st = new StringTokenizer(sf.getDescription(), "<");
String token, link;
int startTag;
String tag = null;
while (st.hasMoreElements())
{
token = st.nextToken("&>");
if (token.equalsIgnoreCase("html") || token.startsWith("/"))
{
continue;
}
tag = null;
startTag = token.indexOf("<");
if (startTag > -1)
{
tag = token.substring(startTag + 1);
token = token.substring(0, startTag);
}
if (tag != null && tag.toUpperCase().startsWith("A HREF="))
{
if (token.length() > 0)
{
sb.append(token);
}
link = tag.substring(tag.indexOf("\"") + 1, tag.length() - 1);
String label = st.nextToken("<>");
sf.addLink(label + "|" + link);
sb.append(label + "%LINK%");
}
else if (tag != null && tag.equalsIgnoreCase("br"))
{
sb.append("\n");
}
else if (token.startsWith("lt;"))
{
sb.append("<" + token.substring(3));
}
else if (token.startsWith("gt;"))
{
sb.append(">" + token.substring(3));
}
else if (token.startsWith("amp;"))
{
sb.append("&" + token.substring(4));
}
else
{
sb.append(token);
}
}
if (removeHTML)
{
sf.description = sb.toString();
}
}
/**
* generate a features file for seqs includes non-pos features by default.
*
* @param seqs
* source of sequence features
* @param visible
* hash of feature types and colours
* @return features file contents
*/
public String printJalviewFormat(SequenceI[] seqs, Hashtable visible)
{
return printJalviewFormat(seqs, visible, true, true);
}
/**
* generate a features file for seqs with colours from visible (if any)
*
* @param seqs
* source of features
* @param visible
* hash of Colours for each feature type
* @param visOnly
* when true only feature types in 'visible' will be output
* @param nonpos
* indicates if non-positional features should be output (regardless
* of group or type)
* @return features file contents
*/
public String printJalviewFormat(SequenceI[] seqs, Hashtable visible,
boolean visOnly, boolean nonpos)
{
StringBuffer out = new StringBuffer();
SequenceFeature[] next;
boolean featuresGen = false;
if (visOnly && !nonpos && (visible == null || visible.size() < 1))
{
// no point continuing.
return "No Features Visible";
}
if (visible != null && visOnly)
{
// write feature colours only if we're given them and we are generating
// viewed features
// TODO: decide if feature links should also be written here ?
Enumeration en = visible.keys();
String type, color;
while (en.hasMoreElements())
{
type = en.nextElement().toString();
if (visible.get(type) instanceof GraduatedColor)
{
GraduatedColor gc = (GraduatedColor) visible.get(type);
// TODO: NOW: colour by label, autoscale flags.
color = Format.getHexString(gc.getMinColor()) + "|"
+ Format.getHexString(gc.getMaxColor())
+ (gc.isAutoScale() ? "|" : "|abso|") + gc.getMin() + "|"
+ gc.getMax() + "|";
if (gc.getThreshType() != AnnotationColourGradient.NO_THRESHOLD)
{
if (gc.getThreshType() == AnnotationColourGradient.BELOW_THRESHOLD)
{
color += "below";
}
else
{
if (gc.getThreshType() != AnnotationColourGradient.ABOVE_THRESHOLD)
{
System.err.println("WARNING: Unsupported threshold type ("
+ gc.getThreshType() + ") : Assuming 'above'");
}
color += "above";
}
// add the value
color += "|" + gc.getThresh();
}
else
{
color += "none";
}
}
else if (visible.get(type) instanceof java.awt.Color)
{
color = Format.getHexString((java.awt.Color) visible.get(type));
}
else
{
// legacy support for integer objects containing colour triplet values
color = Format.getHexString(new java.awt.Color(Integer
.parseInt(visible.get(type).toString())));
}
out.append(type + "\t" + color + "\n");
}
}
// Work out which groups are both present and visible
Vector groups = new Vector();
int groupIndex = 0;
boolean isnonpos = false;
for (int i = 0; i < seqs.length; i++)
{
next = seqs[i].getSequenceFeatures();
if (next != null)
{
for (int j = 0; j < next.length; j++)
{
isnonpos = next[j].begin == 0 && next[j].end == 0;
if ((!nonpos && isnonpos)
|| (!isnonpos && visOnly && !visible
.containsKey(next[j].type)))
{
continue;
}
if (next[j].featureGroup != null
&& !groups.contains(next[j].featureGroup))
{
groups.addElement(next[j].featureGroup);
}
}
}
}
String group = null;
do
{
if (groups.size() > 0 && groupIndex < groups.size())
{
group = groups.elementAt(groupIndex).toString();
out.append("\nSTARTGROUP\t" + group + "\n");
}
else
{
group = null;
}
for (int i = 0; i < seqs.length; i++)
{
next = seqs[i].getSequenceFeatures();
if (next != null)
{
for (int j = 0; j < next.length; j++)
{
isnonpos = next[j].begin == 0 && next[j].end == 0;
if ((!nonpos && isnonpos)
|| (!isnonpos && visOnly && !visible
.containsKey(next[j].type)))
{
// skip if feature is nonpos and we ignore them or if we only
// output visible and it isn't non-pos and it's not visible
continue;
}
if (group != null
&& (next[j].featureGroup == null || !next[j].featureGroup
.equals(group)))
{
continue;
}
if (group == null && next[j].featureGroup != null)
{
continue;
}
// we have features to output
featuresGen = true;
if (next[j].description == null
|| next[j].description.equals(""))
{
out.append(next[j].type + "\t");
}
else
{
if (next[j].links != null
&& next[j].getDescription().indexOf("") == -1)
{
out.append("");
}
out.append(next[j].description + " ");
if (next[j].links != null)
{
for (int l = 0; l < next[j].links.size(); l++)
{
String label = next[j].links.elementAt(l).toString();
String href = label.substring(label.indexOf("|") + 1);
label = label.substring(0, label.indexOf("|"));
if (next[j].description.indexOf(href) == -1)
{
out
.append("" + label
+ "");
}
}
if (next[j].getDescription().indexOf("") == -1)
{
out.append("");
}
}
out.append("\t");
}
out.append(seqs[i].getName()
+ "\t-1\t"
+ next[j].begin
+ "\t"
+ next[j].end
+ "\t"
+ next[j].type
+ ((next[j].score != Float.NaN) ? "\t" + next[j].score
+ "\n" : "\n"));
}
}
}
if (group != null)
{
out.append("ENDGROUP\t" + group + "\n");
groupIndex++;
}
else
{
break;
}
} while (groupIndex < groups.size() + 1);
if (!featuresGen)
{
return "No Features Visible";
}
return out.toString();
}
/**
* generate a gff file for sequence features includes non-pos features by
* default.
*
* @param seqs
* @param visible
* @return
*/
public String printGFFFormat(SequenceI[] seqs, Hashtable visible)
{
return printGFFFormat(seqs, visible, true, true);
}
public String printGFFFormat(SequenceI[] seqs, Hashtable visible,
boolean visOnly, boolean nonpos)
{
StringBuffer out = new StringBuffer();
SequenceFeature[] next;
String source;
boolean isnonpos;
for (int i = 0; i < seqs.length; i++)
{
if (seqs[i].getSequenceFeatures() != null)
{
next = seqs[i].getSequenceFeatures();
for (int j = 0; j < next.length; j++)
{
isnonpos = next[j].begin == 0 && next[j].end == 0;
if ((!nonpos && isnonpos)
|| (!isnonpos && visOnly && !visible
.containsKey(next[j].type)))
{
continue;
}
source = next[j].featureGroup;
if (source == null)
{
source = next[j].getDescription();
}
out.append(seqs[i].getName() + "\t" + source + "\t"
+ next[j].type + "\t" + next[j].begin + "\t"
+ next[j].end + "\t" + next[j].score + "\t");
if (next[j].getValue("STRAND") != null)
{
out.append(next[j].getValue("STRAND") + "\t");
}
else
{
out.append(".\t");
}
if (next[j].getValue("FRAME") != null)
{
out.append(next[j].getValue("FRAME"));
}
else
{
out.append(".");
}
if (next[j].getValue("ATTRIBUTES") != null)
{
out.append(next[j].getValue("ATTRIBUTES"));
}
out.append("\n");
}
}
}
return out.toString();
}
/**
* this is only for the benefit of object polymorphism - method does nothing.
*/
public void parse()
{
// IGNORED
}
/**
* this is only for the benefit of object polymorphism - method does nothing.
*
* @return error message
*/
public String print()
{
return "USE printGFFFormat() or printJalviewFormat()";
}
}