*/\r
package jalview.io;\r
\r
+import jalview.datamodel.AlignmentI;\r
import jalview.datamodel.AlignmentAnnotation;\r
import jalview.datamodel.Annotation;\r
+import jalview.datamodel.DBRefEntry;\r
+import jalview.datamodel.Mapping;\r
import jalview.datamodel.Sequence;\r
import jalview.datamodel.SequenceFeature;\r
import jalview.datamodel.SequenceI;\r
+import jalview.util.Format;\r
\r
import java.io.BufferedReader;\r
import java.io.FileReader;\r
import java.util.ArrayList;\r
import java.util.Enumeration;\r
import java.util.Hashtable;\r
+import java.util.List;\r
import java.util.StringTokenizer;\r
import java.util.Vector;\r
\r
{\r
// static Logger logger = Logger.getLogger("jalview.io.StockholmFile");\r
protected ArrayList<RNA> result;\r
+ \r
+ StringBuffer out; // output buffer\r
\r
- public String id;\r
+ AlignmentI al;\r
\r
public StockholmFile()\r
{\r
}\r
\r
+ /**
+ * Creates a new StockholmFile object for output.
+ */
+ public StockholmFile(AlignmentI al)
+ {
+ this.al = al;
+ }
+
public StockholmFile(String inFile, String type) throws IOException\r
{\r
super(inFile, type);\r
// --------------- Variable Definitions -------------------\r
String line;\r
String version;\r
- String id;\r
+ // String id;
Hashtable seqAnn = new Hashtable(); // Sequence related annotations\r
Hashtable seqs = new Hashtable();\r
Regex p, r, rend, s, x;\r
if (rend.search(line))\r
{\r
// End of the alignment, pass stuff back\r
+ this.noSeqs = seqs.size();
\r
- this.noSeqs = seqs.size();\r
+ String seqdb,dbsource = null;
+ Regex pf = new Regex("PF[0-9]{5}(.*)"); // Finds AC for Pfam
+ Regex rf = new Regex("RF[0-9]{5}(.*)"); // Finds AC for Rfam
+ if (getAlignmentProperty("AC") != null)
+ {
+ String dbType = getAlignmentProperty("AC").toString();
+ if (pf.search(dbType))
+ {
+ // PFAM Alignment - so references are typically from Uniprot
+ dbsource = "PFAM";
+ }
+ else if (rf.search(dbType))
+ {
+ dbsource = "RFAM";
+ }
+ }
// logger.debug("Number of sequences: " + this.noSeqs);\r
Enumeration accs = seqs.keys();\r
while (accs.hasMoreElements())\r
int end = -1;\r
String sid = acc;\r
/*\r
- * Retrieve hash of annotations for this accession\r
- * Associate Annotation with accession\r
+ * Retrieve hash of annotations for this accession Associate
+ * Annotation with accession
*/\r
Hashtable accAnnotations = null;\r
\r
String src = dbr.substring(0, dbr.indexOf(";"));\r
String acn = dbr.substring(dbr.indexOf(";") + 1);\r
jalview.util.DBRefUtils.parseToDbRef(seqO, src, "0", acn);\r
- // seqO.addDBRef(dbref);\r
}\r
} \r
- if (accAnnotations != null && accAnnotations.containsKey("SS"))\r
+
+ if (accAnnotations != null && accAnnotations.containsKey("AC"))
+ {
+ if (dbsource != null)
+ {
+ String dbr = (String) accAnnotations.get("AC");
+ if (dbr != null)
{\r
- Vector v = (Vector) accAnnotations.get("SS");\r
+ // we could get very clever here - but for now - just try to guess accession type from source of alignment plus structure of accession
+ guessDatabaseFor(seqO, dbr, dbsource);
\r
- for (int i = 0; i < v.size(); i++)\r
- {\r
- AlignmentAnnotation an = (AlignmentAnnotation) v.elementAt(i);\r
- seqO.addAlignmentAnnotation(an);\r
- //annotations.add(an);\r
}\r
}\r
+ // else - do what ? add the data anyway and prompt the user to specify what references these are ?
+ }
\r
Hashtable features = null;\r
// We need to adjust the positions of all features to account for gaps\r
// TODO: map coding region to core jalview feature types\r
String type = i.nextElement().toString();\r
Hashtable content = (Hashtable) features.remove(type);\r
+
+ // add alignment annotation for this feature
+ String key = type2id(type);
+ if (key != null)
+ {
+ if (accAnnotations != null
+ && accAnnotations.containsKey(key))
+ {
+ Vector vv = (Vector) accAnnotations.get(key);
+ for (int ii = 0; ii < vv.size(); ii++)
+ {
+ AlignmentAnnotation an = (AlignmentAnnotation) vv
+ .elementAt(ii);
+ seqO.addAlignmentAnnotation(an);
+ }
+ }
+ }
+
Enumeration j = content.keys();\r
while (j.hasMoreElements())\r
{\r
ann = new Hashtable();\r
seqAnn.put(acc, ann);\r
}\r
- //TODO test structure, call parseAnnotationRow with vector from hashtable for specific sequence\r
+ // TODO test structure, call parseAnnotationRow with vector from
+ // hashtable for specific sequence
Hashtable features;\r
// Get an object with all the content for an annotation\r
if (ann.containsKey("features"))\r
ns += seq;\r
content.put(description, ns);\r
- if(type.equals("SS")){\r
+// if(type.equals("SS")){\r
Hashtable strucAnn;\r
if (seqAnn.containsKey(acc))\r
{\r
strucAnn.put(type, newStruc);\r
seqAnn.put(acc, strucAnn);\r
}\r
- }\r
+// }\r
else\r
{\r
System.err\r
}\r
}\r
\r
+/**\r
+ * Demangle an accession string and guess the originating sequence database for a given sequence\r
+ * @param seqO sequence to be annotated\r
+ * @param dbr Accession string for sequence\r
+ * @param dbsource source database for alignment (PFAM or RFAM)\r
+ */\r
+ private void guessDatabaseFor(Sequence seqO, String dbr, String dbsource)\r
+ {\r
+ DBRefEntry dbrf=null;\r
+ List<DBRefEntry> dbrs=new ArrayList<DBRefEntry>();\r
+ String seqdb="Unknown",sdbac=""+dbr;\r
+ int st=-1,en=-1,p;\r
+ if ((st=sdbac.indexOf("/"))>-1)\r
+ {\r
+ String num,range=sdbac.substring(st+1);\r
+ sdbac = sdbac.substring(0,st);\r
+ if ((p=range.indexOf("-"))>-1)\r
+ {\r
+ p++;\r
+ if (p<range.length())\r
+ {\r
+ num = range.substring(p).trim();\r
+ try {\r
+ en = Integer.parseInt(num);\r
+ } catch (NumberFormatException x)\r
+ {\r
+ // could warn here that index is invalid\r
+ en = -1;\r
+ }\r
+ }\r
+ } else {\r
+ p=range.length();\r
+ }\r
+ num=range.substring(0,p).trim();\r
+ try {\r
+ st = Integer.parseInt(num);\r
+ } catch (NumberFormatException x)\r
+ {\r
+ // could warn here that index is invalid\r
+ st = -1;\r
+ }\r
+ }\r
+ if (dbsource.equals("PFAM")) {\r
+ seqdb = "UNIPROT";\r
+ if (sdbac.indexOf(".")>-1)\r
+ {\r
+ // strip of last subdomain\r
+ sdbac = sdbac.substring(0,sdbac.indexOf("."));\r
+ dbrf = jalview.util.DBRefUtils.parseToDbRef(seqO, seqdb, dbsource, sdbac);\r
+ if (dbrf!=null)\r
+ {\r
+ dbrs.add(dbrf);\r
+ }\r
+ }\r
+ dbrf = jalview.util.DBRefUtils.parseToDbRef(seqO, dbsource, dbsource, dbr);\r
+ if (dbr!=null)\r
+ {\r
+ dbrs.add(dbrf);\r
+ }\r
+ } else {\r
+ seqdb = "EMBL"; // total guess - could be ENA, or something else these days\r
+ if (sdbac.indexOf(".")>-1)\r
+ {\r
+ // strip off last subdomain\r
+ sdbac = sdbac.substring(0,sdbac.indexOf("."));\r
+ dbrf = jalview.util.DBRefUtils.parseToDbRef(seqO, seqdb, dbsource, sdbac);\r
+ if (dbrf!=null)\r
+ {\r
+ dbrs.add(dbrf);\r
+ }\r
+ }\r
+ \r
+ dbrf = jalview.util.DBRefUtils.parseToDbRef(seqO, dbsource, dbsource, dbr);\r
+ if (dbrf!=null)\r
+ {\r
+ dbrs.add(dbrf);\r
+ }\r
+ }\r
+ if (st!=-1 && en!=-1)\r
+ {\r
+ for (DBRefEntry d:dbrs)\r
+ {\r
+ jalview.util.MapList mp = new jalview.util.MapList(new int[] { seqO.getStart(),seqO.getEnd()},new int[] { st,en},1,1);\r
+ jalview.datamodel.Mapping mping = new Mapping(mp);\r
+ d.setMap(mping);\r
+ }\r
+ }\r
+ }\r
+\r
\r
/**\r
* Parse a file in Stockholm format into Jalview's data model using VARNA\r
// DEBUG System.out.println("this is the secondary scructure:"\r
// +result.size());\r
SequenceI[] seqs = new SequenceI[result.size()];\r
+ String id=null;\r
for (int i = 0; i < result.size(); i++)\r
{\r
// DEBUG System.err.println("Processing i'th sequence in Stockholm file")\r
convert2 = closeparen.replaceAll(convert1);\r
annots = convert2;\r
\r
- String type = (label.indexOf("_cons") == label.length() - 5) ? label\r
- .substring(0, label.length() - 5) : label;\r
+ String type = label;\r
+ if (label.contains("_cons"))\r
+ {\r
+ type = (label.indexOf("_cons") == label.length() - 5) ? label\r
+ .substring(0, label.length() - 5) : label;\r
+ }\r
boolean ss = false;\r
type = id2type(type);\r
if (type.equals("secondary structure"))\r
return annot;\r
}\r
\r
- public static String print(SequenceI[] s)\r
+ public String print(SequenceI[] s)
+ {
+ // find max length of id
+ int max = 0;
+ int maxid = 0;
+ int in = 0;
+ Hashtable dataRef = null;
+ while ((in < s.length) && (s[in] != null))
+ {
+ String tmp = printId(s[in]);
+ if (s[in].getSequence().length > max)
+ {
+ max = s[in].getSequence().length;
+ }
+
+ if (tmp.length() > maxid)
+ {
+ maxid = tmp.length();
+ }
+ if (s[in].getDBRef() != null)
+ {
+ for (int idb = 0; idb < s[in].getDBRef().length; idb++)
+ {
+ if (dataRef == null)
+ dataRef = new Hashtable();
+
+ String datAs1 = s[in].getDBRef()[idb].getSource().toString()
+ + " ; "
+ + s[in].getDBRef()[idb].getAccessionId().toString();
+ dataRef.put(tmp, datAs1);
+ }
+ }
+ in++;
+ }
+ maxid += 9;
+ int i = 0;
+
+ // output database type
+ if (al.getProperties() != null)
+ {
+ if (!al.getProperties().isEmpty())
+ {
+ Enumeration key = al.getProperties().keys();
+ Enumeration val = al.getProperties().elements();
+ while (key.hasMoreElements())
+ {
+ out.append("#=GF " + key.nextElement() + " " + val.nextElement());
+ out.append(newline);
+ }
+ }
+ }
+
+ // output database accessions
+ if (dataRef != null)
+ {
+ Enumeration en = dataRef.keys();
+ while (en.hasMoreElements())
+ {
+ Object idd = en.nextElement();
+ String type = (String) dataRef.remove(idd);
+ out.append(new Format("%-" + (maxid - 2) + "s").form("#=GS "
+ + idd.toString() + " "));
+ if (type.contains("PFAM") || type.contains("RFAM"))
+ {
+
+ out.append(" AC " + type.substring(type.indexOf(";") + 1));
+ }
+ else
+ {
+ out.append(" DR " + type + " ");
+ }
+ out.append(newline);
+ }
+ }
+
+ // output annotations
+ while (i < s.length && s[i] != null)
+ {
+ if (s[i].getDatasetSequence() != null)
+ {
+ SequenceI ds = s[i].getDatasetSequence();
+ AlignmentAnnotation[] alAnot;
+ Annotation[] ann;
+ Annotation annot;
+ alAnot = s[i].getAnnotation();
+ String feature = "";
+ if (alAnot != null)
+ {
+ for (int j = 0; j < alAnot.length; j++)
+ {
+ if (ds.getSequenceFeatures() != null)
+ {
+ feature = ds.getSequenceFeatures()[0].type;
+ }
+ String key = type2id(feature);
+
+ if (key == null)
+ continue;
+
+ // out.append("#=GR ");
+ out.append(new Format("%-" + maxid + "s").form("#=GR "
+ + printId(s[i]) + " " + key + " "));
+ ann = alAnot[j].annotations;
+ String seq = "";
+ for (int k = 0; k < ann.length; k++)
+ {
+ annot = ann[k];
+ String ch = (annot == null) ? Character.toString(s[i]
+ .getCharAt(k)) : annot.displayCharacter;
+ if (ch.length() == 0)
+ {
+ if (key.equals("SS"))
+ {
+ char ll = annot.secondaryStructure;
+ seq = (Character.toString(ll).equals(" ")) ? seq + "C"
+ : seq + ll;
+ }
+ else
+ {
+ seq += ".";
+ }
+ }
+ else if (ch.length() == 1)
+ {
+ seq += ch;
+ }
+ else if (ch.length() > 1)
+ {
+ seq += ch.charAt(1);
+ }
+ }
+ out.append(seq);
+ out.append(newline);
+ }
+ }
+ }
+
+ out.append(new Format("%-" + maxid + "s").form(printId(s[i]) + " "));
+ out.append(s[i].getSequenceAsString());
+ out.append(newline);
+ i++;
+ }
+
+ // alignment annotation
+ AlignmentAnnotation aa;
+ if (al.getAlignmentAnnotation() != null)
+ {
+ for (int ia = 0; ia < al.getAlignmentAnnotation().length; ia++)
+ {
+ aa = al.getAlignmentAnnotation()[ia];
+ if (aa.autoCalculated || !aa.visible)
+ {
+ continue;
+ }
+ String seq = "";
+ String label;
+
+ if (aa.label.equals("seq"))
+ label = "seq_cons";
+ else
+ label = type2id(aa.label.toLowerCase()) + "_cons";
+
+ if (label == null)
+ label = aa.label;
+
+ out.append(new Format("%-" + maxid + "s").form("#=GC " + label
+ + " "));
+ for (int j = 0; j < aa.annotations.length; j++)
+ {
+ String ch = (aa.annotations[j] == null) ? "-"
+ : aa.annotations[j].displayCharacter;
+ if (ch.length() == 0)
+ {
+ char ll = aa.annotations[j].secondaryStructure;
+ if (Character.toString(ll).equals(" "))
+ seq += "C";
+ else
+ seq += ll;
+ }
+ else if (ch.length() == 1)
+ {
+ seq += ch;
+ }
+ else if (ch.length() > 1)
{\r
- return "not yet implemented";\r
+ seq += ch.charAt(1);
+ }
+ }
+ out.append(seq);
+ out.append(newline);
+ }
+ }
+ return out.toString();
}\r
\r
public String print()\r
{\r
- return print(getSeqsAsArray());\r
+ out = new StringBuffer();
+ out.append("# STOCKHOLM 1.0");
+ out.append(newline);
+ print(getSeqsAsArray());
+
+ out.append("//");
+ out.append(newline);
+ return out.toString();
}\r
\r
private static Hashtable typeIds = null;\r
+ id);\r
return id;\r
}\r
+
+ protected static String type2id(String type)
+ {
+ String key = null;
+ Enumeration e = typeIds.keys();
+ while (e.hasMoreElements())
+ {
+ Object ll = e.nextElement();
+ if (typeIds.get(ll).toString().equals(type))
+ {
+ key = (String) ll;
+ break;
+ }
+ }
+ if (key != null)
+ {
+ return (String) key;
+ }
+ System.err.println("Warning : Unknown Stockholm annotation type: "
+ + type);
+ return key;
+ }
/**\r
* make a friendly ID string.\r
* \r
git://source.jalview.org / jalview.git / blobdiff