Generic_Overlay_Heatmap

ÿþ//+------------------------------------------------------------------+

//|                                      Generic_Overlay_Heatmap.mq5 |

//|                        Copyright 2018, MetaQuotes Software Corp. |

//|                                                 https://mql5.com |

//+------------------------------------------------------------------+

#property copyright "Copyright 2018, MetaQuotes Software Corp."

#property link      "https://mql5.com"

#property version   "1.00"

#property description "Generic Overlay Heatmap indicator.\n"

#property description "Heatmap according to Behavior of choosen indicator."

#property description "This version covers the following oscillators:"

#property description "RSI, Stochastic, CCI, Ultimate Oscillator,\nMACD and Williams Percent Range."

#property indicator_separate_window

#property indicator_buffers 7

#property indicator_plots   3

//--- plot UP

#property indicator_label1  "Up"

#property indicator_type1   DRAW_ARROW

#property indicator_color1  clrForestGreen

#property indicator_style1  STYLE_SOLID

#property indicator_width1  1

//--- plot DN

#property indicator_label2  "Down"

#property indicator_type2   DRAW_ARROW

#property indicator_color2  clrOrangeRed

#property indicator_style2  STYLE_SOLID

#property indicator_width2  1

//--- plot NL

#property indicator_label3  "Neutral"

#property indicator_type3   DRAW_ARROW

#property indicator_color3  clrLightGray

#property indicator_style3  STYLE_SOLID

#property indicator_width3  1

//--- enums

enum ENUM_BEHAVIORS

  {

   BEHAVIOR_SLOPE,      // Slope

   BEHAVIOR_LEVEL,      // Level

   BEHAVIOR_OBOS,       // Overbought/Oversold

   BEHAVIOR_SIG_MA      // Signal MA

  };

//---

enum ENUM_IND_TO_USE

  {

   IND_TO_USE_RSI,      // RSI

   IND_TO_USE_STO,      // Stochastic

   IND_TO_USE_CCI,      // CCI

   IND_TO_USE_UO,       // Ultimate osc

   IND_TO_USE_MACD,     // MACD

   IND_TO_USE_WPR       // WPR

  };

//--- input parameters

input ENUM_IND_TO_USE      InpIndToUse       = IND_TO_USE_CCI; // Indicator to use

input ENUM_BEHAVIORS       InpModeComp       = BEHAVIOR_OBOS;  // Behavior to analyze

//--- Signal MA

input uint                 InpPeriodMA       =  20;            // Signal MA period

input ENUM_MA_METHOD       InpMethodMA       =  MODE_SMA;      // Signal MA method

input ENUM_APPLIED_PRICE   InpAppliedPriceMA =  PRICE_CLOSE;   // Signal MA applied price

//--- RSI

input uint                 InpPeriodRSI      =  14;            // RSI period

input double               InpMainLevelRSI   =  50;            // RSI main level

input double               InpOverboughtRSI  =  70;            // RSI overbought

input double               InpOversoldRSI    =  30;            // RSI oversold

//--- Stochastic

input uint                 InpPeriodK        =  9;             // Stochastic period %K

input uint                 InpPeriodD        =  6;             // Stochastic period %D

input uint                 InpSlowing        =  3;             // Stochastic slowing

input double               InpMainLevelSto   =  50;            // Stochastic main level

input double               InpOverboughtSto  =  80;            // Stochastic overbought

input double               InpOversoldSto    =  20;            // Stochastic oversold

//--- CCI

input uint                 InpPeriodCCI      =  14;            // CCI period

input double               InpMainLevelCCI   =  0;             // CCI main level

input double               InpOverboughtCCI  =  150;           // CCI overbought

input double               InpOversoldCCI    = -150;           // CCI oversold

//--- Ultimate Oscillator

input uint                 InpPeriod1UO      =  7;             // Ultimate Oscillator first momentum period

input uint                 InpPeriod2UO      =  14;            // Ultimate Oscillator second momentum period

input uint                 InpPeriod3UO      =  28;            // Ultimate Oscillator third momentum period

input double               InpMainLevelUO    =  50;            // Ultimate Oscillator main level

input double               InpOverboughtUO   =  70;            // Ultimate Oscillator overbought

input double               InpOversoldUO     =  30;            // Ultimate Oscillator oversold

//--- MACD

input uint                 InpPeriodFastMACD =  12;            // MACD fast EMA period

input uint                 InpPeriodSlowMACD =  26;            // MACD slow EMA period

input uint                 InpPeriodSigMACD  =  9;             // MACD signal period

input double               InpMainLevelMACD  =  0;             // MACD main level

input double               InpThresholdMACD  =  200;           // MACD threshold (in points)

//--- WPR

input uint                 InpPeriodWPR      =  14;            // WPR period

input double               InpMainLevelWPR   = -50;            // WPR main level

input double               InpOverboughtWPR  = -20;            // WPR overbought

input double               InpOversoldWPR    = -80;            // WPR oversold



#define        COUNT       (3)

//--- indicator buffers

double         BufferUP[];

double         BufferDN[];

double         BufferNL[];

//--- UO buffers

double         BufferBP[];

double         BufferTR[];

//--- Temp

double         BufferMA[];

double         BufferIND[];

//--- global variables

string         prefix;

int            wnd;

//--- Ultimate Oscillator

double         overbought_uo;

double         oversold_uo;

double         main_level_uo;

int            period_1_uo;

int            period_2_uo;

int            period_3_uo;

int            period_max_uo;

//--- RSI

double         main_level_rsi;

double         overbought_rsi;

double         oversold_rsi;

int            period_rsi;

//--- Stochastic

double         main_level_sto;

double         overbought_sto;

double         oversold_sto;

int            period_k;

int            period_d;

int            slowing;

int            period_max_sto;

//--- CCI

double         main_level_cci;

double         overbought_cci;

double         oversold_cci;

int            period_cci;

//--- MACD

double         main_level_macd;

double         threshold_macd;

int            period_fast;

int            period_slow;

int            period_sig;

int            period_max_macd;

//--- WPR

double         main_level_wpr;

double         overbought_wpr;

double         oversold_wpr;

int            period_wpr;

//--- Signal MA

int            period_ma_sig;

//--- Indicator

double         main_level_ind;

double         overbought_ind;

double         oversold_ind;

int            period_ind;

int            period_max;

int            weight_sum;

int            handle_ind;

#include <MovingAverages.mqh>

//+------------------------------------------------------------------+

//| Custom indicator initialization function                         |

//+------------------------------------------------------------------+

int OnInit()

  {

//--- set global variables

   prefix=MQLInfoString(MQL_PROGRAM_NAME)+"_";

   wnd=ChartWindowFind();

   SizeByScale();

   Descriptions();

//--- Ultimate Oscillator

   main_level_uo=InpMainLevelUO;

   period_1_uo=int(InpPeriod1UO<1 ? 1 : InpPeriod1UO);

   period_2_uo=int(InpPeriod2UO<1 ? 1 : InpPeriod2UO);

   period_3_uo=int(InpPeriod3UO<1 ? 1 : InpPeriod3UO);

   period_max_uo=fmax(period_1_uo,fmax(period_2_uo,period_3_uo));

   overbought_uo=(InpOverboughtUO>100 ? 100 : InpOverboughtUO<0.1 ? 0.1 : InpOverboughtUO);

   oversold_uo=(InpOversoldUO>=overbought_uo ? overbought_uo-0.1 : InpOversoldUO<0 ? 0 : InpOversoldUO);

//--- RSI

   main_level_rsi=InpMainLevelRSI;

   period_rsi=int(InpPeriodRSI<1 ? 1 : InpPeriodRSI);

   overbought_rsi=(InpOverboughtRSI>100 ? 100 : InpOverboughtRSI<0.1 ? 0.1 : InpOverboughtRSI);

   oversold_rsi=(InpOversoldRSI<0 ? 0 : InpOversoldRSI>=overbought_rsi ? overbought_rsi-0.1 : InpOversoldRSI);

//--- Stochastic

   main_level_sto=InpMainLevelSto;

   period_k=int(InpPeriodK<1 ? 1 : InpPeriodK);

   period_d=int(InpPeriodD<1 ? 1 : InpPeriodD);

   slowing=int(InpSlowing<1 ? 1 : InpSlowing);

   period_max_sto=fmax(slowing,fmax(period_k,period_d));

   overbought_sto=(InpOverboughtSto>100 ? 100 : InpOverboughtSto<0.1 ? 0.1 : InpOverboughtSto);

   oversold_sto=(InpOversoldSto<0 ? 0 : InpOversoldSto>=overbought_sto ? overbought_sto-0.1 : InpOversoldSto);

//--- CCI

   main_level_cci=InpMainLevelCCI;

   period_cci=int(InpPeriodCCI<1 ? 1 : InpPeriodCCI);

   overbought_cci=(fabs(InpOverboughtCCI)<0.1 ? 0.1 : fabs(InpOverboughtCCI));

   oversold_cci=(-fabs(InpOversoldCCI)>-0.1 ? -0.1 : -fabs(InpOversoldCCI));

//--- MACD

   main_level_macd=InpMainLevelMACD;

   period_fast=int(InpPeriodFastMACD<1 ? 1 : InpPeriodFastMACD);

   period_slow=int(InpPeriodSlowMACD==period_fast ? period_fast+1 : InpPeriodSlowMACD<1 ? 1 : InpPeriodSlowMACD);

   period_sig=int(InpPeriodSigMACD<1 ? 1 : InpPeriodSigMACD);

   period_max_macd=fmax(period_sig,fmax(period_fast,period_slow));

   threshold_macd=(InpThresholdMACD<0 ? 0 : InpThresholdMACD)*Point();

//--- WPR

   main_level_wpr=InpMainLevelWPR;

   period_wpr=int(InpPeriodWPR<2 ? 2 : InpPeriodWPR);

   double ob=-fabs(InpOverboughtWPR);

   double os=-fabs(InpOversoldWPR);

   overbought_wpr=(ob>0 ? 0 : ob<-99.0 ? -99.0 : ob);

   oversold_wpr=(os<-100.0 ? -100.0 : os>=overbought_wpr ? overbought_wpr-1.0 : os);

   if(overbought_wpr<=oversold_wpr) overbought_wpr=oversold_wpr+1.0;

//--- Signal MA

   period_ma_sig=int(InpPeriodMA<2 ? 2 : InpPeriodMA);

//--- indicator buffers mapping

   SetIndexBuffer(0,BufferUP,INDICATOR_DATA);

   SetIndexBuffer(1,BufferDN,INDICATOR_DATA);

   SetIndexBuffer(2,BufferNL,INDICATOR_DATA);

   SetIndexBuffer(3,BufferBP,INDICATOR_CALCULATIONS);

   SetIndexBuffer(4,BufferTR,INDICATOR_CALCULATIONS);

   SetIndexBuffer(5,BufferMA,INDICATOR_CALCULATIONS);

   SetIndexBuffer(6,BufferIND,INDICATOR_CALCULATIONS);

//--- setting a code from the Wingdings charset as the property of PLOT_ARROW

   for(int i=0; i<COUNT; i++)

      PlotIndexSetInteger(i,PLOT_ARROW,167);

//--- setting buffer arrays as timeseries

   ArraySetAsSeries(BufferUP,true);

   ArraySetAsSeries(BufferDN,true);

   ArraySetAsSeries(BufferNL,true);

   ArraySetAsSeries(BufferBP,true);

   ArraySetAsSeries(BufferTR,true);

   ArraySetAsSeries(BufferMA,true);

   ArraySetAsSeries(BufferIND,true);

//---

   string ind_params="";

   if(InpIndToUse==IND_TO_USE_UO)

     {

     period_ind=period_max_uo;

     main_level_ind=main_level_uo;

     overbought_ind=overbought_uo;

     oversold_ind=oversold_uo;

     ind_params=(string)period_1_uo+","+(string)period_2_uo+","+(string)period_3_uo;

     }

   else

     {

      ResetLastError();

      switch(InpIndToUse)

        {

         case IND_TO_USE_RSI :

           period_ind=period_rsi;

           main_level_ind=main_level_rsi;

           overbought_ind=overbought_rsi;

           oversold_ind=oversold_rsi;

           ind_params=(string)period_rsi;

           handle_ind=iRSI(NULL,PERIOD_CURRENT,period_rsi,PRICE_CLOSE);

           if(handle_ind==INVALID_HANDLE)

             {

              Print("The iRSI(",ind_params,") object was not created: Error ",GetLastError());

              return INIT_FAILED;

             }

           break;

         case IND_TO_USE_STO :

           period_ind=period_max_sto;

           main_level_ind=main_level_sto;

           overbought_ind=overbought_sto;

           oversold_ind=oversold_sto;

           ind_params=(string)period_k+","+(string)period_d+","+(string)slowing;

           handle_ind=iStochastic(NULL,PERIOD_CURRENT,period_k,period_d,slowing,MODE_SMA,STO_LOWHIGH);

           if(handle_ind==INVALID_HANDLE)

             {

              Print("The iStochastic(",ind_params,") object was not created: Error ",GetLastError());

              return INIT_FAILED;

             }

           break;

         case IND_TO_USE_CCI :

           period_ind=period_cci;

           main_level_ind=main_level_cci;

           overbought_ind=overbought_cci;

           oversold_ind=oversold_cci;

           ind_params=(string)period_cci;

           handle_ind=iCCI(NULL,PERIOD_CURRENT,period_cci,PRICE_TYPICAL);

           if(handle_ind==INVALID_HANDLE)

             {

              Print("The iCCI(",ind_params,") object was not created: Error ",GetLastError());

              return INIT_FAILED;

             }

           break;

         case IND_TO_USE_MACD :

           period_ind=period_max_macd;

           main_level_ind=main_level_macd;

           overbought_ind=threshold_macd;

           oversold_ind=-threshold_macd;

           ind_params=(string)period_fast+","+(string)period_slow+","+(string)period_sig;

           handle_ind=iMACD(NULL,PERIOD_CURRENT,period_fast,period_slow,period_sig,PRICE_CLOSE);

           if(handle_ind==INVALID_HANDLE)

             {

              Print("The iMACD(",ind_params,") object was not created: Error ",GetLastError());

              return INIT_FAILED;

             }

           break;

         //---IND_TO_USE_WPR

         default:

           period_ind=period_wpr;

           main_level_ind=main_level_wpr;

           overbought_ind=overbought_wpr;

           oversold_ind=oversold_wpr;

           ind_params=(string)period_wpr;

           handle_ind=iWPR(NULL,PERIOD_CURRENT,period_wpr);

           if(handle_ind==INVALID_HANDLE)

             {

              Print("The iWPR(",ind_params,") object was not created: Error ",GetLastError());

              return INIT_FAILED;

             }

           break;

        }

     }

//--- setting indicator parameters

   string ind_data=(IndToString()+"("+ind_params+")"+(InpModeComp==BEHAVIOR_SIG_MA ? " / "+MethodToString(InpMethodMA)+"("+IndToString()+"("+ind_params+"),"+(string)period_ma_sig+")" : ""));

   IndicatorSetString(INDICATOR_SHORTNAME,"Generic Overlay Heatmap "+ind_data);

   IndicatorSetInteger(INDICATOR_DIGITS,Digits());

   IndicatorSetInteger(INDICATOR_HEIGHT,60);

   IndicatorSetDouble(INDICATOR_MINIMUM,0);

   IndicatorSetDouble(INDICATOR_MAXIMUM,1);

//---

   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//| Custom indicator iteration function                              |

//+------------------------------------------------------------------+

int OnCalculate(const int rates_total,

                const int prev_calculated,

                const datetime &time[],

                const double &open[],

                const double &high[],

                const double &low[],

                const double &close[],

                const long &tick_volume[],

                const long &volume[],

                const int &spread[])

  {

//--- @>25@:0 :>;8G5AB20 4>ABC?=KE 10@>2

   if(rates_total<fmax(period_max_uo,4)) return 0;

//--- @>25@:0 8 @0AGQB :>;8G5AB20 ?@>AG8BK205<KE 10@>2

   int limit=rates_total-prev_calculated;

   if(limit>1)

     {

      int v=(InpIndToUse==IND_TO_USE_UO ? period_max_uo+2 : 2);

      limit=rates_total-v;

      ArrayInitialize(BufferUP,EMPTY_VALUE);

      ArrayInitialize(BufferDN,EMPTY_VALUE);

      ArrayInitialize(BufferNL,EMPTY_VALUE);

      ArrayInitialize(BufferBP,0);

      ArrayInitialize(BufferTR,0);

      ArrayInitialize(BufferMA,0);

      ArrayInitialize(BufferIND,0);

     }

//--- >43>B>2:0 40==KE

   if(InpIndToUse!=IND_TO_USE_UO)

     {

      int count=(limit>1 ? rates_total : 1),copied=0;

      copied=CopyBuffer(handle_ind,0,0,count,BufferIND);

      if(copied!=count) return 0;

     }

   else

     {

      for(int i=limit; i>=0 && !IsStopped(); i--)

        {

         BufferBP[i]=close[i]-fmin(low[i],close[i+1]);

         BufferTR[i]=fmax(high[i],close[i+1])-fmin(low[i],close[i+1]);

        }

      //---  0AGQB UO

      for(int i=limit; i>=0 && !IsStopped(); i--)

        {

         double bp_sum1=0;

         double tr_sum1=0;

         double bp_sum2=0;

         double tr_sum2=0;

         double bp_sum3=0;

         double tr_sum3=0;

   

         for(int j=(i+period_1_uo-1); j>=i; j--)

           {

            bp_sum1+=BufferBP[j];

            tr_sum1+=BufferTR[j];

           }

         double avg1=(tr_sum1!=0 ? bp_sum1/tr_sum1 : 0);

         for(int j=(i+period_2_uo-1); j>=i; j--)

           {

            bp_sum2+=BufferBP[j];

            tr_sum2+=+BufferTR[j];

           }

         double avg2=(tr_sum2!=0 ? bp_sum2/tr_sum2 : 0);

         for(int j=(i+period_3_uo-1); j>=i; j--)

           {

            bp_sum3+=BufferBP[j];

            tr_sum3+=BufferTR[j];

           }

         double avg3=(tr_sum3!=0 ? bp_sum3/tr_sum3 : 0);

         BufferIND[i]=100.0*((4.0*avg1)+(2.0*avg2)+avg3)/7.0;//(4+2+1)

        }

     }

   switch(InpMethodMA)

     {

      case MODE_EMA  : if(ExponentialMAOnBuffer(rates_total,prev_calculated,period_ind,period_ma_sig,BufferIND,BufferMA)==0) return 0;                break;

      case MODE_SMMA : if(SmoothedMAOnBuffer(rates_total,prev_calculated,period_ind,period_ma_sig,BufferIND,BufferMA)==0) return 0;                   break;

      case MODE_LWMA : if(LinearWeightedMAOnBuffer(rates_total,prev_calculated,period_ind,period_ma_sig,BufferIND,BufferMA,weight_sum)==0) return 0;  break;

      //---MODE_SMA

      default        : if(SimpleMAOnBuffer(rates_total,prev_calculated,period_ind,period_ma_sig,BufferIND,BufferMA)==0) return 0;                     break;

     }

   

//---  0AGQB 8=48:0B>@0

   for(int i=limit; i>=0 && !IsStopped(); i--)

     {

      SetNL(i);

      //--- Slope

      if(InpModeComp==BEHAVIOR_SLOPE)

        {

         if(BufferIND[i]>BufferIND[i+1])

            SetUP(i);

         else if(BufferIND[i]<BufferIND[i+1])

            SetDN(i);

         else

            SetNL(i);

        }

      //--- Level

      if(InpModeComp==BEHAVIOR_LEVEL)

        {

         if(BufferIND[i]>main_level_ind)

            SetUP(i);

         else if(BufferIND[i]<main_level_ind)

            SetDN(i);

         else

            SetNL(i);

        }

      //--- OBOS

      if(InpModeComp==BEHAVIOR_OBOS)

        {

         if(BufferIND[i]>overbought_ind)

            SetUP(i);

         else if(BufferIND[i]<oversold_ind)

            SetDN(i);

         else

            SetNL(i);

        }

      //--- MA Signal

      if(InpModeComp==BEHAVIOR_SIG_MA)

        {

         if(BufferIND[i]>BufferMA[i])

            SetUP(i);

         else if(BufferIND[i]<BufferMA[i])

            SetDN(i);

         else

            SetNL(i);

        }

     }

   

//--- return value of prev_calculated for next call

   return(rates_total);

  }

//+------------------------------------------------------------------+

//| ChartEvent function                                              |

//+------------------------------------------------------------------+

void OnChartEvent(const int id,

                  const long &lparam,

                  const double &dparam,

                  const string &sparam)

  {

   if(id==CHARTEVENT_CHART_CHANGE)

     {

      for(int i=0;i<COUNT;i++)

         PlotIndexSetInteger(i,PLOT_LINE_WIDTH,SizeByScale());

      Descriptions();

      ChartRedraw();

     }

  }

//+------------------------------------------------------------------+

//| >72@0I05B @07<5@, A>>B25BAB2CNI89 <0AHB01C                      |

//+------------------------------------------------------------------+

uchar SizeByScale(void)

  {

   uchar scale=(uchar)ChartGetInteger(0,CHART_SCALE);

   uchar size=(scale<3 ? 1 : scale==3 ? 2 : scale==4 ? 5 : 8);

   return size;

  }

//+------------------------------------------------------------------+

//| ?8A0=85                                                         |

//+------------------------------------------------------------------+

void Descriptions(void)

  {

   int x=4;

   int y=1;

   int arr_colors[]={indicator_color1,indicator_color2,indicator_color3};

   string arr_texts[]={"Up direction","Down direction","Neutral"};

   string arr_names[COUNT];

   for(int i=0; i<COUNT; i++)

     {

      arr_names[i]=prefix+"label"+(string)i;

      arr_colors[i]=PlotIndexGetInteger(i,PLOT_LINE_COLOR);

      x=(i==0 ? x : i==1 ? 110 : 230);

      Label(arr_names[i],x,y,CharToString(167),16,arr_colors[i],"Wingdings");

      Label(arr_names[i]+"_txt",x+10,y+5,arr_texts[i],10,clrGray,"Calibri");

     }

  }

//+------------------------------------------------------------------+

//| K2>48B B5:AB>2CN <5B:C                                          |

//+------------------------------------------------------------------+

void Label(const string name,const int x,const int y,const string text,const int size,const color clr,const string font)

  {

   if(ObjectFind(0,name)!=wnd)

     {

      ObjectCreate(0,name,OBJ_LABEL,wnd,0,0,0,0);

      ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);

      ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);

     }

   ObjectSetInteger(0,name,OBJPROP_XDISTANCE,x);

   ObjectSetInteger(0,name,OBJPROP_YDISTANCE,y);

   ObjectSetInteger(0,name,OBJPROP_CORNER,CORNER_LEFT_LOWER);

   ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_LEFT_LOWER);

   ObjectSetInteger(0,name,OBJPROP_FONTSIZE,size);

   ObjectSetInteger(0,name,OBJPROP_COLOR,clr);

//---

   ObjectSetString(0,name,OBJPROP_FONT,font);

   ObjectSetString(0,name,OBJPROP_TEXT,text);

   ObjectSetString(0,name,OBJPROP_TOOLTIP,"\n");

  }

//+------------------------------------------------------------------+

//| >72@0I05B =08<5=>20=85 <5B>40                                 |

//+------------------------------------------------------------------+

string MethodToString(ENUM_MA_METHOD method)

  {

   return StringSubstr(EnumToString(method),5);

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void SetUP(const int shift)

  {

   BufferUP[shift]=0.5;

   BufferDN[shift]=BufferNL[shift]=EMPTY_VALUE;

  }  

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void SetDN(const int shift)

  {

   BufferDN[shift]=0.5;

   BufferUP[shift]=BufferNL[shift]=EMPTY_VALUE;

  }  

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void SetNL(const int shift)

  {

   BufferNL[shift]=0.5;

   BufferUP[shift]=BufferDN[shift]=EMPTY_VALUE;

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

string IndToString()

  {

   return(StringSubstr(EnumToString(InpIndToUse),11));

  }

//+------------------------------------------------------------------+