pluginbase.Helpers.Geometry.AxisAlignedBox Struct Reference

Represents an axis-aligned bounding box More...

Inheritance diagram for pluginbase.Helpers.Geometry.AxisAlignedBox:

Public Member Functions
	AxisAlignedBox (AxisAlignedBox aab)
	AxisAlignedBox (Vector3d a, Vector3d b)
AxisAlignedBox	Merge (AxisAlignedBox other)
bool	PointIn (Vector3d pt)
unsafe bool	Intersects (Ray ray, out double distance)

Static Public Member Functions
static AxisAlignedBox	FromPointCloud (IEnumerable< Vector3 > points)
	Gets the AABB from a set of points in a cloud More...
static AxisAlignedBox	FromPointCloud (IEnumerable< Vector3d > points)
	Gets the AABB from a set of points in a cloud More...
static AxisAlignedBox	Transform (AxisAlignedBox box, Matrix4d mat)
	Transform an AABB by a matrix and return that new value More...
static AxisAlignedBox	Transform (AxisAlignedBox box, Matrix4 mat)
	Transforms an AABB by a matrix and returns that value More...

Public Attributes
readonly Vector3d	Min
	The minimum point of the bounding box More...
readonly Vector3d	Max
	The maximum point of the bounding box More...

Static Public Attributes
static readonly AxisAlignedBox	Zero = new AxisAlignedBox(Vector3d.Zero, Vector3d.Zero)
	A zero-sized bounding box More...
static readonly AxisAlignedBox	UnitBox = new AxisAlignedBox(-Vector3d.One * 0.5, Vector3d.One * 0.5)
	The unit box from -0.5 to 0.5 More...

Detailed Description

Represents an axis-aligned bounding box

Constructor & Destructor Documentation

AxisAlignedBox() [1/2]

pluginbase.Helpers.Geometry.AxisAlignedBox.AxisAlignedBox

(

AxisAlignedBox

aab

)

        {
            Min = aab.Min;
            Max = aab.Max;
        }

AxisAlignedBox() [2/2]

pluginbase.Helpers.Geometry.AxisAlignedBox.AxisAlignedBox	(	Vector3d	a,
		Vector3d	b
	)

        {
            Max = Vector3d.ComponentMax(a, b);
            Min = Vector3d.ComponentMin(a, b);
        }

Member Function Documentation

FromPointCloud() [1/2]

static AxisAlignedBox pluginbase.Helpers.Geometry.AxisAlignedBox.FromPointCloud ( IEnumerable< Vector3 >  points )

static

Gets the AABB from a set of points in a cloud

Returns

The point cloud.

Parameters

points

Points.

        {
            Vector3 min = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
            Vector3 max = new Vector3(float.MinValue, float.MinValue, float.MinValue);
            foreach(Vector3 pt in points)
            {
                if (pt.X < min.X) min.X = pt.X;
                if (pt.Y < min.Y) min.Y = pt.Y;
                if (pt.Z < min.Z) min.Z = pt.Z;

                if (pt.X > max.X) max.X = pt.X;
                if (pt.Y > max.Y) max.Y = pt.Y;
                if (pt.Z > max.Z) max.Z = pt.Z;
            }
            return new AxisAlignedBox((Vector3d)min, (Vector3d)max);
        }

FromPointCloud() [2/2]

static AxisAlignedBox pluginbase.Helpers.Geometry.AxisAlignedBox.FromPointCloud ( IEnumerable< Vector3d >  points )

static

Gets the AABB from a set of points in a cloud

Returns

The point cloud.

Parameters

points

Points.

        {
            Vector3d min = new Vector3d(double.MaxValue, double.MaxValue, double.MaxValue);
            Vector3d max = new Vector3d(double.MinValue, double.MinValue, double.MinValue);
            foreach(Vector3d pt in points)
            {
                if (pt.X < min.X) min.X = pt.X;
                if (pt.Y < min.Y) min.Y = pt.Y;
                if (pt.Z < min.Z) min.Z = pt.Z;

                if (pt.X > max.X) max.X = pt.X;
                if (pt.Y > max.Y) max.Y = pt.Y;
                if (pt.Z > max.Z) max.Z = pt.Z;
            }
            return new AxisAlignedBox(min, max);
        }

Intersects()

unsafe bool pluginbase.Helpers.Geometry.AxisAlignedBox.Intersects	(	Ray	ray,
		out double	distance
	)

Attribute: 3

;

Attribute: 3

;

Attribute: i] < this.Min[i

)

Attribute: i

= LEFT;

Attribute: i] = this.Min[i

;

Attribute: i] > this.Max[i

)

Attribute: i

= RIGHT;

Attribute: i] = this.Max[i

;

Attribute: i

= MIDDLE;

Attribute: 3

;

Attribute: i] != MIDDLE && direction[i

!= 0)

Attribute: i] = (candidatePlane[i] - ray.Point[i])/direction[i

;

Attribute: i

= -1;

Attribute: whichPlane] < maxT[i

)

Attribute: whichPlane

< 0f)

Attribute: 3

;

Attribute: i] = ray.Point[i] + maxT[i] * direction[i

;

Attribute: i] == RIGHT && coord[i] < this.Min[i

) ||

Attribute: i] == LEFT && coord[i] > this.Max[i

))

Attribute: i] = candidatePlane[i

;

Attribute: whichPlane

;

Implements pluginbase.Helpers.Geometry.IIntersectable.

        {
            const int RIGHT = 0;
            const int LEFT = 1;
            const int MIDDLE = 2;

            double* candidatePlane = stackalloc double[3];
            byte* quadrant = stackalloc byte[3];
            bool inside = true;
            distance = 0f;

            for (int i = 0; i < 3; i++)
            {
                if (ray.Point[i] < this.Min[i])
                {
                    quadrant[i] = LEFT;
                    candidatePlane[i] = this.Min[i];
                    inside = false;
                }
                else if (ray.Point[i] > this.Max[i])
                {
                    quadrant[i] = RIGHT;
                    candidatePlane[i] = this.Max[i];
                    inside = false;
                }
                else
                {
                    quadrant[i] = MIDDLE;
                }
            }

            if (inside)
            {
                return false;
            }

            double* maxT = stackalloc double[3];
            var direction = ray.Direction;
            for (int i = 0; i < 3; i++)
            {
                if (quadrant[i] != MIDDLE && direction[i] != 0)
                {
                    maxT[i] = (candidatePlane[i] - ray.Point[i])/direction[i];
                }
                else
                {
                    maxT[i] = -1;
                }
            }

            int whichPlane = 0;
            for (int i = 1; i < 3; i++)
            {
                if (maxT[whichPlane] < maxT[i])
                {
                    whichPlane = i;
                }
            }

            if (maxT[whichPlane] < 0f)
            {
                return false;
            }

            double* coord = stackalloc double[3];
            for (int i = 0; i < 3; i++)
            {
                if (whichPlane != i)
                {
                    coord[i] = ray.Point[i] + maxT[i] * direction[i];
                    if ((quadrant[i] == RIGHT && coord[i] < this.Min[i]) ||
                        (quadrant[i] == LEFT && coord[i] > this.Max[i]))
                    {
                        return false;
                    }
                }
                else
                {
                    coord[i] = candidatePlane[i];
                }
            }

            distance = maxT[whichPlane];
            return true;

        }

Merge()

AxisAlignedBox pluginbase.Helpers.Geometry.AxisAlignedBox.Merge

(

AxisAlignedBox

other

)

        {
            return new AxisAlignedBox(
                Vector3d.ComponentMin(this.Min, other.Min),
                Vector3d.ComponentMax(this.Max, other.Max));
        }

PointIn()

bool pluginbase.Helpers.Geometry.AxisAlignedBox.PointIn

(

Vector3d

pt

)

        {
            return pt.X > Min.X && pt.X < Max.X
                && pt.Y > Min.Y && pt.Y < Max.Y
                && pt.Z > Min.Z && pt.Z < Max.Z;
        }

Transform() [1/2]

static AxisAlignedBox pluginbase.Helpers.Geometry.AxisAlignedBox.Transform ( AxisAlignedBox  box, Matrix4d  mat  )

static

Transform an AABB by a matrix and return that new value

Parameters

box	Box.
mat	Mat.

        {
            return new AxisAlignedBox(
                Vector3d.Transform(box.Min, mat),
                Vector3d.Transform(box.Max, mat)
                );
        }

Transform() [2/2]

static AxisAlignedBox pluginbase.Helpers.Geometry.AxisAlignedBox.Transform ( AxisAlignedBox  box, Matrix4  mat  )

static

Transforms an AABB by a matrix and returns that value

Parameters

box	Box.
mat	Mat.

        {
            return new AxisAlignedBox(
                (Vector3d)Vector3.TransformPosition((Vector3)box.Min, mat),
                (Vector3d)Vector3.TransformPosition((Vector3)box.Max, mat)
                );
        }

Member Data Documentation

Max

readonly Vector3d pluginbase.Helpers.Geometry.AxisAlignedBox.Max

The maximum point of the bounding box

Min

readonly Vector3d pluginbase.Helpers.Geometry.AxisAlignedBox.Min

The minimum point of the bounding box

UnitBox

readonly AxisAlignedBox pluginbase.Helpers.Geometry.AxisAlignedBox.UnitBox = new AxisAlignedBox(-Vector3d.One * 0.5, Vector3d.One * 0.5)

static

The unit box from -0.5 to 0.5

Zero

readonly AxisAlignedBox pluginbase.Helpers.Geometry.AxisAlignedBox.Zero = new AxisAlignedBox(Vector3d.Zero, Vector3d.Zero)

static

A zero-sized bounding box

---

The documentation for this struct was generated from the following file:

• pluginbase/Helpers/Geometry/AxisAlignedBox.cs