FLImagingFoundation/FLCylinder3.h

#pragma once

 
#include "FLFigure3.h"
#include "FLCircle3.h"

namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class FL_EXPORT CFLCylinder3 : public CFLFigure3
        {
        public:
            CFLCircle3<T> flcBase;

            T tHeight;

            CFLCylinder3();

            virtual ~CFLCylinder3();


            CFLCylinder3(const CFLCylinder3<float>& rhs);
            CFLCylinder3(const CFLCylinder3<double>& rhs);
            CFLCylinder3(const CFLCylinder3<float>* pRhs);
            CFLCylinder3(const CFLCylinder3<double>* pRhs);


            CFLCylinder3(const CFLFigure& flf);
            CFLCylinder3(const CFLFigure* pFlf);


            CFLCylinder3(const CFLCircle3<float>& flcBase, double f64Height);
            CFLCylinder3(const CFLCircle3<float>* pFlcBase, double f64Height);
            CFLCylinder3(const CFLCircle3<double>& flcBase, double f64Height);
            CFLCylinder3(const CFLCircle3<double>* pFlcBase, double f64Height);


            virtual const CResult Set(const CFLCylinder3<float>& flcy);
            virtual const CResult Set(const CFLCylinder3<float>* pFlcy);
            virtual const CResult Set(const CFLCylinder3<double>& flcy);
            virtual const CResult Set(const CFLCylinder3<double>* pFlcy);
 
            virtual const CResult Set(const CFLFigure& flf) override;
            virtual const CResult Set(const CFLFigure* pFlf) override;


            virtual const CResult Set(const CFLCircle3<float>& flcBase, double f64Height);
            virtual const CResult Set(const CFLCircle3<float>* pFlcBase, double f64Height);
            virtual const CResult Set(const CFLCircle3<double>& flcBase, double f64Height);
            virtual const CResult Set(const CFLCircle3<double>* pFlcBase, double f64Height);
            
            virtual const CFLPoint3<T> GetTopCenter() const;

            virtual const CFLPoint3<T> GetBottomCenter() const;


            virtual bool Contains(const Base::TPoint3<float>& tp3) const;
            virtual bool Contains(const Base::TPoint3<float>* pTp3) const;
            virtual bool Contains(const Base::TPoint3<double>& tp3) const;
            virtual bool Contains(const Base::TPoint3<double>* pTp3) const;


            virtual bool Contains(const CFLPoint3<float>& flp3) const;
            virtual bool Contains(const CFLPoint3<float>* pFlp3) const;
            virtual bool Contains(const CFLPoint3<double>& flp3) const;
            virtual bool Contains(const 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<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>>& 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>>* 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<float>* pTp3Begin, const Base::TPoint3<float>* pTp3End) const;
            virtual bool IsCollision(const Base::TPoint3<double>& tp3Begin, const Base::TPoint3<double>& tp3End) 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<float>* pFlp3Begin, const Foundation::CFLPoint3<float>* pFlp3End) const;
            virtual bool IsCollision(const Foundation::CFLPoint3<double>& flp3Begin, const Foundation::CFLPoint3<double>& flp3End) const;
            virtual bool IsCollision(const Foundation::CFLPoint3<double>* pFlp3Begin, const Foundation::CFLPoint3<double>* pFlp3End) const;
 
            virtual void Clear() override;
 
            virtual EFigureDeclType GetDeclType() const override;
            virtual EFigureTemplateType GetTemplateType() const override;
 
            using CFLFigure::IsSpecEqual;
            virtual bool IsSpecEqual(const CFLFigure* pFlfRhs, EFigureSpecCompareType eSpecType = EFigureSpecCompareType_Coordinates) const override;
 
            using CFLFigure::Swap;
            virtual const CResult Swap(CFLFigure* pFlfRight) override;
 
            virtual double GetArea() const override;
            virtual double GetVolume() const override;
            virtual double GetHeight() const override;
 
            using CFLFigure3::Offset;
            virtual const CResult Offset(double x, double y, double z) override;
 
            using CFLFigure3::Multiply;
            virtual const CResult Multiply(double x, double y, double z) override;
 
            using CFLFigure3::GetCenterOfGravity;
            virtual const CResult GetCenterOfGravity(double& x, double& y, double& z) const override;
 
            using CFLFigure3::GetCenterOfVertices;
            virtual const CResult GetCenterOfVertices(double& x, double& y, double& z) const override;


            const CFLCylinder3<T>& operator=(const CFLCylinder3<float>& rhs);
            const CFLCylinder3<T>& operator=(const CFLCylinder3<double>& rhs);

            const CFLCylinder3<T>& operator+=(const double& value);


            const CFLCylinder3<T>& operator+=(const CFLPoint3<float>& flpPoint);
            const CFLCylinder3<T>& operator+=(const CFLPoint3<double>& flpPoint);


            const CFLCylinder3<T>& operator+=(const Base::TPoint3<float>& tpPoint);
            const CFLCylinder3<T>& operator+=(const Base::TPoint3<double>& tpPoint);

            const CFLCylinder3<T>& operator-=(const double& value);


            const CFLCylinder3<T>& operator-=(const CFLPoint3<float>& flpPoint);
            const CFLCylinder3<T>& operator-=(const CFLPoint3<double>& flpPoint);


            const CFLCylinder3<T>& operator-=(const Base::TPoint3<float>& tpPoint);
            const CFLCylinder3<T>& operator-=(const Base::TPoint3<double>& tpPoint);

            const CFLCylinder3<T>& operator*=(const double& value);


            const CFLCylinder3<T>& operator*=(const CFLPoint3<float>& flpPoint);
            const CFLCylinder3<T>& operator*=(const CFLPoint3<double>& flpPoint);


            const CFLCylinder3<T>& operator*=(const Base::TPoint3<float>& tpPoint);
            const CFLCylinder3<T>& operator*=(const Base::TPoint3<double>& tpPoint);

            const CFLCylinder3<T>& operator/=(const double& value);


            const CFLCylinder3<T>& operator/=(const CFLPoint3<float>& flpPoint);
            const CFLCylinder3<T>& operator/=(const CFLPoint3<double>& flpPoint);


            const CFLCylinder3<T>& operator/=(const Base::TPoint3<float>& tpPoint);
            const CFLCylinder3<T>& operator/=(const Base::TPoint3<double>& tpPoint);

            CFLCylinder3<T> operator+(const double& value) const;


            CFLCylinder3<T> operator+(const Base::TPoint3<float>& tpPoint) const;
            CFLCylinder3<T> operator+(const Base::TPoint3<double>& tpPoint) const;


            CFLCylinder3<T> operator+(const CFLPoint3<float>& flpPoint) const;
            CFLCylinder3<T> operator+(const CFLPoint3<double>& flpPoint) const;

            CFLCylinder3<T> operator-(const double& value) const;


            CFLCylinder3<T> operator-(const Base::TPoint3<float>& tpPoint) const;
            CFLCylinder3<T> operator-(const Base::TPoint3<double>& tpPoint) const;


            CFLCylinder3<T> operator-(const CFLPoint3<float>& flpPoint) const;
            CFLCylinder3<T> operator-(const CFLPoint3<double>& flpPoint) const;

            CFLCylinder3<T> operator*(const double& value) const;


            CFLCylinder3<T> operator*(const Base::TPoint3<float>& tpPoint) const;
            CFLCylinder3<T> operator*(const Base::TPoint3<double>& tpPoint) const;


            CFLCylinder3<T> operator*(const CFLPoint3<float>& flpPoint) const;
            CFLCylinder3<T> operator*(const CFLPoint3<double>& flpPoint) const;

            CFLCylinder3<T> operator/(const double& value) const;


            CFLCylinder3<T> operator/(const Base::TPoint3<float>& tpPoint) const;
            CFLCylinder3<T> operator/(const Base::TPoint3<double>& tpPoint) const;


            CFLCylinder3<T> operator/(const CFLPoint3<float>& flpPoint) const;
            CFLCylinder3<T> operator/(const CFLPoint3<double>& flpPoint) const;

            CFLCylinder3<T> operator-() const;

            friend CFLCylinder3<T> operator+(const double& value, const CFLCylinder3<T>& flcy)
            {
                CFLCylinder3<T> t(flcy);
                t += value;
                return t;
            }

            friend CFLCylinder3<T> operator-(const double& value, const CFLCylinder3<T>& flcy)
            {
                CFLCylinder3<T> t(flcy);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLCylinder3<T> operator*(const double& value, const CFLCylinder3<T>& flcy)
            {
                CFLCylinder3<T> t(flcy);
                t *= value;
                return t;
            }

            friend CFLCylinder3<T> operator/(const double& value, const CFLCylinder3<T>& flcy)
            {
                CFLCylinder3<T> flcyResult(flcy);
                flcyResult.flcBase.flpCenter = value / flcy.flcBase.flpCenter;
                return flcyResult;
            }
 
            using CFLFigure3::Rotate;
            virtual const CResult Rotate(const CFLGeometry3DQuaternion<float>* pQuat, const CFLPoint3<float>* pFlp3Pivot = nullptr) override;
            virtual const CResult Rotate(const CFLGeometry3DQuaternion<double>* pQuat, const CFLPoint3<double>* pFlp3Pivot = nullptr) override;
 
            using CFLFigure3::Scale;
            virtual const CResult Scale(double f64PivotX, double f64PivotY, double f64PivotZ, double f64ScaleX, double f64ScaleY, double f64ScaleZ) override;
 
            using CFLFigure3::Transform;
            virtual const CResult Transform(const CMatrix<float>* pMatTransform) override;
            virtual const CResult Transform(const CMatrix<double>* pMatTransform) override;
 
            using CFLFigure3::GetBoundingBox;
            virtual const CResult GetBoundingBox(double& f64MinX, double& f64MinY, double& f64MinZ, double& f64MaxX, double& f64MaxY, double& f64MaxZ) const override;
            virtual const CResult GetBoundingBox(float& f32MinX, float& f32MinY, float& f32MinZ, float& f32MaxX, float& f32MaxY, float& f32MaxZ) const override;
 
 
            SupportToDuplicateObject(CFLCylinder3<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLCylinder3<float> CFLCylinder3F;
        typedef CFLCylinder3<double> CFLCylinder3D;
    }
}