Binder Grille regulier : pas fini. (1f5c4e3e) · Commits · Emeric Verschuur / lray

LrBinder.cpp

+11 −5

Original line number	Diff line number	Diff line
		@@ -19,7 +19,10 @@
		#include "LrBinder.h"

		LrBinder::LrBinder()
		: m_liste_objets(), min(0.0, 0.0, 0.0), max(0.0, 0.0, 0.0)
		:
		m_liste_objets(),
		min(INFINITY, INFINITY, INFINITY),
		max(-INFINITY, -INFINITY, -INFINITY)
		{

		}
		@@ -31,7 +34,10 @@ LrBinder::LrBinder(const LrBinder & source)
		}

		LrBinder::LrBinder(const LrEntityList liste_objets)
		: m_liste_objets(liste_objets), min(0.0, 0.0, 0.0), max(0.0,0.0, 0.0)
		:
		m_liste_objets(liste_objets),
		min(INFINITY, INFINITY, INFINITY),
		max(-INFINITY, -INFINITY, -INFINITY)
		{
		}

LrBinder.h

+9 −10

Original line number	Diff line number	Diff line
		@@ -75,7 +75,6 @@ class LrBinder
		LrPoint min;
		LrPoint max;


		Real maxIntersection(Real tx, Real ty, Real tz) const;
		Real minIntersection(Real tx, Real ty, Real tz) const;
		};

LrBinderRegularGrid.cpp

+282 −109

Original line number	Diff line number	Diff line
		@@ -15,26 +15,42 @@
		#include "config.h"
		#endif

		#include <iostream>
		#include "LrBinderRegularGrid.h"
		#include "LrGeometry.h"
		#include <iostream>


		using namespace std;

		LrBinderRegularGrid::LrBinderRegularGrid()
		: LrBinder()
		:
		LrBinder()
		{
		initBinder();
		}

		LrBinderRegularGrid::LrBinderRegularGrid(const LrBinderRegularGrid & source)
		: LrBinder(source)
		:
		LrBinder(source),
		m_nbVoxelX(source.m_nbVoxelX),
		m_nbVoxelY(source.m_nbVoxelY),
		m_nbVoxelZ(source.m_nbVoxelZ),
		m_lenBinder(source.m_lenBinder),
		m_lenVoxel(source.m_lenVoxel),
		m_tabVoxel(source.m_tabVoxel)
		{
		initBinder();
		}

		LrBinderRegularGrid::LrBinderRegularGrid(const LrEntityList &entities)
		: LrBinder(entities)
		LrBinderRegularGrid::LrBinderRegularGrid(const LrEntityList &entities, int nbVoxelX, int nbVoxelY, int nbVoxelZ)
		:
		LrBinder(entities),
		m_nbVoxelX(nbVoxelX),
		m_nbVoxelY(nbVoxelY),
		m_nbVoxelZ(nbVoxelZ),
		m_lenBinder(),
		m_lenVoxel(),
		m_tabVoxel(nbVoxelXnbVoxelYnbVoxelZ)
		{
		initBinder();
		}
		@@ -44,115 +60,271 @@ LrBinderRegularGrid::~LrBinderRegularGrid()

		}


		void LrBinderRegularGrid::initBinder()
		{
		LrEntity::LrGeometryList geolist;

		for(LrEntityList::iterator itObjs = m_liste_objets.begin(); itObjs != m_liste_objets.end(); itObjs++)
		Real lenVoxelX, lenVoxelY, lenVoxelZ;
		Real minTMP, maxTMP;
		int nbFragments;
		int numVoxelMin, numVoxelMax;
		int minVoxelI, minVoxelJ, minVoxelK;
		int maxVoxelI, maxVoxelJ, maxVoxelK;
		LrInfoVoxel infoVoxel;
		LrPoint minCur, maxCur;

		// Initialisation de la taille de la binder
		for(LrEntityList::iterator itEntity = m_liste_objets.begin(); itEntity != m_liste_objets.end(); itEntity++)
		{
		(*itObjs)->mkGeometryList(geolist);

		(*itEntity)->getMinMax(minCur, maxCur);

		if(minCur.x < min.x) min.x = minCur.x;
		if(maxCur.x > max.x) max.x = maxCur.x;

		if(minCur.y < min.y) min.y = minCur.y;
		if(maxCur.y > max.y) max.y = maxCur.y;

		if(minCur.z < min.z) min.z = minCur.z;
		if(maxCur.z > max.z) max.z = maxCur.z;

		}

		LrPoint Max(INFINITY, INFINITY, INFINITY);
		LrPoint Min(-INFINITY, -INFINITY, -INFINITY);;
		m_lenBinder = LrVector(min,max);

		LrPoint Max_cur = LrPoint::ZERO;
		LrPoint Min_cur = LrPoint::ZERO;
		lenVoxelX = (max.x - min.x) / m_nbVoxelX;
		lenVoxelY = (max.y - min.y) / m_nbVoxelY;
		lenVoxelZ = (max.z - min.z) / m_nbVoxelZ;

		for(LrEntity::LrGeometryList::iterator itGeos = geolist.begin(); itGeos != geolist.end(); itGeos++)
		{
		m_lenVoxel = LrVector(lenVoxelX,lenVoxelY,lenVoxelZ);


		/(itGeos)->getMinMax(Min_cur, Max_cur);
		// Initialisation des listes d'entités
		for (LrEntityList::iterator itEntity = m_liste_objets.begin(); itEntity != m_liste_objets.end(); itEntity++)
		{

		nbFragments = (*itEntity)->getNbFragments();

		if(Min_cur.x < min.x) min.x = Min_cur.x;
		if(Max_cur.x < max.x) max.x = Max_cur.x;
		for(int i=0; i < nbFragments; i++) {

		if(Min_cur.y < min.y) min.y = Min_cur.y;
		if(Max_cur.y < max.y) max.y = Max_cur.y;
		(*itEntity)->getMinMax(minTMP, maxTMP, i, infoVoxel.m_entite, infoVoxel.m_numFragment);

		if(Min_cur.z < min.z) min.z = Min_cur.z;
		if(Max_cur.z < max.z) max.z = Max_cur.z;*/

		(*itGeos)->getMinMax(Min_cur, Max_cur);
		minVoxelI = ((minTMP.x - min.x) / m_lenBinder.x) * m_nbVoxelX;
		minVoxelJ = ((minTMP.y - min.y) / m_lenBinder.y) * m_nbVoxelY;
		minVoxelK = ((minTMP.z - min.z) / m_lenBinder.z) * m_nbVoxelZ;

		//pour la boite englobate
		if(Min_cur.x > min.x) min.x = Min_cur.x;
		if(Max_cur.x > max.x) max.x = Max_cur.x;
		//PAS X
		if(Min_cur.x < Min.x) Min.x = Min_cur.x;
		if(Max_cur.x < Max.x) Max.x = Max_cur.x;
		maxVoxelI = ((maxTMP.x - min.x) / m_lenBinder.x) * m_nbVoxelX;
		maxVoxelJ = ((maxTMP.y - min.y) / m_lenBinder.y) * m_nbVoxelY;
		maxVoxelK = ((maxTMP.z - min.z) / m_lenBinder.z) * m_nbVoxelZ;

		for (int i = minVoxelI; i <= maxVoxelI; i++) {
		for (int j = minVoxelJ; j <= maxVoxelJ; j++) {
		for (int k = minVoxelK; k <= maxVoxelK; k++) {

		if(Min_cur.y > min.y) min.y = Min_cur.y;
		if(Max_cur.y > max.y) max.y = Max_cur.y;
		//PAS Y
		if(Min_cur.y < Min.y) Min.y = Min_cur.y;
		if(Max_cur.y < Max.y) Max.y = Max_cur.y;
		int numCase = (i + m_nbVoxelX * (j + k * m_nbVoxelY));
		m_tabVoxel[numCase].push_back(infoVoxel);

		if(Min_cur.z > min.z) min.z = Min_cur.z;
		if(Max_cur.z > max.z) max.z = Max_cur.z;
		//PAS Z
		if(Min_cur.z < Min.z) Min.x = Min_cur.z;
		if(Max_cur.z < Max.z) Max.x = Max_cur.z;
		}
		}
		}
		}
		}

		Xpas = Max.x - Min.x;
		Ypas = Max.y - Min.y;
		Zpas = Max.z - Min.z;
		}

		bool LrBinderRegularGrid::getIntersection(const LrRay &ray, LrHit *hit, Real minbound, Real maxbound) const
		{
		Real tx_max;
		Real tx_min;
		if(ray.getDirection().x < 0 )
		{
		tx_min = (max.x - ray.getOrigin().x) / ray.getDirection().x;
		tx_max = (min.x - ray.getOrigin().x) / ray.getDirection().x;

		Real distEntry = -INFINITY;
		Real distExit = INFINITY;
		bool origInBinder = false;
		LrPoint orig = ray.getOrigin();
		Lrvector dir = ray.getDirection();
		LrPoint pointEntry;
		int curVoxelX, curVoxelY, curVoxelZ;


		if (orig.x>min.x && orig.x<max.x &&
		orig.y>min.y && orig.y<max.y &&
		orig.z>min.z && orig.z<max.z) {

		origInBinder = true;
		}
		else
		{
		tx_min = (min.x - ray.getOrigin().x) / ray.getDirection().x;
		tx_max = (max.x - ray.getOrigin().x) / ray.getDirection().x;

		if (origInBinder) {
		distEntry = 0;
		}
		Real ty_min;
		Real ty_max;
		if(ray.getDirection().y < 0 )
		{
		ty_min = (max.y - ray.getOrigin().y) / ray.getDirection().y;
		ty_max = (min.y - ray.getOrigin().y) / ray.getDirection().y;


		// ### Debut : Intersection en X
		if (dir.x > EPSILON) {

		int distExitTMP = (max.x - orig.x - EPSILON)/dir.x;

		if (distExitTMP < distExit) {
		distExit = distExitTMP;
		}
		else
		{
		ty_min = (min.y - ray.getOrigin().y) / ray.getDirection().y;
		ty_max = (max.y - ray.getOrigin().y) / ray.getDirection().y;

		if (!origInBinder) {

		int distEntryTMP = (min.x - orig.x + EPSILON)/dir.x;

		if (distEntryTMP > distEntry) {
		distEntry = distEntryTMP;
		}

		Real tz_min;
		Real tz_max;
		if(ray.getDirection().z < 0)
		{
		tz_min = (max.z - ray.getOrigin().z) / ray.getDirection().z;
		tz_max = (min.z - ray.getOrigin().z) / ray.getDirection().z;
		}
		else
		{
		tz_min = (min.z - ray.getOrigin().z) / ray.getDirection().z;
		tz_max = (max.z - ray.getOrigin().z) / ray.getDirection().z;

		} else if (dir.x < EPSILON) {

		int distExitTMP = (min.x - orig.x + EPSILON)/dir.x;

		if (distExitTMP < distExit) {
		distExit = distExitTMP;
		}

		Real tmax = maxIntersection(tx_min, ty_min,tz_min);
		Real tmin = minIntersection(tx_max, ty_max, tz_max);
		if (!origInBinder) {

		if(tmax < tmin)
		{
		//prochain voxel
		int distEntryTMP = (max.x - orig.x - EPSILON)/dir.x;

		if (distEntryTMP > distEntry) {
		distEntry = distEntryTMP;
		}

		}

		} else {
		if ((orig.x < min.x) \|\| orig.> max.x)) {
		return false
		}
		}
		// ### Fin : Intersection en X



		// ### Debut : Intersection en Y
		if (dir.y > EPSILON) {

		int distExitTMP = (max.y - orig.y - EPSILON)/dir.y;

		if (distExitTMP < distExit) {
		distExit = distExitTMP;
		}

		if (!origInBinder) {

		int distEntryTMP = (min.y - orig.y + EPSILON)/dir.y;

		if (distEntryTMP > distEntry) {
		distEntry = distEntryTMP;
		}

		}

		} else if (dir.y < EPSILON) {

		int distExitTMP = (min.y - orig.y + EPSILON)/dir.y;

		if (distExitTMP < distExit) {
		distExit = distExitTMP;
		}

		if (!origInBinder) {

		int distEntryTMP = (max.y - orig.y - EPSILON)/dir.y;

		if (distEntryTMP > distEntry) {
		distEntry = distEntryTMP;
		}

		}

		} else {
		if ((orig.y < min.y) \|\| orig.> max.y)) {
		return false
		}
		}
		// ### Fin : Intersection en Y



		// ### Debut : Intersection en Z
		if (dir.z > EPSILON) {

		int distExitTMP = (max.z - orig.z - EPSILON)/dir.z;

		if (distEitTMP < distExit) {
		distExit = distExitTMP;
		}

		if (!origInBinder) {

		int distEntryTMP = (min.z - orig.z + EPSILON)/dir.z;

		if (distEntryTMP > distEntry) {
		distEntry = distEntryTMP;
		}

		}

		} else if (dir.z < EPSILON) {

		int distExitTMP = (min.z - orig.z + EPSILON)/dir.z;

		if (distExitTMP < distExit) {
		distExit = distExitTMP;
		}

		if (!origInBinder) {

		int distEntryTMP = (max.z - orig.z - EPSILON)/dir.z;

		if (distEntryTMP > distEntry) {
		distEntry = distEntryTMP;
		}

		}

		} else {
		if ((orig.z < min.z) \|\| orig.> max.z)) {
		return false
		}
		}
		// ### Fin : Intersection en Z

		if (distExit < EPSILON) {
		return false;
		}

		if (distExit < distEntry) {
		return false;
		}

		pointEntry = ray.getPoint(distEntry + EPSILON);

		curVoxelX = ((pointEntry.x - min.x) / m_lenBinder.x) * m_nbVoxelX;
		curVoxelY = ((pointEntry.x - min.x) / m_lenBinder.x) * m_nbVoxelX;
		curVoxelZ = ((pointEntry.x - min.x) / m_lenBinder.x) * m_nbVoxelX;

		if (origInBinder) {
		minbound = 2 * EPSILON;
		} else {
		minbound = distEntry;
		}
		maxbound = minbound;



		// Initialisation de la progression




		// Progression

		/*

		LrPoint Voxel_cur(tx_min, ty_min, tz_min);
		///LrPoint Dmin = (); *////

		bool intersection, oneintersect = false;
		for(LrEntityList::const_iterator itObjs = m_liste_objets.begin(); itObjs != m_liste_objets.end(); itObjs++)
		@@ -166,8 +338,9 @@ bool LrBinderRegularGrid::getIntersection(const LrRay &ray, LrHit *hit, Real min
		else
		break;
		}

		}
		}
		return false;

		*/
		}

LrBinderRegularGrid.h

+40 −14

Original line number	Diff line number	Diff line
		@@ -18,6 +18,8 @@
		#include <list>
		#include "LrBinder.h"
		#include "LrEntity.h"
		#include "LrVector.h"
		#include <vector>


		class LrBinderRegularGrid : public LrBinder
		@@ -28,7 +30,7 @@ class LrBinderRegularGrid : public LrBinder

		LrBinderRegularGrid();
		LrBinderRegularGrid(const LrBinderRegularGrid & source);
		LrBinderRegularGrid(const LrEntityList &entities);
		LrBinderRegularGrid(const LrEntityList &entities, int nbVoxelX, int nbVoxelY, int nbVoxelZ);

		virtual ~LrBinderRegularGrid();

		@@ -48,15 +50,39 @@ class LrBinderRegularGrid : public LrBinder
		* compte pour ce calcul.
		*/
		virtual bool getIntersection(const LrRay &ray, LrHit *hit,
		Real minBound=0, Real maxBound=INFINITY) const;
		Real minbound=0, Real maxbound=INFINITY) const;


		virtual void initBinder();

		private :
		Real Xpas;
		Real Ypas;
		Real Zpas;

		class LrInfoVoxel {

		public:

		LrEntity* m_entite;
		int m_numFragment;
		};

		/// @brief nombre de voxel en X dans la structure accélératrice.
		int m_nbVoxelX;

		/// @brief nombre de voxel en Y dans la structure accélératrice.
		int m_nbVoxelY;

		/// @brief nombre de voxel en Z dans la structure accélératrice.
		int m_nbVoxelZ;

		/// @brief vecteur diagonale en point min et max de la structure accélératrice.
		LrVector m_lenBinder;

		/// @brief vecteur diagonale en point min et max d'un voxel.
		LrVector m_lenVoxel;

		/// @brief Tableau de tableau de structure infoVoxel.
		std::vector<std::vector< LrInfoVoxel> > m_tabVoxel;

		};
		#endif