lumiera_/src/lib/time/quantiser.cpp

/*
  Quantiser  -  aligning time values to a time grid

  Copyright (C)         Lumiera.org
    2010,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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 2 of
  the License, or (at your option) any later version.

  This program 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 this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

* *****************************************************/


#include "lib/time/quantiser.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/time/timequant.hpp"
#include "lib/time.h"

#include <boost/rational.hpp>

using boost::rational_cast;
using std::string;


namespace error = lumiera::error;

namespace lib {
namespace time {
  
  
  namespace { // implementation helpers...
    
    template<typename NUM>
    inline NUM
    __ensure_notZero (NUM n)
    {
      if (!n)
        throw error::Logic ("Impossible to quantise to an zero spaced grid"
                           , error::LUMIERA_ERROR_BOTTOM_VALUE);
      return n;
    }
    
  }//(End) implementation helpers
  
  
  
  Quantiser::~Quantiser() { } // hint to emit the VTable here...
  
  
  /** */
  QuTime::QuTime (TimeValue raw, Symbol gridID)
    : Time(raw)          /////////////////////////////////////////////////TODO fetch quantiser
    { }
  
  
  /** */
  QuTime::QuTime (TimeValue raw, Quantiser const& quantisation_to_use)
    : Time(raw)          /////////////////////////////////////////////////TODO fetch quantiser
    { }
  
  
  
  /** Create a quantiser based on a fixed constant spaced grid, rooted at the reference point
   *  as origin of the scale. Quantisation then means to determine the grid interval containing
   *  a given raw time value. Here, the grid interval number zero \em starts at the origin;
   *  each interval includes its lower bound and excludes its upper bound.*/
  FixedFrameQuantiser::FixedFrameQuantiser (FrameRate const& frames_per_second, TimeValue referencePoint)
    : origin_(referencePoint)
    , raster_(frames_per_second.duration())
    { }
  
  
  
  /** alignment to a simple fixed size grid.
   *  The actual calculation first determines the number
   *  of the grid interval containing the given rawTime,
   *  then followed by multiplying this interval number
   *  with the grid spacing.
   * @return time of the start point of the grid interval
   *      containing the rawTime, relative to the origin
   *      of the time scale used by this quantiser.
   * @warning returned time values are limited by the
   *      range of an 64bit integer  
   * @see #lumiera_quantise_time
   */
  TimeValue
  FixedFrameQuantiser::gridAlign (TimeValue const& rawTime)
  {
    return TimeValue (lumiera_quantise_time (_raw(rawTime), _raw(origin_), _raw(raster_)));
  }
  
  
  
  LUMIERA_ERROR_DEFINE (UNKNOWN_GRID, "referring to an undefined grid or scale in value quantisation");
  
  
  
}} // lib::time