src/rcrt/math/HCoord4D.cpp

Go to the documentation of this file.

#include <cmath>
#include "HCoord4D.h"
#include "NotNormalizableException.h"
using namespace std;

namespace rcrt
{


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


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


HCoord4D::HCoord4D(float xc, float yc, float zc, float wc)
{
        values[0] = xc;
        values[1] = yc;
        values[2] = zc;
        values[3] = wc;
}


HCoord4D::HCoord4D(const HCoord4D& coords)
{
        assign(coords);
}


HCoord4D::HCoord4D(const Point3D& p)
{
        values[0] = p.x();
        values[1] = p.y();
        values[2] = p.z();
        values[3] = 1;
}


HCoord4D::HCoord4D(const Vec3D& vec)
{
        values[0] = vec.x();
        values[1] = vec.y();
        values[2] = vec.z();
        values[3] = 0;
}


HCoord4D::~HCoord4D()
{
}


const HCoord4D& HCoord4D::operator= (const HCoord4D& coord)
{
        assign(coord);

        return *this;
}


HCoord4D HCoord4D::operator+ (const HCoord4D& coord) const
{
        return HCoord4D(values[0]+coord.values[0],
                        values[1]+coord.values[1],
                        values[2]+coord.values[2],
                        values[3]+coord.values[3]);
}


HCoord4D HCoord4D::operator- (const HCoord4D& coord) const
{
        return HCoord4D(values[0]-coord.values[0],
                        values[1]-coord.values[1],
                        values[2]-coord.values[2],
                        values[3]-coord.values[3]);
}


float HCoord4D::operator* (const HCoord4D& coord) const
{
        return values[0]*coord.values[0]+
                        values[1]*coord.values[1]+
                        values[2]*coord.values[2]+
                        values[3]*coord.values[3];
}


const HCoord4D& HCoord4D::normalize()
{
        if(values[3] == 0)
                throw NotNormalizableException();
        else{
                float rec = 1/values[3];
                values[0] *= rec;
                values[1] *= rec;
                values[2] *= rec;
                values[3] = 1;
        }
        
        return *this;
}


HCoord4D HCoord4D::normalized() const
{
        if(values[3] == 0)
                throw NotNormalizableException();
        else{
                float rec = 1/values[3];
                return HCoord4D(values[0]*rec,values[1]*rec,values[2]*rec,1);
        }
}


bool HCoord4D::isNormalized() const
{
        return values[3] == 1;
}


float HCoord4D::norm() const
{
        return sqrt(values[0]*values[0]+values[1]*values[1]+values[2]*values[2]+values[3]*values[3]);
}


Point3D HCoord4D::toPoint3D() const
{
        float rec = 1/values[3];
        return Point3D(values[0]*rec,values[1]*rec,values[2]*rec);
}


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


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


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


const float& HCoord4D::w() const
{
        return values[3];
}

}

---