src/rcrt/math/Point3D.cpp

Go to the documentation of this file.

#include <cmath>
#include "Point3D.h"

namespace rcrt
{


Point3D::Point3D()
{
        values[0] = values[1] = values[2] = 0;
}


Point3D::Point3D(const float& val)
{
        values[0] = values[1] = values[2] = val;
}


Point3D::Point3D(const float& xc, const float& yc, const float& zc)
{
        values[0] = xc;
        values[1] = yc;
        values[2] = zc;
}


Point3D::Point3D(const Point3D& p)
{
        assign(p);
}

Point3D::Point3D(const Vec3D& vec)
{
        values[0] = vec[0];
        values[1] = vec[1];
        values[2] = vec[2];
}


Point3D::~Point3D()
{
}


void Point3D::assign(const Point3D& p)
{
        if(&p != this){
                values[0] = p.values[0];
                values[1] = p.values[1];
                values[2] = p.values[2];
        }
}



const Point3D& Point3D::operator= (const Point3D& p)
{
        assign(p);
                
        return *this;
}


Point3D Point3D::operator+ (const Vec3D& vec) const
{
        return Point3D(values[0]+vec.x(),
                        values[1]+vec.y(),
                        values[2]+vec.z());
}


Point3D Point3D::operator- (const Vec3D& vec) const
{
        return Point3D(values[0]-vec.x(),
                        values[1]-vec.y(),
                        values[2]-vec.z());
}


Vec3D Point3D::operator+ (const Point3D& p) const
{
        return Vec3D(values[0]+p.values[0],
                        values[1]+p.values[1],
                        values[2]+p.values[2]);
}


Vec3D Point3D::operator- (const Point3D& p) const
{
        return Vec3D(values[0]-p.values[0],
                        values[1]-p.values[1],
                        values[2]-p.values[2]);
}


Point3D Point3D::operator* (const float& f) const
{
        return Point3D(values[0]*f,values[1]*f,values[2]*f);
}


Point3D Point3D::operator/ (const float& f) const
{
        float g = 1/f;
        return Point3D(values[0]*g,values[1]*g,values[2]*g);
}

float Point3D::operator[] (int i) const
{
        return values[i];
}

float& Point3D::operator[] (int i)
{
        return values[i];
}

bool Point3D::operator!= (const Point3D& p) const
{
        return values[0] != p.values[0] || values[1] != p.values[1]
                || values[2] != p.values[2];
}

bool Point3D::operator== (const Point3D& p) const
{
        return values[0] == p.values[0] && values[1] == p.values[1]
                && values[2] == p.values[2];
}

Vec3D Point3D::getPosVec3D() const
{
        return Vec3D(values[0], values[1], values[2]);
}


Point3D Point3D::abs() const
{
        return Point3D(fabs(values[0]),fabs(values[1]),fabs(values[2]));
}

bool Point3D::equals(const Point3D& p) const
{
        for(int i = 0; i < 4; i++)
                if(values[i] != p.values[i])
                        return false;
        return true;
}


const float& Point3D::x() const
{
        return values[0];
}


const float& Point3D::y() const
{
        return values[1];
}


const float& Point3D::z() const
{
        return values[2];
}

}

---