pathlinesegtest.cpp

Go to the documentation of this file.

#include <iomanip>
using namespace std;

#include <commandline.h>
#include <graphmisc.h>
#include <minexpdim.h>
#include <pathlineseg.h>
#include <pathlinesegdraw.h>
#include <pathlinesegtest.h>
#include <print.h>
#include <stringserialization.h>
#include <zpr.h>

pathlinesegtest* pathlinesegtest::self=0;

string pathlinesegtest::doc[] = 
{
  "",
  "Display pathlineseg by reading a file.",
  "Read a pathlineseg from a string.",
  "Test equivalent dist01 and pathlinesegvec() function.",
  "Minimize a path and optionally save: file2=\"somefile.txt\"."
};

pathlinesegtest::pathlinesegtest(int argc, char** argv)
{
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize(600,600);
  glutCreateWindow("");
  glutDisplayFunc(display01);
  glutKeyboardFunc(keyboard01);

  OpenGLinitialisation();

  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);
  glEnable(GL_NORMALIZE);

  xGraphics.set();
}

void pathlinesegtest::test01(int argc, char** argv)
{
  cout << "Display pathlineseg. file=\"somefile.txt\"" << "\n"; 
  cout << "  optional: pointsdraw, pointsnumber, pointsnumber, " << "\n";
  cout << "  curvepointsdraw, controldraw, segdraw." << "\n";

  assert(self==0);
  self = new pathlinesegtest(argc,argv);

  gobjpush(new myaxes(1.0));

  // Read segments file in and graphically display.

  string cmdarg("./main prog=30 file=path001.txt");

  commandline cmd(argc,argv);
  string file="";
  cmd.mapvar(file,"file");
  if (file.empty())
  {
    cout << "error: need file eg" << endl;
    cout << "  " << cmdarg << endl;
    return;
  }
 
  string str;
  bool res=filestring::serialize(str,file);
  if (res==false)
  {
    cout << "error: " << cmdarg << endl; 
    return;
  }
  if (str.empty())
  { 
    cout << "error: empty file input." << endl; return; 
  }

  pathlineseg ps;
  ps.serializeInverse(str);

  cout << (stringc)ps << endl;

  pathlinesegdraw* psd = new pathlinesegdraw(&ps,false);

  cmd.mapvar(psd->pointsdraw,"pointsdraw");
  cmd.mapvar(psd->pointsnumber,"pointsnumber");
  cmd.mapvar(psd->curvepointsdraw,"curvepointsdraw");
  cmd.mapvar(psd->controldraw,"controldraw");
  cmd.mapvar(psd->segsdraw,"segsdraw");
  psd->update();
  gobjpush(psd);

//cout << SHOW(res);
// cout << "*" <<  str << "*" << endl;

  zpr zz;
  zz.update();
  glutMainLoop();
}

void pathlinesegtest::display01()
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  gobj::global->draw();

  glerrordisplay();
  
  glutSwapBuffers();
}

void pathlinesegtest::keyboard01(unsigned char key, int x, int y)
{
  switch (key)
  {
    case 27:
      exit(0);
      break;
  }
}

void pathlinesegtest::test02()
{
  pathlineseg ps;

  uint sg[] = { 1,2,2,3,3,4 };
  copy(sg,sg+6,back_inserter(ps.segments));

  cout << (stringc)ps << endl;
  cout << endl;

  cout << "serializeInverse" << endl;
  string s2=
"<path>\
<info>Path line segments</info>\
<points2D>\
 0 0\
 0.0 0.0\
 .2 .3 .4 .7\
 1.2 .2\
 1.6 .12\
</points2D>\
<control>\
1 2 3 4\
</control>\
<segments>\
1 2 2 3 3 4\
</segments>\
</path>";

  pathlineseg ps2;
  ps2.serializeInverse(s2);

  cout << (stringc)ps2 << endl;
}

int pathlinesegtest::unittest01(int argc, char** argv)
{
  commandline cmd(argc,argv);
  string file="path002.txt";
  cmd.mapvar(file,"file");
  if (file.empty())
  {
    cout << "error: need file in command line eg file=path002.txt" << endl;
    return 1;
  }

  string str;
  assertreturnOS(filestring::serialize(str,file));
  assertreturnOS(str.empty()==false);

  pathlineseg ps;
  ps.serializeInverse(str);

cout << (stringc)ps << endl;
  double psdist01=ps.dist01();
cout << SHOW(psdist01) << endl;
//cout << SHOW(ps.dist01()) << endl;

cout << endl;

  pathlinesegvec psf(ps);

  psf.read();
  psf.distfn=1;
  psf();
  cout << printvecfunc(psf.xi,psf.dim+1) << endl;

  // TODO - read a pathlineseg file in
  // and print out.
  

  double psfdist = psf.fnvalue();
  cout << SHOW(psfdist) << endl;

  // Testing that the two distance functions are the same.
  assertreturnOS(zero<double>::test(psdist01-psfdist));

  double psdist02=ps.dist02();
  psf.distfn=2;
  cout << SHOW(psdist02) << endl;
  psf();
  psfdist=psf.fnvalue();
  cout << SHOW(psfdist) << endl;
  assertreturnOS(zero<double>::test(psdist02-psfdist));

  // Testing writing back to instance.
  for (uint i=0; i<=psf.dim; ++i)
  {
    psf.xi[i] = 0.5 + i;
  }
  cout << printvecfunc(psf.xi,psf.dim+1) << endl;
  psf.write();

  cout << (stringc)ps << endl;


  return 0;
}


int pathlinesegtest::test03(int argc, char** argv)
{
  commandline cmd(argc,argv);
  string file="path002.txt";
  cmd.mapvar(file,"file");
  if (file.empty())
  {
    cout << "error: need file in command line eg file=path002.txt" << endl;
    return 1;
  }

  string str;
  assertreturnOS(filestring::serialize(str,file));
  assertreturnOS(str.empty()==false);

  // Aim: display original and minimized paths.

  // Original 
  pathlineseg ps0;
  ps0.serializeInverse(str);

  // Path to be minimized.
  pathlineseg ps;
  ps.serializeInverse(str);

  pathlinesegvec* psf = new pathlinesegvec(ps);
  psf->read();

  double h0=0.3;
  cmd.mapvar(h0,"h0");
  minexpdimN<double> mn(*psf,h0);

  // Change the distance function.
  cmd.mapvar(psf->distfn,"distfn");

  mn.reset();

  cout << printvecfunc(psf->xi,psf->dim+1) << endl;

  uint i=0;
  uint imax=4;
  cmd.mapvar(imax,"imax");
  do
  {
    ++mn;
    cout << setw(3) << i << " " << printvecfunc(mn.xi,psf->dim+1) << endl;
    //cout << " " << mn.fn->counter << " " << mn.himax() << endl;
    ++i;


  } while ( (i<imax) );

  psf->write();


  string file2("");
  cmd.mapvar(file2,"file2");
  if (file2.empty())
  { 
    cout << (stringc)ps << endl;
  }
  else
  {
    assertreturnOS(filestring::deserialize(file2,(stringc)ps));
  }

  return 0;
}