formatting
[jalview.git] / src / jalview / analysis / Dna.java
1 /*\r
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)\r
3  * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle\r
4  * \r
5  * This file is part of Jalview.\r
6  * \r
7  * Jalview is free software: you can redistribute it and/or\r
8  * modify it under the terms of the GNU General Public License \r
9  * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.\r
10  * \r
11  * Jalview is distributed in the hope that it will be useful, but \r
12  * WITHOUT ANY WARRANTY; without even the implied warranty \r
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR \r
14  * PURPOSE.  See the GNU General Public License for more details.\r
15  * \r
16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.\r
17  */\r
18 package jalview.analysis;\r
19 \r
20 import java.util.Enumeration;\r
21 import java.util.Hashtable;\r
22 import java.util.Vector;\r
23 \r
24 import jalview.datamodel.AlignedCodonFrame;\r
25 import jalview.datamodel.Alignment;\r
26 import jalview.datamodel.AlignmentAnnotation;\r
27 import jalview.datamodel.AlignmentI;\r
28 import jalview.datamodel.Annotation;\r
29 import jalview.datamodel.ColumnSelection;\r
30 import jalview.datamodel.DBRefEntry;\r
31 import jalview.datamodel.FeatureProperties;\r
32 import jalview.datamodel.Mapping;\r
33 import jalview.datamodel.Sequence;\r
34 import jalview.datamodel.SequenceFeature;\r
35 import jalview.datamodel.SequenceI;\r
36 import jalview.schemes.ResidueProperties;\r
37 import jalview.util.MapList;\r
38 import jalview.util.ShiftList;\r
39 \r
40 public class Dna\r
41 {\r
42   /**\r
43    * \r
44    * @param cdp1\r
45    * @param cdp2\r
46    * @return -1 if cdp1 aligns before cdp2, 0 if in the same column or cdp2 is\r
47    *         null, +1 if after cdp2\r
48    */\r
49   private static int compare_codonpos(int[] cdp1, int[] cdp2)\r
50   {\r
51     if (cdp2 == null\r
52             || (cdp1[0] == cdp2[0] && cdp1[1] == cdp2[1] && cdp1[2] == cdp2[2]))\r
53       return 0;\r
54     if (cdp1[0] < cdp2[0] || cdp1[1] < cdp2[1] || cdp1[2] < cdp2[2])\r
55       return -1; // one base in cdp1 precedes the corresponding base in the\r
56     // other codon\r
57     return 1; // one base in cdp1 appears after the corresponding base in the\r
58     // other codon.\r
59   }\r
60 \r
61   /**\r
62    * DNA->mapped protein sequence alignment translation given set of sequences\r
63    * 1. id distinct coding regions within selected region for each sequence 2.\r
64    * generate peptides based on inframe (or given) translation or (optionally\r
65    * and where specified) out of frame translations (annotated appropriately) 3.\r
66    * align peptides based on codon alignment\r
67    */\r
68   /**\r
69    * id potential products from dna 1. search for distinct products within\r
70    * selected region for each selected sequence 2. group by associated DB type.\r
71    * 3. return as form for input into above function\r
72    */\r
73   /**\r
74    * \r
75    */\r
76   /**\r
77    * create a new alignment of protein sequences by an inframe translation of\r
78    * the provided NA sequences\r
79    * \r
80    * @param selection\r
81    * @param seqstring\r
82    * @param viscontigs\r
83    * @param gapCharacter\r
84    * @param annotations\r
85    * @param aWidth\r
86    * @param dataset\r
87    *          destination dataset for translated sequences and mappings\r
88    * @return\r
89    */\r
90   public static AlignmentI CdnaTranslate(SequenceI[] selection,\r
91           String[] seqstring, int viscontigs[], char gapCharacter,\r
92           AlignmentAnnotation[] annotations, int aWidth, Alignment dataset)\r
93   {\r
94     return CdnaTranslate(selection, seqstring, null, viscontigs,\r
95             gapCharacter, annotations, aWidth, dataset);\r
96   }\r
97 \r
98   /**\r
99    * \r
100    * @param selection\r
101    * @param seqstring\r
102    * @param product\r
103    *          - array of DbRefEntry objects from which exon map in seqstring is\r
104    *          derived\r
105    * @param viscontigs\r
106    * @param gapCharacter\r
107    * @param annotations\r
108    * @param aWidth\r
109    * @param dataset\r
110    * @return\r
111    */\r
112   public static AlignmentI CdnaTranslate(SequenceI[] selection,\r
113           String[] seqstring, DBRefEntry[] product, int viscontigs[],\r
114           char gapCharacter, AlignmentAnnotation[] annotations, int aWidth,\r
115           Alignment dataset)\r
116   {\r
117     AlignedCodonFrame codons = new AlignedCodonFrame(aWidth); // stores hash of\r
118     // subsequent\r
119     // positions for\r
120     // each codon\r
121     // start position\r
122     // in alignment\r
123     int s, sSize = selection.length;\r
124     Vector pepseqs = new Vector();\r
125     for (s = 0; s < sSize; s++)\r
126     {\r
127       SequenceI newseq = translateCodingRegion(selection[s], seqstring[s],\r
128               viscontigs, codons, gapCharacter,\r
129               (product != null) ? product[s] : null); // possibly anonymous\r
130       // product\r
131       if (newseq != null)\r
132       {\r
133         pepseqs.addElement(newseq);\r
134         SequenceI ds = newseq;\r
135         while (ds.getDatasetSequence() != null)\r
136         {\r
137           ds = ds.getDatasetSequence();\r
138         }\r
139         dataset.addSequence(ds);\r
140       }\r
141     }\r
142     if (codons.aaWidth == 0)\r
143       return null;\r
144     SequenceI[] newseqs = new SequenceI[pepseqs.size()];\r
145     pepseqs.copyInto(newseqs);\r
146     AlignmentI al = new Alignment(newseqs);\r
147     al.padGaps(); // ensure we look aligned.\r
148     al.setDataset(dataset);\r
149     translateAlignedAnnotations(annotations, al, codons);\r
150     al.addCodonFrame(codons);\r
151     return al;\r
152   }\r
153 \r
154   /**\r
155    * fake the collection of DbRefs with associated exon mappings to identify if\r
156    * a translation would generate distinct product in the currently selected\r
157    * region.\r
158    * \r
159    * @param selection\r
160    * @param viscontigs\r
161    * @return\r
162    */\r
163   public static boolean canTranslate(SequenceI[] selection,\r
164           int viscontigs[])\r
165   {\r
166     for (int gd = 0; gd < selection.length; gd++)\r
167     {\r
168       SequenceI dna = selection[gd];\r
169       jalview.datamodel.DBRefEntry[] dnarefs = jalview.util.DBRefUtils\r
170               .selectRefs(dna.getDBRef(),\r
171                       jalview.datamodel.DBRefSource.DNACODINGDBS);\r
172       if (dnarefs != null)\r
173       {\r
174         // intersect with pep\r
175         // intersect with pep\r
176         Vector mappedrefs = new Vector();\r
177         DBRefEntry[] refs = dna.getDBRef();\r
178         for (int d = 0; d < refs.length; d++)\r
179         {\r
180           if (refs[d].getMap() != null && refs[d].getMap().getMap() != null\r
181                   && refs[d].getMap().getMap().getFromRatio() == 3\r
182                   && refs[d].getMap().getMap().getToRatio() == 1)\r
183           {\r
184             mappedrefs.addElement(refs[d]); // add translated protein maps\r
185           }\r
186         }\r
187         dnarefs = new DBRefEntry[mappedrefs.size()];\r
188         mappedrefs.copyInto(dnarefs);\r
189         for (int d = 0; d < dnarefs.length; d++)\r
190         {\r
191           Mapping mp = dnarefs[d].getMap();\r
192           if (mp != null)\r
193           {\r
194             for (int vc = 0; vc < viscontigs.length; vc += 2)\r
195             {\r
196               int[] mpr = mp.locateMappedRange(viscontigs[vc],\r
197                       viscontigs[vc + 1]);\r
198               if (mpr != null)\r
199               {\r
200                 return true;\r
201               }\r
202             }\r
203           }\r
204         }\r
205       }\r
206     }\r
207     return false;\r
208   }\r
209 \r
210   /**\r
211    * generate a set of translated protein products from annotated sequenceI\r
212    * \r
213    * @param selection\r
214    * @param viscontigs\r
215    * @param gapCharacter\r
216    * @param dataset\r
217    *          destination dataset for translated sequences\r
218    * @param annotations\r
219    * @param aWidth\r
220    * @return\r
221    */\r
222   public static AlignmentI CdnaTranslate(SequenceI[] selection,\r
223           int viscontigs[], char gapCharacter, Alignment dataset)\r
224   {\r
225     int alwidth = 0;\r
226     Vector cdnasqs = new Vector();\r
227     Vector cdnasqi = new Vector();\r
228     Vector cdnaprod = new Vector();\r
229     for (int gd = 0; gd < selection.length; gd++)\r
230     {\r
231       SequenceI dna = selection[gd];\r
232       jalview.datamodel.DBRefEntry[] dnarefs = jalview.util.DBRefUtils\r
233               .selectRefs(dna.getDBRef(),\r
234                       jalview.datamodel.DBRefSource.DNACODINGDBS);\r
235       if (dnarefs != null)\r
236       {\r
237         // intersect with pep\r
238         Vector mappedrefs = new Vector();\r
239         DBRefEntry[] refs = dna.getDBRef();\r
240         for (int d = 0; d < refs.length; d++)\r
241         {\r
242           if (refs[d].getMap() != null && refs[d].getMap().getMap() != null\r
243                   && refs[d].getMap().getMap().getFromRatio() == 3\r
244                   && refs[d].getMap().getMap().getToRatio() == 1)\r
245           {\r
246             mappedrefs.addElement(refs[d]); // add translated protein maps\r
247           }\r
248         }\r
249         dnarefs = new DBRefEntry[mappedrefs.size()];\r
250         mappedrefs.copyInto(dnarefs);\r
251         for (int d = 0; d < dnarefs.length; d++)\r
252         {\r
253           Mapping mp = dnarefs[d].getMap();\r
254           StringBuffer sqstr = new StringBuffer();\r
255           if (mp != null)\r
256           {\r
257             Mapping intersect = mp.intersectVisContigs(viscontigs);\r
258             // generate seqstring for this sequence based on mapping\r
259 \r
260             if (sqstr.length() > alwidth)\r
261               alwidth = sqstr.length();\r
262             cdnasqs.addElement(sqstr.toString());\r
263             cdnasqi.addElement(dna);\r
264             cdnaprod.addElement(intersect);\r
265           }\r
266         }\r
267       }\r
268       SequenceI[] cdna = new SequenceI[cdnasqs.size()];\r
269       DBRefEntry[] prods = new DBRefEntry[cdnaprod.size()];\r
270       String[] xons = new String[cdnasqs.size()];\r
271       cdnasqs.copyInto(xons);\r
272       cdnaprod.copyInto(prods);\r
273       cdnasqi.copyInto(cdna);\r
274       return CdnaTranslate(cdna, xons, prods, viscontigs, gapCharacter,\r
275               null, alwidth, dataset);\r
276     }\r
277     return null;\r
278   }\r
279 \r
280   /**\r
281    * translate na alignment annotations onto translated amino acid alignment al\r
282    * using codon mapping codons\r
283    * \r
284    * @param annotations\r
285    * @param al\r
286    * @param codons\r
287    */\r
288   public static void translateAlignedAnnotations(\r
289           AlignmentAnnotation[] annotations, AlignmentI al,\r
290           AlignedCodonFrame codons)\r
291   {\r
292     // //////////////////////////////\r
293     // Copy annotations across\r
294     //\r
295     // Can only do this for columns with consecutive codons, or where\r
296     // annotation is sequence associated.\r
297 \r
298     int pos, a, aSize;\r
299     if (annotations != null)\r
300     {\r
301       for (int i = 0; i < annotations.length; i++)\r
302       {\r
303         // Skip any autogenerated annotation\r
304         if (annotations[i].autoCalculated)\r
305         {\r
306           continue;\r
307         }\r
308 \r
309         aSize = codons.getaaWidth(); // aa alignment width.\r
310         jalview.datamodel.Annotation[] anots = (annotations[i].annotations == null) ? null\r
311                 : new jalview.datamodel.Annotation[aSize];\r
312         if (anots != null)\r
313         {\r
314           for (a = 0; a < aSize; a++)\r
315           {\r
316             // process through codon map.\r
317             if (codons.codons[a] != null\r
318                     && codons.codons[a][0] == (codons.codons[a][2] - 2))\r
319             {\r
320               anots[a] = getCodonAnnotation(codons.codons[a],\r
321                       annotations[i].annotations);\r
322             }\r
323           }\r
324         }\r
325 \r
326         jalview.datamodel.AlignmentAnnotation aa = new jalview.datamodel.AlignmentAnnotation(\r
327                 annotations[i].label, annotations[i].description, anots);\r
328         aa.graph = annotations[i].graph;\r
329         aa.graphGroup = annotations[i].graphGroup;\r
330         aa.graphHeight = annotations[i].graphHeight;\r
331         if (annotations[i].getThreshold() != null)\r
332         {\r
333           aa.setThreshold(new jalview.datamodel.GraphLine(annotations[i]\r
334                   .getThreshold()));\r
335         }\r
336         if (annotations[i].hasScore)\r
337         {\r
338           aa.setScore(annotations[i].getScore());\r
339         }\r
340         if (annotations[i].sequenceRef != null)\r
341         {\r
342           SequenceI aaSeq = codons\r
343                   .getAaForDnaSeq(annotations[i].sequenceRef);\r
344           if (aaSeq != null)\r
345           {\r
346             // aa.compactAnnotationArray(); // throw away alignment annotation\r
347             // positioning\r
348             aa.setSequenceRef(aaSeq);\r
349             aa.createSequenceMapping(aaSeq, aaSeq.getStart(), true); // rebuild\r
350             // mapping\r
351             aa.adjustForAlignment();\r
352             aaSeq.addAlignmentAnnotation(aa);\r
353           }\r
354 \r
355         }\r
356         al.addAnnotation(aa);\r
357       }\r
358     }\r
359   }\r
360 \r
361   private static Annotation getCodonAnnotation(int[] is,\r
362           Annotation[] annotations)\r
363   {\r
364     // Have a look at all the codon positions for annotation and put the first\r
365     // one found into the translated annotation pos.\r
366     int contrib = 0;\r
367     Annotation annot = null;\r
368     for (int p = 0; p < 3; p++)\r
369     {\r
370       if (annotations[is[p]] != null)\r
371       {\r
372         if (annot == null)\r
373         {\r
374           annot = new Annotation(annotations[is[p]]);\r
375           contrib = 1;\r
376         }\r
377         else\r
378         {\r
379           // merge with last\r
380           Annotation cpy = new Annotation(annotations[is[p]]);\r
381           if (annot.colour == null)\r
382           {\r
383             annot.colour = cpy.colour;\r
384           }\r
385           if (annot.description == null || annot.description.length() == 0)\r
386           {\r
387             annot.description = cpy.description;\r
388           }\r
389           if (annot.displayCharacter == null)\r
390           {\r
391             annot.displayCharacter = cpy.displayCharacter;\r
392           }\r
393           if (annot.secondaryStructure == 0)\r
394           {\r
395             annot.secondaryStructure = cpy.secondaryStructure;\r
396           }\r
397           annot.value += cpy.value;\r
398           contrib++;\r
399         }\r
400       }\r
401     }\r
402     if (contrib > 1)\r
403     {\r
404       annot.value /= (float) contrib;\r
405     }\r
406     return annot;\r
407   }\r
408 \r
409   /**\r
410    * Translate a na sequence\r
411    * \r
412    * @param selection\r
413    *          sequence displayed under viscontigs visible columns\r
414    * @param seqstring\r
415    *          ORF read in some global alignment reference frame\r
416    * @param viscontigs\r
417    *          mapping from global reference frame to visible seqstring ORF read\r
418    * @param codons\r
419    *          Definition of global ORF alignment reference frame\r
420    * @param gapCharacter\r
421    * @param newSeq\r
422    * @return sequence ready to be added to alignment.\r
423    */\r
424   public static SequenceI translateCodingRegion(SequenceI selection,\r
425           String seqstring, int[] viscontigs, AlignedCodonFrame codons,\r
426           char gapCharacter, DBRefEntry product)\r
427   {\r
428     Vector skip = new Vector();\r
429     int skipint[] = null;\r
430     ShiftList vismapping = new ShiftList(); // map from viscontigs to seqstring\r
431     // intervals\r
432     int vc, scontigs[] = new int[viscontigs.length];\r
433     int npos = 0;\r
434     for (vc = 0; vc < viscontigs.length; vc += 2)\r
435     {\r
436       if (vc == 0)\r
437       {\r
438         vismapping.addShift(npos, viscontigs[vc]);\r
439       }\r
440       else\r
441       {\r
442         // hidden region\r
443         vismapping.addShift(npos, viscontigs[vc] - viscontigs[vc - 1] + 1);\r
444       }\r
445       scontigs[vc] = viscontigs[vc];\r
446       scontigs[vc + 1] = viscontigs[vc + 1];\r
447     }\r
448 \r
449     StringBuffer protein = new StringBuffer();\r
450     String seq = seqstring.replace('U', 'T');\r
451     char codon[] = new char[3];\r
452     int cdp[] = new int[3], rf = 0, lastnpos = 0, nend;\r
453     int aspos = 0;\r
454     int resSize = 0;\r
455     for (npos = 0, nend = seq.length(); npos < nend; npos++)\r
456     {\r
457       if (!jalview.util.Comparison.isGap(seq.charAt(npos)))\r
458       {\r
459         cdp[rf] = npos; // store position\r
460         codon[rf++] = seq.charAt(npos); // store base\r
461       }\r
462       // filled an RF yet ?\r
463       if (rf == 3)\r
464       {\r
465         String aa = ResidueProperties.codonTranslate(new String(codon));\r
466         rf = 0;\r
467         if (aa == null)\r
468         {\r
469           aa = String.valueOf(gapCharacter);\r
470           if (skipint == null)\r
471           {\r
472             skipint = new int[]\r
473             { cdp[0], cdp[2] };\r
474           }\r
475           skipint[1] = cdp[2];\r
476         }\r
477         else\r
478         {\r
479           if (skipint != null)\r
480           {\r
481             // edit scontigs\r
482             skipint[0] = vismapping.shift(skipint[0]);\r
483             skipint[1] = vismapping.shift(skipint[1]);\r
484             for (vc = 0; vc < scontigs.length; vc += 2)\r
485             {\r
486               if (scontigs[vc + 1] < skipint[0])\r
487               {\r
488                 continue;\r
489               }\r
490               if (scontigs[vc] <= skipint[0])\r
491               {\r
492                 if (skipint[0] == scontigs[vc])\r
493                 {\r
494 \r
495                 }\r
496                 else\r
497                 {\r
498                   int[] t = new int[scontigs.length + 2];\r
499                   System.arraycopy(scontigs, 0, t, 0, vc - 1);\r
500                   // scontigs[vc]; //\r
501                 }\r
502               }\r
503             }\r
504             skip.addElement(skipint);\r
505             skipint = null;\r
506           }\r
507           if (aa.equals("STOP"))\r
508           {\r
509             aa = "X";\r
510           }\r
511           resSize++;\r
512         }\r
513         // insert/delete gaps prior to this codon - if necessary\r
514         boolean findpos = true;\r
515         while (findpos)\r
516         {\r
517           // first ensure that the codons array is long enough.\r
518           codons.checkCodonFrameWidth(aspos);\r
519           // now check to see if we place the aa at the current aspos in the\r
520           // protein alignment\r
521           switch (Dna.compare_codonpos(cdp, codons.codons[aspos]))\r
522           {\r
523           case -1:\r
524             codons.insertAAGap(aspos, gapCharacter);\r
525             findpos = false;\r
526             break;\r
527           case +1:\r
528             // this aa appears after the aligned codons at aspos, so prefix it\r
529             // with a gap\r
530             aa = "" + gapCharacter + aa;\r
531             aspos++;\r
532             // if (aspos >= codons.aaWidth)\r
533             // codons.aaWidth = aspos + 1;\r
534             break; // check the next position for alignment\r
535           case 0:\r
536             // codon aligns at aspos position.\r
537             findpos = false;\r
538           }\r
539         }\r
540         // codon aligns with all other sequence residues found at aspos\r
541         protein.append(aa);\r
542         lastnpos = npos;\r
543         if (codons.codons[aspos] == null)\r
544         {\r
545           // mark this column as aligning to this aligned reading frame\r
546           codons.codons[aspos] = new int[]\r
547           { cdp[0], cdp[1], cdp[2] };\r
548         }\r
549         if (aspos >= codons.aaWidth)\r
550         {\r
551           // update maximum alignment width\r
552           // (we can do this without calling checkCodonFrameWidth because it was\r
553           // already done above)\r
554           codons.setAaWidth(aspos);\r
555         }\r
556         // ready for next translated reading frame alignment position (if any)\r
557         aspos++;\r
558       }\r
559     }\r
560     if (resSize > 0)\r
561     {\r
562       SequenceI newseq = new Sequence(selection.getName(),\r
563               protein.toString());\r
564       if (rf != 0)\r
565       {\r
566         jalview.bin.Cache.log\r
567                 .debug("trimming contigs for incomplete terminal codon.");\r
568         // map and trim contigs to ORF region\r
569         vc = scontigs.length - 1;\r
570         lastnpos = vismapping.shift(lastnpos); // place npos in context of\r
571         // whole dna alignment (rather\r
572         // than visible contigs)\r
573         // incomplete ORF could be broken over one or two visible contig\r
574         // intervals.\r
575         while (vc >= 0 && scontigs[vc] > lastnpos)\r
576         {\r
577           if (vc > 0 && scontigs[vc - 1] > lastnpos)\r
578           {\r
579             vc -= 2;\r
580           }\r
581           else\r
582           {\r
583             // correct last interval in list.\r
584             scontigs[vc] = lastnpos;\r
585           }\r
586         }\r
587 \r
588         if (vc > 0 && (vc + 1) < scontigs.length)\r
589         {\r
590           // truncate map list to just vc elements\r
591           int t[] = new int[vc + 1];\r
592           System.arraycopy(scontigs, 0, t, 0, vc + 1);\r
593           scontigs = t;\r
594         }\r
595         if (vc <= 0)\r
596           scontigs = null;\r
597       }\r
598       if (scontigs != null)\r
599       {\r
600         npos = 0;\r
601         // map scontigs to actual sequence positions on selection\r
602         for (vc = 0; vc < scontigs.length; vc += 2)\r
603         {\r
604           scontigs[vc] = selection.findPosition(scontigs[vc]); // not from 1!\r
605           scontigs[vc + 1] = selection.findPosition(scontigs[vc + 1]); // exclusive\r
606           if (scontigs[vc + 1] == selection.getEnd())\r
607             break;\r
608         }\r
609         // trim trailing empty intervals.\r
610         if ((vc + 2) < scontigs.length)\r
611         {\r
612           int t[] = new int[vc + 2];\r
613           System.arraycopy(scontigs, 0, t, 0, vc + 2);\r
614           scontigs = t;\r
615         }\r
616         /*\r
617          * delete intervals in scontigs which are not translated. 1. map skip\r
618          * into sequence position intervals 2. truncate existing ranges and add\r
619          * new ranges to exclude untranslated regions. if (skip.size()>0) {\r
620          * Vector narange = new Vector(); for (vc=0; vc<scontigs.length; vc++) {\r
621          * narange.addElement(new int[] {scontigs[vc]}); } int sint=0,iv[]; vc =\r
622          * 0; while (sint<skip.size()) { skipint = (int[]) skip.elementAt(sint);\r
623          * do { iv = (int[]) narange.elementAt(vc); if (iv[0]>=skipint[0] &&\r
624          * iv[0]<=skipint[1]) { if (iv[0]==skipint[0]) { // delete beginning of\r
625          * range } else { // truncate range and create new one if necessary iv =\r
626          * (int[]) narange.elementAt(vc+1); if (iv[0]<=skipint[1]) { // truncate\r
627          * range iv[0] = skipint[1]; } else { } } } else if (iv[0]<skipint[0]) {\r
628          * iv = (int[]) narange.elementAt(vc+1); } } while (iv[0]) } }\r
629          */\r
630         MapList map = new MapList(scontigs, new int[]\r
631         { 1, resSize }, 3, 1);\r
632 \r
633         // update newseq as if it was generated as mapping from product\r
634 \r
635         if (product != null)\r
636         {\r
637           newseq.setName(product.getSource() + "|"\r
638                   + product.getAccessionId());\r
639           if (product.getMap() != null)\r
640           {\r
641             // Mapping mp = product.getMap();\r
642             // newseq.setStart(mp.getPosition(scontigs[0]));\r
643             // newseq.setEnd(mp\r
644             // .getPosition(scontigs[scontigs.length - 1]));\r
645           }\r
646         }\r
647         transferCodedFeatures(selection, newseq, map, null, null);\r
648         SequenceI rseq = newseq.deriveSequence(); // construct a dataset\r
649         // sequence for our new\r
650         // peptide, regardless.\r
651         // store a mapping (this actually stores a mapping between the dataset\r
652         // sequences for the two sequences\r
653         codons.addMap(selection, rseq, map);\r
654         return rseq;\r
655       }\r
656     }\r
657     // register the mapping somehow\r
658     //\r
659     return null;\r
660   }\r
661 \r
662   /**\r
663    * Given a peptide newly translated from a dna sequence, copy over and set any\r
664    * features on the peptide from the DNA. If featureTypes is null, all features\r
665    * on the dna sequence are searched (rather than just the displayed ones), and\r
666    * similarly for featureGroups.\r
667    * \r
668    * @param dna\r
669    * @param pep\r
670    * @param map\r
671    * @param featureTypes\r
672    *          hash who's keys are the displayed feature type strings\r
673    * @param featureGroups\r
674    *          hash where keys are feature groups and values are Boolean objects\r
675    *          indicating if they are displayed.\r
676    */\r
677   private static void transferCodedFeatures(SequenceI dna, SequenceI pep,\r
678           MapList map, Hashtable featureTypes, Hashtable featureGroups)\r
679   {\r
680     SequenceFeature[] sf = dna.getDatasetSequence().getSequenceFeatures();\r
681     Boolean fgstate;\r
682     jalview.datamodel.DBRefEntry[] dnarefs = jalview.util.DBRefUtils\r
683             .selectRefs(dna.getDBRef(),\r
684                     jalview.datamodel.DBRefSource.DNACODINGDBS);\r
685     if (dnarefs != null)\r
686     {\r
687       // intersect with pep\r
688       for (int d = 0; d < dnarefs.length; d++)\r
689       {\r
690         Mapping mp = dnarefs[d].getMap();\r
691         if (mp != null)\r
692         {\r
693         }\r
694       }\r
695     }\r
696     if (sf != null)\r
697     {\r
698       for (int f = 0; f < sf.length; f++)\r
699       {\r
700         fgstate = (featureGroups == null) ? null : ((Boolean) featureGroups\r
701                 .get(sf[f].featureGroup));\r
702         if ((featureTypes == null || featureTypes.containsKey(sf[f]\r
703                 .getType())) && (fgstate == null || fgstate.booleanValue()))\r
704         {\r
705           if (FeatureProperties.isCodingFeature(null, sf[f].getType()))\r
706           {\r
707             // if (map.intersectsFrom(sf[f].begin, sf[f].end))\r
708             {\r
709 \r
710             }\r
711           }\r
712         }\r
713       }\r
714     }\r
715   }\r
716 }\r