FLGeometry3DLine.h

#pragma once
 
#include "FLGeometry3DAxis.h"

namespace FLImaging
{
    namespace Foundation
    {
        template <typename Ty>
        class FL_EXPORT CMatrixFor3DTransform;
 
        template <typename Ty>
        class FL_EXPORT CFLGeometry3DDirection;
 
        template <typename Ty>
        class FL_EXPORT CFLPoint3;

        template <typename Ty>
        class FL_EXPORT CFLGeometry3DLine : public Base::CFLBase
        {
        public:
            CFLGeometry3DLine();

            CFLGeometry3DLine(const CFLGeometry3DAxis<Ty>& axisPos);

            CFLGeometry3DLine(const CFLPoint3<Ty>& flp3Origin, const CFLGeometry3DDirection<Ty>& dir);

            void Reverse();

            CFLGeometry3DLine<Ty> GetReversed() const;

            void SetDirection(const CFLGeometry3DDirection<Ty>& dir);

            void SetLocation(const CFLPoint3<Ty>& flp3Origin);

            void SetPosition(const CFLGeometry3DAxis<Ty>& axis);

            const CFLGeometry3DDirection<Ty>* GetDirection() const;

            const CFLPoint3<Ty>* GetLocation() const;

            const CFLGeometry3DAxis<Ty>* GetPosition() const;

            double GetAngle(const CFLGeometry3DLine<Ty>& rhs) const;

            double GetAngleInRadian(const CFLGeometry3DLine<Ty>& rhs) const;

            bool Contains(const CFLPoint3<Ty>& flp3, double f64LinearTolerance) const;

            double GetDistance(const CFLPoint3<Ty>& flp3Point) const;

            double GetDistance(const CFLGeometry3DLine<Ty>& rhs) const;

            double GetSquareDistance(const CFLPoint3<Ty>& flp3) const;

            double GetSquareDistance(const CFLGeometry3DLine<Ty>& rhs) const;

            CFLGeometry3DLine<Ty> GetNormalLine(const CFLPoint3<Ty>& flp3) const;

            const CResult Reflect(const CFLPoint3<Ty>& flp3Pivot);

            CFLGeometry3DLine<Ty> GetReflected(const CFLPoint3<Ty>& flp3Pivot) const;

            const CResult Reflect(const CFLGeometry3DAxis<Ty>& axisOfSymmetry);

            CFLGeometry3DLine<Ty> GetReflected(const CFLGeometry3DAxis<Ty>& axisOfSymmetry) const;

            const CResult Reflect(const CFLGeometry3DCoordinateSystemRH<Ty>& planeOfSymmetry);

            CFLGeometry3DLine<Ty> GetReflected(const CFLGeometry3DCoordinateSystemRH<Ty>& planeOfSymmetry) const;

            const CResult Rotate(const CFLGeometry3DAxis<Ty>& axisOfRotation, double f64Angle);

            CFLGeometry3DLine<Ty> GetRotated(const CFLGeometry3DAxis<Ty>& axisOfRotation, double f64Angle) const;

            const CResult Scale(double f64Scale, const CFLPoint3<Ty>& flp3Pivot);

            CFLGeometry3DLine<Ty> GetScaled(double f64Scale, const CFLPoint3<Ty>& flp3Pivot) const;

            const CResult Transform(const CMatrixFor3DTransform<Ty>& trsf);

            CFLGeometry3DLine<Ty> GetTransformed(const CMatrixFor3DTransform<Ty>& trsf) const;

            const CResult Translate(const CFLGeometry3DVector<Ty>& vecTranslate);

            CFLGeometry3DLine<Ty> GetTranslated(const CFLGeometry3DVector<Ty>& vecTranslate) const;

            const CResult Translate(const CFLPoint3<Ty>& flp3From, const CFLPoint3<Ty>& flp3To);

            CFLGeometry3DLine<Ty> GetTranslated(const CFLPoint3<Ty>& flp3From, const CFLPoint3<Ty>& flp3To) const;
 
            SupportToDuplicateObject(CFLGeometry3DLine<Ty>, *this);
            DeclareGetClassType();
 
        protected:
            CFLGeometry3DAxis<Ty> m_axisPos;
        };
    }
}