simplexD1listlinked.h

Go to the documentation of this file.

#ifndef SIMPLEXD1LISTLINKED_H
#define SIMPLEXD1LISTLINKED_H


#include <cassert>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

#include <typedefs.h>
#include <point.h>
#include <print.h>
#include <tokenizer.h>

template< typename VI, typename INDX > 
class simplexD1listlinked
{
public:

  VI vi;

  INDX length;

  simplexD1listlinked(VI vi_, INDX length_)
    : vi(vi_), length(length_) {}

  template< typename T >
  void readindexed( T const * beg );

  operator stringc () const;

  boolc serializeInverse(stringc & s);

  void makelinks(INDX const pointsmaxindex);

  void consistantwinding();
};


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


template< typename VI, typename INDX >
void simplexD1listlinked<VI,INDX>::consistantwinding()
{
  INDX w=1;
  INDX t;
  for (INDX i=1; i<=length; ++i)
  {
    t=vi[w].ni[0];
    if (vi[t].piInverse( vi[w].pi[1] ) != 0 )
      vi[t].togglelinedirection();
    w = t;
  }
}

template< typename VI, typename INDX >
void simplexD1listlinked<VI,INDX>::makelinks(INDX const pointsmaxindex)
{
  // Build a table of points to simplexes
  point2<INDX> pts[pointsmaxindex+1];

  INDX a;
  INDX b;

  for (INDX i=0; i<length; ++i)
  {
    a = vi[i].pi[0];
    b = vi[i].pi[1];
    if (pts[a].x == 0)
      pts[a].x = i;
    else
      pts[a].y = i;
    if (pts[b].x == 0)
      pts[b].x = i;
    else
      pts[b].y = i;
  }

//cout << "Points to Simplexes table" << endl;
//for (INDX k=1; k<pointsmaxindex+1; ++k)
//{
//  cout << k << ": " << pts[k] << endl;
//}

  INDX s1;
  INDX s2;
  INDX w;
  for (INDX k=1; k<pointsmaxindex+1; ++k)
  {
    s1 = pts[k].x;
    s2 = pts[k].y;
    if (s1==0)
      continue;
    if (s2==0)
      continue;

    // Link the two lines.

    w = ((vi[s2].piInverse(k))+1)%2;
    vi[s2].ni[ w ] = s1;

    w = ((vi[s1].piInverse(k))+1)%2;
    vi[s1].ni[ w ] = s2;
  }
}

template< typename VI, typename INDX >
boolc simplexD1listlinked<VI,INDX>::serializeInverse(stringc & s)
{
  tokenizer tokenstream;
  tokenstream.readaslinesgeneral(s);

  INDX mylength;
  tokenstream.reset();
  stringstream(tokenstream()) >> mylength;
  ++tokenstream;
  assert(mylength==length);
  if (mylength!=length)
    return false;

//cout << SHOW(s) << endl;

  for (INDX i=0; i<length; ++i)
  {
    string z(tokenstream());
    ++tokenstream;
    z += (" " + tokenstream());
    ++tokenstream;
    z += (" " + tokenstream());
    ++tokenstream;
    z += (" " + tokenstream());
    ++tokenstream;
//cout << SHOW(z) << endl;
    vi[i].serializeInverse(z);
  }

  return true;
}

template< typename VI, typename INDX >
template< typename T >
void simplexD1listlinked<VI,INDX>::readindexed( T const * beg )
{
  T const * x = beg;

  for (INDX i=0; i<length; ++i)
  {
    vi[i].construct(*x,*(x+1));
    ++x; ++x;
//cout << SHOW(i) << endl;
  }
}

template< typename VI, typename INDX >
simplexD1listlinked<VI,INDX>::operator stringc () const
{
  stringstream ss;
  ss << length << "\n";
  INDX i=0;
  for ( ; i<length; ++i )
  {
    ss << (string)vi[i] << "\n";
  }

  return ss.str();
}




#endif