main.cpp

Go to the documentation of this file.

#include <cassert>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>

using namespace std;

#include <GL/glut.h>
#include <GL/gl.h>

#include <zpr.h>
#include <graphmisc.h>
#include <print.h>
#include <commandline.h>



#include <gobj.h>

#include <halfspaceD2.h>
#include <halfspaceD2draw.h>

#include <d3tess.h>

#include <d3clipping.h>

#include <d3circlepartition.h>
#include <d3circlepartitiondraw.h>

#include <d2partitiondraw.h>

#include <d3meshiterrecursive.h>

#include <d3meshpartition.h>
#include <d3meshpartitiondraw.h>

#include <test01obj.h>


typedef unsigned int uint;
typedef unsigned int const uintc;

typedef point2<double> pt2;
typedef point3<double> pt3;

void tessinitgeneral
(
  d3tess & tess,
  double const * d,
  uintc dsz,
  uintc * ti,
  uintc tisz
)
{
  tess.reset();

  for (uint i=0; i<dsz; ++i)
    tess.pt.push_back( pt3(d[i*2],d[i*2+1],0.0) );

  uint k;
  for (uint i=0; i<tisz; ++i)
  {
    k=i*6;
    tess.viadd( ti[k], ti[k+1], ti[k+2], ti[k+3], ti[k+4], ti[k+5] );
  }

  tess.debugcheck();
}



void tessinit03
(d3tess & tess)
{
  uintc dsz=4;
  double const d[] = 
  { 
    0.0, 0.0,
    2.0, 0.0,
    2.0, 2.0,
    0.0, 6.0
  };

  uintc tisz=2;
  uint ti[] = 
  {
    1,2,3,   0,2,0,
    1,3,4,  0,0,1
  };
 
  tessinitgeneral(tess,d,dsz,ti,tisz);
}

// Writes a non-convex tessellation
void tessinit01(d3tess & tess)
{
  tess.reset();

  uintc dsz=16;
  double const d[dsz*2] = 
  { 
    0.0, 0.0,   // The tessellation starts from index 1.
    2.0, 0.0,
    2.0, 2.0,
    4.0, 2.0,
    4.0, 0.0,

    6.0, 0.0,
    6.0, 6.0,
    2.0, 5.0,
    4.0, 5.0,
    4.0, 4.0,
 
    2.0, 4.0,
    0.0, 6.0,
    1.0, 0.0,
    2.0, 6.0,
    3.0, 4.0,

    2.0, 3.0

  };

  for (uint i=0; i<dsz; ++i)
    tess.pt.push_back( pt3(d[i*2],d[i*2+1],0.0) );

  uintc tisz=12;
  uint ti[] = 
  {
    1,2,3,   0,2,0,
    1,3,12,  3,0,1,
    3,11,12, 12,2,4,
    3,4,11,  5,3,0,
    4,10,11, 0,4,6,

    10,4,6,  7,8,5,
    5,6,4,   6,0,0,
    6,7,10,  9,6,0,
    10,7,9,  10,0,8,
    7,8,9,   0,9,11,
    
    8,7,12,  0,12,10,
    12,11,8, 0,11,3

  };

  uint k;
  for (uint i=0; i<tisz; ++i)
  {
    k=i*6;
    tess.viadd( ti[k], ti[k+1], ti[k+2], ti[k+3], ti[k+4], ti[k+5] );
  }

  tess.debugcheck();

}

void tessinit02(d3tess & tess)
{
  tess.reset();

  uintc dsz=6;
  double const d[dsz*2] = 
  { 
    1.0, 0.0,
    3.0, 0.5,
    0.5, 1.0,
   -0.5, 2.0,
    0.0, 0.5

  };

  for (uint i=0; i<dsz; ++i)
    tess.pt.push_back( pt3(d[i*2],d[i*2+1],0.0) );

  uintc tisz=3;
  uint ti[] = 
  {
    1,2,3,   0,2,0,
    5,1,3,   1,3,0,
    5,3,4,   0,0,2
  };

  uint k;
  for (uint i=0; i<tisz; ++i)
  {
    k=i*6;
    tess.viadd( ti[k], ti[k+1], ti[k+2], ti[k+3], ti[k+4], ti[k+5] );
  }

  tess.debugcheck();
}



void test01(d3tess & tess)
{
  tessinit01(tess);

  cout << endl << endl << "Split on boundary" << endl << endl;
  //cout << "No neighbors" << endl;
  //tess.splitonboundary(1,2,13);

  //tess.splitonboundary(1,3,13);
  //splitmidpoint(tess,1,3);
    
  tess.debugcheck();
/*
  tess.splitonboundary(11,0,14);
  tess.debugcheck();

  tess.splitonboundary(3,2,16);
  tess.debugcheck();

*/


}



int main(int argc, char** argv)
{
  commandline cmd(argc,argv);
  uint prog(0);
  cmd.mapvar(prog,"prog");

  switch (prog)
  {
    case 0:
      cout << "Test programs for clipping workspace" << endl << endl;
      cout << "$./main prog=3         - clipping A with another mesh" << endl;
      cout << "$./main prog=2         - clipping A with circle partition" << endl;
      cout << "$/.main prog=1         - clipping A with halfspace" << endl;
      break;
  
    case 1:
    {
      test01obj<halfspaceD2< pt3, double >,halfspaceD2draw> x
      (
        tessinit01,
        new halfspaceD2< pt3, double >( pt3(2.5,-2.0,0.0), pt3(8.0,7.5,0.0) ),
        argc,argv,GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH,800,600,""
      );

      x.eval();
      glutMainLoop();
      break;
    }

    case 2:
    {
      test01obj<d3circlepartition,d3circlepartitiondraw> x
      (
        tessinit01,
        new d3circlepartition( pt2(2.0,2.0), 1.5),
        argc,argv,GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH,800,600,""
      );

      x.eval();
      glutMainLoop();

      break;
    }

    case 3:
    {
      unsigned int const N(100);
      d3tess * meshB = new d3tess(N);
      tessinit02(*meshB);
      
      test01obj<d3meshpartition,d3meshpartitiondraw> x
      (
        tessinit03,
        new d3meshpartition(*meshB),
        argc,argv,GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH,800,600,""
      );

      x.eval();
      glutMainLoop();

      break;
    }

    default: cout << "error:  No case handled." << endl; return 1;
  }

  return 0;
}