Point3D.h

Go to the documentation of this file.

 
// ###########################################################################################################################################################################################################################################################################################################################
 
#pragma once
 
namespace ot {
 
    template <class T> class Point3D {
    public:
        Point3D(T _x, T _y, T _z);
 
        Point3D(const Point3D<T> & _other);
 
        Point3D<T> & operator = (const Point3D<T> & _other);
        Point3D<T> operator + (const Point3D<T> & _other) const;
        Point3D<T> operator - (const Point3D<T> & _other) const;
        Point3D<T> operator * (const Point3D<T> & _other) const;
        Point3D<T> operator / (const Point3D<T> & _other) const;
        Point3D<T> & operator += (const Point3D<T> & _other);
        Point3D<T> & operator -= (const Point3D<T> & _other);
        Point3D<T> & operator *= (const Point3D<T> & _other);
        Point3D<T> & operator /= (const Point3D<T> & _other);
        bool operator == (const Point3D<T> & _other);
        bool operator != (const Point3D<T> & _other);
 
        inline T x(void) const { return m_x; }
 
        inline T y(void) const { return m_y; }
 
        inline T z(void) const { return m_z; }
 
        void setX(T _x) { m_x = _x; }
 
        void setY(T _y) { m_y = _y; }
 
        void setZ(T _z) { m_z = _z; }
 
        T addX(T _v);
 
        T addY(T _v);
 
        T addZ(T _z);
 
        T subX(T _v);
 
        T subY(T _v);
 
        T subZ(T _v);
 
    private:
        // Block default constructor
        Point3D() = delete;
 
        T       m_x;            
        T       m_y;            
        T       m_z;            
 
    }; // class Point3D
 
    template <class T> Point3D<T>::Point3D(T _x, T _y, T _z) { m_x = _x; m_y = _y; m_z = _z; }
 
    template <class T> Point3D<T>::Point3D(const Point3D<T> & _other) { m_x = _other.x(); m_y = _other.y(); m_z = _other.z(); }
 
    template <class T> Point3D<T> & Point3D<T>::operator = (const Point3D<T> & _other) {
        m_x = _other.x(); m_y = _other.y(); m_z = _other.z();
        return *this;
    }
 
    template <class T> Point3D<T> Point3D<T>::operator + (const Point3D<T> & _other) const {
        Point3D<T> ret(m_x + _other.m_x, m_y + _other.m_y, m_z + _other.m_z);
        return ret;
    }
 
    template <class T> Point3D<T> Point3D<T>::operator - (const Point3D<T> & _other) const {
        Point3D<T> ret(m_x - _other.m_x, m_y - _other.m_y, m_z - _other.m_z);
        return ret;
    }
 
    template <class T> Point3D<T> Point3D<T>::operator * (const Point3D<T> & _other) const {
        Point3D<T> ret(m_x * _other.m_x, m_y * _other.m_y, m_z * _other.m_z);
        return ret;
    }
 
    template <class T> Point3D<T> Point3D<T>::operator / (const Point3D<T> & _other) const {
        T x = m_x;
        T y = m_y;
        T z = m_z;
        if (_other.m_x != 0) { x /= _other.m_x; }
        if (_other.m_y != 0) { y /= _other.m_y; }
        if (_other.m_z != 0) { z /= _other.m_z; }
        Point3D<T> ret(x, y, z);
        return ret;
    }
 
    template <class T>  Point3D<T> & Point3D<T>::operator += (const Point3D<T> & _other) {
        m_x = m_x + _other.m_x;
        m_y = m_y + _other.m_y;
        m_z = m_z + _other.m_z;
        return *this;
    }
 
    template <class T>  Point3D<T> & Point3D<T>::operator -= (const Point3D<T> & _other) {
        m_x = m_x - _other.m_x;
        m_y = m_y - _other.m_y;
        m_z = m_z - _other.m_z;
        return *this;
    }
 
    template <class T>  Point3D<T> & Point3D<T>::operator *= (const Point3D<T> & _other) {
        m_x = m_x * _other.m_x;
        m_y = m_y * _other.m_y;
        m_z = m_z * _other.m_z;
        return *this;
    }
 
    template <class T>  Point3D<T> & Point3D<T>::operator /= (const Point3D<T> & _other) {
        if (_other.m_x != 0) { m_x /= _other.m_x; }
        if (_other.m_y != 0) { m_y /= _other.m_y; }
        if (_other.m_z != 0) { m_z /= _other.m_z; }
        return *this;
    }
 
    template <class T> bool Point3D<T>::operator == (const Point3D<T> & _other) {
        if (m_x != _other.x()) { return false; }
        if (m_y != _other.y()) { return false; }
        if (m_z != _other.z()) { return false; }
        return true;
    }
 
    template <class T> bool Point3D<T>::operator != (const Point3D<T> & _other) { return !(*this == _other); }
    
    template <class T> T Point3D<T>::addX(T _v) { m_x = m_x + _v; return m_x; }
 
    template <class T> T Point3D<T>::addY(T _v) { m_y = m_y + _v; return m_y; }
 
    template <class T> T Point3D<T>::addZ(T _v) { m_z = m_z + _v; return m_z; }
 
    template <class T> T Point3D<T>::subX(T _v) { m_x = m_x - _v; return m_x; }
 
    template <class T> T Point3D<T>::subY(T _v) { m_y = m_y - _v; return m_y; }
 
    template <class T> T Point3D<T>::subZ(T _v) { m_z = m_z - _v; return m_z; }
 
}