line.h

Go to the documentation of this file.

#ifndef LINE_H
#define LINE_H

#include <mathlib.h>
#include <typedefs.h>
#include <zero.h>

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

  PT nml;

  PT pos;

  line(PT const & nml_, PT const & pos_);

  line(PT const & p0, PT const & p1, boolc endpoints);

  void construct(PT const & nml_,PT const & pos_); 
  void constructfromendpoints(PT const & p0, PT const & p1)
    { pos=p0; nml=(p1-p0); }

  void normalize();

  void normalize(PD const len);
    
  PT const operator () (PD const t) const
    { return pos + nml*t; }

  boolc tD2(PD & t, PT const & p) const;

  boolc tD3(PD & t, PT const & p) const;
  
  operator stringc () const;

  boolc isnormalzero() const
    { return zero<PD>::test(nml.dot()); }

  void nearestpoint(PD & t, PT const & p) const;

  void nearestpointcapped(PD & t, PT const & p) const;
  
  void nearestpoint(PT & q, PT const & p) const;

  static void nearestpointonline
  (
    PT & x,
    PT const & p,
    PT const & a,
    PT const & b
  );

  boolc lineD3minimized
  (
    PD & t1, 
    PD & t2, 
    line<PT,PD> const & L2
  ) const;


  boolc intersects
  (
    PD & t0,
    PD & t1,
    line<PT,PD> const & L2
  );

};


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

template< typename PT, typename PD >
boolc line<PT,PD>::intersects
(
  PD & t0,
  PD & t1,
  line<PT,PD> const & L2
)
{
  return solver<PD>::d2linearequ
  (
    t0,
    t1,
    nml.x,
    L2.nml.x*((PD)-1.0),
    nml.y,
    L2.nml.y*((PD)-1.0),
    L2.pos.x-pos.x,
    L2.pos.y-pos.y
  );
}

template< typename PT, typename PD >
line<PT,PD>:: operator stringc () const
{
  return (stringc)nml + " " + (stringc)pos;
}

template< typename PT, typename PD >
boolc line<PT,PD>::lineD3minimized
(
  PD & t1, 
  PD & t2, 
  line<PT,PD> const & L2
) const
{
  PT C(pos-L2.pos);
  PT E1(nml);
  PT E2(L2.nml*(-1));

  bool res;
  res = solver<PD>::d2linearequ
  (
    t1,t2,
    E1.dot(),E1.dot(E2),
    E1.dot(E2),E2.dot(),
    C.dot(E1)*(-1),
    C.dot(E2)*(-1)
  );

  return res;
}

template< typename PT, typename PD >
void line<PT,PD>::construct(PT const & nml_,PT const & pos_) 
{ 
  nml = nml_; 
  pos=pos_; 
}

template< typename PT, typename PD >
line<PT,PD>::line(PT const & p0, PT const & p1, boolc endpoints)
  : nml(p1-p0), pos(p0) 
{ 
  assert(endpoints); 
}

template< typename PT, typename PD >
line<PT,PD>::line(PT const & nml_, PT const & pos_)
  :nml(nml_), pos(pos_) 
{
}

template< typename PT, typename PD >
void line<PT,PD>::normalize()
{ 
  nml.normalize(); 
}

template< typename PT, typename PD >
void line<PT,PD>::normalize(PD const len)
{ 
  nml.normalize(); 
  nml *= len; 
}

template< typename PT, typename PD >
boolc line<PT,PD>::tD2(PD & t, PT const & p) const
{
  if (zero<PD>::test(nml.x))
  {
    if (zero<PD>::test(nml.y))
      return false;

    t = (p.y-pos.y)/nml.y;
  }
  else
    t = (p.x-pos.x)/nml.x;

  assert( zero<PD>::test( (operator()(t)-p).dot()) );
  return true;
}

template< typename PT, typename PD >
boolc line<PT,PD>::tD3(PD & t, PT const & p) const
{
  if (zero<PD>::test(nml.x))
  {
    if (zero<PD>::test(nml.y))
    {
      if (zero<PD>::test(nml.z))
        return false;

      t = (p.z-pos.z)/nml.z;
    }
    else
      t = (p.y-pos.y)/nml.y;
  }
  else
    t = (p.x-pos.x)/nml.x;

  assert( zero<PD>::test( (operator()(t)-p).dot()) );
  return true;
}

template< typename PT, typename PD >
void line<PT,PD>::nearestpoint(PD & t, PT const & p) const
{
  assert(zero<PD>::test(nml.dot())==false);

  t=(p-pos).dot(nml)/nml.dot();
}

template< typename PT, typename PD >
void line<PT,PD>::nearestpointcapped(PD & t, PT const & p) const
{
  nearestpoint(t,p);
  if (t<((PD)0.0))
    t = (PD)0.0;
  if (t>((PD)1.0))
    t = (PD)1.0;
}

template< typename PT, typename PD >
void line<PT,PD>::nearestpoint(PT & q, PT const & p) const
{
  assert(zero<PD>::test(nml.dot())==false);

  q = pos;
  q += nml*(p-pos).dot(nml)/nml.dot();
}

template< typename PT, typename PD >
void line<PT,PD>::nearestpointonline
(
  PT & x,
  PT const & p,
  PT const & a,
  PT const & b
)
{  
  assert(zero<PD>::test(b.dot())==false);
  x = a + b*( (p-a).dot(b)/(b.dot(b)) );
}


#endif