Grid.hpp

Go to the documentation of this file.

#ifndef GRID_HPP
#define GRID_HPP

#include <Geom.hpp>

#include <assert.h>

// class Ray;

class Grid3
{
public:
   class Cell
  {
  public:
    Cell() { tris = 0; }
    ~Cell() { if(tris) delete [] tris; }
    void addTriangle(int t)  
    { 
    int *otris = tris;
    int ntris = otris ? otris[0]+1 : 1;
    tris = new int[ntris+1]; // element count also
    tris[0] = ntris;
    if(otris)
      {
      std::copy(otris+1,otris+ntris,tris+1);
      delete [] otris; 
      }
    tris[ntris] = t;
    }
    int  getTriangleCount() { return tris ? tris[0] : 0; }
    int  getTriangle(int i) { return tris[i+1]; }
  private:
    int* tris;
  };  
               Grid3(int n, const Vector3& min, const Vector3& max);
  void         rasterizeTriangle(const Vector3& v0, const Vector3& v1, const Vector3& v2, int id);
  bool         insideBounds(const Vector3& p)
  {
  if( (p.x > gmin.x && p.x < gmax.x) &&
    (p.y > gmin.y && p.y < gmax.y) &&
    (p.z > gmin.z && p.z < gmax.z) ) 
    return true;
  else 
    return false;
  }

  // void         initCellWalk(const Ray& r);
  /* inline Cell& getCurrentCell()
  {
  return getCell(traverser.getPos());
  }
  inline void  nextCell()
  {
  traverser.next();
  }*/

  /* inline bool inside()
  {
  Vector3 ipos = traverser.getPos();
  return (ipos.x >= 0 && ipos.y >= 0 && ipos.z >= 0 &&
      ipos.x < n && ipos.y < n && ipos.z < n);
      }*/

  Vector3 getCellSize() const { return cellSize; }

  // returns the min-corner of cell
  Vector3  getCoords(const Vector3i& ci)
  {
  Vector3 pos;
  pos.x = ci.x*cellSize.x;
  pos.y = ci.y*cellSize.y;
  pos.z = ci.z*cellSize.z;
  return pos+gmin;
  }
  // private:  

  Vector3i getGridCoords(const Vector3& pos)
  {
  Vector3 c = (pos-gmin).descale(cellSize);
  Vector3i ci(c.x,c.y,c.z);
  return ci;  
  }


  
  Cell& getCell(const Vector3& pos)
  {
  Vector3 c = (pos-gmin).descale(cellSize);
  Vector3i ci(c.x,c.y,c.z);
  return getCell(ci); 
  }
  Cell& getCell(const Vector3i& ci)
  {
  assert(ci.x < n && ci.y < n && ci.z < n);
  return cells[ci.x*n*n+ci.y*n+ci.z];
  } 

  Cell *cells;
  Vector3 gmin,gmax;
  Vector3 cellSize;
  int   n;

  // Traverser traverser;
};

#endif

---