1d5f996b44279f5339d86474ac3f19bf364be00c
[jalview.git] / Dna.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.analysis;
22
23 import java.util.ArrayList;
24 import java.util.Arrays;
25 import java.util.Comparator;
26 import java.util.List;
27 import java.util.Map;
28
29 import jalview.api.AlignViewportI;
30 import jalview.datamodel.AlignedCodon;
31 import jalview.datamodel.AlignedCodonFrame;
32 import jalview.datamodel.Alignment;
33 import jalview.datamodel.AlignmentAnnotation;
34 import jalview.datamodel.AlignmentI;
35 import jalview.datamodel.Annotation;
36 import jalview.datamodel.DBRefEntry;
37 import jalview.datamodel.DBRefSource;
38 import jalview.datamodel.FeatureProperties;
39 import jalview.datamodel.GraphLine;
40 import jalview.datamodel.Mapping;
41 import jalview.datamodel.Sequence;
42 import jalview.datamodel.SequenceFeature;
43 import jalview.datamodel.SequenceI;
44 import jalview.schemes.ResidueProperties;
45 import jalview.util.Comparison;
46 import jalview.util.DBRefUtils;
47 import jalview.util.MapList;
48 import jalview.util.ShiftList;
49
50 public class Dna
51 {
52   private static final String STOP_X = "X";
53
54   private static final Comparator<AlignedCodon> comparator = new CodonComparator();
55
56   /*
57    * 'final' variables describe the inputs to the translation, which should not
58    * be modified.
59    */
60   final private List<SequenceI> selection;
61
62   final private String[] seqstring;
63
64   final private int[] contigs;
65
66   final private char gapChar;
67
68   final private AlignmentAnnotation[] annotations;
69
70   final private int dnaWidth;
71
72   final private Alignment dataset;
73
74   /*
75    * Working variables for the translation.
76    * 
77    * The width of the translation-in-progress protein alignment.
78    */
79   private int aaWidth = 0;
80
81   /*
82    * This array will be built up so that position i holds the codon positions
83    * e.g. [7, 9, 10] that match column i (base 0) in the aligned translation.
84    * Note this implies a contract that if two codons do not align exactly, their
85    * translated products must occupy different column positions.
86    */
87   private AlignedCodon[] alignedCodons;
88
89   /**
90    * Constructor given a viewport and the visible contigs.
91    * 
92    * @param viewport
93    * @param visibleContigs
94    */
95   public Dna(AlignViewportI viewport, int[] visibleContigs)
96   {
97     this.selection = Arrays.asList(viewport.getSequenceSelection());
98     this.seqstring = viewport.getViewAsString(true);
99     this.contigs = visibleContigs;
100     this.gapChar = viewport.getGapCharacter();
101     this.annotations = viewport.getAlignment().getAlignmentAnnotation();
102     this.dnaWidth = viewport.getAlignment().getWidth();
103     this.dataset = viewport.getAlignment().getDataset();
104   }
105
106   /**
107    * Test whether codon positions cdp1 should align before, with, or after cdp2.
108    * Returns zero if all positions match (or either argument is null). Returns
109    * -1 if any position in the first codon precedes the corresponding position
110    * in the second codon. Else returns +1 (some position in the second codon
111    * precedes the corresponding position in the first).
112    *
113    * Note this is not necessarily symmetric, for example:
114    * <ul>
115    * <li>compareCodonPos([2,5,6], [3,4,5]) returns -1</li>
116    * <li>compareCodonPos([3,4,5], [2,5,6]) also returns -1</li>
117    * </ul>
118    * 
119    * @param ac1
120    * @param ac2
121    * @return
122    */
123   public static final int compareCodonPos(AlignedCodon ac1, AlignedCodon ac2)
124   {
125     return comparator.compare(ac1, ac2);
126     // return jalview_2_8_2compare(ac1, ac2);
127   }
128
129   /**
130    * Codon comparison up to Jalview 2.8.2. This rule is sequence order dependent
131    * - see http://issues.jalview.org/browse/JAL-1635
132    * 
133    * @param ac1
134    * @param ac2
135    * @return
136    */
137   private static int jalview_2_8_2compare(AlignedCodon ac1, AlignedCodon ac2)
138   {
139     if (ac1 == null || ac2 == null || (ac1.equals(ac2)))
140     {
141       return 0;
142     }
143     if (ac1.pos1 < ac2.pos1 || ac1.pos2 < ac2.pos2 || ac1.pos3 < ac2.pos3)
144     {
145       // one base in cdp1 precedes the corresponding base in the other codon
146       return -1;
147     }
148     // one base in cdp1 appears after the corresponding base in the other codon.
149     return 1;
150   }
151
152   /**
153    * 
154    * @return
155    */
156   public AlignmentI translateCdna()
157   {
158     AlignedCodonFrame acf = new AlignedCodonFrame();
159
160     alignedCodons = new AlignedCodon[dnaWidth];
161
162     int s;
163     int sSize = selection.size();
164     List<SequenceI> pepseqs = new ArrayList<SequenceI>();
165     for (s = 0; s < sSize; s++)
166     {
167       SequenceI newseq = translateCodingRegion(selection.get(s),
168               seqstring[s], acf, pepseqs);
169
170       if (newseq != null)
171       {
172         pepseqs.add(newseq);
173         SequenceI ds = newseq;
174         if (dataset != null)
175         {
176           while (ds.getDatasetSequence() != null)
177           {
178             ds = ds.getDatasetSequence();
179           }
180           dataset.addSequence(ds);
181         }
182       }
183     }
184
185     SequenceI[] newseqs = pepseqs.toArray(new SequenceI[pepseqs.size()]);
186     AlignmentI al = new Alignment(newseqs);
187     // ensure we look aligned.
188     al.padGaps();
189     // link the protein translation to the DNA dataset
190     al.setDataset(dataset);
191     translateAlignedAnnotations(al, acf);
192     al.addCodonFrame(acf);
193     return al;
194   }
195
196   /**
197    * fake the collection of DbRefs with associated exon mappings to identify if
198    * a translation would generate distinct product in the currently selected
199    * region.
200    * 
201    * @param selection
202    * @param viscontigs
203    * @return
204    */
205   public static boolean canTranslate(SequenceI[] selection,
206           int viscontigs[])
207   {
208     for (int gd = 0; gd < selection.length; gd++)
209     {
210       SequenceI dna = selection[gd];
211       DBRefEntry[] dnarefs = DBRefUtils
212               .selectRefs(dna.getDBRef(),
213                       jalview.datamodel.DBRefSource.DNACODINGDBS);
214       if (dnarefs != null)
215       {
216         // intersect with pep
217         List<DBRefEntry> mappedrefs = new ArrayList<DBRefEntry>();
218         DBRefEntry[] refs = dna.getDBRef();
219         for (int d = 0; d < refs.length; d++)
220         {
221           if (refs[d].getMap() != null && refs[d].getMap().getMap() != null
222                   && refs[d].getMap().getMap().getFromRatio() == 3
223                   && refs[d].getMap().getMap().getToRatio() == 1)
224           {
225             mappedrefs.add(refs[d]); // add translated protein maps
226           }
227         }
228         dnarefs = mappedrefs.toArray(new DBRefEntry[mappedrefs.size()]);
229         for (int d = 0; d < dnarefs.length; d++)
230         {
231           Mapping mp = dnarefs[d].getMap();
232           if (mp != null)
233           {
234             for (int vc = 0; vc < viscontigs.length; vc += 2)
235             {
236               int[] mpr = mp.locateMappedRange(viscontigs[vc],
237                       viscontigs[vc + 1]);
238               if (mpr != null)
239               {
240                 return true;
241               }
242             }
243           }
244         }
245       }
246     }
247     return false;
248   }
249
250   /**
251    * Translate nucleotide alignment annotations onto translated amino acid
252    * alignment using codon mapping codons
253    * 
254    * @param al
255    *          the translated protein alignment
256    */
257   protected void translateAlignedAnnotations(AlignmentI al,
258           AlignedCodonFrame acf)
259   {
260     // Can only do this for columns with consecutive codons, or where
261     // annotation is sequence associated.
262
263     if (annotations != null)
264     {
265       for (AlignmentAnnotation annotation : annotations)
266       {
267         /*
268          * Skip hidden or autogenerated annotation. Also (for now), RNA
269          * secondary structure annotation. If we want to show this against
270          * protein we need a smarter way to 'translate' without generating
271          * invalid (unbalanced) structure annotation.
272          */
273         if (annotation.autoCalculated || !annotation.visible
274                 || annotation.isRNA())
275         {
276           continue;
277         }
278
279         int aSize = aaWidth;
280         Annotation[] anots = (annotation.annotations == null) ? null
281                 : new Annotation[aSize];
282         if (anots != null)
283         {
284           for (int a = 0; a < aSize; a++)
285           {
286             // process through codon map.
287             if (a < alignedCodons.length && alignedCodons[a] != null
288                     && alignedCodons[a].pos1 == (alignedCodons[a].pos3 - 2))
289             {
290               anots[a] = getCodonAnnotation(alignedCodons[a],
291                       annotation.annotations);
292             }
293           }
294         }
295
296         AlignmentAnnotation aa = new AlignmentAnnotation(annotation.label,
297                 annotation.description, anots);
298         aa.graph = annotation.graph;
299         aa.graphGroup = annotation.graphGroup;
300         aa.graphHeight = annotation.graphHeight;
301         if (annotation.getThreshold() != null)
302         {
303           aa.setThreshold(new GraphLine(annotation
304                   .getThreshold()));
305         }
306         if (annotation.hasScore)
307         {
308           aa.setScore(annotation.getScore());
309         }
310
311         final SequenceI seqRef = annotation.sequenceRef;
312         if (seqRef != null)
313         {
314           SequenceI aaSeq = acf.getAaForDnaSeq(seqRef);
315           if (aaSeq != null)
316           {
317             // aa.compactAnnotationArray(); // throw away alignment annotation
318             // positioning
319             aa.setSequenceRef(aaSeq);
320             // rebuild mapping
321             aa.createSequenceMapping(aaSeq, aaSeq.getStart(), true);
322             aa.adjustForAlignment();
323             aaSeq.addAlignmentAnnotation(aa);
324           }
325         }
326         al.addAnnotation(aa);
327       }
328     }
329   }
330
331   private static Annotation getCodonAnnotation(AlignedCodon is,
332           Annotation[] annotations)
333   {
334     // Have a look at all the codon positions for annotation and put the first
335     // one found into the translated annotation pos.
336     int contrib = 0;
337     Annotation annot = null;
338     for (int p = 1; p <= 3; p++)
339     {
340       int dnaCol = is.getBaseColumn(p);
341       if (annotations[dnaCol] != null)
342       {
343         if (annot == null)
344         {
345           annot = new Annotation(annotations[dnaCol]);
346           contrib = 1;
347         }
348         else
349         {
350           // merge with last
351           Annotation cpy = new Annotation(annotations[dnaCol]);
352           if (annot.colour == null)
353           {
354             annot.colour = cpy.colour;
355           }
356           if (annot.description == null || annot.description.length() == 0)
357           {
358             annot.description = cpy.description;
359           }
360           if (annot.displayCharacter == null)
361           {
362             annot.displayCharacter = cpy.displayCharacter;
363           }
364           if (annot.secondaryStructure == 0)
365           {
366             annot.secondaryStructure = cpy.secondaryStructure;
367           }
368           annot.value += cpy.value;
369           contrib++;
370         }
371       }
372     }
373     if (contrib > 1)
374     {
375       annot.value /= contrib;
376     }
377     return annot;
378   }
379
380   /**
381    * Translate a na sequence
382    * 
383    * @param selection
384    *          sequence displayed under viscontigs visible columns
385    * @param seqstring
386    *          ORF read in some global alignment reference frame
387    * @param acf
388    *          Definition of global ORF alignment reference frame
389    * @param proteinSeqs
390    * @return sequence ready to be added to alignment.
391    */
392   protected SequenceI translateCodingRegion(SequenceI selection,
393           String seqstring, AlignedCodonFrame acf,
394           List<SequenceI> proteinSeqs)
395   {
396     List<int[]> skip = new ArrayList<int[]>();
397     int skipint[] = null;
398     ShiftList vismapping = new ShiftList(); // map from viscontigs to seqstring
399     // intervals
400     int vc;
401     int[] scontigs = new int[contigs.length];
402     int npos = 0;
403     for (vc = 0; vc < contigs.length; vc += 2)
404     {
405       if (vc == 0)
406       {
407         vismapping.addShift(npos, contigs[vc]);
408       }
409       else
410       {
411         // hidden region
412         vismapping.addShift(npos, contigs[vc] - contigs[vc - 1] + 1);
413       }
414       scontigs[vc] = contigs[vc];
415       scontigs[vc + 1] = contigs[vc + 1];
416     }
417
418     // allocate a roughly sized buffer for the protein sequence
419     StringBuilder protein = new StringBuilder(seqstring.length() / 2);
420     String seq = seqstring.replace('U', 'T').replace('u', 'T');
421     char codon[] = new char[3];
422     int cdp[] = new int[3];
423     int rf = 0;
424     int lastnpos = 0;
425     int nend;
426     int aspos = 0;
427     int resSize = 0;
428     for (npos = 0, nend = seq.length(); npos < nend; npos++)
429     {
430       if (!Comparison.isGap(seq.charAt(npos)))
431       {
432         cdp[rf] = npos; // store position
433         codon[rf++] = seq.charAt(npos); // store base
434       }
435       if (rf == 3)
436       {
437         /*
438          * Filled up a reading frame...
439          */
440         AlignedCodon alignedCodon = new AlignedCodon(cdp[0], cdp[1], cdp[2]);
441         String aa = ResidueProperties.codonTranslate(new String(codon));
442         rf = 0;
443         final String gapString = String.valueOf(gapChar);
444         if (aa == null)
445         {
446           aa = gapString;
447           if (skipint == null)
448           {
449             skipint = new int[]
450             { alignedCodon.pos1, alignedCodon.pos3 /* cdp[0], cdp[2] */};
451           }
452           skipint[1] = alignedCodon.pos3; // cdp[2];
453         }
454         else
455         {
456           if (skipint != null)
457           {
458             // edit scontigs
459             skipint[0] = vismapping.shift(skipint[0]);
460             skipint[1] = vismapping.shift(skipint[1]);
461             for (vc = 0; vc < scontigs.length;)
462             {
463               if (scontigs[vc + 1] < skipint[0])
464               {
465                 // before skipint starts
466                 vc += 2;
467                 continue;
468               }
469               if (scontigs[vc] > skipint[1])
470               {
471                 // finished editing so
472                 break;
473               }
474               // Edit the contig list to include the skipped region which did
475               // not translate
476               int[] t;
477               // from : s1 e1 s2 e2 s3 e3
478               // to s: s1 e1 s2 k0 k1 e2 s3 e3
479               // list increases by one unless one boundary (s2==k0 or e2==k1)
480               // matches, and decreases by one if skipint intersects whole
481               // visible contig
482               if (scontigs[vc] <= skipint[0])
483               {
484                 if (skipint[0] == scontigs[vc])
485                 {
486                   // skipint at start of contig
487                   // shift the start of this contig
488                   if (scontigs[vc + 1] > skipint[1])
489                   {
490                     scontigs[vc] = skipint[1];
491                     vc += 2;
492                   }
493                   else
494                   {
495                     if (scontigs[vc + 1] == skipint[1])
496                     {
497                       // remove the contig
498                       t = new int[scontigs.length - 2];
499                       if (vc > 0)
500                       {
501                         System.arraycopy(scontigs, 0, t, 0, vc - 1);
502                       }
503                       if (vc + 2 < t.length)
504                       {
505                         System.arraycopy(scontigs, vc + 2, t, vc, t.length
506                                 - vc + 2);
507                       }
508                       scontigs = t;
509                     }
510                     else
511                     {
512                       // truncate contig to before the skipint region
513                       scontigs[vc + 1] = skipint[0] - 1;
514                       vc += 2;
515                     }
516                   }
517                 }
518                 else
519                 {
520                   // scontig starts before start of skipint
521                   if (scontigs[vc + 1] < skipint[1])
522                   {
523                     // skipint truncates end of scontig
524                     scontigs[vc + 1] = skipint[0] - 1;
525                     vc += 2;
526                   }
527                   else
528                   {
529                     // divide region to new contigs
530                     t = new int[scontigs.length + 2];
531                     System.arraycopy(scontigs, 0, t, 0, vc + 1);
532                     t[vc + 1] = skipint[0];
533                     t[vc + 2] = skipint[1];
534                     System.arraycopy(scontigs, vc + 1, t, vc + 3,
535                             scontigs.length - (vc + 1));
536                     scontigs = t;
537                     vc += 4;
538                   }
539                 }
540               }
541             }
542             skip.add(skipint);
543             skipint = null;
544           }
545           if (aa.equals("STOP"))
546           {
547             aa = STOP_X;
548           }
549           resSize++;
550         }
551         boolean findpos = true;
552         while (findpos)
553         {
554           /*
555            * Compare this codon's base positions with those currently aligned to
556            * this column in the translation.
557            */
558           final int compareCodonPos = compareCodonPos(alignedCodon,
559                   alignedCodons[aspos]);
560           switch (compareCodonPos)
561           {
562           case -1:
563
564             /*
565              * This codon should precede the mapped positions - need to insert a
566              * gap in all prior sequences.
567              */
568             insertAAGap(aspos, proteinSeqs);
569             findpos = false;
570             break;
571
572           case +1:
573
574             /*
575              * This codon belongs after the aligned codons at aspos. Prefix it
576              * with a gap and try the next position.
577              */
578             aa = gapString + aa;
579             aspos++;
580             break;
581
582           case 0:
583
584             /*
585              * Exact match - codon 'belongs' at this translated position.
586              */
587             findpos = false;
588           }
589         }
590         protein.append(aa);
591         lastnpos = npos;
592         if (alignedCodons[aspos] == null)
593         {
594           // mark this column as aligning to this aligned reading frame
595           alignedCodons[aspos] = alignedCodon;
596         }
597         else if (!alignedCodons[aspos].equals(alignedCodon))
598         {
599           throw new IllegalStateException("Tried to coalign "
600                   + alignedCodons[aspos].toString() + " with "
601                   + alignedCodon.toString());
602         }
603         if (aspos >= aaWidth)
604         {
605           // update maximum alignment width
606           aaWidth = aspos;
607         }
608         // ready for next translated reading frame alignment position (if any)
609         aspos++;
610       }
611     }
612     if (resSize > 0)
613     {
614       SequenceI newseq = new Sequence(selection.getName(),
615               protein.toString());
616       if (rf != 0)
617       {
618         final String errMsg = "trimming contigs for incomplete terminal codon.";
619         System.err.println(errMsg);
620         // map and trim contigs to ORF region
621         vc = scontigs.length - 1;
622         lastnpos = vismapping.shift(lastnpos); // place npos in context of
623         // whole dna alignment (rather
624         // than visible contigs)
625         // incomplete ORF could be broken over one or two visible contig
626         // intervals.
627         while (vc >= 0 && scontigs[vc] > lastnpos)
628         {
629           if (vc > 0 && scontigs[vc - 1] > lastnpos)
630           {
631             vc -= 2;
632           }
633           else
634           {
635             // correct last interval in list.
636             scontigs[vc] = lastnpos;
637           }
638         }
639
640         if (vc > 0 && (vc + 1) < scontigs.length)
641         {
642           // truncate map list to just vc elements
643           int t[] = new int[vc + 1];
644           System.arraycopy(scontigs, 0, t, 0, vc + 1);
645           scontigs = t;
646         }
647         if (vc <= 0)
648         {
649           scontigs = null;
650         }
651       }
652       if (scontigs != null)
653       {
654         npos = 0;
655         // map scontigs to actual sequence positions on selection
656         for (vc = 0; vc < scontigs.length; vc += 2)
657         {
658           scontigs[vc] = selection.findPosition(scontigs[vc]); // not from 1!
659           scontigs[vc + 1] = selection.findPosition(scontigs[vc + 1]); // exclusive
660           if (scontigs[vc + 1] == selection.getEnd())
661           {
662             break;
663           }
664         }
665         // trim trailing empty intervals.
666         if ((vc + 2) < scontigs.length)
667         {
668           int t[] = new int[vc + 2];
669           System.arraycopy(scontigs, 0, t, 0, vc + 2);
670           scontigs = t;
671         }
672         /*
673          * delete intervals in scontigs which are not translated. 1. map skip
674          * into sequence position intervals 2. truncate existing ranges and add
675          * new ranges to exclude untranslated regions. if (skip.size()>0) {
676          * Vector narange = new Vector(); for (vc=0; vc<scontigs.length; vc++) {
677          * narange.addElement(new int[] {scontigs[vc]}); } int sint=0,iv[]; vc =
678          * 0; while (sint<skip.size()) { skipint = (int[]) skip.elementAt(sint);
679          * do { iv = (int[]) narange.elementAt(vc); if (iv[0]>=skipint[0] &&
680          * iv[0]<=skipint[1]) { if (iv[0]==skipint[0]) { // delete beginning of
681          * range } else { // truncate range and create new one if necessary iv =
682          * (int[]) narange.elementAt(vc+1); if (iv[0]<=skipint[1]) { // truncate
683          * range iv[0] = skipint[1]; } else { } } } else if (iv[0]<skipint[0]) {
684          * iv = (int[]) narange.elementAt(vc+1); } } while (iv[0]) } }
685          */
686         MapList map = new MapList(scontigs, new int[]
687         { 1, resSize }, 3, 1);
688
689         transferCodedFeatures(selection, newseq, map, null, null);
690
691         /*
692          * Construct a dataset sequence for our new peptide.
693          */
694         SequenceI rseq = newseq.deriveSequence();
695
696         /*
697          * Store a mapping (between the dataset sequences for the two
698          * sequences).
699          */
700         // SIDE-EFFECT: acf stores the aligned sequence reseq; to remove!
701         acf.addMap(selection, rseq, map);
702         return rseq;
703       }
704     }
705     // register the mapping somehow
706     //
707     return null;
708   }
709
710   /**
711    * Insert a gap into the aligned proteins and the codon mapping array.
712    * 
713    * @param pos
714    * @param proteinSeqs
715    * @return
716    */
717   protected void insertAAGap(int pos,
718           List<SequenceI> proteinSeqs)
719   {
720     aaWidth++;
721     for (SequenceI seq : proteinSeqs)
722     {
723       seq.insertCharAt(pos, gapChar);
724     }
725
726     checkCodonFrameWidth();
727     if (pos < aaWidth)
728     {
729       aaWidth++;
730
731       /*
732        * Shift from [pos] to the end one to the right, and null out [pos]
733        */
734       System.arraycopy(alignedCodons, pos, alignedCodons, pos + 1,
735               alignedCodons.length - pos - 1);
736       alignedCodons[pos] = null;
737     }
738   }
739
740   /**
741    * Check the codons array can accommodate a single insertion, if not resize
742    * it.
743    */
744   protected void checkCodonFrameWidth()
745   {
746     if (alignedCodons[alignedCodons.length - 1] != null)
747     {
748       /*
749        * arraycopy insertion would bump a filled slot off the end, so expand.
750        */
751       AlignedCodon[] c = new AlignedCodon[alignedCodons.length + 10];
752       System.arraycopy(alignedCodons, 0, c, 0, alignedCodons.length);
753       alignedCodons = c;
754     }
755   }
756
757   /**
758    * Given a peptide newly translated from a dna sequence, copy over and set any
759    * features on the peptide from the DNA. If featureTypes is null, all features
760    * on the dna sequence are searched (rather than just the displayed ones), and
761    * similarly for featureGroups.
762    * 
763    * @param dna
764    * @param pep
765    * @param map
766    * @param featureTypes
767    *          hash whose keys are the displayed feature type strings
768    * @param featureGroups
769    *          hash where keys are feature groups and values are Boolean objects
770    *          indicating if they are displayed.
771    */
772   private static void transferCodedFeatures(SequenceI dna, SequenceI pep,
773           MapList map, Map<String, Object> featureTypes,
774           Map<String, Boolean> featureGroups)
775   {
776     SequenceFeature[] sfs = dna.getSequenceFeatures();
777     Boolean fgstate;
778     DBRefEntry[] dnarefs = DBRefUtils.selectRefs(dna.getDBRef(),
779             DBRefSource.DNACODINGDBS);
780     if (dnarefs != null)
781     {
782       // intersect with pep
783       for (int d = 0; d < dnarefs.length; d++)
784       {
785         Mapping mp = dnarefs[d].getMap();
786         if (mp != null)
787         {
788         }
789       }
790     }
791     if (sfs != null)
792     {
793       for (SequenceFeature sf : sfs)
794       {
795         fgstate = (featureGroups == null) ? null : featureGroups
796                 .get(sf.featureGroup);
797         if ((featureTypes == null || featureTypes.containsKey(sf.getType()))
798                 && (fgstate == null || fgstate.booleanValue()))
799         {
800           if (FeatureProperties.isCodingFeature(null, sf.getType()))
801           {
802             // if (map.intersectsFrom(sf[f].begin, sf[f].end))
803             {
804
805             }
806           }
807         }
808       }
809     }
810   }
811 }