src/jalview/io/vamsas/Rangetype.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   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
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.io.vamsas;
  22
  23 import jalview.io.VamsasAppDatastore;
  24 import jalview.util.MessageManager;
  25
  26 import java.util.List;
  27 import java.util.Vector;
  28
  29 import uk.ac.vamsas.client.Vobject;
  30 import uk.ac.vamsas.objects.core.Local;
  31 import uk.ac.vamsas.objects.core.MapType;
  32 import uk.ac.vamsas.objects.core.Mapped;
  33 import uk.ac.vamsas.objects.core.RangeType;
  34 import uk.ac.vamsas.objects.core.Seg;
  35
  36 /**
  37  * Enhances DatastoreItem objects with additional functions to do with RangeType
  38  * objects
  39  *
  40  * @author JimP
  41  *
  42  */
  43 public abstract class Rangetype extends DatastoreItem
  44 {
  45
  46   public Rangetype()
  47   {
  48     super();
  49   }
  50
  51   public Rangetype(VamsasAppDatastore datastore)
  52   {
  53     super(datastore);
  54   }
  55
  56   public Rangetype(VamsasAppDatastore datastore, Vobject vobj, Class jvClass)
  57   {
  58     super(datastore, vobj, jvClass);
  59   }
  60
  61   public Rangetype(VamsasAppDatastore datastore, Object jvobj, Class vClass)
  62   {
  63     super(datastore, jvobj, vClass);
  64   }
  65
  66   /**
  67    * get real bounds of a RangeType's specification. start and end are an
  68    * inclusive range within which all segments and positions lie. TODO: refactor
  69    * to vamsas utils
  70    *
  71    * @param dseta
  72    * @return int[] { start, end}
  73    */
  74   protected int[] getBounds(RangeType dseta)
  75   {
  76     if (dseta != null)
  77     {
  78       int[] se = null;
  79       if (dseta.getSegCount() > 0 && dseta.getPosCount() > 0)
  80       {
  81         throw new Error(
  82                 MessageManager
  83                         .getString("error.invalid_vamsas_rangetype_cannot_resolve_lists"));
  84       }
  85       if (dseta.getSegCount() > 0)
  86       {
  87         se = getSegRange(dseta.getSeg(0), true);
  88         for (int s = 1, sSize = dseta.getSegCount(); s < sSize; s++)
  89         {
  90           int nse[] = getSegRange(dseta.getSeg(s), true);
  91           if (se[0] > nse[0])
  92           {
  93             se[0] = nse[0];
  94           }
  95           if (se[1] < nse[1])
  96           {
  97             se[1] = nse[1];
  98           }
  99         }
 100       }
 101       if (dseta.getPosCount() > 0)
 102       {
 103         // could do a polarity for pos range too. and pass back indication of
 104         // discontinuities.
 105         int pos = dseta.getPos(0).getI();
 106         se = new int[] { pos, pos };
 107         for (int p = 0, pSize = dseta.getPosCount(); p < pSize; p++)
 108         {
 109           pos = dseta.getPos(p).getI();
 110           if (se[0] > pos)
 111           {
 112             se[0] = pos;
 113           }
 114           if (se[1] < pos)
 115           {
 116             se[1] = pos;
 117           }
 118         }
 119       }
 120       return se;
 121     }
 122     return null;
 123   }
 124
 125   /**
 126    * map from a rangeType's internal frame to the referenced object's coordinate
 127    * frame.
 128    *
 129    * @param dseta
 130    * @return int [] { ref(pos)...} for all pos in rangeType's frame.
 131    */
 132   protected int[] getMapping(RangeType dseta)
 133   {
 134     Vector posList = new Vector();
 135     if (dseta != null)
 136     {
 137       int[] se = null;
 138       if (dseta.getSegCount() > 0 && dseta.getPosCount() > 0)
 139       {
 140         throw new Error(
 141                 MessageManager
 142                         .getString("error.invalid_vamsas_rangetype_cannot_resolve_lists"));
 143       }
 144       if (dseta.getSegCount() > 0)
 145       {
 146         for (int s = 0, sSize = dseta.getSegCount(); s < sSize; s++)
 147         {
 148           se = getSegRange(dseta.getSeg(s), false);
 149           int se_end = se[1 - se[2]] + (se[2] == 0 ? 1 : -1);
 150           for (int p = se[se[2]]; p != se_end; p += se[2] == 0 ? 1 : -1)
 151           {
 152             posList.add(new Integer(p));
 153           }
 154         }
 155       }
 156       else if (dseta.getPosCount() > 0)
 157       {
 158         int pos = dseta.getPos(0).getI();
 159
 160         for (int p = 0, pSize = dseta.getPosCount(); p < pSize; p++)
 161         {
 162           pos = dseta.getPos(p).getI();
 163           posList.add(new Integer(pos));
 164         }
 165       }
 166     }
 167     if (posList != null && posList.size() > 0)
 168     {
 169       int[] range = new int[posList.size()];
 170       for (int i = 0; i < range.length; i++)
 171       {
 172         range[i] = ((Integer) posList.elementAt(i)).intValue();
 173       }
 174       posList.clear();
 175       return range;
 176     }
 177     return null;
 178   }
 179
 180   protected int[] getIntervals(RangeType range)
 181   {
 182     int[] intervals = null;
 183     Vector posList = new Vector();
 184     if (range != null)
 185     {
 186       int[] se = null;
 187       if (range.getSegCount() > 0 && range.getPosCount() > 0)
 188       {
 189         throw new Error(
 190                 MessageManager
 191                         .getString("error.invalid_vamsas_rangetype_cannot_resolve_lists"));
 192       }
 193       if (range.getSegCount() > 0)
 194       {
 195         for (int s = 0, sSize = range.getSegCount(); s < sSize; s++)
 196         {
 197           se = getSegRange(range.getSeg(s), false);
 198           posList.addElement(new Integer(se[0]));
 199           posList.addElement(new Integer(se[1]));
 200         }
 201       }
 202       else if (range.getPosCount() > 0)
 203       {
 204         int pos = range.getPos(0).getI();
 205
 206         for (int p = 0, pSize = range.getPosCount(); p < pSize; p++)
 207         {
 208           pos = range.getPos(p).getI();
 209           posList.add(new Integer(pos));
 210           posList.add(new Integer(pos));
 211         }
 212       }
 213     }
 214     if (posList != null && posList.size() > 0)
 215     {
 216       intervals = new int[posList.size()];
 217       java.util.Enumeration e = posList.elements();
 218       int i = 0;
 219       while (e.hasMoreElements())
 220       {
 221         intervals[i++] = ((Integer) e.nextElement()).intValue();
 222       }
 223     }
 224     return intervals;
 225   }
 226
 227   /**
 228    * initialise a range type object from a set of start/end inclusive intervals
 229    *
 230    * @param mrt
 231    * @param ranges
 232    */
 233   protected void initRangeType(RangeType mrt, List<int[]> ranges)
 234   {
 235     for (int[] range : ranges)
 236     {
 237       Seg vSeg = new Seg();
 238       vSeg.setStart(range[0]);
 239       vSeg.setEnd(range[1]);
 240       vSeg.setInclusive(true);
 241       mrt.addSeg(vSeg);
 242     }
 243   }
 244
 245   /**
 246    *
 247    * @param maprange
 248    *          where the from range is the local mapped range, and the to range
 249    *          is the 'mapped' range in the MapRangeType
 250    * @param default unit for local
 251    * @param default unit for mapped
 252    * @return MapList
 253    */
 254   protected jalview.util.MapList parsemapType(MapType maprange, int localu,
 255           int mappedu)
 256   {
 257     jalview.util.MapList ml = null;
 258     int[] localRange = getIntervals(maprange.getLocal());
 259     int[] mappedRange = getIntervals(maprange.getMapped());
 260     long lu = maprange.getLocal().hasUnit() ? maprange.getLocal().getUnit()
 261             : localu;
 262     long mu = maprange.getMapped().hasUnit() ? maprange.getMapped()
 263             .getUnit() : mappedu;
 264     ml = new jalview.util.MapList(localRange, mappedRange, (int) lu,
 265             (int) mu);
 266     return ml;
 267   }
 268
 269   protected jalview.util.MapList parsemapType(MapType map)
 270   {
 271     if (!map.getLocal().hasUnit() || map.getMapped().hasUnit())
 272     {
 273       jalview.bin.Cache.log
 274               .warn("using default mapping length of 1:1 for map "
 275                       + (map.isRegistered() ? map.getVorbaId().toString()
 276                               : ("<no Id registered> " + map.toString())));
 277     }
 278     return parsemapType(map, 1, 1);
 279   }
 280
 281   /**
 282    * initialise a MapType object from a MapList object.
 283    *
 284    * @param maprange
 285    * @param ml
 286    * @param setUnits
 287    */
 288   protected void initMapType(MapType maprange, jalview.util.MapList ml,
 289           boolean setUnits)
 290   {
 291     initMapType(maprange, ml, setUnits, false);
 292   }
 293
 294   /**
 295    *
 296    * @param maprange
 297    * @param ml
 298    * @param setUnits
 299    * @param reverse
 300    *          - reverse MapList mapping for Local and Mapped ranges and units
 301    */
 302   protected void initMapType(MapType maprange, jalview.util.MapList ml,
 303           boolean setUnits, boolean reverse)
 304   {
 305     if (ml == null)
 306     {
 307       throw new Error(
 308               MessageManager
 309                       .getString("error.implementation_error_maplist_is_null"));
 310     }
 311     maprange.setLocal(new Local());
 312     maprange.setMapped(new Mapped());
 313     if (!reverse)
 314     {
 315       initRangeType(maprange.getLocal(), ml.getFromRanges());
 316       initRangeType(maprange.getMapped(), ml.getToRanges());
 317     }
 318     else
 319     {
 320       initRangeType(maprange.getLocal(), ml.getToRanges());
 321       initRangeType(maprange.getMapped(), ml.getFromRanges());
 322     }
 323     if (setUnits)
 324     {
 325       if (!reverse)
 326       {
 327         maprange.getLocal().setUnit(ml.getFromRatio());
 328         maprange.getMapped().setUnit(ml.getToRatio());
 329       }
 330       else
 331       {
 332         maprange.getLocal().setUnit(ml.getToRatio());
 333         maprange.getMapped().setUnit(ml.getFromRatio());
 334       }
 335       // TODO: and verify - raise an implementation fault notice if local/mapped
 336       // range % Local/Mapped Ratio != 0
 337       // if (uk.ac.vamsas.objects.utils.Range.getIntervals(range))
 338
 339     }
 340   }
 341
 342 }