FLCircle3.h

#pragma once

 
#include "FLPoint3.h"

namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class FL_EXPORT CFLCircle3 : public CFLFigure
        {
        public:
            CFLPoint3<T> flpCenter;

            CFLPoint3<T> flpNormal;

            T radius;

            CFLCircle3();

            virtual ~CFLCircle3();

            CFLCircle3(int32_t radius, const CFLPoint3<T>& flp3Center, const CFLPoint3<T>& flp3Normal);

            CFLCircle3(int64_t radius, const CFLPoint3<T>& flp3Center, const CFLPoint3<T>& flp3Normal);

            CFLCircle3(float radius, const CFLPoint3<T>& flp3Center, const CFLPoint3<T>& flp3Normal);

            CFLCircle3(double radius, const CFLPoint3<T>& flp3Center, const CFLPoint3<T>& flp3Normal);

            CFLCircle3(const CFLCircle3<float>& flc3);

            CFLCircle3(const CFLCircle3<double>& flc3);

            CFLCircle3(const CFLCircle3<float>* pFlc3);

            CFLCircle3(const CFLCircle3<double>* pFlc3);

            CFLCircle3(const CFLFigure& flf);

            CFLCircle3(const CFLFigure* pFlf);

            const CFLCircle3<T>& operator=(const CFLCircle3<float>& flc3);

            const CFLCircle3<T>& operator=(const CFLCircle3<double>& flc3);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            CFLCircle3<T> operator-() const;
 
 
            //Friend operator
            // Arithmetic operator

            friend CFLCircle3<double> operator+(const int32_t& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                t += value;
                return t;
            }

            friend CFLCircle3<double> operator+(const int64_t& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                t += value;
                return t;
            }

            friend CFLCircle3<double> operator+(const float& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                t += value;
                return t;
            }

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

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

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

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

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

            friend CFLCircle3<double> operator*(const int32_t& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                t *= value;
                return t;
            }

            friend CFLCircle3<double> operator*(const int64_t& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                t *= value;
                return t;
            }

            friend CFLCircle3<double> operator*(const float& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                t *= value;
                return t;
            }

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

            friend CFLCircle3<double> operator/(const int32_t& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                CFLPoint3<T> flp3CenterRhs = t.GetCenterCoord();
                t.SetCenter((double)value, (double)value, (double)value);
                t.Multiply((double)flp3CenterRhs.x ? 1. / (double)flp3CenterRhs.x : 1.);
                return t;
            }

            friend CFLCircle3<double> operator/(const int64_t& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                CFLPoint3<T> flp3CenterRhs = t.GetCenterCoord();
                t.SetCenter((double)value, (double)value, (double)value);
                t.Multiply((double)flp3CenterRhs.x ? 1. / (double)flp3CenterRhs.x : 1.);
                return t;
            }

            friend CFLCircle3<double> operator/(const float& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                CFLPoint3<T> flp3CenterRhs = t.GetCenterCoord();
                t.SetCenter(value, value, value);
                t.Multiply((double)flp3CenterRhs.x ? 1. / (double)flp3CenterRhs.x : 1.);
                return t;
            }

            friend CFLCircle3<double> operator/(const double& value, const CFLCircle3<T>& circle)
            {
                CFLCircle3<double> t(circle);
                CFLPoint3<T> flp3CenterRhs = t.GetCenterCoord();
                t.SetCenter(value, value, value);
                t.Multiply((double)flp3CenterRhs.x ? 1. / (double)flp3CenterRhs.x : 1.);
                return t;
            }


            virtual const CResult Set(int32_t radius, const CFLPoint3<T>& flp3Center, const CFLPoint3<T>& flp3Normal);

            virtual const CResult Set(int64_t radius, const CFLPoint3<T>& flp3Center, const CFLPoint3<T>& flp3Normal);

            virtual const CResult Set(float radius, const CFLPoint3<T>& flp3Center, const CFLPoint3<T>& flp3Normal);

            virtual const CResult Set(double radius, const CFLPoint3<T>& flp3Center, const CFLPoint3<T>& flp3Normal);

            virtual const CResult Set(const CFLCircle3<float>& flc3);

            virtual const CResult Set(const CFLCircle3<double>& flc3);

            virtual const CResult Set(const CFLCircle3<float>* pFlc3);

            virtual const CResult Set(const CFLCircle3<double>* pFlc3);

            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(float x, float y, float z);

            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 SetCenter(double x, double y, double z);

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

            virtual const CResult SetCenter(float x, float y, float z);

            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 Foundation::CFLPoint3<T> GetCenterCoord() const;
 
        private:
            using CFLFigure::GetCenter;
 
            SupportToDuplicateObject(CFLCircle3<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLCircle3<float> CFLCircle3F;
        typedef CFLCircle3<double> CFLCircle3D;
    }
}