D:/Programmierung/C/TRTK/include/TRTK/Plane.hpp

#ifndef PLANE_HPP
#define PLANE_HPP

#include <TRTK/Coordinate.hpp>
#include <math.h>
#include <Line3D.hpp>
#include <Eigen/Dense>
#include <Eigen/Core>
using namespace Eigen;

namespace TRTK
{
    template <class T>
    class Plane
    {
    public:
        typedef T value_type;

        Plane<T>(const Plane<T>&);                                                      
        Plane<T>(const Coordinate<T>&, const Coordinate<T>&, const Coordinate<T>&);     
        Plane<T>(const Line3D<T>&, const Line3D<T>&);                                   
        Plane<T>(const Coordinate<T>&, const Coordinate<T>&);                           
        Plane<T>(const Line3D<T>&, const Coordinate<T>&);                               

        Coordinate<T> pointOnPlane;
        Coordinate<T> normalVector;

        Coordinate<T>  getPoint() const;                        
        Coordinate<T>   getNormalVector() const;                

        void setPointOnPlane(const Coordinate<T> point) const;       
        void setNormalVector(const Coordinate<T> vector) const;      
    //  void set(const Coordinate<T> point, const Coordinate<T> vector) const;
        bool isParallel(const Plane<T>&) const; 
        bool isIntersecting(const Plane<T>&);   


        double getDistancePoint(const Coordinate<T>&) const;    
        double getDistansePlane(const Plane<T>&) const;     
        

        Line3D<T> getIntersectingLine(const Plane<T>&) const;   
        double getAngleBetweenPlanes(const Plane<T>&) const;    
        double getAngleBetweenPlaneAndLine(const Line3D<T>&) const; 
        Coordinate<T>   intersectionLineAndPlane(const Line3D<T>&) const;   
        //void Ausgleichsebene(const Coordinate<T>&, const Coordinate<T>&); ///<
    };


    template <class T> //Three points
    Plane<T>::Plane(const Plane<T>& plane)
    {
        this->pointOnPlane = plane.pointOnPlane;
        this->normalVector = plane.normalVector;

    }

    template <class T> //Three points
    Plane<T>::Plane(const Coordinate<T>& pointA, const Coordinate<T>& pointB, const Coordinate<T>& pointC)
    {
        this->pointOnPlane = pointA;  //Ortsvektor
        Coordinate<T> ab = pointA - pointB; // Richtungsvektor1
        Coordinate<T> bc = pointB - pointC; // Richtungsvektor2
        Coordinate<T> normalVector = ab.cross(bc);
        this->normalVector = normalVector;

    }

    template <class T> //Two Lines
    Plane<T>::Plane(const Line3D<T>& line1, const Line3D<T>& line2)
    {
        //Gegeben sind zwei Geraden, die nicht windschief sind, sondern sich schneiden oder parrallel zu einander sind
        if (line1.isParallel(line2) || line1.isIntersecting(line2)){
            //  Man wählt sich den Schnittpunkt der beiden Geraden als Stützvektor
            //und fügt beide Richtungsvektoren der Gleichungen als Spannvektoren hinzu und erhällt die Paramerterform der Ebene.
            this->pointOnPlane = line1.point;
            this->normalVector = line1.direction.cross(line2.direction);
        }
        else{
            //Geraden sind windschief
            std::stringstream os;
            os << "***\nFunction: " << __FUNCTION__ << " failed in File: " << __FILE__ << " Line: " << __LINE__ << "Lines are croocked 0\n";
            ErrorObj error;
            error.setClassName("Line3D");
            error.setFunctionName(__FUNCTION__);
            error.setErrorMessage(os.str());
            throw error;
        }
    }

    template <class T> //Point and normalvector
    Plane<T>::Plane(const Coordinate<T>& point, const Coordinate<T>& normalvector)
    {
        pointOnPlane = point;  //Ortsvektor
        normalVector = normalvector;
    }

    template <class T>// One line and one point
    Plane<T>::Plane(const Line3D<T>& line, const Coordinate<T>& pointA)
    {
        //  //Aus einem Punkt und einer Gerade lassen sich schnell drei Punkte erstellen.Ein Punkt ist uns schon durch A gegeben. Die anderen beiden wählen wir uns aus der Gerade.
        this->pointOnPlane = pointA;  //Ortsvektor
        Coordinate<T> pointB = line.point + 1 * line.direction;
        Coordinate<T> pointC = line.point + 2 * line.direction;

        Coordinate<T> AB = pointA - pointB; // Richtungsvektor1
        Coordinate<T> BC = pointB - pointC; // Richtungsvektor2

        Coordinate<T> normalVector = AB.cross(BC);
        this->normalVector = normalVector;

    }
     

    template <class T>
    double Plane<T>::getDistancePoint(const Coordinate<T>& point) const{
        // lege eine Gerade durch den Punkt und suche den Durchstoeungspunkt
        Line3D<T> line2(point, normalVector.normalized());
        Coordinate<T> vHelpPoint = intersectionLineAndPlane(line2);
        // bilde Differenz von vHelpPoint und vPoint
        Coordinate<T>  vDiff = vHelpPoint - point;
        // bilde den Betrag und damit die Entfernung
        double dist = vDiff.norm();
        return dist;
    }

    template <class T>
    double Plane<T>::getDistansePlane(const Plane<T>& plane2) const{
        //Hesse-Normalform bestimmen:
        Coordinate<T> m_result1 = pointOnPlane*normalVector;
        double result = (m_result1.x() + m_result1.y() + m_result1.z()) * (-1);
        double normalVector1 = std::sqrt(normalVector.norm());
        double normalVector2 = std::sqrt(plane2.normalVector.norm());
        Coordinate<T> m_point2(0, 0, result / normalVector.z());
        //Punkt in Hesse-Normalform einsetzen:
        double dist = normalVector.x()*m_point2.x() - normalVector.y()*m_point2.x() - normalVector.z()*m_point2.z() - result;
        return dist;
    }

    template <class T>
    bool Plane<T>::isIntersecting(const Plane<T>& plane2) {
        if (getDistansePlane(plane2) == 0){
            return true;
        }
        else {
            return false;
        }
    }

    template <class T>
    bool Plane<T>::isParallel(const Plane<T>& plane2) const{
        double r1 = normalVector.x() / plane2.normalVector.x();
        double r2 = normalVector.y() / plane2.normalVector.y();
        double r3 = normalVector.z() / plane2.normalVector.z();
        if (r1 == r2 && r2 == r3){
            return true;
        }
        else{
            return false;
        }
    }

    template <class T>
    Line3D<T> Plane<T>::getIntersectingLine(const Plane<T>& plane2) const{
    // Wir haben zwei Ebenen in Paramatherform

        //Der Richtungsvektor der Geraden berechnet sich dann durch:
        Coordinate<T> norm_line = plane2.normalVector.cross(normalVector);
        //Wir benötigen jetzt noch den Stützvektor. 
        //Dazu formen wir, wie oben erwähnt, die Ebenendarstellungen von der Normalenform in die allgemeine Ebenenform  



        double result1 = (m_result1.x() + m_result1.y() + m_result1.z());
        Coordinate<T> m_result2 = plane2.pointOnPlane*plane2.normalVector;
        double result2 = (m_result2.x() + m_result2.y() + m_result2.z());

        //Ein Richtungsvektor ergibt sich daher aus dem Vektorprodukt der beiden Normalenvektoren.
        Coordinate<T> normalSchnitt = normalVector.cross(plane2.normalVector);
        double normalVector1 = normalVector.norm();
        double normalVector2 = plane2.normalVector.norm();
        return normalSchnitt;
    }


    template <class T>
    double Plane<T>::getAngleBetweenPlanes(const Plane<T>& plane2) const{
        Coordinate<T> sum = plane2.normalVector * normalVector;
        double CoordinSumme = sum.x() + sum.y() + sum.z();
        double ret = CoordinSumme / (normalVector.norm() *plane2.normalVector.norm());
        return (ret);
    }
    template <class T>double Plane<T>::getAngleBetweenPlaneAndLine(const Line3D<T>& line2)const{
        Coordinate<T> sum = line2.direction * normalVector;
        double CoordinSumme = sum.x() + sum.y() + sum.z();
        double ret = CoordinSumme / (normalVector.norm() *line2.direction.norm());
        return ret;
    }
    template <class T>
    Coordinate<T>   Plane<T>::intersectionLineAndPlane(const Line3D<T> & line2) const{
        // gucken, dass Line nicht parallel zu Ebene liegt
        if (line2.direction.dot(normalVector) != 0){
        double dLambda = pointOnPlane.dot(normalVector) - line2.point.dot(line2.direction) / (normalVector.dot(line2.direction));
        Coordinate<double> vIntersection = (pointOnPlane + dLambda * normalVector);
        return vIntersection;
        }
        else{
            std::stringstream os;
            os << "***\nFunction: " << __FUNCTION__ << " failed in File: " << __FILE__ << " Line: " << __LINE__ << "Line and Plane are parallel 0\n";
            ErrorObj error;
            error.setClassName("Line3D");
            error.setFunctionName(__FUNCTION__);
            error.setErrorMessage(os.str());
            throw error;
        }
    }

    template <class T>
    Coordinate<T>  Plane<T>::getPoint() const{
        return pointOnPlane; 
    }

    template <class T>
    Coordinate<T>   Plane<T>::getNormalVector() const{
        return normalVector; 
    }
    template <class T>
    void Plane<T>::setPointOnPlane(const Coordinate<T> point) const{
        pointOnPlane = point; 
    }
    template <class T>
    void Plane<T>::setNormalVector(const Coordinate<T> vector) const{
        normalVector = vector; 
    }

    //template <class T>
    //void Plane<T>::set(const Coordinate<T> point, const Coordinate<T> vector) const{
    //  normalVector = vector;
    //  pointOnPlane = point;
    //}
} //End of the namespace TRTK

#endif