src/rcrt/primitives/AABB.cpp

Go to the documentation of this file.

#include "AABB.h"
#include <limits>
#include <algorithm>

using namespace std;

namespace rcrt
{

AABB::AABB(SolidObject* parent):Primitive(parent),minP(numeric_limits<float>::infinity()), maxP(-numeric_limits<float>::infinity())
{
        center = (minP+maxP.getPosVec3D())*0.5;
}


AABB::AABB(const Point3D& min, const Point3D& max, SolidObject* parent):Primitive(parent),minP(numeric_limits<float>::infinity()),
maxP(-numeric_limits<float>::infinity())
{
        extend(min);
        extend(max);
}


AABB::~AABB()
{
}


Intersection AABB::intersect(Ray& ray) const
{
        float tmin, tmax, tymin, tymax, tzmin, tzmax;
        const float& invrdx = ray.invDir().x();
        const float& invrdy = ray.invDir().y();
        const float& invrdz = ray.invDir().z();
        Axis ax = X_AXIS;
        if(!isnan(invrdx)){
            if (invrdx >= 0)
            {
                tmin = (minP.x() - ray.org().x()) * invrdx;
                tmax = (maxP.x() - ray.org().x()) * invrdx;
            }else
            {
                tmin = (maxP.x() - ray.org().x()) * invrdx;
                tmax = (minP.x() - ray.org().x()) * invrdx;
            }
        } else {
                tmin = -numeric_limits<float>::infinity();
                tmax = numeric_limits<float>::infinity();
        }
        
        if(!isnan(invrdx)){
            if (invrdy >= 0)
            {
                tymin = (minP.y() - ray.org().y()) * invrdy;
                tymax = (maxP.y() - ray.org().y()) * invrdy;
            }else
            {
                tymin = (maxP.y() - ray.org().y()) * invrdy;
                tymax = (minP.y() - ray.org().y()) * invrdy;
            }
        } else {
                tymin = -numeric_limits<float>::infinity();
                tymax = numeric_limits<float>::infinity();
        }

    if ( (tmin > tymax) || (tymin > tmax) ) return Intersection();
    if ( tymin > tmin){
        ax = Y_AXIS;
        tmin = tymin;
    }
    if ( tymax < tmax) tmax = tymax;

    if(!isnan(invrdz)) {
            if (invrdz >= 0)
            {
                tzmin = (minP.z() - ray.org().z()) * invrdz;
                tzmax = (maxP.z() - ray.org().z()) * invrdz;
            }else
            {
                tzmin = (maxP.z() - ray.org().z()) * invrdz;
                tzmax = (minP.z() - ray.org().z()) * invrdz;
            }
        } else {
        tzmin = -numeric_limits<float>::infinity();
        tzmax = numeric_limits<float>::infinity();
    }

    if ( (tmin > tzmax) || (tzmin > tmax) ) return Intersection();
    if ( tzmin > tmin){
        ax = Z_AXIS;
        tmin = tzmin;
    }
    if ( tzmax < tmax) tmax = tzmax;

    // check if values are valid
    if (tmax < 0 || tmin == -numeric_limits<float>::infinity()
                || tmax == numeric_limits<float>::infinity()) return Intersection();
    if (tmin < 0){
        tmin = tmax;
    }
    
    //a,b could be calculated better, but this is more efficient and enough for normals
    float a,b;
    switch(ax){
    case X_AXIS:
        a = getLength(Y_AXIS)+getLength(Z_AXIS)/2;
        b = getLength(Y_AXIS)/2; break;
    case Y_AXIS:
        a = getLength(Y_AXIS)+getLength(Z_AXIS)/2;
        b = getLength(Y_AXIS) + getLength(X_AXIS)/2; break;
    default:
        a = getLength(Y_AXIS)/2;
        b = getLength(Y_AXIS)+getLength(X_AXIS)/2;
    }
    
    return Intersection(tmin, this, ray.atDistance(tmin), a, b);
}


const AABB& AABB::getBoundingBox() const
{
        return *this;
}

const Point3D& AABB::getCentroid() const
{
        return center;
}


void AABB::extend(const AABB& box)
{
        extend(box.minP);
        extend(box.maxP);
}

void AABB::extend(const Point3D& p)
{
        float xmin = min(p.x(), minP.x());
        float xmax = max(p.x(), maxP.x());
        float ymin = min(p.y(), minP.y());
        float ymax = max(p.y(), maxP.y());
        float zmin = min(p.z(), minP.z());
        float zmax = max(p.z(), maxP.z());
        
        minP = Point3D(xmin,ymin,zmin);
        maxP = Point3D(xmax,ymax,zmax);

        center = ((minP+maxP.getPosVec3D())*0.5);
}

float AABB::getLength(Axis a) const
{
        switch(a){
        case X_AXIS:
                return maxP.x() - minP.x();
        case Y_AXIS:
                return maxP.y() - minP.y();
        default:
                return maxP.z() - minP.z();
        }
}

Axis AABB::getMainAxis() const
{
        float xl = getLength(X_AXIS);
        float yl = getLength(Y_AXIS);
        float zl = getLength(Z_AXIS);
        
        if(xl < yl){
                if(yl < zl)
                        return Z_AXIS;
                return Y_AXIS;
        }
        else if(xl < zl)
                return Z_AXIS;
        return X_AXIS;
                
}

float AABB::getMin(Axis a) const
{
        switch(a){
        case X_AXIS:
                return minP.x();
        case Y_AXIS:
                return minP.y();
        default:
                return minP.z();
        }
}

float AABB::getMax(Axis a) const
{
        switch(a){
        case X_AXIS:
                return maxP.x();
        case Y_AXIS:
                return maxP.y();
        default:
                return maxP.z();
        }
}

const Point3D& AABB::getMaxP() const
{
        return maxP;
}

const Point3D& AABB::getMinP() const
{
        return minP;
}

bool AABB::equals(const AABB& box) const
{
        return minP.equals(box.minP) && maxP.equals(box.maxP);
}

AABB AABB::transformed(const Matrix4D& mat) const
{
        AABB box;
        box.extend(mat*minP);
        box.extend(mat*maxP);
        box.extend(mat*Point3D(minP.x(),minP.y(),maxP.z()));
        box.extend(mat*Point3D(minP.x(),maxP.y(),minP.z()));
        box.extend(mat*Point3D(minP.x(),maxP.y(),maxP.z()));
        box.extend(mat*Point3D(maxP.x(),minP.y(),minP.z()));
        box.extend(mat*Point3D(maxP.x(),minP.y(),maxP.z()));
        box.extend(mat*Point3D(maxP.x(),maxP.y(),minP.z()));
        return box;
}

Vec3D AABB::getSNormal(float a, float b) const
{
        return getGNormal(a,b);
}

Vec3D AABB::getGNormal(float a, float b) const
{
        float lX = getLength(X_AXIS);
        float lY = getLength(Y_AXIS);
        float lZ = getLength(Z_AXIS);
        if(a < 0 || b < 0 || a > 2*lY+lZ)
                return Vec3D(1,1,1);
        if(a < lY){
                if(b > lY && b < 2*lY)
                        return Vec3D(0,0,-1);
                return Vec3D(1,1,1);
        } else if(a < lY+lZ){
                float l = 2*lY+2*lX;
                if(b > l)
                        return Vec3D(1,1,1);
                l -= lX;
                if(b > l)
                        return Vec3D(0,-1,0);
                l -= lY;
                if(b > l)
                        return Vec3D(1,0,0);
                l -= lX;
                if(b > l)
                        return Vec3D(0,1,0);
                return Vec3D(-1,0,0);
        } else if(b >= lY && b <= 2*lY)
                return Vec3D(0,0,1);
        return Vec3D(1,1,1);
}

Point2D AABB::getUV(float a, float b) const
{
        return Point2D(a,b);
}

float AABB::getVolume() const
{
        return fabs(maxP[0] - minP[0]) * fabs(maxP[1] - minP[1]) * fabs(maxP[2] - minP[2]);
}

float AABB::getSurfaceArea() const
{
        float a = fabs(maxP[0] - minP[0]);
        float b = fabs(maxP[1] - minP[1]);
        float c = fabs(maxP[2] - minP[2]);
        return 2 * (a*b + a*c + b*c);
}

bool AABB::isEmpty() const {
        return minP == Point3D(std::numeric_limits<float>::infinity()) && maxP == Point3D(-std::numeric_limits<float>::infinity());
}

void AABB::contract(const AABB& box)
{
        minP = Point3D(box.getMinP()[0] > minP[0] ? box.getMinP()[0] : minP[0],
                        box.getMinP()[1] > minP[1] ? box.getMinP()[1] : minP[1],
                        box.getMinP()[2] > minP[2] ? box.getMinP()[2] : minP[2]);
        
        maxP = Point3D(box.getMaxP()[0] < maxP[0] ? box.getMaxP()[0] : maxP[0],
                                box.getMaxP()[1] < maxP[1] ? box.getMaxP()[1] : maxP[1],
                                box.getMaxP()[2] < maxP[2] ? box.getMaxP()[2] : maxP[2]);
        
}

void AABB::clipPlane(Axis axis, float plane, AABB& lBox, AABB& rBox) const {
        /*if (minP[axis] > plane) {
                rBox = AABB(minP,maxP);
                return;
        }
        
        if (maxP[axis] < plane) {
                lBox = AABB(minP,maxP);
                return;
        }
        */
        Point3D maxLP = maxP; maxLP[axis] = plane;
        Point3D minRP = minP; minRP[axis] = plane;
        
        lBox = AABB(minP,maxLP);
        rBox = AABB(minRP, maxP);
}

}

---