Disable memory checker for now
[jalview.git] / src / jalview / datamodel / Mapping.java
1 package jalview.datamodel;
2
3 import jalview.util.MapList;
4
5 public class Mapping {
6   /**
7    * Contains the
8    * start-end pairs mapping from 
9    * the associated sequence to the 
10    * sequence in the database 
11    * coordinate system
12    * it also takes care of step difference between coordinate systems
13    */
14   MapList map=null;
15   /**
16    * The seuqence that map maps the associated seuqence to (if any).
17    */
18   SequenceI to=null;
19   public Mapping(MapList map) {
20     super();
21     this.map = map;
22   }
23   public Mapping(SequenceI to, MapList map) {
24     this(map);
25     this.to = to;
26   }
27   /**
28    * create a new mapping from
29    * @param to the sequence being mapped
30    * @param exon int[] {start,end,start,end} series on associated sequence
31    * @param is int[] {start,end,...} ranges on the reference frame being mapped to
32    * @param i step size on associated sequence
33    * @param j step size on mapped frame
34    */
35   public Mapping(SequenceI to, int[] exon, int[] is, int i, int j)
36   {
37     this(to, new MapList(exon, is, i, j));
38   }
39   /**
40    * create a duplicate (and independent) mapping object with 
41    * the same reference to any SequenceI being mapped to.
42    * @param map2
43    */
44   public Mapping(Mapping map2)
45   {
46     if (map2!=this && map2!=null) {
47       if (map2.map!=null) 
48       {
49         map=new MapList(map2.map);
50       }
51       to = map2.to;
52     }
53   }
54   /**
55    * @return the map
56    */
57   public MapList getMap() {
58     return map;
59   }
60
61   /**
62    * @param map the map to set
63    */
64   public void setMap(MapList map) {
65     this.map = map;
66   }
67   /**
68    * Equals that compares both the to references and MapList mappings.
69    * @param other
70    * @return 
71    */
72   public boolean equals(Mapping other) {
73     if (other==null)
74       return false;
75     if (other==this)
76       return true;
77     if (other.to!=to)
78       return false;
79     if ((map!=null && other.map==null) || (map==null && other.map!=null))
80       return false;
81     if (map.equals(other.map))
82       return true;
83     return false;
84   }
85   /**
86    * get the 'initial' position in the associated
87    * sequence for a position in the mapped reference frame
88    * @param mpos
89    * @return
90    */
91   public int getPosition(int mpos) 
92   {
93     if (map!=null) {
94       int[] mp = map.shiftTo(mpos);
95       if (mp!=null)
96       {
97         return mp[0];
98       }
99     }
100     return mpos;
101   }
102   public int[] getWord(int mpos) {
103     if (map!=null) {
104       int[] mp=map.shiftTo(mpos);
105       if (mp!=null) {
106         return new int[] {mp[0], mp[0]+mp[2]*(map.getFromRatio()-1)}; 
107       }
108     }
109     return null;
110   }
111   /**
112    * width of mapped unit in associated sequence 
113    * 
114    */
115   public int getWidth() {
116     if (map!=null) {
117       return map.getFromRatio();
118     }
119     return 1;
120   }
121
122   /**
123    * width of unit in mapped reference frame
124    * @return
125    */
126   public int getMappedWidth() {
127     if (map!=null) {
128       return map.getToRatio();
129     }
130     return 1;
131   }
132   /**
133    * get mapped position in the associated
134    * reference frame for position pos in the
135    * associated sequence.
136    * @param pos
137    * @return
138    */
139   public int getMappedPosition(int pos) {
140     if (map!=null) {
141       int[] mp = map.shiftFrom(pos);
142       if (mp!=null)
143       {
144         return mp[0];
145       }
146     }
147     return pos;
148   }
149   public int[] getMappedWord(int pos) {
150     if (map!=null) {
151       int[] mp = map.shiftFrom(pos);
152       if (mp!=null)
153       {
154         return new int[] { mp[0], mp[0]+mp[2]*(map.getToRatio()-1)};
155       }
156     }
157     return null;
158   }
159   /**
160    * locates the region of feature f in the associated sequence's reference frame 
161    * @param f
162    * @return one or more features corresponding to f
163    */
164   public SequenceFeature[] locateFeature(SequenceFeature f)
165   {
166     // this is a stopgap - features broken over exon boundaries will not be
167     // broken into a collection of feature fragments.
168     // TODO: implement creation of several features from a single feature on a discontinuously mapped seuqence
169     // need a function like int [] fromrange = map.getRange(from,to)
170     // need to make subgrouped sequence features.
171     if (true) {
172       if (map!=null) {
173         int[] frange = map.locateInFrom(f.getBegin(), f.getEnd());
174         SequenceFeature[] vf = new SequenceFeature[frange.length/2];
175         for (int i=0,v=0;i<frange.length;i+=2) {
176           vf[v] = new SequenceFeature(f);
177           vf[v].setBegin(frange[i]);
178           vf[v].setEnd(frange[i+1]);
179           if (frange.length>2)
180             vf[v].setDescription(f.getDescription() +"\nPart "+v);
181         }
182         return vf;
183       }
184     }
185     if (false){
186       int[] word = getWord(f.getBegin());
187       if (word[0]<word[1]) 
188       {
189         f.setBegin(word[0]);
190       } else {
191         f.setBegin(word[1]);
192       }
193       word = getWord(f.getEnd());
194       if (word[0]>word[1]) 
195       {
196         f.setEnd(word[0]);
197       } else {
198         f.setEnd(word[1]);
199       }
200     }
201     // give up and just return the feature.
202     return new SequenceFeature[] { f };
203   }
204       
205     /**
206    * return a series of contigs on the associated sequence corresponding to
207    * the from,to interval on the mapped reference frame
208    * @param from
209    * @param to
210    * @return
211    */
212   public int[] locateRange(int from, int to) {
213     //TODO
214     return null;
215   }
216   /**
217    * return a series of contigs on the mapped reference frame corresponding to
218    * the from,to interval on the associated sequence
219    * @param from
220    * @param to
221    * @return
222    */
223   public int[] locateMappedRange(int from, int to) {
224     //TODO 
225     return null;
226   }
227 }