linechopped.h

Go to the documentation of this file.

#ifndef LINECHOPPED_H
#define LINECHOPPED_H

#include <cassert>
#include <list>
#include <sstream>
using namespace std;

#include <line.h>
#include <mathlib.h>
#include <point.h>

template< typename PT, typename PD >
class linechopped
{
public:

  line<PT,PD> ln;

  list< point2<PD> > chain;

  linechopped
  ( 
    line<PT,PD> const & ln_,
    point2<PD> const & seg
  )
    : ln(ln_)
    { chain.push_back( seg ); }

  typedef typename list< point2<PD> >::iterator listiter;

  boolc split
  (
    listiter & posnew,
    listiter pos, 
    line<PT,PD> const & L2
  );

};


template< typename PT, typename INDX >
class pointindexed
{
public:

  PT pt;
  INDX index;

  pointindexed(PT const & pt_, INDX const index_)
    : pt(pt_), index(index_) {}

  operator string () const
    { string s( (stringc)pt ); s += " "; stringstream ss; 
     ss << index; return s + ss.str(); }

  boolc operator == ( pointindexed<PT,INDX> const & p2 ) const 
    { return (index==p2.index) && (pt==p2.pt); }
};

template< typename PT, typename INDX >
ostream & operator << (ostream & os, pointindexed<PT,INDX> const & p)
  { return os << (stringc)p; }


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

  line<PT,PD> ln;

  list< pointindexed< point2<PD>, INDX> > chain;

  linechoppedindexed
  ( 
    line<PT,PD> const & ln_,
    pointindexed< point2<PD>, INDX > const & seg
  )
    : ln(ln_)
    { chain.push_back( seg ); }

  typedef typename list< pointindexed< point2<PD>, INDX > >::iterator 
    listiter;

  boolc split
  (
    listiter & posnew,
    listiter pos, 
    line<PT,PD> const & L2
  );


};



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



template< typename PT, typename PD >
boolc linechopped<PT,PD>::split
(
  listiter & posnew,
  listiter pos, 
  line<PT,PD> const & L2
)
{
  bool res;
  point2<PD> t;
  res = solver<PD>::d2linearequ
    (t,ln.nml,L2.nml*((PD)-1.0), L2.pos - ln.pos);

  if (res==false)
    return false;

  PD t0(t[0]);

  if (t0<(*pos)[0])
    return false;

  if (t0>(*pos)[1])
    return false;

  // The line is being split.

  PD k0((*pos)[0]);
  (*pos)[0] = t0;
  
  posnew = chain.insert(pos,point2<PD>(k0,t0));

  return true;
}



template< typename PT, typename PD, typename INDX >
boolc linechoppedindexed<PT,PD,INDX>::split
(
  listiter & posnew,
  listiter pos, 
  line<PT,PD> const & L2
)
{
  bool res;
  point2<PD> t;
  res = solver<PD>::d2linearequ
    (t,ln.nml,L2.nml*((PD)-1.0), L2.pos - ln.pos);

  if (res==false)
    return false;

  PD t0(t[0]);

  if (t0<(*pos).pt[0])
    return false;

  if (t0>(*pos).pt[1])
    return false;

  PD k0((*pos).pt[0]);
  (*pos).pt[0] = t0;
  
  posnew = chain.insert(pos,pointindexed< point2<PD>, INDX >( point2<PD>(k0,t0),0));

  return true;
}







#endif