FLTriangle.h

#pragma once

 
#include "FLFigure.h"
#include "FLPoint.h"

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

            CFLTriangle();

            virtual ~CFLTriangle();

            CFLTriangle(int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t x2, int32_t y2);

            CFLTriangle(int64_t x0, int64_t y0, int64_t x1, int64_t y1, int64_t x2, int64_t y2);

            CFLTriangle(float x0, float y0, float x1, float y1, float x2, float y2);

            CFLTriangle(double x0, double y0, double x1, double y1, double x2, double y2);

            CFLTriangle(const Base::TPoint<int32_t>& tpPoint0, const Base::TPoint<int32_t>& tpPoint1, const Base::TPoint<int32_t>& tpPoint2);

            CFLTriangle(const Base::TPoint<int64_t>& tpPoint0, const Base::TPoint<int64_t>& tpPoint1, const Base::TPoint<int64_t>& tpPoint2);

            CFLTriangle(const Base::TPoint<float>& tpPoint0, const Base::TPoint<float>& tpPoint1, const Base::TPoint<float>& tpPoint2);

            CFLTriangle(const Base::TPoint<double>& tpPoint0, const Base::TPoint<double>& tpPoint1, const Base::TPoint<double>& tpPoint2);

            CFLTriangle(const Base::TPoint<int32_t>* pTpPoint0, const Base::TPoint<int32_t>* pTpPoint1, const Base::TPoint<int32_t>* pTpPoint2);

            CFLTriangle(const Base::TPoint<int64_t>* pTpPoint0, const Base::TPoint<int64_t>* pTpPoint1, const Base::TPoint<int64_t>* pTpPoint2);

            CFLTriangle(const Base::TPoint<float>* pTpPoint0, const Base::TPoint<float>* pTpPoint1, const Base::TPoint<float>* pTpPoint2);

            CFLTriangle(const Base::TPoint<double>* pTpPoint0, const Base::TPoint<double>* pTpPoint1, const Base::TPoint<double>* pTpPoint2);

            CFLTriangle(const CFLPoint<int32_t>& flpPoint0, const CFLPoint<int32_t>& flpPoint1, const CFLPoint<int32_t>& flpPoint2);

            CFLTriangle(const CFLPoint<int64_t>& flpPoint0, const CFLPoint<int64_t>& flpPoint1, const CFLPoint<int64_t>& flpPoint2);

            CFLTriangle(const CFLPoint<float>& flpPoint0, const CFLPoint<float>& flpPoint1, const CFLPoint<float>& flpPoint2);

            CFLTriangle(const CFLPoint<double>& flpPoint0, const CFLPoint<double>& flpPoint1, const CFLPoint<double>& flpPoint2);

            CFLTriangle(const CFLPoint<int32_t>* pFlpPoint0, const CFLPoint<int32_t>* pFlpPoint1, const CFLPoint<int32_t>* pFlpPoint2);

            CFLTriangle(const CFLPoint<int64_t>* pFlpPoint0, const CFLPoint<int64_t>* pFlpPoint1, const CFLPoint<int64_t>* pFlpPoint2);

            CFLTriangle(const CFLPoint<float>* pFlpPoint0, const CFLPoint<float>* pFlpPoint1, const CFLPoint<float>* pFlpPoint2);

            CFLTriangle(const CFLPoint<double>* pFlpPoint0, const CFLPoint<double>* pFlpPoint1, const CFLPoint<double>* pFlpPoint2);

            CFLTriangle(const CFLTriangle<int32_t>& flt);

            CFLTriangle(const CFLTriangle<int64_t>& flt);

            CFLTriangle(const CFLTriangle<float>& flt);

            CFLTriangle(const CFLTriangle<double>& flt);

            CFLTriangle(const CFLTriangle<int32_t>* pFlt);

            CFLTriangle(const CFLTriangle<int64_t>* pFlt);

            CFLTriangle(const CFLTriangle<float>* pFlt);

            CFLTriangle(const CFLTriangle<double>* pFlt);

            CFLTriangle(const CFLFigure& flf);

            CFLTriangle(const CFLFigure* pFlf);

            const CFLTriangle<T>& operator=(const CFLTriangle<int32_t>& flt);

            const CFLTriangle<T>& operator=(const CFLTriangle<int64_t>& flt);

            const CFLTriangle<T>& operator=(const CFLTriangle<float>& flt);

            const CFLTriangle<T>& operator=(const CFLTriangle<double>& flt);

            bool operator==(const CFLTriangle<int32_t>& flt) const;

            bool operator==(const CFLTriangle<int64_t>& flt) const;

            bool operator==(const CFLTriangle<float>& flt) const;

            bool operator==(const CFLTriangle<double>& flt) const;
 

            bool operator!=(const CFLTriangle<int32_t>& flt) const;

            bool operator!=(const CFLTriangle<int64_t>& flt) const;

            bool operator!=(const CFLTriangle<float>& flt) const;

            bool operator!=(const CFLTriangle<double>& flt) const;

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

            const CFLTriangle<T>& operator+=(const CFLPoint<int32_t>& flpPoint);

            const CFLTriangle<T>& operator+=(const CFLPoint<int64_t>& flpPoint);

            const CFLTriangle<T>& operator+=(const CFLPoint<float>& flpPoint);

            const CFLTriangle<T>& operator+=(const CFLPoint<double>& flpPoint);

            const CFLTriangle<T>& operator+=(const Base::TPoint<int32_t>& tpPoint);

            const CFLTriangle<T>& operator+=(const Base::TPoint<int64_t>& tpPoint);

            const CFLTriangle<T>& operator+=(const Base::TPoint<float>& tpPoint);

            const CFLTriangle<T>& operator+=(const Base::TPoint<double>& tpPoint);

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

            const CFLTriangle<T>& operator-=(const CFLPoint<int32_t>& flpPoint);

            const CFLTriangle<T>& operator-=(const CFLPoint<int64_t>& flpPoint);

            const CFLTriangle<T>& operator-=(const CFLPoint<float>& flpPoint);

            const CFLTriangle<T>& operator-=(const CFLPoint<double>& flpPoint);

            const CFLTriangle<T>& operator-=(const Base::TPoint<int32_t>& tpPoint);

            const CFLTriangle<T>& operator-=(const Base::TPoint<int64_t>& tpPoint);

            const CFLTriangle<T>& operator-=(const Base::TPoint<float>& tpPoint);

            const CFLTriangle<T>& operator-=(const Base::TPoint<double>& tpPoint);

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

            const CFLTriangle<T>& operator*=(const CFLPoint<int32_t>& flpPoint);

            const CFLTriangle<T>& operator*=(const CFLPoint<int64_t>& flpPoint);

            const CFLTriangle<T>& operator*=(const CFLPoint<float>& flpPoint);

            const CFLTriangle<T>& operator*=(const CFLPoint<double>& flpPoint);

            const CFLTriangle<T>& operator*=(const Base::TPoint<int32_t>& tpPoint);

            const CFLTriangle<T>& operator*=(const Base::TPoint<int64_t>& tpPoint);

            const CFLTriangle<T>& operator*=(const Base::TPoint<float>& tpPoint);

            const CFLTriangle<T>& operator*=(const Base::TPoint<double>& tpPoint);

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

            const CFLTriangle<T>& operator/=(const CFLPoint<int32_t>& flpPoint);

            const CFLTriangle<T>& operator/=(const CFLPoint<int64_t>& flpPoint);

            const CFLTriangle<T>& operator/=(const CFLPoint<float>& flpPoint);

            const CFLTriangle<T>& operator/=(const CFLPoint<double>& flpPoint);

            const CFLTriangle<T>& operator/=(const Base::TPoint<int32_t>& tpPoint);

            const CFLTriangle<T>& operator/=(const Base::TPoint<int64_t>& tpPoint);

            const CFLTriangle<T>& operator/=(const Base::TPoint<float>& tpPoint);

            const CFLTriangle<T>& operator/=(const Base::TPoint<double>& tpPoint);

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

            CFLTriangle<T> operator+(const Base::TPoint<int32_t>& tpPoint) const;

            CFLTriangle<T> operator+(const Base::TPoint<int64_t>& tpPoint) const;

            CFLTriangle<T> operator+(const Base::TPoint<float>& tpPoint) const;

            CFLTriangle<T> operator+(const Base::TPoint<double>& tpPoint) const;

            CFLTriangle<T> operator+(const CFLPoint<int32_t>& flpPoint) const;

            CFLTriangle<T> operator+(const CFLPoint<int64_t>& flpPoint) const;

            CFLTriangle<T> operator+(const CFLPoint<float>& flpPoint) const;

            CFLTriangle<T> operator+(const CFLPoint<double>& flpPoint) const;

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

            CFLTriangle<T> operator-(const Base::TPoint<int32_t>& tpPoint) const;

            CFLTriangle<T> operator-(const Base::TPoint<int64_t>& tpPoint) const;

            CFLTriangle<T> operator-(const Base::TPoint<float>& tpPoint) const;

            CFLTriangle<T> operator-(const Base::TPoint<double>& tpPoint) const;

            CFLTriangle<T> operator-(const CFLPoint<int32_t>& flpPoint) const;

            CFLTriangle<T> operator-(const CFLPoint<int64_t>& flpPoint) const;

            CFLTriangle<T> operator-(const CFLPoint<float>& flpPoint) const;

            CFLTriangle<T> operator-(const CFLPoint<double>& flpPoint) const;

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

            CFLTriangle<T> operator*(const Base::TPoint<int32_t>& tpPoint) const;

            CFLTriangle<T> operator*(const Base::TPoint<int64_t>& tpPoint) const;

            CFLTriangle<T> operator*(const Base::TPoint<float>& tpPoint) const;

            CFLTriangle<T> operator*(const Base::TPoint<double>& tpPoint) const;

            CFLTriangle<T> operator*(const CFLPoint<int32_t>& flpPoint) const;

            CFLTriangle<T> operator*(const CFLPoint<int64_t>& flpPoint) const;

            CFLTriangle<T> operator*(const CFLPoint<float>& flpPoint) const;

            CFLTriangle<T> operator*(const CFLPoint<double>& flpPoint) const;

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

            CFLTriangle<T> operator/(const Base::TPoint<int32_t>& tpPoint) const;

            CFLTriangle<T> operator/(const Base::TPoint<int64_t>& tpPoint) const;

            CFLTriangle<T> operator/(const Base::TPoint<float>& tpPoint) const;

            CFLTriangle<T> operator/(const Base::TPoint<double>& tpPoint) const;

            CFLTriangle<T> operator/(const CFLPoint<int32_t>& flpPoint) const;

            CFLTriangle<T> operator/(const CFLPoint<int64_t>& flpPoint) const;

            CFLTriangle<T> operator/(const CFLPoint<float>& flpPoint) const;

            CFLTriangle<T> operator/(const CFLPoint<double>& flpPoint) const;

            CFLTriangle<T> operator-() const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            virtual const CResult Set(const CFLPoint<int32_t>& flpPoint0, const CFLPoint<int32_t>& flpPoint1, const CFLPoint<int32_t>& flpPoint2);

            virtual const CResult Set(const CFLPoint<int64_t>& flpPoint0, const CFLPoint<int64_t>& flpPoint1, const CFLPoint<int64_t>& flpPoint2);

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

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

            virtual const CResult Set(const CFLPoint<int32_t>* pFlpPoint0, const CFLPoint<int32_t>* pFlpPoint1, const CFLPoint<int32_t>* pFlpPoint2);

            virtual const CResult Set(const CFLPoint<int64_t>* pFlpPoint0, const CFLPoint<int64_t>* pFlpPoint1, const CFLPoint<int64_t>* pFlpPoint2);

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

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

            virtual const CResult Set(const CFLTriangle<int32_t>& flt);

            virtual const CResult Set(const CFLTriangle<int64_t>& flt);

            virtual const CResult Set(const CFLTriangle<float>& flt);

            virtual const CResult Set(const CFLTriangle<double>& flt);

            virtual const CResult Set(const CFLTriangle<int32_t>* pFlt);

            virtual const CResult Set(const CFLTriangle<int64_t>* pFlt);

            virtual const CResult Set(const CFLTriangle<float>* pFlt);

            virtual const CResult Set(const CFLTriangle<double>* pFlt);
 
            using CFLFigure::Set;
            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;
 
            virtual bool IsValid() const override;
            virtual bool IsFigureValid() const override;
 
            virtual const CResult MakeFigureValid() override;
            virtual const CResult MakeFigureInvalid() override;
 
            using CFLFigure::IsSpecEqual;
            virtual bool IsSpecEqual(const CFLFigure* pFlfRhs, EFigureSpecCompareType eSpecType = EFigureSpecCompareType_Coordinates) const override;
 
            virtual double GetWidth() const override;
            virtual double GetHeight() const override;
            virtual double GetAngle() const override;
            virtual double GetArea() const override;
            virtual double GetPerimeter() const override;
            virtual double GetLength() const override;
            virtual uint64_t GetVertexCountRecursive(EIncludingRegionType eType = EIncludingRegionType_All) const override;
            virtual const CResult GetVertexCount(CFLFigureArray& flfaResult, EIncludingRegionType eType = EIncludingRegionType_All, bool bRecursive = true) const override;
            virtual const CResult GetVertexCount(CFLFigureArray* pFlfaResult, EIncludingRegionType eType = EIncludingRegionType_All, bool bRecursive = true) const override;
 
            virtual const CResult ReverseSequence() override;
            virtual EWindingDirection GetWindingDirection() const sealed;

            virtual const CResult ReverseWindingDirection();

            virtual const CResult ChangeOriginIndex(int64_t i64IndexToBeOrigin);
 
            using CFLFigure::GetBoundaryRect;
            virtual const CResult GetBoundaryRect(double& left, double& top, double& right, double& bottom) const override;
 
            using CFLFigure::Inflate;
            virtual const CResult Inflate(double left, double top, double right, double bottom) override;
 
            using CFLFigure::Offset;
            virtual const CResult Offset(double x, double y) override;
 
            using CFLFigure::Multiply;
            virtual const CResult Multiply(double f64MulX, double f64MulY) override;
 
            using CFLFigure::Scale;
            virtual const CResult Scale(double f64PivotX, double f64PivotY, double f64RatioX, double f64RatioY) override;
 
            using CFLFigure::Rotate;
            virtual const CResult Rotate(double f64Angle, double f64PivotX, double f64PivotY) override;
 
            using CFLFigure::GetCenter;
            virtual const CResult GetCenter(double& x, double& y) const override;
 
            using CFLFigure::GetCenterOfGravity;
            virtual const CResult GetCenterOfGravity(double& x, double& y) const override;
 
            using CFLFigure::Flip;
            virtual const CResult Flip(EFigureFlipDirection eDirection, double f64PivotX, double f64PivotY) override;
 
            using CFLFigure::Warp;
            virtual const CResult Warp(const CFLQuad<double>* pFlqSourceRegion, const CFLQuad<double>* pFlqTargetRegion, CFLFigureArray* pFlfaResult, EWarpingType eWarpingType = EWarpingType_Bilinear) const override;
            virtual const CResult Warp(const CFLPointArray* pFlpaSource, const CFLPointArray* pFlpaTarget, CFLFigureArray* pFlfaResult, EWarpingType eWarpingType = EWarpingType_Bicubic, int32_t i32Extension = 2) const override;
 
            using CFLFigure::Swap;
            virtual const CResult Swap(CFLFigure* pFlfRight) override;
 
            using CFLFigure::GetMinimumEnclosingRectangle;
            virtual const CResult GetMinimumEnclosingRectangle(CFLQuad<double>* pQuad) const override;
 
            using CFLFigure::Extend;
 
            using CFLFigure::GetMinimumDistance;
            using CFLFigure::GetMaximumDistance;
 
            using CFLFigure::GetPointsOfMinimumDistance;
            virtual const CResult GetPointsOfMinimumDistance(const CFLFigure* pFlfTarget, CFLPointArray* pFlpaResult) const override;
 
            using CFLFigure::GetPointsOfMaximumDistance;
            virtual const CResult GetPointsOfMaximumDistance(const CFLFigure* pFlfTarget, CFLPointArray* pFlpaResult) const override;
 
            using CFLFigure::GetRasterRegion;
            virtual const CResult GetRasterRegion(CFLFigureArray* pFlfaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TRect<int32_t>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TRect<int64_t>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TRect<float>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TRect<double>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
            virtual const CResult GetRasterRegion(Base::CFLArray<Base::TPoint3<int32_t>>* pFlaResult, const CFLRect<int64_t>* pFlrROI = nullptr) const override;
 
            virtual bool IsCollision(const CFLFigure& figure) const override;
            virtual bool IsCollision(const CFLFigure* pFigure) const override;
 
            using CFLFigure::IsCollision;
            virtual bool IsCollision(const CFLPoint<double>* pPoint) const override;
            virtual bool IsCollision(const CFLLine<double>* pLine) const override;
            virtual bool IsCollision(const CFLRect<double>* pRect) const override;
            virtual bool IsCollision(const CFLRoundRect<double>* pRect) const override;
            virtual bool IsCollision(const CFLQuad<double>* pQuad) const override;
            virtual bool IsCollision(const CFLCircle<double>* pRect) const override;
            virtual bool IsCollision(const CFLEllipse<double>* pEll) const override;
            virtual bool IsCollision(const CFLDoughnut<double>* pDoughnut) const override;
            virtual bool IsCollision(const CFLCubicSpline* pFlcs) const override;
            virtual bool IsCollision(const CFLBezierQuadraticCurve* pFlbc2) const override;
            virtual bool IsCollision(const CFLBezierCubicCurve* pFlbc3) const override;
            virtual bool IsCollision(const CFLBezierQuarticCurve* pFlbc4) const override;
            virtual bool IsCollision(const CFLRegion* pFlrg) const override;
            virtual bool IsCollision(const CFLComplexRegion* pFlcr) const override;
            virtual bool IsCollision(const CFLFigureArray* pFlfa) const override;
            virtual bool IsCollision(const CFLPointArray* pFlpa) const override;
 
            virtual const CResult GetIntersection(const CFLFigure& figure, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLFigure* pFigure, CFLFigureArray* pFlfaResult) const override;
 
            using CFLFigure::GetIntersection;
            virtual const CResult GetIntersection(const CFLLine<double>* pLine, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLRect<double>* pRect, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLRoundRect<double>* pRect, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLQuad<double>* pQuad, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLCircle<double>* pCir, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLEllipse<double>* pEll, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLDoughnut<double>* pDoughnut, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLCubicSpline* pFlcs, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLBezierQuadraticCurve* pFlbc2, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLBezierCubicCurve* pFlbc3, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLBezierQuarticCurve* pFlbc4, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLRegion* pFlrg, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLComplexRegion* pFlcr, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetIntersection(const CFLFigureArray* pFlfaOperand, CFLFigureArray* pFlfaResult) const override;
 
            using CFLFigure::GetRegionOfIntersection;
            using CFLFigure::GetRegionOfUnion;
            using CFLFigure::GetRegionOfSubtraction;
            using CFLFigure::GetRegionOfExclusiveOr;
 
            virtual const CResult GetRasterContour(Base::CFLArray<Base::TPoint<int32_t>>* pFlaResult, bool bExcludeSingleDelta = false) const override;
            virtual const CResult GetRasterContour(CFLFigureArray* pFlfaResult, bool bExcludeSingleDelta = false) const override;
            virtual const CResult GetRasterContour(CFLPointArray* pFlpaResult, bool bExcludeSingleDelta = false) const override;
 
            virtual const CResult GetSamplingPointsOnSegment(double f64SamplingDistance, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetSamplingPointsOnSegment(double f64SamplingDistance, CFLPointArray* pFlpaResult) const override;
 
            virtual const CResult GetSamplingVectorOnSegment(double f64SamplingDistance, CFLFigureArray* pFlfaResult) const override;
            virtual const CResult GetSamplingVectorOnSegment(double f64SamplingDistance, CFLPointArray* pFlpaResult) const override;
 
            SupportToDuplicateObject(CFLTriangle<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLTriangle<int32_t> CFLTriangleL;
        typedef CFLTriangle<int64_t> CFLTriangleLL;
        typedef CFLTriangle<float> CFLTriangleF;
        typedef CFLTriangle<double> CFLTriangleD;
    }
}