pobject.hpp

Ugrás a fájl dokumentációjához.

 
#ifndef POBJECT_HPP
#define POBJECT_HPP
 
#include <iostream>
using namespace std;
 
namespace bme {

    template<typename T>
    class PObject {
    private:
        T x, y, z;
 
        void scale() {
            if (z != T(0)) {
                x /= z;
                y /= z;
                z = T(1);
            }
            else if (y != T(0)) {
                x /= y;
                y = T(1);
            }
            else if (x != T(0)) {
                x = T(1);
            }
        }
 
        T dot(const PObject<T>& other) const {
            return x * other.x + y * other.y + z * other.z;
        }
 
    protected:
        bool equals(const PObject<T>& other) const {
            return ((x == other.x) && (y == other.y) && (z == other.z));
        }

        bool less(const PObject<T>& other) const {
            if (x < other.x) { return true; }
            if (x > other.x) { return false; }
            if (y < other.y) { return true; }
            if (y > other.y) { return false; }
            if (z < other.z) { return true; }
            return false;
        }

        bool incident(const PObject<T>& other) const {
            return dot(other) == T(0);
        }

        PObject<T> op(const PObject<T>& other) const {
            if (equals(other)) { return PObject<T>(T(0), T(0), T(0)); }
 
            T c1 = y * other.z - z * other.y;
            T c2 = z * other.x - x * other.z;
            T c3 = x * other.y - y * other.x;
 
            return PObject<T>(c1, c2, c3);
 
        }
 
    public:
        PObject() {
            x = y = T(0);
            z = T(1);
        }
        PObject(T a, T b, T c) {
            x = a;
            y = b;
            z = c;
            scale();
        }

        T getX() const { return x; }
        T getY() const { return y; }
        T getZ() const { return z; }

        bool is_invalid() const {
            return (x == T(0)) && (y == T(0)) && (z == T(0));
        }
    };

    template<typename T>
    ostream& operator<<(ostream& os, const PObject<T>& A) {
        os << "<" << A.getX() << "," << A.getY() << "," << A.getZ() << ">";
        return os;
    }

    template<typename T>
    bool dependent(const PObject<T>& A, const PObject<T>& B, const PObject<T>& C) {
        T a1 = A.getX();
        T a2 = A.getY();
        T a3 = A.getZ();
 
        T b1 = B.getX();
        T b2 = B.getY();
        T b3 = B.getZ();
 
        T c1 = C.getX();
        T c2 = C.getY();
        T c3 = C.getZ();
 
        T det = a1 * b2 * c3 + a2 * b3 * c1 + a3 * b1 * c2
            - a3 * b2 * c1 - a1 * b3 * c2 - a2 * b1 * c3;
 
        return det == T(0);
    }
 
}
 
#endif