vcsl_scale.cxx

Go to the documentation of this file.

// This is core/vcsl/vcsl_scale.cxx
#include "vcsl_scale.h"
#include <cassert>
#ifdef _MSC_VER
#  include <vcl_msvc_warnings.h>
#endif

//---------------------------------------------------------------------------
// Is `this' invertible at time `time'?
// REQUIRE: valid_time(time)
//---------------------------------------------------------------------------
bool vcsl_scale::is_invertible(double time) const
{
  // require
  assert(valid_time(time));

  return ((this->duration()==0)&&(scale_[0]!=0.0))||(scale_value(time)!=0.0);
}

//---------------------------------------------------------------------------
// Set the scale value of a static scale
//---------------------------------------------------------------------------
void vcsl_scale::set_static(double new_scale)
{
  scale_.clear();
  scale_.push_back(new_scale);
  vcsl_spatial_transformation::set_static();
}

//---------------------------------------------------------------------------
// Image of `v' by `this'
// REQUIRE: is_valid()
//---------------------------------------------------------------------------
vnl_vector<double> vcsl_scale::execute(const vnl_vector<double> &v,
                                       double time) const
{
  // require
  assert(is_valid());

  double value=scale_value(time);
  vnl_vector<double> result(v.size());
  for (unsigned int i=0;i<v.size();++i)
    result.put(i,value*v.get(i));

  return result;
}

//---------------------------------------------------------------------------
// Image of `v' by the inverse of `this'
// REQUIRE: is_valid()
// REQUIRE: is_invertible(time)
//---------------------------------------------------------------------------
vnl_vector<double> vcsl_scale::inverse(const vnl_vector<double> &v,
                                       double time) const
{
  // require
  assert(is_valid());
  assert(is_invertible(time));

  double value=scale_value(time);
  vnl_vector<double> result(v.size());
  for (unsigned int i=0;i<v.size();++i)
    result.put(i,v.get(i)/value);

  return result;
}

//---------------------------------------------------------------------------
// Compute the value of the parameter at time `time'
//---------------------------------------------------------------------------
double vcsl_scale::scale_value(double time) const
{
  if (this->duration()==0) // static
    return scale_[0];
  else
  {
    int i=matching_interval(time);
    switch (interpolator_[i])
    {
     case vcsl_linear:
      return lsi(scale_[i],scale_[i+1],i,time);
     case vcsl_cubic:
      assert(!"vcsl_cubic net yet implemented");
      break;
     case vcsl_spline:
      assert(!"vcsl_spline net yet implemented");
      break;
     default:
      assert(!"This is impossible");
      break;
    }
  }
  return 0.0; // never reached if asserts are in effect
}