simplexD1tessindexed.h

Go to the documentation of this file.

#ifndef SIMPLEXD1TESSINDEXED_H
#define SIMPLEXD1TESSINDEXED_H


#include <vector>
#include <sstream>
using namespace std;

#include <print.h>
#include <simplexD1indexed.h>
#include <tokenizer.h>
#include <typedefs.h>
#include <vectorreadin.h>

template< typename PT, typename PD, typename INDX > 
class simplexD1tessindexed
{
public:

  vector< PT > pts;
  vector< simplexD1indexed<INDX> > vi;

  simplexD1tessindexed();

  void construct
  ( 
    PD const * points,
    INDX const pointsize,
    INDX const * lines,
    INDX const linessize
  );
    
  operator stringc () const;

  void serializeInverse(stringc & s);

  boolc operator == (simplexD1tessindexed<PT,PD,INDX> const & s2 ) const
  {
//cout << "Tesing sizes" << endl;
//cout << SHOW(pts.size()) << endl;
//cout << SHOW(s2.pts.size()) << endl;
    if (pts.size()!=s2.pts.size())
      return false;

    if (vi.size()!=s2.vi.size())
      return false;

//cout << "Checking points" << endl;
    for (uint i=0; i<pts.size(); ++i)
    {
      if (pts[i]!=s2.pts[i])
        return false;
    }
//cout << "Checking indexes" << endl;
    for (uint i=0; i<vi.size(); ++i)
    {
      if (!(vi[i]==s2.vi[i]))
        return false;
    }
 
    return true;
  }






};


//---------------------------------------------------------
// Implementation

template< typename PT, typename PD, typename INDX >
simplexD1tessindexed<PT,PD,INDX>::simplexD1tessindexed()
{
  pts.push_back(PT());
  vi.push_back( simplexD1indexed<INDX>() );
}


template< typename PT, typename PD, typename INDX > 
void simplexD1tessindexed<PT,PD,INDX>::serializeInverse(stringc & s)
{
  pts.clear();
  vi.clear();

  tokenizer tokenstream;
  tokenstream.readaslinesgeneral(s);

  tokenstream.reset();
  uint ptssize;
  stringstream(tokenstream()) >> ptssize;
  ++tokenstream;
//cout << "ptssize=" << ptssize << endl;

  PD x,y;
  for (uint i=0; i<ptssize; ++i)
  {
    stringstream(tokenstream()) >> x;
    ++tokenstream;
    stringstream(tokenstream()) >> y;
    ++tokenstream;
//cout << "x=" << x << " y=" << y << endl;
    pts.push_back( PT(x,y) );
  }

  uint visize;
  stringstream(tokenstream()) >> visize;
  ++tokenstream;
//cout << "visize=" << visize << endl;
  INDX a,b;
  for (uint i=0; i<visize; ++i)
  {
    stringstream(tokenstream()) >> a;
    ++tokenstream;
    stringstream(tokenstream()) >> b;
    ++tokenstream;
//cout << "a=" << a << " b=" << b << " c=" << c << endl;

    vi.push_back( simplexD1indexed<INDX>(a,b) );
  }

}


template< typename PT, typename PD, typename INDX >
simplexD1tessindexed<PT,PD,INDX>::operator stringc () const
{
  stringstream ss;
  
  uint imax = pts.size();
  ss << imax << "\n";
  for (uint i=0; i<imax; ++i)
    ss << pts[i] << "\n";
  imax = vi.size();
  ss << imax << "\n";
  for (uint i=0; i<imax; ++i)
    ss << vi[i] << "\n";

  return ss.str();
}


template< typename PT, typename PD, typename INDX >
void simplexD1tessindexed<PT,PD,INDX>::construct
( 
  PD const * points,
  INDX const pointsize,
  INDX const * lines,
  INDX const linessize
)
{
  vectorreadingD2(pts,points,pointsize);
  vectorreadingD2(vi,lines,linessize);
}








#endif