simplexD1listlinked< VI, INDX > Class Template Reference

Implemented linked simplexes in 1D. More...

#include <simplexD1listlinked.h>

Collaboration diagram for simplexD1listlinked< VI, INDX >:

List of all members.

Public Member Functions
	simplexD1listlinked (VI vi_, INDX length_)
	Pass the array vi[] reference and length.
template<typename T >
void	readindexed (T const *beg)
	Read indexed lines.
	operator stringc () const
	Serialize this object.
boolc	serializeInverse (stringc &s)
	Read in/construct an object.
void	makelinks (INDX const pointsmaxindex)
	Assuming this is an indexed list of lines without links, an O(n) algorithm connects the lines.
void	consistantwinding ()
	Assuming this is a linked loop, it can be made either clockwise or anticlockise.
Public Attributes
VI	vi
	Assume vi[] of simplexD1linked<INDX>.
INDX	length
	Length of vi array.

---

Detailed Description

template<typename VI, typename INDX>
class simplexD1listlinked< VI, INDX >

Implemented linked simplexes in 1D.

See simpelxD1linked. The structure can be built from indexed simplexes, assuming one linked line which I will call a curve.

vi[0] is a dummy variable because 0 is used to indicate nothing.

Definition at line 25 of file simplexD1listlinked.h.

---

Constructor & Destructor Documentation

template<typename VI, typename INDX>

simplexD1listlinked< VI, INDX >::simplexD1listlinked	(	VI	vi_,
		INDX	length_
	)			[inline]

Pass the array vi[] reference and length.

Definition at line 36 of file simplexD1listlinked.h.

    : vi(vi_), length(length_) {}

---

Member Function Documentation

template<typename VI , typename INDX >

void simplexD1listlinked< VI, INDX >::consistantwinding

(

)

[inline]

Assuming this is a linked loop, it can be made either clockwise or anticlockise.

Follow the links and swap points as necessary: vi[i].pi[0] is not equal to vi[k].pi[0] when i!=k.

Definition at line 85 of file simplexD1listlinked.h.

References simplexD1listlinked< VI, INDX >::length, and simplexD1listlinked< VI, INDX >::vi.

Referenced by simplexD1listlinkedtest::test03().

{
  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

)

[inline]

Assuming this is an indexed list of lines without links, an O(n) algorithm connects the lines.

Definition at line 99 of file simplexD1listlinked.h.

References simplexD1listlinked< VI, INDX >::length, pts, simplexD1listlinked< VI, INDX >::vi, point2< T >::x, and point2< T >::y.

Referenced by simplexD1listlinkedtest::test03().

{
  // 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 >

simplexD1listlinked< VI, INDX >::operator stringc

(

)

const [inline]

Serialize this object.

Definition at line 197 of file simplexD1listlinked.h.

References simplexD1listlinked< VI, INDX >::length, and simplexD1listlinked< VI, INDX >::vi.

{
  stringstream ss;
  ss << length << "\n";
  INDX i=0;
  for ( ; i<length; ++i )
  {
    ss << (string)vi[i] << "\n";
  }

  return ss.str();
}

template<typename VI , typename INDX >

template<typename T >

void simplexD1listlinked< VI, INDX >::readindexed

(

T const *

beg

)

[inline]

Read indexed lines.

  typedef vector< simplexD1linked<uint> > vec;
  vec v2(8);
  simplexD1listlinked< vec &, uint > s1(v2,8);   
 
  uint v[] = 
  { 
    0, 0, 
    2, 6,
    7, 5,
    4, 1,
    5, 4,
    6, 1,
    3, 7,
    2, 3
  }; 
  s1.readindexed(v);

Definition at line 184 of file simplexD1listlinked.h.

References simplexD1listlinked< VI, INDX >::length, and simplexD1listlinked< VI, INDX >::vi.

Referenced by simplexD1listlinkedtest::test01(), simplexD1listlinkedtest::test02(), and simplexD1listlinkedtest::test03().

{
  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 >

boolc simplexD1listlinked< VI, INDX >::serializeInverse

(

stringc &

s

)

[inline]

Read in/construct an object.

Definition at line 150 of file simplexD1listlinked.h.

References simplexD1listlinked< VI, INDX >::length, tokenizer::readaslinesgeneral(), tokenizer::reset(), and simplexD1listlinked< VI, INDX >::vi.

Referenced by simplexD1listlinkedtest::test02().

{
  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;
}

---

Member Data Documentation

template<typename VI, typename INDX>

INDX simplexD1listlinked< VI, INDX >::length

Length of vi array.

Definition at line 33 of file simplexD1listlinked.h.

Referenced by simplexD1listlinked< VI, INDX >::consistantwinding(), simplexD1listlinked< VI, INDX >::makelinks(), simplexD1listlinked< VI, INDX >::operator stringc(), simplexD1listlinked< VI, INDX >::readindexed(), and simplexD1listlinked< VI, INDX >::serializeInverse().

template<typename VI, typename INDX>

VI simplexD1listlinked< VI, INDX >::vi

Assume vi[] of simplexD1linked<INDX>.

Definition at line 30 of file simplexD1listlinked.h.

Referenced by simplexD1listlinked< VI, INDX >::consistantwinding(), simplexD1listlinked< VI, INDX >::makelinks(), simplexD1listlinked< VI, INDX >::operator stringc(), simplexD1listlinked< VI, INDX >::readindexed(), and simplexD1listlinked< VI, INDX >::serializeInverse().

---

The documentation for this class was generated from the following file:

• simplextess/simplexD1listlinked.h