Geom.hpp

Go to the documentation of this file.

#ifndef GEOM_HPP
#define GEOM_HPP

#include "Vector3.hpp"
#include "Vector2.hpp"
#include "TriBoxOverlap.hpp"
#include <vector>

#ifndef Vector3i
typedef Vector3T<int> Vector3i;
#endif

class DTraverser
{
public:
  DTraverser(const Vector3& pos, const Vector3& dir)
  {
  p = pos;
  d = dir;
  d.normalize();
  d/=100.0;
  ipos = pos;
  }
 

  void next()
  {
  Vector3i newPos = ipos;
  while(newPos == ipos)
    {
    p += d;
    newPos = p;
    }
  ipos = newPos;
  }
  
  Vector3i getPos() { return ipos; } 
private:
  Vector3i ipos;
  Vector3 p;
  Vector3 d;
};


class Traverser
{
public:
  Traverser() {}
  
  Traverser(const Vector3& pos, const Vector3& dir)
  {
  init(pos,dir);
  }

  void init(const Vector3& pos, const Vector3& dir)
  {
  ipos = pos;
  if(dir.x > 0)
    { tMax.x = (ceil(pos.x)-pos.x)/dir.x; step.x = 1; }
  else 
    { tMax.x = (floor(pos.x)-pos.x)/dir.x; step.x = -1; }

  if(dir.y > 0)
    { tMax.y = (ceil(pos.y)-pos.y)/dir.y; step.y = 1; }
  else 
    { tMax.y = (floor(pos.y)-pos.y)/dir.y; step.y = -1;}

  if(dir.z > 0)
    { tMax.z = (ceil(pos.z)-pos.z)/dir.z; step.z = 1; }
  else 
    { tMax.z = (floor(pos.z)-pos.z)/dir.z; step.z = -1; }

  tDelta.x = fabs(1.0/dir.x);
  tDelta.y = fabs(1.0/dir.y);
  tDelta.z = fabs(1.0/dir.z);
  }
 

  void next()
  {
  
  if(tMax.x < tMax.y)
    {
    if(tMax.x < tMax.z)
      {
      ipos.x += step.x;
      tMax.x += tDelta.x;
      }
    else 
      {
      ipos.z += step.z;
      tMax.z += tDelta.z;
      }
    }
  else
    {
    if(tMax.y < tMax.z)
      {
      ipos.y += step.y;
      tMax.y += tDelta.y;
      }
    else
      {
      ipos.z += step.z;
      tMax.z += tDelta.z;
      }
    }
  }
  
  Vector3i getPos() { return ipos; } 
private:
  Vector3i ipos;
  Vector3i step;
  Vector3 tMax;
  Vector3 tDelta;
};

inline Vector3 disk2sphere(const Vector2& a)
{
  float r = a.length();
  Vector3 res;
  res.z = 1-r*2;
  float K = sqrt(2.0-r*r);
  res.x = a.x*K;
  res.y = a.y*K;
  return res;
}

class PoissonSphere
{
public:
  PoissonSphere(int n, double limitDistance = -1.0)
  {
  next = 0;
  points.resize(n);

  double limitDistSqr;
  if(limitDistance < 0.0)
    limitDistSqr = 2.2/n;
  else
    limitDistSqr = limitDistance*limitDistance;
  int i = 0;
  while(i < (int) points.size())
    {
    
    Vector3 candidate = randOnSphere();
    bool bad = false;
    for(int j = 0; j < i; j++)
      {
      if((candidate-points[j]).lengthSqr() < limitDistSqr)
        {
        bad = true;
        break;
        }
      }
    if(!bad) points[i++] = candidate;
    }
  }
  
  Vector3 getNext()  { return points[next++ % points.size()]; } 
  int     getCount() { return points.size(); }
private:
  std::vector<Vector3> points;
  int next;
};

inline bool intersectTriangleAABox(const Vector3& v1, const Vector3& v2, const Vector3& v3,const Vector3& bmin,const Vector3& bmax)
{
  float triverts[3][3];
  triverts[0][0] = v1.x;
  triverts[0][1] = v1.y;
  triverts[0][2] = v1.z;

  triverts[1][0] = v2.x;
  triverts[1][1] = v2.y;
  triverts[1][2] = v2.z;

  triverts[2][0] = v3.x;
  triverts[2][1] = v3.y;
  triverts[2][2] = v3.z;

  Vector3 boxhfsize = (bmax-bmin)*0.5;
  Vector3 boxctr = (bmin+bmax)*0.5;
  
  return triBoxOverlap((float*)&boxctr,(float*)&boxhfsize,triverts);
}

inline void getBoundingBox(Vector3i& min, Vector3i& max, const Vector3i* arr, int n)
{
  min.set(std::numeric_limits<int>::max());
  max.set(std::numeric_limits<int>::min());
  for(int i = 0; i < n; i++)
  {
    min.x = arr[i].x < min.x ? arr[i].x : min.x; 
    min.y = arr[i].y < min.y ? arr[i].y : min.y; 
    min.z = arr[i].z < min.z ? arr[i].z : min.z; 
    max.x = arr[i].x > max.x ? arr[i].x : max.x; 
    max.y = arr[i].y > max.y ? arr[i].y : max.y; 
    max.z = arr[i].z > max.z ? arr[i].z : max.z; 
  }
}

#endif

---