codebase / stimlib

  #ifndef RTS_RECT_H
  #define RTS_RECT_H
  
  //enable CUDA_CALLABLE macro
  #include "../cuda/callable.h"
  #include "../math/vector.h"
  #include "../math/triangle.h"
  #include "../math/quaternion.h"
  #include <iostream>
  #include <iomanip>
  #include <algorithm>
  

  namespace stim{

  
  //template for a rectangle class in ND space
  template <class T, int N = 3>
  struct rect
  {
  	/*
  		^                   O
  		|                   
  		|                   
  		Y         C         
  		|                   
  		|                   
  		O---------X--------->
  	*/
  
  private:
  

  	stim::vec<T, N> C;
  	stim::vec<T, N> X;
  	stim::vec<T, N> Y;

  
  	CUDA_CALLABLE void scale(T factor){
  		X *= factor;
  		Y *= factor;
  	}
  
  	CUDA_CALLABLE void normal(vec<T, N> n){		//orient the rectangle along the specified normal
  
  		n = n.norm();								//normalize, just in case
  		vec<T, N> n_current = X.cross(Y).norm();	//compute the current normal
  		quaternion<T> q;							//create a quaternion
  		q.CreateRotation(n_current, n);				//initialize a rotation from n_current to n
  
  		//apply the quaternion to the vectors and position
  		X = q.toMatrix3() * X;
  		Y = q.toMatrix3() * Y;
  	}
  
  	CUDA_CALLABLE void init(){
  		C = vec<T, N>(0, 0, 0);
  		X = vec<T, N>(1, 0, 0);
  		Y = vec<T, N>(0, 1, 0);
  	}
  
  public:
  
  	CUDA_CALLABLE rect(){
  		init();
  	}
  
  	CUDA_CALLABLE rect(T size, T z_pos = (T)0){
  		init();			//use the default setup
  		scale(size);	//scale the rectangle
  		C[2] = z_pos;
  	}
  
  	CUDA_CALLABLE rect(T size, vec<T, N> c, vec<T, N> n = vec<T, N>(0, 0, 1)){
  		init();			//start with the default setting
  		C = c;
  		scale(size);	//scale the rectangle
  		normal(n);		//orient
  
  	}
  
  	/*CUDA_CALLABLE rect(vec<T, N> a, vec<T, N> b, vec<T, N> c)
  	{
  		A = a;		
  		Y = b - a;
  		X = c - a - Y;
  
  	}*/
  
  	/*******************************************************************
  	Constructor - create a rect from a position, normal, and rotation
  	*******************************************************************/

  	/*CUDA_CALLABLE rect(stim::vec<T, N> c, stim::vec<T, N> normal, T width, T height, T theta)

  	{
  
          //compute the X direction - start along world-space X

          Y = stim::vec<T, N>(0, 1, 0);

          if(Y == normal)

              Y = stim::vec<T, N>(0, 0, 1);

  
          X = Y.cross(normal).norm();
  
          std::cout<<X<<std::endl;
  
          //rotate the X axis by theta radians

          stim::quaternion<T> q;

          q.CreateRotation(theta, normal);
          X = q.toMatrix3() * X;
          Y = normal.cross(X);
  
          //normalize everything
          X = X.norm();
          Y = Y.norm();
  
          //scale to match the rect width and height
          X = X * width;
          Y = Y * height;
  
          //set the corner of the plane
          A = c - X * 0.5f - Y * 0.5f;
  
          std::cout<<X<<std::endl;
  	}*/
  
  	//boolean comparison
  	bool operator==(const rect<T, N> & rhs)
  	{
  		if(C == rhs.C && X == rhs.X && Y == rhs.Y)
  			return true;
  		else
  			return false;
  	}
  
  	/*******************************************
  	Return the normal for the rect
  	*******************************************/

  	CUDA_CALLABLE stim::vec<T, N> n()

  	{
          return (X.cross(Y)).norm();
  	}
  

  	CUDA_CALLABLE stim::vec<T, N> p(T a, T b)

  	{

  		stim::vec<T, N> result;

  		//given the two parameters a, b = [0 1], returns the position in world space
  		vec<T, N> A = C - X * (T)0.5 - Y * (T)0.5;
  		result = A + X * a + Y * b;
  
  		return result;
  	}
  

  	CUDA_CALLABLE stim::vec<T, N> operator()(T a, T b)

  	{
  		return p(a, b);
  	}
  
  	std::string str()
  	{
  		std::stringstream ss;
  		vec<T, N> A = C - X * (T)0.5 - Y * (T)0.5;

  		ss<<std::left<<"B="<<std::setfill('-')<<std::setw(20)<<A + Y<<">"<<"C="<<A + Y + X<<std::endl;
  		ss<<std::setfill(' ')<<std::setw(23)<<"|"<<"|"<<std::endl<<std::setw(23)<<"|"<<"|"<<std::endl;
  		ss<<std::left<<"A="<<std::setfill('-')<<std::setw(20)<<A<<">"<<"D="<<A + X;

  
          return ss.str();
  
  	}
  
  	CUDA_CALLABLE rect<T, N> operator*(T rhs)
  	{
  		//scales the plane by a scalar value
  
  		//create the new rectangle
  		rect<T, N> result = *this;
  		result.scale(rhs);
  
  		return result;
  
  	}
  
  	CUDA_CALLABLE T dist(vec<T, N> p)
  	{
          //compute the distance between a point and this rect
  
  		vec<T, N> A = C - X * (T)0.5 - Y * (T)0.5;
  
          //first break the rect up into two triangles
          triangle<T, N> T0(A, A+X, A+Y);
          triangle<T, N> T1(A+X+Y, A+X, A+Y);
  
  
          T d0 = T0.dist(p);
          T d1 = T1.dist(p);
  
          if(d0 < d1)
              return d0;
          else
              return d1;
  	}
  
  	CUDA_CALLABLE T dist_max(vec<T, N> p)
  	{
  		vec<T, N> A = C - X * (T)0.5 - Y * (T)0.5;
          T da = (A - p).len();
          T db = (A+X - p).len();
          T dc = (A+Y - p).len();
          T dd = (A+X+Y - p).len();
  
          return std::max( da, std::max(db, std::max(dc, dd) ) );
  	}
  };
  
  }	//end namespace rts
  
  template <typename T, int N>

  std::ostream& operator<<(std::ostream& os, stim::rect<T, N> R)

  {
      os<<R.str();
      return os;
  }
  
  
  #endif