X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequenceFeature.java;h=f17bd3349604541fd923c9da101bf16e77abea80;hb=bab4b08733a9543bdce5c0b9d1c32ca7d18ad9e3;hp=cba91dfa22f7639d03753d4b6d63b91a01eb7ec5;hpb=8116c10ff719ac0b542b33dbabfc9051634bf5ea;p=jalview.git diff --git a/src/jalview/datamodel/SequenceFeature.java b/src/jalview/datamodel/SequenceFeature.java index cba91df..f17bd33 100755 --- a/src/jalview/datamodel/SequenceFeature.java +++ b/src/jalview/datamodel/SequenceFeature.java @@ -1,197 +1,557 @@ -package jalview.datamodel; - -import jalview.util.*; -import jalview.jbgui.*; -import jalview.schemes.*; -import java.awt.*; - -public class SequenceFeature { - int start; - int end; - String type; - String description; - Color color; - Sequence sequence; - String id; - double score; - int strand; - double pvalue; - double pid; - - public SequenceFeature() { - } - - public SequenceFeature(Sequence sequence,String type, int start, int end, String description) { - this.sequence = sequence; - this.type = type; - this.start = start; - this.end = end; - this.description = description; - - setColor(); - } - - - public String toGFFString() { - String gff = id + "\t" + type + "\tfeature\t" + start + "\t" + end + "\t" + score + "\t" + strand + "\t."; - return gff; - } - public double getScore() { - return score; - } - - public void setScore(double score) { - this.score = score; - } - - public String getId() { - return this.id; - } - public void setId(String id) { - this.id = id; - } - public void setSequence(Sequence seq) { - this.sequence = seq; - } - public void setStart(int start) { - this.start = start; - } - public void setEnd(int end) { - this.end = end; - } - public int getStrand() { - return strand; - } - public void setStrand(int strand) { - this.strand = strand; - } - public int getStart() { - return start; - } - - public int getEnd() { - return end; - } - - public String getType() { - return type; - } - - public String getDescription() { - return description; - } - - public double getPValue() { - return pvalue; - } - public void setPValue(double value) { - this.pvalue = value; - } - public double getPercentId() { - return pid; - } - public void setPercentId(double pid) { - this.pid = pid; - } - public Color getColor() { - return color; - } - - public void setColor() { - if (type.equals("CHAIN")) { - color = Color.white; - } else if (type.equals("DOMAIN")) { - color = Color.white; - } else if (type.equals("TRANSMEM")) { - color = Color.red.darker(); - } else if (type.equals("SIGNAL")) { - color = Color.cyan; - } else if (type.equals("HELIX")) { - color = Color.magenta; - } else if (type.equals("TURN")) { - color = Color.cyan; - } else if (type.equals("SHEET")) { - color = Color.yellow; - } else if (type.equals("STRAND")) { - color = Color.yellow; - } else if (type.equals("CARBOHYD")) { - color = Color.pink; - } else if (type.equals("ACT_SITE")) { - color = Color.red; - } else if (type.equals("TRANSIT")) { - color = Color.orange; - } else if (type.equals("VARIANT")) { - color = Color.orange.darker(); - } else if (type.equals("BINDING")) { - color = Color.blue; - } else if (type.equals("DISULFID")) { - color = Color.yellow.darker(); - } else if (type.equals("NP_BIND")) { - color = Color.red; - } else if (type.indexOf("BIND") > 0) { - color = Color.red; - } else { - color = Color.lightGray; - } - } - public String print() { - String tmp = new Format("%15s").form(type); - tmp = tmp + new Format("%6d").form(start); - tmp = tmp + new Format("%6d").form(end); - tmp = tmp + " " + description; - return tmp; - } - public void draw(Graphics g, int fstart, int fend, int x1, int y1, int width, int height) { - g.setColor(new Color((float)(Math.random()),(float)(Math.random()),(float)(Math.random()))); - - // int xstart = sequence.findIndex(start); - //int xend = sequence.findIndex(end); - int xstart = start; - int xend = end; - long tstart = System.currentTimeMillis(); - if (!(xend < fstart && xstart > fend)) { - - if (xstart > fstart) { - x1 = x1 + (xstart-fstart)*width; - fstart = xstart; - } - - if (xend < fend) { - fend = xend; - } - - for (int i = fstart; i <= fend; i++) { - char c = sequence.sequence.charAt(i); - if (!jalview.util.Comparison.isGap((c))) - g.fillRect(x1+(i-fstart)*width,y1,width,height); - else - g.drawString("-",x1+(i-fstart)*width,y1+height); - - } - - } - long tend = System.currentTimeMillis(); - System.out.println("Time = " + (tend-tstart) + "ms"); - - } - - public static void main(String[] args) { - SequenceFeature sf = new SequenceFeature(); - - System.out.println("Feature " + sf); - } - public static int CHAIN = 0; - public static int DOMAIN = 1; - public static int TRANSMEM = 2; - public static int SIGNAL = 3; - public static int HELIX = 4; - public static int TURN = 5; - public static int SHEET = 6; - public static int CARBOHYD = 7; - public static int ACT_SITE = 8; - public static int TRANSIT = 9; - public static int VARIANT = 10; - public static int BINDING = 11; - -} - +/* + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * + * 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 . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ +package jalview.datamodel; + +import jalview.datamodel.features.FeatureLocationI; + +import java.util.Comparator; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Vector; + +/** + * DOCUMENT ME! + * + * @author $author$ + * @version $Revision$ + */ +public class SequenceFeature implements FeatureLocationI +{ + /* + * score value if none is set; preferably Float.Nan, but see + * JAL-2060 and JAL-2554 for a couple of blockers to that + */ + private static final float NO_SCORE = 0f; + + private static final String STATUS = "status"; + + private static final String STRAND = "STRAND"; + + // private key for Phase designed not to conflict with real GFF data + private static final String PHASE = "!Phase"; + + // private key for ENA location designed not to conflict with real GFF data + private static final String LOCATION = "!Location"; + + /* + * ATTRIBUTES is reserved for the GFF 'column 9' data, formatted as + * name1=value1;name2=value2,value3;...etc + */ + private static final String ATTRIBUTES = "ATTRIBUTES"; + + /* + * type, begin, end, featureGroup, score and contactFeature are final + * to ensure that the integrity of SequenceFeatures data store + * can't be broken by direct update of these fields + */ + public final String type; + + public final int begin; + + public final int end; + + public final String featureGroup; + + public final float score; + + private final boolean contactFeature; + + public String description; + + /* + * a map of key-value pairs; may be populated from GFF 'column 9' data, + * other data sources (e.g. GenBank file), or programmatically + */ + public Map otherDetails; + + public Vector links; + + /** + * Constructs a duplicate feature. Note: Uses makes a shallow copy of the + * otherDetails map, so the new and original SequenceFeature may reference the + * same objects in the map. + * + * @param cpy + */ + public SequenceFeature(SequenceFeature cpy) + { + this(cpy, cpy.getBegin(), cpy.getEnd(), cpy.getFeatureGroup(), cpy + .getScore()); + } + + /** + * Constructor + * + * @param theType + * @param theDesc + * @param theBegin + * @param theEnd + * @param group + */ + public SequenceFeature(String theType, String theDesc, int theBegin, + int theEnd, String group) + { + this(theType, theDesc, theBegin, theEnd, NO_SCORE, group); + } + + /** + * Constructor including a score value + * + * @param theType + * @param theDesc + * @param theBegin + * @param theEnd + * @param theScore + * @param group + */ + public SequenceFeature(String theType, String theDesc, int theBegin, + int theEnd, float theScore, String group) + { + this.type = theType; + this.description = theDesc; + this.begin = theBegin; + this.end = theEnd; + this.featureGroup = group; + this.score = theScore; + + /* + * for now, only "Disulfide/disulphide bond" is treated as a contact feature + */ + this.contactFeature = "disulfide bond".equalsIgnoreCase(type) + || "disulphide bond".equalsIgnoreCase(type); + } + + /** + * A copy constructor that allows the value of final fields to be 'modified' + * + * @param sf + * @param newType + * @param newBegin + * @param newEnd + * @param newGroup + * @param newScore + */ + public SequenceFeature(SequenceFeature sf, String newType, int newBegin, + int newEnd, String newGroup, float newScore) + { + this(newType, sf.getDescription(), newBegin, newEnd, newScore, + newGroup); + + if (sf.otherDetails != null) + { + otherDetails = new HashMap<>(); + for (Entry entry : sf.otherDetails.entrySet()) + { + otherDetails.put(entry.getKey(), entry.getValue()); + } + } + if (sf.links != null && sf.links.size() > 0) + { + links = new Vector<>(); + for (int i = 0, iSize = sf.links.size(); i < iSize; i++) + { + links.addElement(sf.links.elementAt(i)); + } + } + } + + /** + * A copy constructor that allows the value of final fields to be 'modified' + * + * @param sf + * @param newBegin + * @param newEnd + * @param newGroup + * @param newScore + */ + public SequenceFeature(SequenceFeature sf, int newBegin, int newEnd, + String newGroup, float newScore) + { + this(sf, sf.getType(), newBegin, newEnd, newGroup, newScore); + } + + /** + * Two features are considered equal if they have the same type, group, + * description, start, end, phase, strand, and (if present) 'Name', ID' and + * 'Parent' attributes. + * + * Note we need to check Parent to distinguish the same exon occurring in + * different transcripts (in Ensembl GFF). This allows assembly of transcript + * sequences from their component exon regions. + */ + @Override + public boolean equals(Object o) + { + return equals(o, false); + } + + /** + * Overloaded method allows the equality test to optionally ignore the + * 'Parent' attribute of a feature. This supports avoiding adding many + * superficially duplicate 'exon' or CDS features to genomic or protein + * sequence. + * + * @param o + * @param ignoreParent + * @return + */ + public boolean equals(Object o, boolean ignoreParent) + { + if (o == null || !(o instanceof SequenceFeature)) + { + return false; + } + + SequenceFeature sf = (SequenceFeature) o; + boolean sameScore = Float.isNaN(score) ? Float.isNaN(sf.score) + : score == sf.score; + if (begin != sf.begin || end != sf.end || !sameScore) + { + return false; + } + + if (getStrand() != sf.getStrand()) + { + return false; + } + + if (!(type + description + featureGroup + getPhase()).equals( + sf.type + sf.description + sf.featureGroup + sf.getPhase())) + { + return false; + } + if (!equalAttribute(getValue("ID"), sf.getValue("ID"))) + { + return false; + } + if (!equalAttribute(getValue("Name"), sf.getValue("Name"))) + { + return false; + } + if (!ignoreParent) + { + if (!equalAttribute(getValue("Parent"), sf.getValue("Parent"))) + { + return false; + } + } + return true; + } + + /** + * Returns true if both values are null, are both non-null and equal + * + * @param att1 + * @param att2 + * @return + */ + protected static boolean equalAttribute(Object att1, Object att2) + { + if (att1 == null && att2 == null) + { + return true; + } + if (att1 != null) + { + return att1.equals(att2); + } + return att2.equals(att1); + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + @Override + public int getBegin() + { + return begin; + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + @Override + public int getEnd() + { + return end; + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public String getType() + { + return type; + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public String getDescription() + { + return description; + } + + public void setDescription(String desc) + { + description = desc; + } + + public String getFeatureGroup() + { + return featureGroup; + } + + public void addLink(String labelLink) + { + if (links == null) + { + links = new Vector<>(); + } + + if (!links.contains(labelLink)) + { + links.insertElementAt(labelLink, 0); + } + } + + public float getScore() + { + return score; + } + + /** + * Used for getting values which are not in the basic set. eg STRAND, PHASE + * for GFF file + * + * @param key + * String + */ + public Object getValue(String key) + { + if (otherDetails == null) + { + return null; + } + else + { + return otherDetails.get(key); + } + } + + /** + * Returns a property value for the given key if known, else the specified + * default value + * + * @param key + * @param defaultValue + * @return + */ + public Object getValue(String key, Object defaultValue) + { + Object value = getValue(key); + return value == null ? defaultValue : value; + } + + /** + * Used for setting values which are not in the basic set. eg STRAND, FRAME + * for GFF file + * + * @param key + * eg STRAND + * @param value + * eg + + */ + public void setValue(String key, Object value) + { + if (value != null) + { + if (otherDetails == null) + { + otherDetails = new HashMap<>(); + } + + otherDetails.put(key, value); + } + } + + /* + * The following methods are added to maintain the castor Uniprot mapping file + * for the moment. + */ + public void setStatus(String status) + { + setValue(STATUS, status); + } + + public String getStatus() + { + return (String) getValue(STATUS); + } + + public void setAttributes(String attr) + { + setValue(ATTRIBUTES, attr); + } + + public String getAttributes() + { + return (String) getValue(ATTRIBUTES); + } + + /** + * Return 1 for forward strand ('+' in GFF), -1 for reverse strand ('-' in + * GFF), and 0 for unknown or not (validly) specified + * + * @return + */ + public int getStrand() + { + int strand = 0; + if (otherDetails != null) + { + Object str = otherDetails.get(STRAND); + if ("-".equals(str)) + { + strand = -1; + } + else if ("+".equals(str)) + { + strand = 1; + } + } + return strand; + } + + /** + * Set the value of strand + * + * @param strand + * should be "+" for forward, or "-" for reverse + */ + public void setStrand(String strand) + { + setValue(STRAND, strand); + } + + public void setPhase(String phase) + { + setValue(PHASE, phase); + } + + public String getPhase() + { + return (String) getValue(PHASE); + } + + /** + * Sets the 'raw' ENA format location specifier e.g. join(12..45,89..121) + * + * @param loc + */ + public void setEnaLocation(String loc) + { + setValue(LOCATION, loc); + } + + /** + * Gets the 'raw' ENA format location specifier e.g. join(12..45,89..121) + * + * @param loc + */ + public String getEnaLocation() + { + return (String) getValue(LOCATION); + } + + /** + * Readable representation, for debug only, not guaranteed not to change + * between versions + */ + @Override + public String toString() + { + return String.format("%d %d %s %s", getBegin(), getEnd(), getType(), + getDescription()); + } + + /** + * Overridden to ensure that whenever two objects are equal, they have the + * same hashCode + */ + @Override + public int hashCode() + { + String s = getType() + getDescription() + getFeatureGroup() + + getValue("ID") + getValue("Name") + getValue("Parent") + + getPhase(); + return s.hashCode() + getBegin() + getEnd() + (int) getScore() + + getStrand(); + } + + /** + * Answers true if the feature's start/end values represent two related + * positions, rather than ends of a range. Such features may be visualised or + * reported differently to features on a range. + */ + @Override + public boolean isContactFeature() + { + return contactFeature; + } + + /** + * Answers true if the sequence has zero start and end position + * + * @return + */ + public boolean isNonPositional() + { + return begin == 0 && end == 0; + } +} + +class SFSortByEnd implements Comparator +{ + @Override + public int compare(SequenceFeature a, SequenceFeature b) + { + return a.getEnd() - b.getEnd(); + } +} + +class SFSortByBegin implements Comparator +{ + @Override + public int compare(SequenceFeature a, SequenceFeature b) + { + return a.getBegin() - b.getBegin(); + } +}