src/jalview/datamodel/Mapping.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6)
   3  * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
   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 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 package jalview.datamodel;
  19
  20 import java.util.Vector;
  21
  22 import jalview.util.MapList;
  23
  24 public class Mapping
  25 {
  26   /**
  27    * Contains the start-end pairs mapping from the associated sequence to the
  28    * sequence in the database coordinate system it also takes care of step
  29    * difference between coordinate systems
  30    */
  31   MapList map = null;
  32
  33   /**
  34    * The seuqence that map maps the associated seuqence to (if any).
  35    */
  36   SequenceI to = null;
  37
  38   public Mapping(MapList map)
  39   {
  40     super();
  41     this.map = map;
  42   }
  43
  44   public Mapping(SequenceI to, MapList map)
  45   {
  46     this(map);
  47     this.to = to;
  48   }
  49
  50   /**
  51    * create a new mapping from
  52    *
  53    * @param to
  54    *          the sequence being mapped
  55    * @param exon
  56    *          int[] {start,end,start,end} series on associated sequence
  57    * @param is
  58    *          int[] {start,end,...} ranges on the reference frame being mapped
  59    *          to
  60    * @param i
  61    *          step size on associated sequence
  62    * @param j
  63    *          step size on mapped frame
  64    */
  65   public Mapping(SequenceI to, int[] exon, int[] is, int i, int j)
  66   {
  67     this(to, new MapList(exon, is, i, j));
  68   }
  69
  70   /**
  71    * create a duplicate (and independent) mapping object with the same reference
  72    * to any SequenceI being mapped to.
  73    *
  74    * @param map2
  75    */
  76   public Mapping(Mapping map2)
  77   {
  78     if (map2 != this && map2 != null)
  79     {
  80       if (map2.map != null)
  81       {
  82         map = new MapList(map2.map);
  83       }
  84       to = map2.to;
  85     }
  86   }
  87
  88   /**
  89    * @return the map
  90    */
  91   public MapList getMap()
  92   {
  93     return map;
  94   }
  95
  96   /**
  97    * @param map
  98    *          the map to set
  99    */
 100   public void setMap(MapList map)
 101   {
 102     this.map = map;
 103   }
 104
 105   /**
 106    * Equals that compares both the to references and MapList mappings.
 107    *
 108    * @param other
 109    * @return
 110    */
 111   public boolean equals(Mapping other)
 112   {
 113     if (other == null)
 114       return false;
 115     if (other == this)
 116       return true;
 117     if (other.to != to)
 118       return false;
 119     if ((map != null && other.map == null)
 120             || (map == null && other.map != null))
 121       return false;
 122     if (map.equals(other.map))
 123       return true;
 124     return false;
 125   }
 126
 127   /**
 128    * get the 'initial' position in the associated sequence for a position in the
 129    * mapped reference frame
 130    *
 131    * @param mpos
 132    * @return
 133    */
 134   public int getPosition(int mpos)
 135   {
 136     if (map != null)
 137     {
 138       int[] mp = map.shiftTo(mpos);
 139       if (mp != null)
 140       {
 141         return mp[0];
 142       }
 143     }
 144     return mpos;
 145   }
 146
 147   /**
 148    * gets boundary in direction of mapping
 149    *
 150    * @param position
 151    *          in mapped reference frame
 152    * @return int{start, end} positions in associated sequence (in direction of
 153    *         mapped word)
 154    */
 155   public int[] getWord(int mpos)
 156   {
 157     if (map != null)
 158     {
 159       return map.getToWord(mpos);
 160     }
 161     return null;
 162   }
 163
 164   /**
 165    * width of mapped unit in associated sequence
 166    *
 167    */
 168   public int getWidth()
 169   {
 170     if (map != null)
 171     {
 172       return map.getFromRatio();
 173     }
 174     return 1;
 175   }
 176
 177   /**
 178    * width of unit in mapped reference frame
 179    *
 180    * @return
 181    */
 182   public int getMappedWidth()
 183   {
 184     if (map != null)
 185     {
 186       return map.getToRatio();
 187     }
 188     return 1;
 189   }
 190
 191   /**
 192    * get mapped position in the associated reference frame for position pos in
 193    * the associated sequence.
 194    *
 195    * @param pos
 196    * @return
 197    */
 198   public int getMappedPosition(int pos)
 199   {
 200     if (map != null)
 201     {
 202       int[] mp = map.shiftFrom(pos);
 203       if (mp != null)
 204       {
 205         return mp[0];
 206       }
 207     }
 208     return pos;
 209   }
 210
 211   public int[] getMappedWord(int pos)
 212   {
 213     if (map != null)
 214     {
 215       int[] mp = map.shiftFrom(pos);
 216       if (mp != null)
 217       {
 218         return new int[]
 219         { mp[0], mp[0] + mp[2] * (map.getToRatio() - 1) };
 220       }
 221     }
 222     return null;
 223   }
 224
 225   /**
 226    * locates the region of feature f in the associated sequence's reference
 227    * frame
 228    *
 229    * @param f
 230    * @return one or more features corresponding to f
 231    */
 232   public SequenceFeature[] locateFeature(SequenceFeature f)
 233   {
 234     if (true)
 235     { // f.getBegin()!=f.getEnd()) {
 236       if (map != null)
 237       {
 238         int[] frange = map.locateInFrom(f.getBegin(), f.getEnd());
 239         if (frange == null)
 240         {
 241           // JBPNote - this isprobably not the right thing to doJBPHack
 242           return null;
 243         }
 244         SequenceFeature[] vf = new SequenceFeature[frange.length / 2];
 245         for (int i = 0, v = 0; i < frange.length; i += 2, v++)
 246         {
 247           vf[v] = new SequenceFeature(f);
 248           vf[v].setBegin(frange[i]);
 249           vf[v].setEnd(frange[i + 1]);
 250           if (frange.length > 2)
 251             vf[v].setDescription(f.getDescription() + "\nPart " + (v + 1));
 252         }
 253         return vf;
 254       }
 255     }
 256     if (false) // else
 257     {
 258       int[] word = getWord(f.getBegin());
 259       if (word[0] < word[1])
 260       {
 261         f.setBegin(word[0]);
 262       }
 263       else
 264       {
 265         f.setBegin(word[1]);
 266       }
 267       word = getWord(f.getEnd());
 268       if (word[0] > word[1])
 269       {
 270         f.setEnd(word[0]);
 271       }
 272       else
 273       {
 274         f.setEnd(word[1]);
 275       }
 276     }
 277     // give up and just return the feature.
 278     return new SequenceFeature[]
 279     { f };
 280   }
 281
 282   /**
 283    * return a series of contigs on the associated sequence corresponding to the
 284    * from,to interval on the mapped reference frame
 285    *
 286    * @param from
 287    * @param to
 288    * @return int[] { from_i, to_i for i=1 to n contiguous regions in the
 289    *         associated sequence}
 290    */
 291   public int[] locateRange(int from, int to)
 292   {
 293     if (map != null)
 294     {
 295       if (from <= to)
 296       {
 297         from = (map.getToLowest() < from) ? from : map.getToLowest();
 298         to = (map.getToHighest() > to) ? to : map.getToHighest();
 299         if (from > to)
 300           return null;
 301       }
 302       else
 303       {
 304         from = (map.getToHighest() > from) ? from : map.getToHighest();
 305         to = (map.getToLowest() < to) ? to : map.getToLowest();
 306         if (from < to)
 307           return null;
 308       }
 309       return map.locateInFrom(from, to);
 310     }
 311     return new int[]
 312     { from, to };
 313   }
 314
 315   /**
 316    * return a series of mapped contigs mapped from a range on the associated
 317    * sequence
 318    *
 319    * @param from
 320    * @param to
 321    * @return
 322    */
 323   public int[] locateMappedRange(int from, int to)
 324   {
 325     if (map != null)
 326     {
 327
 328       if (from <= to)
 329       {
 330         from = (map.getFromLowest() < from) ? from : map.getFromLowest();
 331         to = (map.getFromHighest() > to) ? to : map.getFromHighest();
 332         if (from > to)
 333           return null;
 334       }
 335       else
 336       {
 337         from = (map.getFromHighest() > from) ? from : map.getFromHighest();
 338         to = (map.getFromLowest() < to) ? to : map.getFromLowest();
 339         if (from < to)
 340           return null;
 341       }
 342       return map.locateInTo(from, to);
 343     }
 344     return new int[]
 345     { from, to };
 346   }
 347
 348   /**
 349    * return a new mapping object with a maplist modifed to only map the visible
 350    * regions defined by viscontigs.
 351    *
 352    * @param viscontigs
 353    * @return
 354    */
 355   public Mapping intersectVisContigs(int[] viscontigs)
 356   {
 357     Mapping copy = new Mapping(this);
 358     if (map != null)
 359     {
 360       int vpos = 0;
 361       int apos = 0;
 362       Vector toRange = new Vector();
 363       Vector fromRange = new Vector();
 364       for (int vc = 0; vc < viscontigs.length; vc += 2)
 365       {
 366         // find a mapped range in this visible region
 367         int[] mpr = locateMappedRange(1 + viscontigs[vc],
 368                 viscontigs[vc + 1] - 1);
 369         if (mpr != null)
 370         {
 371           for (int m = 0; m < mpr.length; m += 2)
 372           {
 373             toRange.addElement(new int[]
 374             { mpr[m], mpr[m + 1] });
 375             int[] xpos = locateRange(mpr[m], mpr[m + 1]);
 376             for (int x = 0; x < xpos.length; x += 2)
 377             {
 378               fromRange.addElement(new int[]
 379               { xpos[x], xpos[x + 1] });
 380             }
 381           }
 382         }
 383       }
 384       int[] from = new int[fromRange.size() * 2];
 385       int[] to = new int[toRange.size() * 2];
 386       int[] r;
 387       for (int f = 0, fSize = fromRange.size(); f < fSize; f++)
 388       {
 389         r = (int[]) fromRange.elementAt(f);
 390         from[f * 2] = r[0];
 391         from[f * 2 + 1] = r[1];
 392       }
 393       for (int f = 0, fSize = toRange.size(); f < fSize; f++)
 394       {
 395         r = (int[]) toRange.elementAt(f);
 396         to[f * 2] = r[0];
 397         to[f * 2 + 1] = r[1];
 398       }
 399       copy.setMap(new MapList(from, to, map.getFromRatio(), map
 400               .getToRatio()));
 401     }
 402     return copy;
 403   }
 404
 405   public static void main(String[] args)
 406   {
 407     /**
 408      * trite test of the intersectVisContigs method for a simple DNA -> Protein
 409      * exon map and a range of visContigs
 410      */
 411     MapList fk = new MapList(new int[]
 412     { 1, 6, 8, 13, 15, 23 }, new int[]
 413     { 1, 7 }, 3, 1);
 414     Mapping m = new Mapping(fk);
 415     Mapping m_1 = m.intersectVisContigs(new int[]
 416     { fk.getFromLowest(), fk.getFromHighest() });
 417     Mapping m_2 = m.intersectVisContigs(new int[]
 418     { 1, 7, 11, 20 });
 419     System.out.println("" + m_1.map.getFromRanges());
 420
 421   }
 422
 423   /**
 424    * get the sequence being mapped to - if any
 425    *
 426    * @return null or a dataset sequence
 427    */
 428   public SequenceI getTo()
 429   {
 430     return to;
 431   }
 432
 433   /**
 434    * set the dataset sequence being mapped to if any
 435    *
 436    * @param tto
 437    */
 438   public void setTo(SequenceI tto)
 439   {
 440     to = tto;
 441   }
 442
 443   /*
 444    * (non-Javadoc)
 445    *
 446    * @see java.lang.Object#finalize()
 447    */
 448   protected void finalize() throws Throwable
 449   {
 450     map = null;
 451     to = null;
 452     super.finalize();
 453   }
 454
 455 }