datastore.C

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include <tumble-conf.h>
#endif /* HAVE_CONFIG_H */

#include "globals.h"
#include "datastore.h"


DataStore::DataStore(PersistantStore& store)
  : data_hash(store), control_points(store), data_points(store) 
{ }

ControlPoint DataStore::add_cp(const Point2D &p)
{
    control_points.push_front(p);
    return control_points.begin();
}

void DataStore::rem_cp(ControlPoint cp)
{
    control_points.erase(cp);
}

DataPoint DataStore::add_dp(ControlPoint cp, const LinearData &d)
{
    DataPoint dp;
    data_points.push_front(d);
    dp = data_points.begin();
    data_hash[cp] = dp;
    return dp;
}

void DataStore::rem_dp(ControlPoint cp, DataPoint dp)
{
    data_points.erase(dp);
    data_hash.erase(cp);
}


void DataStore::replace_cp(const ControlPoint& old_cp,
                           const ControlPoint& new_cp)
{
  Data_Hash_T::iterator data = data_hash.find(old_cp);

  if(data != data_hash.end()){
    assert(!has_data(new_cp));
    DataPoint dp = (*data).second;
    data_hash.erase(data);
    data_hash[new_cp] = dp;
  }
  rem_cp(old_cp);
}

void DataStore::replace_dp(const ControlPoint& cp, const LinearData &new_ld)
{
  rem_dp(cp, get_data(cp));
  add_dp(cp, new_ld);
}

/***************************************************************************
  Data access.
 ***************************************************************************/
DataPoint DataStore::get_data(const ControlPoint& cp) const
{
  Data_Hash_T::const_iterator data = data_hash.find(cp);
  assert(data != data_hash.end());
  return (*data).second;
}

bool DataStore::has_data(const ControlPoint& cp) const
{
  return (data_hash.count(cp) != 0);
}

unsigned DataStore::num_control_points() const 
{
  return control_points.size();
}

unsigned DataStore::num_data_points() const 
{
  return data_points.size();
}

unsigned DataStore::data_length() const 
{
  return data_points.begin()->length;
}


/* EXPENSIVE Function */

void DataStore::add_channels(unsigned num_new_channels)
{
  unsigned old_length = data_length();
  unsigned new_length = num_new_channels+old_length;

  ControlPoint cp;
  for (cp = control_points.begin(); cp != control_points.end() ; cp++ )
    {
      DataPoint dp_old = get_data(cp);
      LinearData ld_new(new_length);
      for (unsigned i = 0; i < old_length; i++)
    {
      ld_new.set( dp_old->get(i), i);
    }
      replace_dp(cp, ld_new);
    }
}





/***************************************************************************
   Channel swapping in the Data and Geometry Vectors
 ***************************************************************************/

void DataStore::write_geo_into(unsigned indexX, unsigned indexY)
{
  assert(indexX < data_length());
  assert(indexY < data_length());

  ControlPoint cp;
  for (cp = control_points.begin(); cp != control_points.end() ; cp++ )
    {
      DataPoint dp = get_data(cp);
      dp->set(cp->x() , indexX);
      dp->set(cp->y() , indexY);
    }
}


void DataStore::read_geo_from(unsigned indexX, unsigned indexY)
{
  assert(indexX < data_length());
  assert(indexY < data_length());

  ControlPoint cp;
  DataPoint dp;
  for (cp = control_points.begin(); cp != control_points.end() ; cp++ )
    {
      dp = get_data(cp);
      cp->assign( dp->get(indexX), dp->get(indexY) );
    }
}

void DataStore::swap_geo_with(unsigned indexX, unsigned indexY)
{
  assert(indexX < data_length());
  assert(indexY < data_length());

  ControlPoint cp;
  DataPoint dp;
  double tempX, tempY;
  for (cp = control_points.begin(); cp != control_points.end() ; cp++ )
    {
      dp = get_data(cp);
      tempX = cp->x();
      tempY = cp->y();
      cp->assign( dp->get(indexX), dp->get(indexY) );
      dp->set(tempX,indexX);
      dp->set(tempY,indexY);
    }
}


void DataStore::copy_data(unsigned indexFrom, unsigned indexTo)
{
  assert(indexFrom < data_length());
  assert(indexTo < data_length());

  for (DataPoint dp = data_points.begin(); dp != data_points.end() ; dp++ )
    {
      dp->set( dp->get(indexFrom), indexTo );
    }
}

void DataStore::copy_data_2(unsigned indexAx, unsigned indexAy, unsigned indexBx, unsigned indexBy)
{
  assert(indexAx < data_length());
  assert(indexAy < data_length());
  assert(indexBx < data_length());
  assert(indexBy < data_length());

  for (DataPoint dp = data_points.begin(); dp != data_points.end() ; dp++ )
    {
      dp->set( dp->get(indexAx), indexBx );
      dp->set( dp->get(indexAy), indexBy );
    }
}

void DataStore::swap_data(unsigned indexA, unsigned indexB)
{
  assert(indexA < data_length());
  assert(indexB < data_length());

  double temp;
  for (DataPoint dp = data_points.begin(); dp != data_points.end() ; dp++ )
    {
      temp = dp -> get(indexB);
      dp->set( dp->get(indexA), indexB );
      dp->set( temp, indexA );
    }
}

void DataStore::swap_data_2(unsigned indexAx, unsigned indexAy, unsigned indexBx, unsigned indexBy)
{
  assert(indexAx < data_length());
  assert(indexAy < data_length());
  assert(indexBx < data_length());
  assert(indexBy < data_length());

  double tempX, tempY;
  for (DataPoint dp = data_points.begin(); dp != data_points.end() ; dp++ )
    {
      tempX = dp -> get(indexBx);
      tempY = dp -> get(indexBy);
      dp->set( dp->get(indexAx), indexBx );
      dp->set( dp->get(indexAy), indexBy );
      dp->set( tempX, indexAx );
      dp->set( tempY, indexAy );
    }
}




/***************************************************************************
  Printing.
 ***************************************************************************/

void DataStore::print() const
{
    std::cout<<*this;
}

std::ostream& operator<<(std::ostream &stream, const DataStore &ds)
{
    stream << "DataStore: " << std::endl;
    stream << " ---control points: " << ds.control_points.size() << std::endl;
    stream << " ---data points:    " << ds.data_points.size() << std::endl;
    stream << " ---data hash size: " << ds.data_hash.size() << std::endl;
    return stream;
}

---