FLFrustum.h

#pragma once
 
#include "FLQuad3.h"
#include "FLGeometry3DPlane.h"
#include "FLGeometry3DVector.h"
 
namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class FL_EXPORT CFLFrustum : public CFLFigure
        {
        public:
            CFLQuad3<T> flqQuads[2];
 
            enum EVertex
            {
                EVertex_LeftTopNear = 0,
 
                EVertex_RightTopNear,
 
                EVertex_RightBottomNear,
 
                EVertex_LeftBottomNear,
 
                EVertex_LeftTopFar,
 
                EVertex_RightTopFar,
 
                EVertex_RightBottomFar,
 
                EVertex_LeftBottomFar,
 
                EVertex_Count,
            };
 
            enum EPlane
            {
                EPlane_Top = 0,
 
                EPlane_Bottom,
 
                EPlane_Left,
 
                EPlane_Right,
 
                EPlane_Near,
 
                EPlane_Far,
            };
 
            CFLFrustum();
 
            virtual ~CFLFrustum();
 
            CFLFrustum(const CFLFrustum<float>& rhs);
 
            CFLFrustum(const CFLFrustum<double>& rhs);
 
            CFLFrustum(const CFLFrustum<float>* pRhs);
 
            CFLFrustum(const CFLFrustum<double>* pRhs);
 
            CFLFrustum(const Base::THexahedron<float>& tHexahedron);
 
            CFLFrustum(const Base::THexahedron<double>& tHexahedron);
 
            CFLFrustum(const Base::THexahedron<float>* pTHexahedron);
 
            CFLFrustum(const Base::THexahedron<double>* pTHexahedron);
 
            CFLFrustum(const CFLQuad3<float>& flqQuad1, const CFLQuad3<float>& flqQuad2);
 
            CFLFrustum(const CFLQuad3<double>& flqQuad1, const CFLQuad3<double>& flqQuad2);
 
            CFLFrustum(const CFLQuad3<float>* pFlqQuad1, const CFLQuad3<float>* pFlqQuad2);
 
            CFLFrustum(const CFLQuad3<double>* pFlqQuad1, const CFLQuad3<double>* pFlqQuad2);
 
            CFLFrustum(const CFLFigure& flf);
 
            CFLFrustum(const CFLFigure* pFlf);
 
            virtual const CResult Set(const CFLFrustum<float>& flfr);
 
            virtual const CResult Set(const CFLFrustum<double>& flfr);
 
            virtual const CResult Set(const CFLFrustum<float>* pFlfr);
 
            virtual const CResult Set(const CFLFrustum<double>* pFlfr);
 
            virtual const CResult Set(const Base::THexahedron<float>& tHexahedron);
 
            virtual const CResult Set(const Base::THexahedron<double>& tHexahedron);
 
            virtual const CResult Set(const Base::THexahedron<float>* pTHexahedron);
 
            virtual const CResult Set(const Base::THexahedron<double>* pTHexahedron);
 
            virtual const CResult Set(const CFLQuad3<float>& flqQuad1, const CFLQuad3<float>& flqQuad2);
 
            virtual const CResult Set(const CFLQuad3<double>& flqQuad1, const CFLQuad3<double>& flqQuad2);
 
            virtual const CResult Set(const CFLQuad3<float>* pFlqQuad1, const CFLQuad3<float>* pFlqQuad2);
 
            virtual const CResult Set(const CFLQuad3<double>* pFlqQuad1, const CFLQuad3<double>* pFlqQuad2);
 
            virtual const CResult SetVertex(EVertex eVertexPos, const Base::TPoint3<float>& tp3) sealed;
 
            virtual const CResult SetVertex(EVertex eVertexPos, const Base::TPoint3<double>& tp3) sealed;
 
            virtual const CResult SetVertex(EVertex eVertexPos, const Base::TPoint3<float>* pTp3) sealed;
 
            virtual const CResult SetVertex(EVertex eVertexPos, const Base::TPoint3<double>* pTp3) sealed;
            
            virtual const CResult SetVertex(EVertex eVertexPos, const Foundation::CFLPoint3<float>& flp3) sealed;
 
            virtual const CResult SetVertex(EVertex eVertexPos, const Foundation::CFLPoint3<double>& flp3) sealed;
 
            virtual const CResult SetVertex(EVertex eVertexPos, const Foundation::CFLPoint3<float>* pFlp3) sealed;
 
            virtual const CResult SetVertex(EVertex eVertexPos, const Foundation::CFLPoint3<double>* pFlp3) sealed;
 
            virtual const Foundation::CFLPoint3<T>* GetVertex(EVertex eVertexPos) const sealed;
 
            virtual const CFLGeometry3DVector<T> GetEquationOfPlane(EPlane ePlane) const sealed;
 
            virtual bool Contains(const Base::TPoint3<float>& tp3) const;
 
            virtual bool Contains(const Base::TPoint3<double>& tp3) const;
 
            virtual bool Contains(const Base::TPoint3<float>* pTp3) const;
 
            virtual bool Contains(const Base::TPoint3<double>* pTp3) const;
 
            virtual bool Contains(const Foundation::CFLPoint3<float>& flp3) const;
 
            virtual bool Contains(const Foundation::CFLPoint3<double>& flp3) const;
 
            virtual bool Contains(const Foundation::CFLPoint3<float>* pFlp3) const;
 
            virtual bool Contains(const Foundation::CFLPoint3<double>* pFlp3) const;
 
            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<float>>& flaVertices, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;
 
            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<double>>& flaVertices, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;
 
            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<float>>* pFlaVertices, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;
 
            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<double>>* pFlaVertices, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;
 
            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<float>>& flaVertices, const Base::CFLArray<int32_t>& flaTargetIndex, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;
 
            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<double>>& flaVertices, const Base::CFLArray<int32_t>& flaTargetIndex, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;
 
            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<float>>* pFlaVertices, const Base::CFLArray<int32_t>& flaTargetIndex, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;
 
            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<double>>* pFlaVertices, const Base::CFLArray<int32_t>& flaTargetIndex, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;
 
            virtual bool IsCollision(const Base::TPoint3<float>& tp3Begin, const Base::TPoint3<float>& tp3End) const;
 
            virtual bool IsCollision(const Base::TPoint3<double>& tp3Begin, const Base::TPoint3<double>& tp3End) const;
 
            virtual bool IsCollision(const Base::TPoint3<float>* pTp3Begin, const Base::TPoint3<float>* pTp3End) const;
 
            virtual bool IsCollision(const Base::TPoint3<double>* pTp3Begin, const Base::TPoint3<double>* pTp3End) const;
 
            virtual bool IsCollision(const Foundation::CFLPoint3<float>& flp3Begin, const Foundation::CFLPoint3<float>& flp3End) const;
 
            virtual bool IsCollision(const Foundation::CFLPoint3<double>& flp3Begin, const Foundation::CFLPoint3<double>& flp3End) const;
 
            virtual bool IsCollision(const Foundation::CFLPoint3<float>* pFlp3Begin, const Foundation::CFLPoint3<float>* pFlp3End) const;
 
            virtual bool IsCollision(const Foundation::CFLPoint3<double>* pFlp3Begin, const Foundation::CFLPoint3<double>* pFlp3End) const;
 
 
            virtual const CResult Set(const CFLFigure& flf) override;
            virtual const CResult Set(const CFLFigure* pFlf) override;
 
            virtual void Clear() override;
 
            virtual EFigureDeclType GetDeclType() const override;
            virtual EFigureTemplateType GetTemplateType() const override;
 
 
            const CFLFrustum<T>& operator=(const CFLFrustum<float>& rhs);
 
            const CFLFrustum<T>& operator=(const CFLFrustum<double>& rhs);
 
            const CFLFrustum<T>& operator=(const Base::THexahedron<float>& rhs);
 
            const CFLFrustum<T>& operator=(const Base::THexahedron<double>& rhs);
 
 
            SupportToDuplicateObject(CFLFrustum<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLFrustum<float> CFLFrustumF;
        typedef CFLFrustum<double> CFLFrustumD;
    }
}