src/org/gel/mauve/SeqFeatureData.java

Go to the documentation of this file.

package org.gel.mauve;

import java.awt.Component;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.StringTokenizer;
import java.util.Vector;

import javax.swing.JOptionPane;

import org.biojava.bio.seq.Feature;
import org.biojava.bio.seq.FeatureFilter;
import org.biojava.bio.seq.FeatureHolder;
import org.biojava.bio.symbol.Location;
import org.gel.mauve.gui.navigation.AnnotationContainsFilter;
import org.gel.mauve.gui.navigation.NavigationPanel;

public class SeqFeatureData implements MauveConstants {

        public static FeatureComparator feature_comp = new FeatureComparator ();

        private SeqFeatureData () {
        }

        public static FeatureFilter getFilter (String [][] data) {
                FeatureFilter and = null;
                for (int i = 0; i < data.length; i++) {
                        StringTokenizer toke = SeqFeatureData
                                        .separateFields (SeqFeatureData
                                                        .readToActual (data[i][NavigationPanel.FIELD]));
                        FeatureFilter or = null;
                        while (toke.hasMoreTokens ()) {
                                FeatureFilter cur = null;
                                cur = new AnnotationContainsFilter (toke.nextToken (),
                                                data[i][NavigationPanel.VALUE].toLowerCase (), Boolean
                                                                .valueOf (data[i][NavigationPanel.EXACT])
                                                                .booleanValue ());
                                if (or != null) {
                                        or = new FeatureFilter.Or (or, cur);
                                } else
                                        or = cur;
                        }
                        if (and != null)
                                and = new FeatureFilter.And (and, or);
                        else
                                and = or;
                }
                and = new FeatureFilter.And (NULL_AVOIDER, and);
                // and = new FeatureFilter.And (ass)), and);
                return and;
        }

        public static LinkedList [] findFeatures (Genome [] nomes, String [][] data) {
                LinkedList [] nome_data = new LinkedList [nomes.length];
                FeatureFilter filter = getFilter (data);
                for (int i = 0; i < nomes.length; i++) {
                        FeatureHolder hold = nomes[i].getAnnotationSequence ();
                        hold = hold.filter (filter, true);
                        LinkedList list = new LinkedList ();
                        list.add (nomes[i]);
                        Iterator itty = hold.features ();
                        while (itty.hasNext ())
                                list.add (itty.next ());
                        nome_data[i] = list;
                }
                return nome_data;
        }

        public static void removeLocationDuplicates (LinkedList feats) {
                if (feats.size () > 1) {
                        Collections.sort (feats, feature_comp);
                        Object first = feats.get (0);
                        Object compare = null;
                        int index = 1;
                        do {
                                compare = feats.get (index);
                                if (feature_comp.compare (first, compare) == 0)
                                        feats.remove (index);
                                else {
                                        first = compare;
                                        index++;
                                }
                        } while (index < feats.size ());
                }
        }

        static class FeatureComparator implements Comparator {
                public int compare (Object a, Object b) {
                        int one = ((Feature) a).getLocation ().getMin ();
                        int two = ((Feature) b).getLocation ().getMin ();
                        return (one == two) ? 0 : (one < two) ? -1 : 1;
                }
        }

        public static StringTokenizer separateFields (String fields) {
                return new StringTokenizer (fields, "/", false);
        }

        public static String readToActual (String field) {
                String actual = (String) READ_TO_ACTUAL.get (field);
                if (actual != null)
                        field = actual;
                else
                        field = field.toLowerCase ();
                return field.replace (' ', '_');
        }

        public static long centerOfFeature (Feature feature) {
                Location loca = feature.getLocation ();
                return loca.getMin () + (loca.getMax () - loca.getMin ()) / 2;
        }

        public static String getTypeFromFilterSpec (FilterCacheSpec spec) {
                if (spec.getFilter () != null)
                        return getTypeFromFilter (spec.getFilter ());
                else
                        return null;
        }

        public static String getTypeFromFilter (FeatureFilter filter) {
                String type = null;
                if (filter instanceof FeatureFilter.ByType)
                        type = ((FeatureFilter.ByType) filter).getType ();
                else if (filter instanceof FeatureFilter.And) {
                        type = getTypeFromFilter (((FeatureFilter.And) filter).getChild1 ());
                        if (type == null)
                                type = getTypeFromFilter (((FeatureFilter.And) filter)
                                                .getChild2 ());
                }
                return type;
        }

        public static Genome [] userSelectedGenomes (Component parent, BaseViewerModel model, 
                        boolean all_ok, boolean needs_annotations) {
                Vector choices = userSelectableGenomes (model, all_ok, needs_annotations);
                Object chosen = JOptionPane.showInputDialog(parent, "Choose Sequence to Navigate", 
                                "Go To. . .", JOptionPane.QUESTION_MESSAGE,
                                null, choices.toArray(), choices.get (0));
                if (chosen == null)
                        return null;
                else
                        return SeqFeatureData.convertIndexToSequence (choices, choices
                                        .indexOf (chosen));
        }

        public static Vector userSelectableGenomes (BaseViewerModel model,
                        boolean all_ok, boolean needs_annotations) {
                Vector choices = model.getGenomes ();
                if (needs_annotations) {
                        Iterator itty = choices.iterator ();
                        while (itty.hasNext ()) {
                                Genome genome = (Genome) itty.next ();
                                if (genome.getAnnotationSequence () == null)
                                        itty.remove ();
                        }
                }
                if (all_ok && choices.size () > 1)
                        choices.add (0, ALL_SEQUENCES);
                return choices;
        }

        public static Genome [] convertIndexToSequence (Vector choices, int index) {
                Genome [] nomes = null;
                if (index == 0 && choices.get (0) instanceof String
                                && ((String) choices.get (0)).equals (ALL_SEQUENCES)) {
                        int max = choices.size ();
                        nomes = new Genome [max - 1];
                        for (int i = 1; i < max; i++)
                                nomes[i - 1] = (Genome) choices.get (i);
                } else {
                        nomes = new Genome [1];
                        nomes[0] = (Genome) choices.get (index);
                }
                return nomes;
        }

}

---