pathlineseg.cpp

Go to the documentation of this file.

#include <line.h>
#include <pathlineseg.h>
#include <print.h>
#include <stringconvert.h>
#include <stringserialization.h>
#include <stringtagparser.h>


pathlineseg::pathlineseg()
{
  pts.push_back( pt2() );
  
}

pathlineseg::operator stringc const ()
{
  string str;
 
  str << "<path>\n";
// TODO optionally write if variable empty
  str << "<info>Path line segements</info>\n";

  str << "<points2D>\n";
  assert(pts.empty()==false);
  if (pts.empty()==false)
    { str << printvecfunc(pts.begin(),pts.size()) << "\n"; }
  str << "</points2D>\n";
  str << "<control>\n";
  if (control.empty()==false)
    { str << printvecfunc(control.begin(),control.size()) << "\n"; }
  str << "</control>\n";
  str << "<segments>\n";
  if (segments.empty()==false)
    { str << printvecfunc(segments.begin(),segments.size()) << "\n"; }
  str << "</segments>\n";
  str << "</path>";

  return str;
}

void pathlineseg::serializeInverse(stringc & str)
{
  //assert(false);
  pts.clear();
  control.clear();
  segments.clear();

  stringtagparser pars(str);

  string s1 = pars.data("info");
  //cout << "*info=" << s1 << "*" << endl;
  string s2=pars.data("points2D");
  vectorstring::serializeInverse(pts,s2);
  vectorstring::serializeInverse(control,pars.data("control"));
  vectorstring::serializeInverse(segments,pars.data("segments"));
}

doublec pathlineseg::dist02() 
{
  double dist=dist01();
  uint kmax=segments.size()/2;
  for (uint k=0; k<kmax; ++k)
  {
    pt2c & p0(pts[ segments[k*2] ]);
    pt2c & p1(pts[ segments[k*2+1] ]);
    dist += (p0-p1).dot();    
  }

  return dist;
}

doublec pathlineseg::dist01() 
{
  double dist=0.0;

  uint kmax=segments.size();
  uint imax=control.size();
  double tpos;
  for (uint k=0; k<kmax; ++k, ++k)
  {
//cout << "p" << segments[k] << " p" << segments[k+1] << " ";
    pt2 p0(pts[ segments[k]]);
    pt2 p1(pts[ segments[k+1]]);
    line< pt2, double > Lk(p0,p1,true);
    //line< pt2, double > Lk( pts[ segments[k]], pts[segments[k+1]], true );

//cout << SHOW(p0) << "  " << SHOW(p1) << endl;
//cout << "ln" << (stringc)Lk << endl;

    for (uint i=0; i<imax; ++i)
    {
      pt2 const & q(pts[control[i]]);
//cout << SHOW(k) << " " << control[i] << " " << q << " ";
      if (Lk.isnormalzero())
      {
//cout << "nm is zero" << endl;
        dist += (Lk.pos-q).dot();
      }
      else
      {
        Lk.nearestpointcapped(tpos,q);
//cout << "nearest point t=" <<  tpos << endl;
        dist += (Lk(tpos)-q).dot();
      }     
//cout << SHOW(dist) << endl;
    }

  }

  return dist;
}

pathlinesegvec::pathlinesegvec(pathlineseg& ps_)
  // n = seg size /2, n is segments.
  // (n+1)*2 point variables
  : funcstate<double>( (ps_.segments.size()/2+1)*2),
  distfn(2), ps(ps_), pts(ps_.pts), control(ps_.control),
  segments(ps_.segments) 
{
}


doublec pathlinesegvec::operator()()
{
  if (distfn==1)
    return dist01();

  assert(distfn==2);
  return dist02();
}

doublec pathlinesegvec::dist02() 
{
  double dist=dist01();
  uint kmax=segments.size()/2;
  for (uint k=0; k<kmax; ++k)
  {
    pt2 p0(xi[ k*2 ],xi[k*2+1]);
    pt2 p1(xi[(k+1)*2],xi[(k+1)*2+1]);
    dist += (p0-p1).dot();    
  }

  xi[dim]=dist;
  return xi[dim];
}

doublec pathlinesegvec::dist01() 
{
  double dist=0.0;

  uint kmax=segments.size()/2;
  uint imax=control.size();
  double tpos;
  for (uint k=0; k<kmax; ++k)
  {
//cout << "p" << segments[k] << " p" << segments[k+1] << " ";
    pt2 p0(xi[ k*2 ],xi[k*2+1]);
    pt2 p1(xi[(k+1)*2],xi[(k+1)*2+1]);
//cout << SHOW(p0) << "  " << SHOW(p1) << endl;
    line< pt2, double > Lk(p0,p1,true);
// cout << "ln" << (stringc)Lk << endl;

    for (uint i=0; i<imax; ++i)
    {
      pt2 const & q(pts[control[i]]);
//cout << SHOW(k) << " " << control[i] << " " << q << " ";
      if (Lk.isnormalzero())
      {
//cout << "nm is zero" << endl;
        dist += (Lk.pos-q).dot();
      }
      else
      {
        Lk.nearestpointcapped(tpos,q);
//cout << "nearest point t=" <<  tpos << endl;
        dist += (Lk(tpos)-q).dot();
      }     
//cout << SHOW(dist) << endl;
    }
  }

//cout << SHOW(dim) << endl;
  xi[dim]=dist;
  return xi[dim];
}

void pathlinesegvec::read()
{
  assertreturn(dim>0);

  xi[0] = pts[segments[0]].x;
  xi[1] = pts[segments[0]].y;

  uint j=2;
  uint imax=segments.size();
  for ( uint i=0; i<imax; ++i,++i)
  {
    assert(i+1<imax);
    xi[j++] = pts[segments[i+1]].x;
    xi[j++] = pts[segments[i+1]].y;
  }
}

void pathlinesegvec::write()
{
  assertreturn(dim>0);
  assertreturn(segments.empty()==false);

  pts[segments[0]].x = xi[0];
  pts[segments[0]].y = xi[1];

  uint kmax=segments.size()/2;
  for (uint k=0; k<kmax; ++k)
  {
    pts[segments[2*k+1]].x = xi[(k+1)*2];
    pts[segments[2*k+1]].y = xi[(k+1)*2+1];
  }
}