//+------------------------------------------------------------------+
//|                                                        Curve.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include <Object.mqh>
#include <Canvas\Canvas.mqh>
//--- forward declaration
class CGraphic;
//--- fucntion for represent custom plot method
typedef void(*PlotFucntion)(double &x[],double &y[],int size,CGraphic *graphic,CCanvas *canvas,void *cbdata);
//--- function for represent curve
typedef double(*CurveFunction)(double);
//--- drawing type
enum ENUM_CURVE_TYPE
  {
   CURVE_POINTS,
   CURVE_LINES,
   CURVE_POINTS_AND_LINES,
   CURVE_STEPS,
   CURVE_HISTOGRAM,
   CURVE_CUSTOM,
   CURVE_NONE
  };
//--- type for the various point shapes that are available 
enum ENUM_POINT_TYPE
  {
   POINT_CIRCLE,
   POINT_SQUARE,
   POINT_DIAMOND,
   POINT_TRIANGLE,
   POINT_TRIANGLE_DOWN,
   POINT_X_CROSS,
   POINT_PLUS,
   POINT_STAR,
   POINT_HORIZONTAL_DASH,
   POINT_VERTICAL_DASH
  };
//+------------------------------------------------------------------+
//| Structure CPoint2D                                               |
//| Usage: 2d point on graphic in Cartesian coordinates              |
//+------------------------------------------------------------------+
struct CPoint2D
  {
   double            x;
   double            y;
  };
//+------------------------------------------------------------------+
//| Class CCurve                                                     |
//| Usage: class to represent the one-dimensional curve              |
//+------------------------------------------------------------------+
class CCurve : public CObject
  {
private:
   uint              m_clr;
   double            m_x[];
   double            m_y[];
   double            m_xmin;
   double            m_xmax;
   double            m_ymin;
   double            m_ymax;
   int               m_size;
   ENUM_CURVE_TYPE   m_type;
   string            m_name;
   //--- lines
   ENUM_LINE_STYLE   m_lines_style;
   ENUM_LINE_END     m_lines_end_style;
   int               m_lines_width;
   bool              m_lines_smooth;
   double            m_lines_tension;
   double            m_lines_step;
   //--- points
   int               m_points_size;
   ENUM_POINT_TYPE   m_points_type;
   bool              m_points_fill;
   uint              m_points_clr;
   //--- steps
   int               m_steps_dimension;
   //--- histogram
   int               m_hisogram_width;
   //--- custom
   PlotFucntion      m_custom_plot_func;
   void             *m_custom_plot_cbdata;
   //--- general property
   bool              m_visible;
   //--- trend line property
   uint              m_trend_clr;
   bool              m_trend_visible;

protected:
   bool              m_trend_calc;
   double            m_trend_coeff[];

public:
                     CCurve(const double &y[],const uint clr,ENUM_CURVE_TYPE type,const string name);
                     CCurve(const double &x[],const double &y[],const uint clr,ENUM_CURVE_TYPE type,const string name);
                     CCurve(const CPoint2D &points[],const uint clr,ENUM_CURVE_TYPE type,const string name);
                     CCurve(CurveFunction function,const double from,const double to,const double step,const uint clr,ENUM_CURVE_TYPE type,const string name);
                    ~CCurve(void);
   //--- gets the general properties
   void              GetX(double &x[]) const { ArrayCopy(x,m_x); }
   void              GetY(double &y[]) const { ArrayCopy(y,m_y); }
   double            XMax(void)        const { return(m_xmax);   }
   double            XMin(void)        const { return(m_xmin);   }
   double            YMax(void)        const { return(m_ymax);   }
   double            YMin(void)        const { return(m_ymin);   }
   int               Size(void)        const { return(m_size);   }
   //--- update                     
   void              Update(const double &y[]);
   void              Update(const double &x[],const double &y[]);
   void              Update(const CPoint2D &points[]);
   void              Update(CurveFunction function,const double from,const double to,const double step);
   //--- gets or sets general options
   uint              Color(void)                 const { return(m_clr);      }
   int               Type(void)                  const { return(m_type);     }
   string            Name(void)                  const { return(m_name);     }
   bool              Visible(void)               const { return(m_visible);  }
   void              Color(const uint clr)       { m_clr=clr;                    }
   void              Type(const int type)        { m_type=(ENUM_CURVE_TYPE)type; }
   void              Name(const string name)     { m_name=name;                  }
   void              Visible(const bool visible) { m_visible=visible;            }
   //--- gets or sets the lines properties
   ENUM_LINE_STYLE   LinesStyle(void)                         const { return(m_lines_style);     }
   ENUM_LINE_END     LinesEndStyle(void)                      const { return(m_lines_end_style); }
   int               LinesWidth(void)                         const { return(m_lines_width);     }
   bool              LinesSmooth(void)                        const { return(m_lines_smooth);    }
   double            LinesSmoothTension(void)                 const { return(m_lines_tension);   }
   double            LinesSmoothStep(void)                    const { return(m_lines_step);      }
   void              LinesStyle(ENUM_LINE_STYLE style)        { m_lines_style=style;         }
   void              LinesEndStyle(ENUM_LINE_END end_style)   { m_lines_end_style=end_style; }
   void              LinesWidth(const int width)              { m_lines_width=width;         }
   void              LinesSmooth(const bool smooth)           { m_lines_smooth=smooth;       }
   void              LinesSmoothTension(const double tension) { m_lines_tension=tension;     }
   void              LinesSmoothStep(const double step)       { m_lines_step=step;           }
   //--- gets or sets the points properties
   int               PointsSize(void)                 const { return(m_points_size); }
   ENUM_POINT_TYPE   PointsType(void)                 const { return(m_points_type); }
   bool              PointsFill(void)                 const { return(m_points_fill); }
   uint              PointsColor(void)                const { return(m_points_clr);  }
   void              PointsSize(const int size)       { m_points_size=size; }
   void              PointsType(ENUM_POINT_TYPE type) { m_points_type=type; }
   void              PointsFill(const bool fill)      { m_points_fill=fill; }
   void              PointsColor(const uint clr)      { m_points_clr=clr;   }
   //--- gets or sets the steps properties
   int               StepsDimension(void) const { return(m_steps_dimension); }
   void              StepsDimension(const int dimension) { m_steps_dimension=dimension; }
   //--- gets or sets the histogram properties
   int               HistogramWidth(void) const { return(m_hisogram_width); }
   void              HistogramWidth(const int width) { m_hisogram_width=width; }
   //--- gets or sets the custom properties
   PlotFucntion      CustomPlotFunction(void)              const { return(m_custom_plot_func);   }
   void             *CustomPlotCBData(void)                const { return(m_custom_plot_cbdata); }
   void              CustomPlotFunction(PlotFucntion func) { m_custom_plot_func=func;     }
   void              CustomPlotCBData(void *cbdata)        { m_custom_plot_cbdata=cbdata; }
   //--- gets or sets the trend line properties
   bool              TrendLineVisible(void)               const { return(m_trend_visible); }
   uint              TrendLineColor(void)                 const { return(m_trend_clr);     }
   void              TrendLineVisible(const bool visible) { m_trend_visible=visible; }
   void              TrendLineColor(const uint clr)       { m_trend_clr=clr;         }
   void              TrendLineCoefficients(double &coefficients[]);

protected:
   virtual void      CalculateCoefficients(void);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CCurve::CCurve(const double &y[],const uint clr,ENUM_CURVE_TYPE type,const string name)
   : m_name(name),
     m_clr(clr),
     m_type(type),
     m_visible(false),
     m_lines_style(STYLE_SOLID),
     m_lines_end_style(LINE_END_ROUND),
     m_lines_width(1),
     m_lines_smooth(false),
     m_lines_tension(0.5),
     m_lines_step(1.0),
     m_points_size(6),
     m_points_type(POINT_CIRCLE),
     m_points_fill(false),
     m_points_clr(clr),
     m_steps_dimension(0),
     m_hisogram_width(1),
     m_custom_plot_func(NULL),
     m_custom_plot_cbdata(NULL),
     m_trend_visible(false),
     m_trend_clr(clr),
     m_trend_calc(false)
  {
//--- keep y array
   m_size=ArraySize(y);
   ArrayResize(m_x,m_size);
   ArrayCopy(m_y,y);
   m_xmax = m_size-1;
   m_xmin = 0.0;
   m_ymax = 0.0;
   m_ymin = 0.0;
   bool yvalid=false;
//--- find min and max values 
   for(int i=0; i<m_size; i++)
     {
      m_x[i]=i;
      if(MathIsValidNumber(m_y[i]))
        {
         if(!yvalid)
           {
            m_ymax=m_y[i];
            m_ymin= m_y[i];
            yvalid=true;
           }
         else
           {
            //--- find max and min of y
            if(m_ymax<y[i])
               m_ymax=y[i];
            else
            if(m_ymin>y[i])
               m_ymin=y[i];
           }
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CCurve::CCurve(const double &x[],const double &y[],const uint clr,ENUM_CURVE_TYPE type,const string name)
   : m_name(name),
     m_clr(clr),
     m_type(type),
     m_visible(false),
     m_lines_style(STYLE_SOLID),
     m_lines_end_style(LINE_END_ROUND),
     m_lines_width(1),
     m_lines_smooth(false),
     m_lines_tension(0.5),
     m_lines_step(1.0),
     m_points_size(6),
     m_points_type(POINT_CIRCLE),
     m_points_fill(false),
     m_points_clr(clr),
     m_steps_dimension(0),
     m_hisogram_width(1),
     m_custom_plot_func(NULL),
     m_custom_plot_cbdata(NULL),
     m_trend_visible(false),
     m_trend_clr(clr),
     m_trend_calc(false)
  {
//--- keep x and y array
   ArrayCopy(m_x,x);
   ArrayCopy(m_y,y);
   m_size = ArraySize(x);
   m_xmax = 0.0;
   m_xmin = 0.0;
   m_ymax = 0.0;
   m_ymin = 0.0;
   bool yvalid=false;
   bool xvalid=false;
//--- find min and max values 
   for(int i=0; i<m_size; i++)
     {
      if(MathIsValidNumber(m_x[i]))
        {
         if(!xvalid)
           {
            m_xmax = x[i];
            m_xmin = x[i];
            xvalid=true;
           }
         else
           {
            //--- find max and min of x
            if(m_xmax<x[i])
               m_xmax=x[i];
            else
            if(m_xmin>x[i])
               m_xmin=x[i];
           }
        }
      if(MathIsValidNumber(m_y[i]))
        {
         if(!yvalid)
           {
            m_ymax = y[i];
            m_ymin = y[i];
            yvalid=true;
           }
         else
           {
            //--- find max and min of y
            if(m_ymax<y[i])
               m_ymax=y[i];
            else
            if(m_ymin>y[i])
               m_ymin=y[i];
           }
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CCurve::CCurve(const CPoint2D &points[],const uint clr,ENUM_CURVE_TYPE type,const string name)
   : m_name(name),
     m_clr(clr),
     m_type(type),
     m_visible(false),
     m_lines_style(STYLE_SOLID),
     m_lines_end_style(LINE_END_ROUND),
     m_lines_width(1),
     m_lines_smooth(false),
     m_lines_tension(0.5),
     m_lines_step(1.0),
     m_points_size(6),
     m_points_type(POINT_CIRCLE),
     m_points_fill(false),
     m_points_clr(clr),
     m_steps_dimension(0),
     m_hisogram_width(1),
     m_custom_plot_func(NULL),
     m_custom_plot_cbdata(NULL),
     m_trend_visible(false),
     m_trend_clr(clr),
     m_trend_calc(false)
  {
//--- preliminary calculation
   m_size=ArraySize(points);
   ArrayResize(m_x,m_size);
   ArrayResize(m_y,m_size);
   m_xmax = 0.0;
   m_xmin = 0.0;
   m_ymax = 0.0;
   m_ymin = 0.0;
   bool xvalid=false;
   bool yvalid=false;
//--- keep x and y array
   for(int i=0; i<m_size; i++)
     {
      m_x[i] = points[i].x;
      m_y[i] = points[i].y;
      if(MathIsValidNumber(m_x[i]))
        {
         if(!xvalid)
           {
            m_xmax = m_x[i];
            m_xmin = m_x[i];
            xvalid=true;
           }
         else
           {
            //--- find max and min of x
            if(m_xmax<m_x[i])
               m_xmax=m_x[i];
            else
            if(m_xmin>m_x[i])
               m_xmin=m_x[i];
           }
        }
      if(MathIsValidNumber(m_y[i]))
        {
         if(!yvalid)
           {
            m_ymax = m_y[i];
            m_ymin = m_y[i];
            yvalid=true;
           }
         else
           {
            //--- find max and min of y
            if(m_ymax<m_y[i])
               m_ymax=m_y[i];
            else
            if(m_ymin>m_y[i])
               m_ymin=m_y[i];
           }
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CCurve::CCurve(CurveFunction function,const double from,const double to,const double step,const uint clr,ENUM_CURVE_TYPE type,const string name)
   : m_name(name),
     m_clr(clr),
     m_type(type),
     m_visible(false),
     m_lines_style(STYLE_SOLID),
     m_lines_end_style(LINE_END_ROUND),
     m_lines_width(1),
     m_lines_smooth(false),
     m_lines_tension(0.5),
     m_lines_step(1.0),
     m_points_size(6),
     m_points_type(POINT_CIRCLE),
     m_points_fill(false),
     m_points_clr(clr),
     m_steps_dimension(0),
     m_hisogram_width(1),
     m_custom_plot_func(NULL),
     m_custom_plot_cbdata(NULL),
     m_trend_visible(false),
     m_trend_clr(clr),
     m_trend_calc(false)
  {
//--- preliminary calculation
   m_size=(int)((to-from)/step)+1;
   ArrayResize(m_x,m_size);
   ArrayResize(m_y,m_size);
   m_xmax = to;
   m_xmin = from;
   m_ymax = 0.0;
   m_ymin = 0.0;
   bool yvalid=false;
//--- keep x and y array
   for(int i=0; i<m_size; i++)
     {
      m_x[i]=from+(i*step);
      m_y[i]=function(m_x[i]);
      if(MathIsValidNumber(m_y[i]))
        {
         if(!yvalid)
           {
            m_ymax=m_y[i];
            m_ymin=m_y[i];
            yvalid=true;
           }
         else
           {
            //--- find max and min of y
            if(m_ymax<m_y[i])
               m_ymax=m_y[i];
            else if(m_ymin>m_y[i])
               m_ymin=m_y[i];
           }
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CCurve::~CCurve(void)
  {
  }
//+------------------------------------------------------------------+
//| Update x and y coordinates of curve                              |
//+------------------------------------------------------------------+
void CCurve::Update(const double &y[])
  {
   m_trend_calc=false;
   ArrayFree(m_y);
   int size=ArraySize(y);
//--- keep y array
   if(m_size!=size)
     {
      m_size=size;
      ArrayResize(m_x,m_size);
     }
   ArrayCopy(m_y,y);
   m_xmax = m_size-1;
   m_xmin = 0.0;
   m_ymax = 0.0;
   m_ymin = 0.0;
   bool yvalid=false;
//--- find min and max values 
   for(int i=0; i<m_size; i++)
     {
      m_x[i]=i;
      if(MathIsValidNumber(m_y[i]))
        {
         if(!yvalid)
           {
            m_ymax=m_y[i];
            m_ymin= m_y[i];
            yvalid=true;
           }
         else
           {
            //--- find max and min of y
            if(m_ymax<y[i])
               m_ymax=y[i];
            else
            if(m_ymin>y[i])
               m_ymin=y[i];
           }
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| Update x and y coordinates of curve                              |
//+------------------------------------------------------------------+
void CCurve::Update(const double &x[],const double &y[])
  {
   m_trend_calc=false;
   ArrayFree(m_x);
   ArrayFree(m_y);
//--- keep x and y array
   ArrayCopy(m_x,x);
   ArrayCopy(m_y,y);
   m_size = ArraySize(x);
   m_xmax = 0.0;
   m_xmin = 0.0;
   m_ymax = 0.0;
   m_ymin = 0.0;
   bool yvalid=false;
   bool xvalid=false;
//--- find min and max values 
   for(int i=0; i<m_size; i++)
     {
      if(MathIsValidNumber(m_x[i]))
        {
         if(!xvalid)
           {
            m_xmax = x[i];
            m_xmin = x[i];
            xvalid=true;
           }
         else
           {
            //--- find max and min of x
            if(m_xmax<x[i])
               m_xmax=x[i];
            else
            if(m_xmin>x[i])
               m_xmin=x[i];
           }
        }
      if(MathIsValidNumber(m_y[i]))
        {
         if(!yvalid)
           {
            m_ymax = y[i];
            m_ymin = y[i];
            yvalid=true;
           }
         else
           {
            //--- find max and min of y
            if(m_ymax<y[i])
               m_ymax=y[i];
            else
            if(m_ymin>y[i])
               m_ymin=y[i];
           }
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| Update x and y coordinates of curve                              |
//+------------------------------------------------------------------+
void CCurve::Update(const CPoint2D &points[])
  {
   m_trend_calc=false;
   int size=ArraySize(points);
//--- preliminary calculation
   if(size!=m_size)
     {
      m_size=size;
      ArrayResize(m_x,m_size);
      ArrayResize(m_y,m_size);
     }
   m_xmax = 0.0;
   m_xmin = 0.0;
   m_ymax = 0.0;
   m_ymin = 0.0;
   bool xvalid=false;
   bool yvalid=false;
//--- keep x and y array
   for(int i=0; i<m_size; i++)
     {
      m_x[i] = points[i].x;
      m_y[i] = points[i].y;
      if(MathIsValidNumber(m_x[i]))
        {
         if(!xvalid)
           {
            m_xmax = m_x[i];
            m_xmin = m_x[i];
            xvalid=true;
           }
         else
           {
            //--- find max and min of x
            if(m_xmax<m_x[i])
               m_xmax=m_x[i];
            else
            if(m_xmin>m_x[i])
               m_xmin=m_x[i];
           }
        }
      if(MathIsValidNumber(m_y[i]))
        {
         if(!yvalid)
           {
            m_ymax = m_y[i];
            m_ymin = m_y[i];
            yvalid=true;
           }
         else
           {
            //--- find max and min of y
            if(m_ymax<m_y[i])
               m_ymax=m_y[i];
            else
            if(m_ymin>m_y[i])
               m_ymin=m_y[i];
           }
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| Update x and y coordinates of curve                              |
//+------------------------------------------------------------------+
void CCurve::Update(CurveFunction function,const double from,const double to,const double step)
  {
   m_trend_calc=false;
   int size=(int)((to-from)/step)+1;
//--- preliminary calculation
   if(size!=m_size)
     {
      m_size=size;
      ArrayResize(m_x,m_size);
      ArrayResize(m_y,m_size);
     }
   m_xmax = to;
   m_xmin = from;
   m_ymax = 0.0;
   m_ymin = 0.0;
   bool yvalid=false;
//--- keep x and y array
   for(int i=0; i<m_size; i++)
     {
      m_x[i]=from+(i*step);
      m_y[i]=function(m_x[i]);
      if(MathIsValidNumber(m_y[i]))
        {
         if(!yvalid)
           {
            m_ymax=m_y[i];
            m_ymin=m_y[i];
            yvalid=true;
           }
         else
           {
            //--- find max and min of y
            if(m_ymax<m_y[i])
               m_ymax=m_y[i];
            else if(m_ymin>m_y[i])
               m_ymin=m_y[i];
           }
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| Gets the coefficients for trend line                             |
//+------------------------------------------------------------------+
void CCurve::TrendLineCoefficients(double &coefficients[])
  {
   if(!m_trend_calc)
     {
      CalculateCoefficients();
      m_trend_calc=true;
     }
   ArrayCopy(coefficients,m_trend_coeff);
  }
//+------------------------------------------------------------------+
//| Calculate coefficients                                           |
//+------------------------------------------------------------------+
void CCurve::CalculateCoefficients(void)
  {
//--- simple linear resgression
   ArrayResize(m_trend_coeff,2);
   double xmean=0.0;
   double ymean=0.0;
   double sum_xy=0.0;
   double sum_xx=0.0;
//--- primary calculate
   for(int i=0; i<m_size; i++)
     {
      xmean+=m_x[i];
      ymean+=m_y[i];
      sum_xy+=m_x[i]*m_y[i];
      sum_xx+=m_x[i]*m_x[i];
     }
   xmean/=m_size;
   ymean/=m_size;
//--- calculate intercept
   m_trend_coeff[0]=(sum_xy -(m_size*xmean*ymean))/(sum_xx -(m_size*xmean*xmean));
//--- calculate slope
   m_trend_coeff[1]=ymean-m_trend_coeff[0]*xmean;
  }
//+------------------------------------------------------------------+