From 09b24449af2408093318ce4c0fcc419d78f040d7 Mon Sep 17 00:00:00 2001
From: pgovyadi <pgovyadi@gmail.com>
Date: Mon, 25 Jan 2016 15:01:20 -0600
Subject: [PATCH]  changes to plane and additing of the old rts plane class

---
 stim/math/plane_old.h | 179 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 179 insertions(+), 0 deletions(-)
 create mode 100644 stim/math/plane_old.h

diff --git a/stim/math/plane_old.h b/stim/math/plane_old.h
new file mode 100644
index 0000000..b009cad
--- /dev/null
+++ b/stim/math/plane_old.h
@@ -0,0 +1,179 @@
+#ifndef RTS_PLANE_H
+#define RTS_PLANE_H
+
+#include <iostream>
+#include <stim/math/vector.h>
+#include "rts/cuda/callable.h"
+
+
+namespace stim{
+template <typename T, int D> class plane;
+}
+
+template <typename T, int D>
+CUDA_CALLABLE stim::plane<T, D> operator-(stim::plane<T, D> v);
+
+namespace stim{
+
+template <class T, int D = 3>
+class plane{
+
+	//a plane is defined by a point and a normal
+
+private:
+
+	vec<T, D> P;	//point on the plane
+	vec<T, D> N;	//plane normal
+
+	CUDA_CALLABLE void init(){
+		P = vec<T, D>(0, 0, 0);
+		N = vec<T, D>(0, 0, 1);
+	}
+
+
+public:
+
+	//default constructor
+	CUDA_CALLABLE plane(){
+		init();
+	}
+	
+	CUDA_CALLABLE plane(vec<T, D> n, vec<T, D> p = vec<T, D>(0, 0, 0)){
+		P = p;
+		N = n.norm();
+	}
+
+	CUDA_CALLABLE plane(T z_pos){
+		init();
+		P[2] = z_pos;
+	}
+
+	//create a plane from three points (a triangle)
+	CUDA_CALLABLE plane(vec<T, D> a, vec<T, D> b, vec<T, D> c){
+		P = c;
+		N = (c - a).cross(b - a);
+		if(N.len() == 0)	//handle the degenerate case when two vectors are the same, N = 0
+			N = 0;
+		else
+			N = N.norm();
+	}
+
+	template< typename U >
+	CUDA_CALLABLE operator plane<U, D>(){
+
+		plane<U, D> result(N, P);
+		return result;
+	}
+
+	CUDA_CALLABLE vec<T, D> norm(){
+		return N;
+	}
+
+	CUDA_CALLABLE vec<T, D> p(){
+		return P;
+	}
+
+	//flip the plane front-to-back
+	CUDA_CALLABLE plane<T, D> flip(){
+		plane<T, D> result = *this;
+		result.N = -result.N;
+		return result;
+	}
+
+	//determines how a vector v intersects the plane (1 = intersects front, 0 = within plane, -1 = intersects back)
+	CUDA_CALLABLE int face(vec<T, D> v){
+		
+		T dprod = v.dot(N);		//get the dot product between v and N
+
+		//conditional returns the appropriate value
+		if(dprod < 0)
+			return 1;
+		else if(dprod > 0)
+			return -1;
+		else
+			return 0;
+	}
+
+	//determine on which side of the plane a point lies (1 = front, 0 = on the plane, -1 = back)
+	CUDA_CALLABLE int side(vec<T, D> p){
+
+		vec<T, D> v = p - P;	//get the vector from P to the query point p
+
+		return face(v);
+	}
+
+	//compute the component of v that is perpendicular to the plane
+	CUDA_CALLABLE vec<T, D> perpendicular(vec<T, D> v){
+		return N * v.dot(N);
+	}
+
+	//compute the projection of v in the plane
+	CUDA_CALLABLE vec<T, D> parallel(vec<T, D> v){
+		return v - perpendicular(v);
+	}
+
+	CUDA_CALLABLE void decompose(vec<T, D> v, vec<T, D>& para, vec<T, D>& perp){
+		perp = N * v.dot(N);
+		para = v - perp;
+	}
+
+	//get both the parallel and perpendicular components of a vector v w.r.t. the plane
+	CUDA_CALLABLE void project(vec<T, D> v, vec<T, D> &v_par, vec<T, D> &v_perp){
+
+		v_perp = v.dot(N);
+		v_par = v - v_perp;
+	}
+
+	//compute the reflection of v off of the plane
+	CUDA_CALLABLE vec<T, D> reflect(vec<T, D> v){
+
+		//compute the reflection using N_prime as the plane normal
+		vec<T, D> par = parallel(v);
+		vec<T, D> r = (-v) + par * 2;
+
+		/*std::cout<<"----------------REFLECT-----------------------------"<<std::endl;
+		std::cout<<str()<<std::endl;
+		std::cout<<"v: "<<v<<std::endl;
+		std::cout<<"r: "<<r<<std::endl;
+		std::cout<<"Perpendicular: "<<perpendicular(v)<<std::endl;
+		std::cout<<"Parallel: "<<par<<std::endl;*/
+		return r;
+
+	}
+
+	CUDA_CALLABLE rts::plane<T, D> operator-()
+	{
+		rts::plane<T, D> p = *this;
+
+		//negate the normal vector
+		p.N = -p.N;
+
+		return p;
+	}
+
+	//output a string
+	std::string str(){
+		std::stringstream ss;
+		ss<<"P: "<<P<<std::endl;
+		ss<<"N: "<<N;
+		return ss.str();
+	}
+
+	///////Friendship
+	//friend CUDA_CALLABLE rts::plane<T, D> operator- <> (rts::plane<T, D> v);
+
+
+
+};
+
+}
+
+//arithmetic operators
+
+//negative operator flips the plane (front to back)
+//template <typename T, int D>
+
+
+
+
+#endif
--
libgit2 0.21.4