#include <cassert>
using namespace std;

#include <pointgrid3D.h>


pointgrid3D::pointgrid3D(uintc M_, uintc N_)
  : M(M_), N(N_), pt(new point3<double>[M*N])
{
  doublec dx = 1.0/((double)N-1.0);
  doublec dy = 1.0/((double)M-1.0);

  double x(0.0);
  double y(0.0);

  uint index(0);
  uint i,k;
  for (i=0; i<M; ++i)
  {
    x = 0.0;
    for (k=0; k<N; ++k)
    {
      pt[index].x = x;
      pt[index].y = y;
      ++index;
      x += dx;
    }
    y += dy;
  }
}

pointgrid3D::pointgrid3D
(
  uintc M_, 
  uintc N_, 
  doublec x0,
  doublec x1,
  doublec y0,
  doublec y1
)
  : M(M_), N(N_), pt(new point3<double>[M*N])
{
  assert(x0<x1);
  assert(y0<y1);

  doublec dx = (x1-x0)/((double)N-1.0);
  doublec dy = (y1-y0)/((double)M-1.0);

  double x(x0);
  double y(y0);

  uint index(0);
  uint i,k;
  for (i=0; i<M; ++i)
  {
    x = x0;
    for (k=0; k<N; ++k)
    {
      pt[index].x = x;
      pt[index].y = y;
      ++index;
      x += dx;
    }
    y += dy;
  }
}

pointgrid3D::pointgrid3D
(
  uintc M_, 
  uintc N_, 
  doublec x0,
  doublec x1,
  doublec z0,
  doublec z1,
  bool const xzsurface
)
  : M(M_), N(N_), pt(new point3<double>[M*N])
{
  assert(xzsurface==true);  // Dummy argument.
  assert(x0<x1);
  assert(z0<z1);

  doublec dx = (x1-x0)/((double)N-1.0);
  doublec dz = (z1-z0)/((double)M-1.0);

  double x(x0);
  double z(z0);

  uint index(0);
  uint i,k;
  for (i=0; i<M; ++i)
  {
    x = x0;
    for (k=0; k<N; ++k)
    {
      pt[index].x = x;
      pt[index].z = z;
      ++index;
      x += dx;
    }
    z += dz;
  }
}

pointgrid3D::~pointgrid3D()
{
  delete[] pt;
}

void pointgrid3D::createIndexedTriangles
(
  vector< point3<double> > & points,
  vector< point3<uint> > & vi
) const
{
  uintc p0 = points.size();

  for (uint i=0; i<M*N; ++i)
    points.push_back(pt[i]);

  for (uint r=1; r<M; ++r)
  {
    for (uint k=1; k<N; ++k)
    {
      vi.push_back
      ( 
        point3<uint>(p0+r*N+k-1,p0+(r-1)*N+k-1,p0+(r-1)*N+k  )  
      );
      vi.push_back
      (
        point3<uint>(p0+r*N+k-1,p0+(r-1)*N+k,p0+r*N+k )
      );
    }
  }
}