package jalview.datamodel; import jalview.util.MapList; public class Mapping { /** * Contains the * start-end pairs mapping from * the associated sequence to the * sequence in the database * coordinate system * it also takes care of step difference between coordinate systems */ MapList map=null; /** * The seuqence that map maps the associated seuqence to (if any). */ SequenceI to=null; public Mapping(MapList map) { super(); this.map = map; } public Mapping(SequenceI to, MapList map) { this(map); this.to = to; } /** * create a new mapping from * @param to the sequence being mapped * @param exon int[] {start,end,start,end} series on associated sequence * @param is int[] {start,end,...} ranges on the reference frame being mapped to * @param i step size on associated sequence * @param j step size on mapped frame */ public Mapping(SequenceI to, int[] exon, int[] is, int i, int j) { this(to, new MapList(exon, is, i, j)); } /** * create a duplicate (and independent) mapping object with * the same reference to any SequenceI being mapped to. * @param map2 */ public Mapping(Mapping map2) { if (map2!=this && map2!=null) { if (map2.map!=null) { map=new MapList(map2.map); } to = map2.to; } } /** * @return the map */ public MapList getMap() { return map; } /** * @param map the map to set */ public void setMap(MapList map) { this.map = map; } /** * Equals that compares both the to references and MapList mappings. * @param other * @return */ public boolean equals(Mapping other) { if (other==null) return false; if (other==this) return true; if (other.to!=to) return false; if ((map!=null && other.map==null) || (map==null && other.map!=null)) return false; if (map.equals(other.map)) return true; return false; } /** * get the 'initial' position in the associated * sequence for a position in the mapped reference frame * @param mpos * @return */ public int getPosition(int mpos) { if (map!=null) { int[] mp = map.shiftTo(mpos); if (mp!=null) { return mp[0]; } } return mpos; } public int[] getWord(int mpos) { if (map!=null) { int[] mp=map.shiftTo(mpos); if (mp!=null) { return new int[] {mp[0], mp[0]+mp[2]*(map.getFromRatio()-1)}; } } return null; } /** * width of mapped unit in associated sequence * */ public int getWidth() { if (map!=null) { return map.getFromRatio(); } return 1; } /** * width of unit in mapped reference frame * @return */ public int getMappedWidth() { if (map!=null) { return map.getToRatio(); } return 1; } /** * get mapped position in the associated * reference frame for position pos in the * associated sequence. * @param pos * @return */ public int getMappedPosition(int pos) { if (map!=null) { int[] mp = map.shiftFrom(pos); if (mp!=null) { return mp[0]; } } return pos; } public int[] getMappedWord(int pos) { if (map!=null) { int[] mp = map.shiftFrom(pos); if (mp!=null) { return new int[] { mp[0], mp[0]+mp[2]*(map.getToRatio()-1)}; } } return null; } /** * locates the region of feature f in the associated sequence's reference frame * @param f * @return one or more features corresponding to f */ public SequenceFeature[] locateFeature(SequenceFeature f) { // this is a stopgap - features broken over exon boundaries will not be // broken into a collection of feature fragments. // TODO: implement creation of several features from a single feature on a discontinuously mapped seuqence // need a function like int [] fromrange = map.getRange(from,to) // need to make subgrouped sequence features. if (true) { if (map!=null) { int[] frange = map.locateInFrom(f.getBegin(), f.getEnd()); SequenceFeature[] vf = new SequenceFeature[frange.length/2]; for (int i=0,v=0;i2) vf[v].setDescription(f.getDescription() +"\nPart "+v); } return vf; } } if (false){ int[] word = getWord(f.getBegin()); if (word[0]word[1]) { f.setEnd(word[0]); } else { f.setEnd(word[1]); } } // give up and just return the feature. return new SequenceFeature[] { f }; } /** * return a series of contigs on the associated sequence corresponding to * the from,to interval on the mapped reference frame * @param from * @param to * @return */ public int[] locateRange(int from, int to) { //TODO return null; } /** * return a series of contigs on the mapped reference frame corresponding to * the from,to interval on the associated sequence * @param from * @param to * @return */ public int[] locateMappedRange(int from, int to) { //TODO return null; } }