point3d.h

Go to the documentation of this file.

#ifndef POINT3D_H
#define POINT3D_H

#include <cmath>
#include <sstream>
#include <algorithm>
#include "raytrace_defs.h"

class Point3D;
typedef Point3D Vector;

inline bool iswhitespace(char c) {
    return c == ' '
        || c == '\n'
        || c == '\r'
        || c == '\t';
}
//{{{
class Point3D {
    public:
        
        double x;
        double y;
        double z;

        Point3D() : x(0.0), y(0.0), z(0.0) {}

        template <class _T>
        Point3D(_T _x, _T _y) : x((double)_x), y((double)_y), z(0.0) {}

        template <class _T>
        Point3D(_T _x, _T _y, _T _z) : x((double)_x), y((double)_y), z((double)_z) {}

        Point3D(std::string str) {
            syslog(LOG_INFO, "%s", str.c_str());
            // remove all whitespace
            std::string::iterator end;
            std::remove_if(str.begin(), end, iswhitespace);
            int openparen   = str.find('(');
            int closeparen  = str.find(')');
            int firstcomma  = str.find(',') + 1;
            int secondcomma = str.find(',', firstcomma) + 1;
            
            x = (double)strtod(str.substr(openparen+1, firstcomma - openparen).c_str(),     NULL);
            y = (double)strtod(str.substr(firstcomma, secondcomma - firstcomma).c_str(),  NULL);
            z = (double)strtod(str.substr(secondcomma, closeparen - secondcomma).c_str(), NULL);
        }

        Point3D(const Point3D &other) : x(other.x), y(other.y), z(other.z) {}

        inline double distance_to(const Point3D &other);

        std::string to_string() {
            std::ostringstream rv;
            rv << "(" << x << ", " << y << ", " << z << ")";
            return rv.str();
        }

        template <class _T>
        void set(_T x, _T y, _T z) {
            this->x = (double)x;
            this->y = (double)y;
            this->z = (double)z;
        }

        void normalize() {
            double norm = sqrtf(x * x + y * y + z * z);
            x /= norm;
            y /= norm;
            z /= norm;
        }

};
//}}}

// This is inline, it must be defined in the header.
//{{{
double Point3D::distance_to(const Point3D &other) {
    double dx = x - other.x;
    double dy = y - other.y;
    double dz = z - other.z;
    return sqrtf(dx*dx + dy*dy + dz*dz);
}
//}}}

//{{{
inline Vector operator-(const Vector &A, const Vector &B) {
    return Vector(A.x - B.x, A.y - B.y, A.z - B.z);
}
//}}}
//{{{
inline Vector operator-(const Vector &A) {
    return Vector( -A.x, -A.y, -A.z);
}
//}}}

//{{{
inline Vector operator+(const Vector &A, const Vector &B) {
    return Vector(A.x + B.x, A.y + B.y, A.z + B.z);
}
//}}}
//{{{
inline Vector operator*(const Vector &A, double factor) {
    return Vector(A.x * factor, A.y * factor, A.z * factor);
}
//}}}

//{{{
inline bool operator==(const Vector &A, const Vector &B) {
    return (A.x == B.x) && (A.y == B.y) && (A.z == B.z);
}
//}}}
//{{{
inline bool operator!=(const Vector &A, const Vector &B) {
    return !(A == B);
}
//}}}

//{{{
inline double dot_product(const Vector &A, const Vector &B) {
    return (A.x * B.x) + (A.y * B.y) + (A.z * B.z);
}
//}}}

//{{{
inline 
Vector cross_product(const Vector& one, const Vector& two)
{
    return Vector(one.y * two.z - one.z * two.y,
                  one.z * two.x - one.x * two.z,
                  one.x * two.y - one.y * two.x);

}
//}}}
//{{{
template <class _T>
inline Vector operator*(Vector &v, const _T n) {
    return Vector(v.x * (double)n, v.y * (double)n, v.z * (double)n);
}
//}}}


#endif

---