FLQuad3.h

#pragma once
 
#include "FLPoint3.h"
 
namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class FL_EXPORT CFLQuad3 : public CFLFigure
        {
        public:
            CFLPoint3<T> flpPoints[4];
 
            CFLQuad3();
 
            virtual ~CFLQuad3();
 
            CFLQuad3(const Base::TPoint3<float>& tpPoint1, const Base::TPoint3<float>& tpPoint2, const Base::TPoint3<float>& tpPoint3, const Base::TPoint3<float>& tpPoint4);
 
            CFLQuad3(const Base::TPoint3<double>& tpPoint1, const Base::TPoint3<double>& tpPoint2, const Base::TPoint3<double>& tpPoint3, const Base::TPoint3<double>& tpPoint4);
 
            CFLQuad3(const Base::TPoint3<float>* pTpPoint1, const Base::TPoint3<float>* pTpPoint2, const Base::TPoint3<float>* pTpPoint3, const Base::TPoint3<float>* pTpPoint4);
 
            CFLQuad3(const Base::TPoint3<double>* pTpPoint1, const Base::TPoint3<double>* pTpPoint2, const Base::TPoint3<double>* pTpPoint3, const Base::TPoint3<double>* pTpPoint4);
 
            CFLQuad3(const CFLPoint3<float>& flpPoint1, const CFLPoint3<float>& flpPoint2, const CFLPoint3<float>& flpPoint3, const CFLPoint3<float>& flpPoint4);
 
            CFLQuad3(const CFLPoint3<double>& flpPoint1, const CFLPoint3<double>& flpPoint2, const CFLPoint3<double>& flpPoint3, const CFLPoint3<double>& flpPoint4);
 
            CFLQuad3(const CFLPoint3<float>* pFlpPoint1, const CFLPoint3<float>* pFlpPoint2, const CFLPoint3<float>* pFlpPoint3, const CFLPoint3<float>* pFlpPoint4);
 
            CFLQuad3(const CFLPoint3<double>* pFlpPoint1, const CFLPoint3<double>* pFlpPoint2, const CFLPoint3<double>* pFlpPoint3, const CFLPoint3<double>* pFlpPoint4);
 
            CFLQuad3(const Base::TQuad3<float>& tqQuad);
 
            CFLQuad3(const Base::TQuad3<double>& tqQuad);
 
            CFLQuad3(const Base::TQuad3<float>* pTqQuad);
 
            CFLQuad3(const Base::TQuad3<double>* pTqQuad);
 
            CFLQuad3(const CFLQuad3<float>& flqQuad);
 
            CFLQuad3(const CFLQuad3<double>& flqQuad);
 
            CFLQuad3(const CFLQuad3<float>* pFlqQuad);
 
            CFLQuad3(const CFLQuad3<double>* pFlqQuad);
 
            CFLQuad3(const Base::TQuad<float>& tqQuad);
 
            CFLQuad3(const Base::TQuad<double>& tqQuad);
 
            CFLQuad3(const Base::TQuad<float>* pTqQuad);
 
            CFLQuad3(const Base::TQuad<double>* pTqQuad);
 
            CFLQuad3(const CFLQuad<float>& flqQuad);
 
            CFLQuad3(const CFLQuad<double>& flqQuad);
 
            CFLQuad3(const CFLQuad<float>* pFlqQuad);
 
            CFLQuad3(const CFLQuad<double>* pFlqQuad);
 
            CFLQuad3(const CFLFigure& flf);
 
            CFLQuad3(const CFLFigure* pFlf);
 
            const CFLQuad3<T>& operator=(const Base::TQuad3<float>& tqQuad);
 
            const CFLQuad3<T>& operator=(const Base::TQuad3<double>& tqQuad);
 
            const CFLQuad3<T>& operator=(const CFLQuad3<float>& flqQuad);
 
            const CFLQuad3<T>& operator=(const CFLQuad3<double>& flqQuad);
 
            const CFLQuad3<T>& operator=(const Base::TQuad<float>& tqQuad);
 
            const CFLQuad3<T>& operator=(const Base::TQuad<double>& tqQuad);
 
            const CFLQuad3<T>& operator=(const CFLQuad<float>& flqQuad);
 
            const CFLQuad3<T>& operator=(const CFLQuad<double>& flqQuad);
 
            const CFLQuad3<T>& operator+=(const double& value);
 
            const CFLQuad3<T>& operator+=(const CFLPoint3<float>& flpPoint);
 
            const CFLQuad3<T>& operator+=(const CFLPoint3<double>& flpPoint);
 
            const CFLQuad3<T>& operator+=(const Base::TPoint3<float>& tpPoint);
 
            const CFLQuad3<T>& operator+=(const Base::TPoint3<double>& tpPoint);
 
            const CFLQuad3<T>& operator-=(const double& value);
 
            const CFLQuad3<T>& operator-=(const CFLPoint3<float>& flpPoint);
 
            const CFLQuad3<T>& operator-=(const CFLPoint3<double>& flpPoint);
 
            const CFLQuad3<T>& operator-=(const Base::TPoint3<float>& tpPoint);
 
            const CFLQuad3<T>& operator-=(const Base::TPoint3<double>& tpPoint);
 
            const CFLQuad3<T>& operator*=(const double& value);
 
            const CFLQuad3<T>& operator*=(const CFLPoint3<float>& flpPoint);
 
            const CFLQuad3<T>& operator*=(const CFLPoint3<double>& flpPoint);
 
            const CFLQuad3<T>& operator*=(const Base::TPoint3<float>& tpPoint);
 
            const CFLQuad3<T>& operator*=(const Base::TPoint3<double>& tpPoint);
 
            const CFLQuad3<T>& operator/=(const double& value);
 
            const CFLQuad3<T>& operator/=(const CFLPoint3<float>& flpPoint);
 
            const CFLQuad3<T>& operator/=(const CFLPoint3<double>& flpPoint);
 
            const CFLQuad3<T>& operator/=(const Base::TPoint3<float>& tpPoint);
 
            const CFLQuad3<T>& operator/=(const Base::TPoint3<double>& tpPoint);
 
            CFLQuad3<T> operator+(const double& value) const;
 
            CFLQuad3<T> operator+(const Base::TPoint3<float>& tpPoint) const;
 
            CFLQuad3<T> operator+(const Base::TPoint3<double>& tpPoint) const;
 
            CFLQuad3<T> operator+(const CFLPoint3<float>& flpPoint) const;
 
            CFLQuad3<T> operator+(const CFLPoint3<double>& flpPoint) const;
 
            CFLQuad3<T> operator-(const double& value) const;
 
            CFLQuad3<T> operator-(const Base::TPoint3<float>& tpPoint) const;
 
            CFLQuad3<T> operator-(const Base::TPoint3<double>& tpPoint) const;
 
            CFLQuad3<T> operator-(const CFLPoint3<float>& flpPoint) const;
 
            CFLQuad3<T> operator-(const CFLPoint3<double>& flpPoint) const;
 
            CFLQuad3<T> operator*(const double& value) const;
 
            CFLQuad3<T> operator*(const Base::TPoint3<float>& tpPoint) const;
 
            CFLQuad3<T> operator*(const Base::TPoint3<double>& tpPoint) const;
 
            CFLQuad3<T> operator*(const CFLPoint3<float>& flpPoint) const;
 
            CFLQuad3<T> operator*(const CFLPoint3<double>& flpPoint) const;
 
            CFLQuad3<T> operator/(const double& value) const;
 
            CFLQuad3<T> operator/(const Base::TPoint3<float>& tpPoint) const;
 
            CFLQuad3<T> operator/(const Base::TPoint3<double>& tpPoint) const;
 
            CFLQuad3<T> operator/(const CFLPoint3<float>& flpPoint) const;
 
            CFLQuad3<T> operator/(const CFLPoint3<double>& flpPoint) const;
 
            friend CFLQuad3<T> operator+(const double& value, const CFLQuad3<T>& quad)
            {
                CFLQuad3<T> t(quad);
                t += value;
                return t;
            }
 
            friend CFLQuad3<T> operator-(const double& value, const CFLQuad3<T>& quad)
            {
                CFLQuad3<T> t(quad);
                t *= -1.;
                t += value;
                return t;
            }
 
            friend CFLQuad3<T> operator*(const double& value, const CFLQuad3<T>& quad)
            {
                CFLQuad3<T> t(quad);
                t *= value;
                return t;
            }
 
            friend CFLQuad3<T> operator/(const double& value, const CFLQuad3<T>& quad)
            {
                CFLQuad3<T> t;
 
                t.flpPoints[0].x = value / quad.flpPoints[0].x;
                t.flpPoints[0].y = value / quad.flpPoints[0].y;
                t.flpPoints[0].z = value / quad.flpPoints[0].z;
                t.flpPoints[1].x = value / quad.flpPoints[1].x;
                t.flpPoints[1].y = value / quad.flpPoints[1].y;
                t.flpPoints[1].z = value / quad.flpPoints[1].z;
                t.flpPoints[2].x = value / quad.flpPoints[2].x;
                t.flpPoints[2].y = value / quad.flpPoints[2].y;
                t.flpPoints[2].z = value / quad.flpPoints[2].z;
                t.flpPoints[3].x = value / quad.flpPoints[3].x;
                t.flpPoints[3].y = value / quad.flpPoints[3].y;
                t.flpPoints[3].z = value / quad.flpPoints[3].z;
 
                return t;
            }
 
            virtual const CResult Set(const Base::TPoint3<float>& tpPoint1, const Base::TPoint3<float>& tpPoint2, const Base::TPoint3<float>& tpPoint3, const Base::TPoint3<float>& tpPoint4);
 
            virtual const CResult Set(const Base::TPoint3<double>& tpPoint1, const Base::TPoint3<double>& tpPoint2, const Base::TPoint3<double>& tpPoint3, const Base::TPoint3<double>& tpPoint4);
 
            virtual const CResult Set(const Base::TPoint3<float>* pTpPoint1, const Base::TPoint3<float>* pTpPoint2, const Base::TPoint3<float>* pTpPoint3, const Base::TPoint3<float>* pTpPoint4);
 
            virtual const CResult Set(const Base::TPoint3<double>* pTpPoint1, const Base::TPoint3<double>* pTpPoint2, const Base::TPoint3<double>* pTpPoint3, const Base::TPoint3<double>* pTpPoint4);
 
            virtual const CResult Set(const CFLPoint3<float>& flpPoint1, const CFLPoint3<float>& flpPoint2, const CFLPoint3<float>& flpPoint3, const CFLPoint3<float>& flpPoint4);
 
            virtual const CResult Set(const CFLPoint3<double>& flpPoint1, const CFLPoint3<double>& flpPoint2, const CFLPoint3<double>& flpPoint3, const CFLPoint3<double>& flpPoint4);
 
            virtual const CResult Set(const CFLPoint3<float>* pFlpPoint1, const CFLPoint3<float>* pFlpPoint2, const CFLPoint3<float>* pFlpPoint3, const CFLPoint3<float>* pFlpPoint4);
 
            virtual const CResult Set(const CFLPoint3<double>* pFlpPoint1, const CFLPoint3<double>* pFlpPoint2, const CFLPoint3<double>* pFlpPoint3, const CFLPoint3<double>* pFlpPoint4);
 
            virtual const CResult Set(const Base::TQuad3<float>& tqQuad);
 
            virtual const CResult Set(const Base::TQuad3<double>& tqQuad);
 
            virtual const CResult Set(const Base::TQuad3<float>* pTqQuad);
 
            virtual const CResult Set(const Base::TQuad3<double>* pTqQuad);
 
            virtual const CResult Set(const CFLQuad3<float>& flqQuad);
 
            virtual const CResult Set(const CFLQuad3<double>& flqQuad);
 
            virtual const CResult Set(const CFLQuad3<float>* pFlqQuad);
 
            virtual const CResult Set(const CFLQuad3<double>* pFlqQuad);
 
            virtual const CResult Set(const Base::TQuad<float>& tqQuad);
 
            virtual const CResult Set(const Base::TQuad<double>& tqQuad);
 
            virtual const CResult Set(const Base::TQuad<float>* pTqQuad);
 
            virtual const CResult Set(const Base::TQuad<double>* pTqQuad);
 
            virtual const CResult Set(const CFLQuad<float>& flqQuad);
 
            virtual const CResult Set(const CFLQuad<double>& flqQuad);
 
            virtual const CResult Set(const CFLQuad<float>* pFlqQuad);
 
            virtual const CResult Set(const CFLQuad<double>* pFlqQuad);
 
            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;
 
            using CFLFigure::Swap;
            virtual const CResult Swap(CFLFigure* pFlfRight) override;
 
            using CFLFigure::Offset;
            virtual const CResult Offset(double x, double y) override;
            virtual const CResult Offset(int32_t val) override;
            virtual const CResult Offset(int64_t val) override;
            virtual const CResult Offset(float val) override;
            virtual const CResult Offset(double val) override;
 
            virtual const CResult Offset(const CFLPoint3<float>& flpPoint);
 
            virtual const CResult Offset(const CFLPoint3<double>& flpPoint);
 
            virtual const CResult Offset(const CFLPoint3<float>* pFlpPoint);
 
            virtual const CResult Offset(const CFLPoint3<double>* pFlpPoint);
 
            virtual const CResult Offset(const Base::TPoint3<float>& tpPoint);
 
            virtual const CResult Offset(const Base::TPoint3<double>& tpPoint);
 
            virtual const CResult Offset(const Base::TPoint3<float>* pTpPoint);
 
            virtual const CResult Offset(const Base::TPoint3<double>* pTpPoint);
 
            virtual const CResult Offset(double x, double y, double z);
 
            using CFLFigure::Multiply;
            virtual const CResult Multiply(double x, double y) override;
            virtual const CResult Multiply(int32_t val) override;
            virtual const CResult Multiply(int64_t val) override;
            virtual const CResult Multiply(float val) override;
            virtual const CResult Multiply(double val) override;
 
            virtual const CResult Multiply(const CFLPoint3<float>& flpPoint);
 
            virtual const CResult Multiply(const CFLPoint3<double>& flpPoint);
 
            virtual const CResult Multiply(const CFLPoint3<float>* pFlpPoint);
 
            virtual const CResult Multiply(const CFLPoint3<double>* pFlpPoint);
 
            virtual const CResult Multiply(const Base::TPoint3<float>& tpPoint);
 
            virtual const CResult Multiply(const Base::TPoint3<double>& tpPoint);
 
            virtual const CResult Multiply(const Base::TPoint3<float>* pTpPoint);
 
            virtual const CResult Multiply(const Base::TPoint3<double>* pTpPoint);
 
            virtual const CResult Multiply(double x, double y, double z);
 
            virtual const CResult ReverseSequence() override;
 
 
            SupportToDuplicateObject(CFLQuad3<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLQuad3<float> CFLQuad3F;
        typedef CFLQuad3<double> CFLQuad3D;
    }
}