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, const 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 Mirror(const CFLPoint3<Ty>& flp3Pivot);
 
            CFLGeometry3DLine<Ty> GetMirrored(const CFLPoint3<Ty>& flp3Pivot) const;
 
            const CResult Mirror(const CFLGeometry3DAxis<Ty>& axisOfSymmetry);
 
            CFLGeometry3DLine<Ty> GetMirrored(const CFLGeometry3DAxis<Ty>& axisOfSymmetry) const;
 
            const CResult Mirror(const CFLGeometry3DCoordinateSystemRH<Ty>& planeOfSymmetry);
 
            CFLGeometry3DLine<Ty> GetMirrored(const CFLGeometry3DCoordinateSystemRH<Ty>& planeOfSymmetry) const;
 
            const CResult Rotate(const CFLGeometry3DAxis<Ty>& axisOfRotation, const double f64Angle);
 
            CFLGeometry3DLine<Ty> GetRotated(const CFLGeometry3DAxis<Ty>& axisOfRotation, const double f64Angle) const;
 
            const CResult Scale(const CFLPoint3<Ty>& flp3Pivot, const double f64Scale);
 
            CFLGeometry3DLine<Ty> GetScaled(const CFLPoint3<Ty>& flp3Pivot, const double f64Scale) 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;
        };
    }
}