simplexD2tessindexed.h

Go to the documentation of this file.

#ifndef SIMPLEXD2TESSINDEXED_H
#define SIMPLEXD2TESSINDEXED_H

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

#include <simplexD2indexed.h>
#include <tessD2misc.h>
#include <tokenizer.h>
#include <typedefs.h>
#include <vectorreadin.h>

/*
\brief A 2D tessellation of indexed triangles.

\par Serialization
\verbatim
number of points+1
0.0 0.0
x y 
...
number of triangles+1 
0 0
a b c
...
\endverbatim

*/
template< typename PT, typename PD, typename INDX >
class simplexD2tessindexed
{
public:

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

  simplexD2tessindexed();


  void construct
  ( 
    PD const * points,
    INDX const pointsize,
    INDX const * triangles,
    INDX const trianglessize
  );
    
  void windinganticlockwise();

  operator stringc () const;

  void serializeInverse(stringc & s);


};

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

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

  tokenizer tokenstream;
  tokenstream.readaslinesgeneral(s);

/*
  tokenstream.readaslines(s);
  tokenstream.subtract(",");
  tokenstream.subtract(" ");

//  tokenstream.printdelimiter="*";
//  cout << tokenstream << endl;

//  cout << endl << endl;

  // Remove leading and trailing space.
  tokenstream.trim();
  // Delete empty tokens.
  tokenstream.remove_if();

//cout << tokenstream << endl;
*/



  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,c;
  for (uint i=0; i<visize; ++i)
  {
    stringstream(tokenstream()) >> a;
    ++tokenstream;
    stringstream(tokenstream()) >> b;
    ++tokenstream;
    stringstream(tokenstream()) >> c;
    ++tokenstream;
//cout << "a=" << a << " b=" << b << " c=" << c << endl;

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

}



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

template< typename PT, typename PD, typename INDX >
simplexD2tessindexed<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 simplexD2tessindexed<PT,PD,INDX>::construct
( 
  PD const * points,
  INDX const pointsize,
  INDX const * triangles,
  INDX const trianglessize
)
{
  vectorreadingD2(pts,points,pointsize);
  vectorreadingD3(vi,triangles,trianglessize);
}


template< typename PT, typename PD, typename INDX >
void simplexD2tessindexed<PT,PD,INDX>::windinganticlockwise()
{
  tessD2misc
  <
    simplexD2tessindexed<PT,PD,INDX>,
    PT,
    INDX 
  > tm(*this);
  tm.windinganticlockwise();
}


#endif