vhacdVolume.cpp File Reference

#include <tesseract_common/macros.h>
#include <tesseract_collision/vhacd/inc/vhacdVolume.h>
#include <bullet/LinearMath/btConvexHullComputer.h>
#include <algorithm>
#include <float.h>
#include <math.h>
#include <queue>
#include <string.h>

Include dependency graph for vhacdVolume.cpp:

Namespaces
namespace	tesseract_collision
namespace	tesseract_collision::VHACD

Macros
#define	X   0
#define	Y   1
#define	Z   2
#define	FINDMINMAX(x0, x1, x2, min, max)
#define	AXISTEST_X01(a, b, fa, fb)
#define	AXISTEST_X2(a, b, fa, fb)
#define	AXISTEST_Y02(a, b, fa, fb)
#define	AXISTEST_Y1(a, b, fa, fb)
#define	AXISTEST_Z12(a, b, fa, fb)
#define	AXISTEST_Z0(a, b, fa, fb)

Functions
int32_t	tesseract_collision::VHACD::PlaneBoxOverlap (const Vec3< double > &normal, const Vec3< double > &vert, const Vec3< double > &maxbox)
int32_t	tesseract_collision::VHACD::TriBoxOverlap (const Vec3< double > &boxcenter, const Vec3< double > &boxhalfsize, const Vec3< double > &triver0, const Vec3< double > &triver1, const Vec3< double > &triver2)
void	tesseract_collision::VHACD::Diagonalize (const double(&A)[3][3], double(&Q)[3][3], double(&D)[3][3])

Macro Definition Documentation

AXISTEST_X01

#define AXISTEST_X01	(		a,
			b,
			fa,
			fb
	)

Value:

  p0 = a * v0[Y] - b * v0[Z];                                                                                          \
  p2 = a * v2[Y] - b * v2[Z];                                                                                          \
  if (p0 < p2)                                                                                                         \
  {                                                                                                                    \
    min = p0;                                                                                                          \
    max = p2;                                                                                                          \
  }                                                                                                                    \
  else                                                                                                                 \
  {                                                                                                                    \
    min = p2;                                                                                                          \
    max = p0;                                                                                                          \
  }                                                                                                                    \
  rad = fa * boxhalfsize[Y] + fb * boxhalfsize[Z];                                                                     \
  if (min > rad || max < -rad)                                                                                         \
    return 0;

AXISTEST_X2

#define AXISTEST_X2	(		a,
			b,
			fa,
			fb
	)

Value:

  p0 = a * v0[Y] - b * v0[Z];                                                                                          \
  p1 = a * v1[Y] - b * v1[Z];                                                                                          \
  if (p0 < p1)                                                                                                         \
  {                                                                                                                    \
    min = p0;                                                                                                          \
    max = p1;                                                                                                          \
  }                                                                                                                    \
  else                                                                                                                 \
  {                                                                                                                    \
    min = p1;                                                                                                          \
    max = p0;                                                                                                          \
  }                                                                                                                    \
  rad = fa * boxhalfsize[Y] + fb * boxhalfsize[Z];                                                                     \
  if (min > rad || max < -rad)                                                                                         \
    return 0;

AXISTEST_Y02

#define AXISTEST_Y02	(		a,
			b,
			fa,
			fb
	)

Value:

  p0 = -a * v0[X] + b * v0[Z];                                                                                         \
  p2 = -a * v2[X] + b * v2[Z];                                                                                         \
  if (p0 < p2)                                                                                                         \
  {                                                                                                                    \
    min = p0;                                                                                                          \
    max = p2;                                                                                                          \
  }                                                                                                                    \
  else                                                                                                                 \
  {                                                                                                                    \
    min = p2;                                                                                                          \
    max = p0;                                                                                                          \
  }                                                                                                                    \
  rad = fa * boxhalfsize[X] + fb * boxhalfsize[Z];                                                                     \
  if (min > rad || max < -rad)                                                                                         \
    return 0;

AXISTEST_Y1

#define AXISTEST_Y1	(		a,
			b,
			fa,
			fb
	)

Value:

  p0 = -a * v0[X] + b * v0[Z];                                                                                         \
  p1 = -a * v1[X] + b * v1[Z];                                                                                         \
  if (p0 < p1)                                                                                                         \
  {                                                                                                                    \
    min = p0;                                                                                                          \
    max = p1;                                                                                                          \
  }                                                                                                                    \
  else                                                                                                                 \
  {                                                                                                                    \
    min = p1;                                                                                                          \
    max = p0;                                                                                                          \
  }                                                                                                                    \
  rad = fa * boxhalfsize[X] + fb * boxhalfsize[Z];                                                                     \
  if (min > rad || max < -rad)                                                                                         \
    return 0;

AXISTEST_Z0

#define AXISTEST_Z0	(		a,
			b,
			fa,
			fb
	)

Value:

  p0 = a * v0[X] - b * v0[Y];                                                                                          \
  p1 = a * v1[X] - b * v1[Y];                                                                                          \
  if (p0 < p1)                                                                                                         \
  {                                                                                                                    \
    min = p0;                                                                                                          \
    max = p1;                                                                                                          \
  }                                                                                                                    \
  else                                                                                                                 \
  {                                                                                                                    \
    min = p1;                                                                                                          \
    max = p0;                                                                                                          \
  }                                                                                                                    \
  rad = fa * boxhalfsize[X] + fb * boxhalfsize[Y];                                                                     \
  if (min > rad || max < -rad)                                                                                         \
    return 0;

AXISTEST_Z12

#define AXISTEST_Z12	(		a,
			b,
			fa,
			fb
	)

Value:

  p1 = a * v1[X] - b * v1[Y];                                                                                          \
  p2 = a * v2[X] - b * v2[Y];                                                                                          \
  if (p2 < p1)                                                                                                         \
  {                                                                                                                    \
    min = p2;                                                                                                          \
    max = p1;                                                                                                          \
  }                                                                                                                    \
  else                                                                                                                 \
  {                                                                                                                    \
    min = p1;                                                                                                          \
    max = p2;                                                                                                          \
  }                                                                                                                    \
  rad = fa * boxhalfsize[X] + fb * boxhalfsize[Y];                                                                     \
  if (min > rad || max < -rad)                                                                                         \
    return 0;

FINDMINMAX

#define FINDMINMAX	(		x0,
			x1,
			x2,
			min,
			max
	)

Value:

  min = max = x0;                                                                                                      \
  if (x1 < min)                                                                                                        \
    min = x1;                                                                                                          \
  if (x1 > max)                                                                                                        \
    max = x1;                                                                                                          \
  if (x2 < min)                                                                                                        \
    min = x2;                                                                                                          \
  if (x2 > max)                                                                                                        \
    max = x2;

X

#define X   0

Y

#define Y   1

Z

#define Z   2