FLTriangle3.h

#pragma once

 
#include "FLPoint3.h"

namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class FL_EXPORT CFLTriangle3 : public CFLFigure
        {
        public:
            CFLPoint3<T> flpPoints[3];

            CFLTriangle3();

            virtual ~CFLTriangle3();

            CFLTriangle3(int32_t x0, int32_t y0, int32_t z0, int32_t x1, int32_t y1, int32_t z1, int32_t x2, int32_t y2, int32_t z2);

            CFLTriangle3(int64_t x0, int64_t y0, int64_t z0, int64_t x1, int64_t y1, int64_t z1, int64_t x2, int64_t y2, int64_t z2);

            CFLTriangle3(float x0, float y0, float z0, float x1, float y1, float z1, float x2, float y2, float z2);

            CFLTriangle3(double x0, double y0, double z0, double x1, double y1, double z1, double x2, double y2, double z2);

            CFLTriangle3(const Base::TPoint3<float>& tpPoint0, const Base::TPoint3<float>& tpPoint1, const Base::TPoint3<float>& tpPoint2);

            CFLTriangle3(const Base::TPoint3<double>& tpPoint0, const Base::TPoint3<double>& tpPoint1, const Base::TPoint3<double>& tpPoint2);

            CFLTriangle3(const Base::TPoint3<float>* pTpPoint0, const Base::TPoint3<float>* pTpPoint1, const Base::TPoint3<float>* pTpPoint2);

            CFLTriangle3(const Base::TPoint3<double>* pTpPoint0, const Base::TPoint3<double>* pTpPoint1, const Base::TPoint3<double>* pTpPoint2);

            CFLTriangle3(const CFLPoint3<float>& flpPoint0, const CFLPoint3<float>& flpPoint1, const CFLPoint3<float>& flpPoint2);

            CFLTriangle3(const CFLPoint3<double>& flpPoint0, const CFLPoint3<double>& flpPoint1, const CFLPoint3<double>& flpPoint2);

            CFLTriangle3(const CFLPoint3<float>* pFlpPoint0, const CFLPoint3<float>* pFlpPoint1, const CFLPoint3<float>* pFlpPoint2);

            CFLTriangle3(const CFLPoint3<double>* pFlpPoint0, const CFLPoint3<double>* pFlpPoint1, const CFLPoint3<double>* pFlpPoint2);

            CFLTriangle3(const CFLTriangle3<float>& fltTri);

            CFLTriangle3(const CFLTriangle3<double>& fltTri);

            CFLTriangle3(const CFLTriangle3<float>* pFltTri);

            CFLTriangle3(const CFLTriangle3<double>* pFltTri);

            CFLTriangle3(const Base::TTriangle3<float>& tt);

            CFLTriangle3(const Base::TTriangle3<double>& tt);

            CFLTriangle3(const Base::TTriangle3<float>* pTt);

            CFLTriangle3(const Base::TTriangle3<double>* pTt);

            CFLTriangle3(const CFLFigure& flf);

            CFLTriangle3(const CFLFigure* pFlf);

            const CFLTriangle3<T>& operator=(const CFLTriangle3<float>& fltTri);

            const CFLTriangle3<T>& operator=(const CFLTriangle3<double>& fltTri);

            const CFLTriangle3<T>& operator=(const Base::TTriangle3<float>& ttTri);

            const CFLTriangle3<T>& operator=(const Base::TTriangle3<double>& ttTri);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            CFLTriangle3<T> operator-() const;

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

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

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

            friend CFLTriangle3<T> operator/(const double& value, const CFLTriangle3<T>& fltTri)
            {
                CFLTriangle3<T> t;
 
                t.flpPoints[0].x = (T)(value / fltTri.flpPoints[0].x);
                t.flpPoints[0].y = (T)(value / fltTri.flpPoints[0].y);
                t.flpPoints[0].z = (T)(value / fltTri.flpPoints[0].z);
                t.flpPoints[1].x = (T)(value / fltTri.flpPoints[1].x);
                t.flpPoints[1].y = (T)(value / fltTri.flpPoints[1].y);
                t.flpPoints[1].z = (T)(value / fltTri.flpPoints[1].z);
                t.flpPoints[2].x = (T)(value / fltTri.flpPoints[2].x);
                t.flpPoints[2].y = (T)(value / fltTri.flpPoints[2].y);
                t.flpPoints[2].z = (T)(value / fltTri.flpPoints[2].z);
 
                return t;
            }

            virtual const CResult Set(int32_t x0, int32_t y0, int32_t z0, int32_t x1, int32_t y1, int32_t z1, int32_t x2, int32_t y2, int32_t z2);

            virtual const CResult Set(int64_t x0, int64_t y0, int64_t z0, int64_t x1, int64_t y1, int64_t z1, int64_t x2, int64_t y2, int64_t z2);

            virtual const CResult Set(float x0, float y0, float z0, float x1, float y1, float z1, float x2, float y2, float z2);

            virtual const CResult Set(double x0, double y0, double z0, double x1, double y1, double z1, double x2, double y2, double z2);

            virtual const CResult Set(const Base::TPoint3<float>& tpPoint0, const Base::TPoint3<float>& tpPoint1, const Base::TPoint3<float>& tpPoint2);

            virtual const CResult Set(const Base::TPoint3<double>& tpPoint0, const Base::TPoint3<double>& tpPoint1, const Base::TPoint3<double>& tpPoint2);

            virtual const CResult Set(const Base::TPoint3<float>* pTpPoint0, const Base::TPoint3<float>* pTpPoint1, const Base::TPoint3<float>* pTpPoint2);

            virtual const CResult Set(const Base::TPoint3<double>* pTpPoint0, const Base::TPoint3<double>* pTpPoint1, const Base::TPoint3<double>* pTpPoint2);

            virtual const CResult Set(const CFLPoint3<float>& flpPoint0, const CFLPoint3<float>& flpPoint1, const CFLPoint3<float>& flpPoint2);

            virtual const CResult Set(const CFLPoint3<double>& flpPoint0, const CFLPoint3<double>& flpPoint1, const CFLPoint3<double>& flpPoint2);

            virtual const CResult Set(const CFLPoint3<float>* pFlpPoint0, const CFLPoint3<float>* pFlpPoint1, const CFLPoint3<float>* pFlpPoint2);

            virtual const CResult Set(const CFLPoint3<double>* pFlpPoint0, const CFLPoint3<double>* pFlpPoint1, const CFLPoint3<double>* pFlpPoint2);

            virtual const CResult Set(const CFLTriangle3<float>& fltTri);

            virtual const CResult Set(const CFLTriangle3<double>& fltTri);

            virtual const CResult Set(const CFLTriangle3<float>* pFltTri);

            virtual const CResult Set(const CFLTriangle3<double>* pFltTri);

            virtual const CResult Set(const Base::TTriangle3<float>& tt);

            virtual const CResult Set(const Base::TTriangle3<double>& tt);

            virtual const CResult Set(const Base::TTriangle3<float>* pTt);

            virtual const CResult Set(const Base::TTriangle3<double>* pTt);
 
            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::IsSpecEqual;
            virtual bool IsSpecEqual(const CFLFigure* pFlfRhs, EFigureSpecCompareType eSpecType = EFigureSpecCompareType_Coordinates) 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 GetCenter(double& x, double& y, double& z) const;

            virtual const CResult GetCenter(float& x, float& y, float& z) const;

            virtual const CResult GetCenter(CFLPoint3<double>& flpCenter) const;

            virtual const CResult GetCenter(CFLPoint3<float>& flpCenter) const;

            virtual const CResult GetCenter(CFLPoint3<double>* pFlpCenter) const;

            virtual const CResult GetCenter(CFLPoint3<float>* pFlpCenter) const;

            virtual const CResult GetCenter(Base::TPoint3<double>& tpCenter) const;

            virtual const CResult GetCenter(Base::TPoint3<float>& tpCenter) const;

            virtual const CResult GetCenter(Base::TPoint3<double>* pTpCenter) const;

            virtual const CResult GetCenter(Base::TPoint3<float>* pTpCenter) const;
 
            virtual const CResult ReverseSequence() override;

            virtual const CResult ChangeOriginIndex(int64_t i64IndexToBeOrigin);
 
        private:
            using CFLFigure::GetCenter;
 
            SupportToDuplicateObject(CFLTriangle3<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLTriangle3<float> CFLTriangle3F;
        typedef CFLTriangle3<double> CFLTriangle3D;
    }
}