ZZ_FF_v4_v1

//+------------------------------------------------------------------+
//|                                                 ZZ_FF_v4.mq4   |
//|                                                 George Tischenko |
//|                    Zig-Zag & Fractal Filter                      |
//+------------------------------------------------------------------+
/*
Ðàñ÷åò öåíîâûõ ýêñòðåìóìîâ ïðîèçâîäèòñÿ ñ ïîìîùüþ ôóíêöèé iHighest / iLowest
Ôèëüòðàöèÿ ïîëó÷åííûõ çíà÷åíèé ïðîèçâîäèòñÿ ñ ïîìîùüþ ôðàêòàëüíîãî ôèëüòðà
äîáàâëåíà âèçóàëèçàöèÿ ôðàêòàëîâ, îïðåäåëåííûõ ïî àëãîðèòìó äàííîãî èíäèêàòîðà
*/
#property copyright "George Tischenko"

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 DodgerBlue
#property indicator_color2 DodgerBlue

extern int ExtPeriod=10;  //êîëè÷åñòâî áàðîâ äëÿ ðàñ÷åòà ýêñòðåìóìîâ
extern int MinAmp=10;     //ìèíèìàëüíîå ðàññòîÿíèå öåíû ìåæäó ñîñåäíèìè ïèêîì è âïàäèíîé (èíà÷å íå ðåãèñòðèðóåòñÿ)

int TimeFirstExtBar,lastUPbar,lastDNbar,TimeOpen; //âðåìÿ îòêðûòèÿ òåêóùåãî áàðà;
double MP,lastUP,lastDN;
double UP[],DN[];
bool downloadhistory=false;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
  TimeFirstExtBar=0;
  TimeOpen=0;
  MP=MinAmp*Point;
  lastUP=0; lastDN=0;
//---- indicators
  IndicatorDigits(Digits);
  IndicatorBuffers(6); 
  
  SetIndexBuffer(0,UP);
  SetIndexStyle(0,DRAW_ZIGZAG,STYLE_SOLID,3);
  
  SetIndexBuffer(1,DN);
  SetIndexStyle(1,DRAW_ZIGZAG);
//----
  SetIndexLabel(0,"UP");
  SetIndexLabel(1,"DN");
  return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
//----
  return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
  int BarsForRecalculation,i;

   int counted_bars = IndicatorCounted();
   if(counted_bars < 0)  return(-1);
   if(counted_bars > 0)   counted_bars--;
   int limit = Bars - counted_bars;
   if(counted_bars==0) limit-=1+ExtPeriod+1;
     
  
  if(limit>2) 
    {
    BarsForRecalculation=Bars-ExtPeriod-1;
    if(downloadhistory) //èñòîðèÿ çàãðóæåíà
      {
      ArrayInitialize(UP,EMPTY_VALUE);
      ArrayInitialize(DN,EMPTY_VALUE);
      }
    else downloadhistory=true;
    }
    
  else BarsForRecalculation=limit;
  if(BarsForRecalculation>0) TimeOpen=Time[limit]; //ïðîâåðèì ýòó ñòðîêó ïðè îòêðûòèè ÌÒ-4 ñ ïåðåðûâîì
  
  
/*
â ñâÿçè ñ òåì, ÷òî ôðàêòàëîì ïî îïðåäåëåíèþ ÿâëÿåòñÿ öåíîâîé ýêñòðåìóì îòíîñèòåëüíî 2 áàðîâ âïðàâî
(îñòàëüíîå ñì. ôóíêöèþ Fractal) - ñîîòâåòñòâåííî ôðàêòàë íà 3 áàðå ìîæåò ñ÷èòàòüñÿ ñôîðìèðîâàííûì 
òîëüêî ïðè îòêðûòèè íóëåâîãî òåêóùåãî áàðà: [3]-2-1-0 Ïîýòîìó ðàñ÷åò öèêëà âûïîëíÿåòñÿ òîëüêî ïðè 
îòêðûòèè íîâîãî áàðà. Âíóòðè áàðà ïðè ïîñòóïëåíèè íîâûõ òèêîâ ðàñ÷åò íå ïðîèçâîäèòñÿ.
*/
  if(TimeOpen<Time[0]) 
    {  
//======== îñíîâíîé öèêë
    while(BarsForRecalculation>1)
     {
     i=BarsForRecalculation+1; lastUP=0; lastDN=0; lastUPbar=i; lastDNbar=i;
     int LET=LastEType(); //ïîèñê ïîñëåäíåãî ýêñòðåìóìà
     
//---- ðàññìîòðèì öåíîâûå ýêñòðåìóìû çà ðàñ÷åòíûé ïåðèîä:       
     int ind1=iHighest(NULL,0,MODE_HIGH,ExtPeriod,i);
     int ind2=iLowest(NULL,0,MODE_LOW,ExtPeriod,i);
     double H=High[ind1];
     double L=Low[ind2];
            
//---- ðàññìîòðèì, èìåþòñÿ ëè íà áàðå [i] ôðàêòàëû ìèíèìàëüíîé èëè ìàêñèìàëüíîé öåí: 
     double Fup=Fractal(1,i); //MODE_UPPER 
     double Fdn=Fractal(2,i); //MODE_LOWER
     
//---- ïðîàíàëèçèðóåì ñèòóàöèþ è ðàññìîòðèì âîçìîæíîñòü ðåãèñòðàöèè íîâûõ ýêñòðåìóìîâ: 

     switch(Comb(i,H,L,Fup,Fdn))
       {
//---- íà ðàñ÷åòíîì áàðå ïîòåíöèàëüíûé ïèê (Comb)      
       case 1 :
         {
         switch(LET)
           {
           case 1 : //ïðåäûäóùèé ýêñòðåìóì òîæå ïèê
             {//âûáèðàåì áîëüøèé:
             if(NormalizeDouble(Fup-lastUP,Digits)>0) {UP[lastUPbar]=EMPTY_VALUE; UP[i]=Fup;}
             break;
             }
           case -1 : if(NormalizeDouble(Fup-lastDN-MP,Digits)>0) UP[i]=Fup; break; //ïðåäûäóùèé ýêñòðåìóì - âïàäèíà
           default : UP[i]=Fup; TimeFirstExtBar=iTime(NULL,0,i); //0 - çíà÷èò ýòî íà÷àëî ðàñ÷åòà 
           }
         break;
         }
          
//---- íà ðàñ÷åòíîì áàðå ïîòåíöèàëüíàÿ âïàäèíà  (Comb)          
       case -1 :
         {
         switch(LET)
          {
          case 1 : if(NormalizeDouble(lastUP-Fdn-MP,Digits)>0) DN[i]=Fdn; break; //ïðåäûäóùèé ýêñòðåìóì - ïèê
          case -1 : //ïðåäûäóùèé ýêñòðåìóì òîæå âïàäèíà
            {
            if(NormalizeDouble(lastDN-Fdn,Digits)>0) {DN[lastDNbar]=EMPTY_VALUE; DN[i]=Fdn;}
            break;
            }
          default : DN[i]=Fdn; TimeFirstExtBar=iTime(NULL,0,i); //0 - çíà÷èò ýòî íà÷àëî ðàñ÷åòà 
          }
        break;
        }
       
//---- íà ðàñ÷åòíîì áàðå ïîòåíöèàëüíûé ïèê è ïîòåíöèàëüíàÿ âïàäèíà (Comb)        
      case 2 : //ïðåäïîëîæèòåëüíî ñíà÷àëà ñôîðìèðîâàëñÿ LOW ïîòîì HIGH (áû÷èé áàð)
        {
        switch(LET)
          {
          case 1 : //ïðåäûäóùèé ýêñòðåìóì - ïèê
            {
            if(NormalizeDouble(Fup-Fdn-MP,Digits)>0)
              {
              if(NormalizeDouble(lastUP-Fdn-MP,Digits)>0) {UP[i]=Fup; DN[i]=Fdn;}
              else 
                {
                if(NormalizeDouble(Fup-lastUP,Digits)>0) {UP[lastUPbar]=EMPTY_VALUE; UP[i]=Fup;}
                }
              }
            else
              {
              if(NormalizeDouble(lastUP-Fdn-MP,Digits)>0) DN[i]=Fdn;
              else
                {
                if(NormalizeDouble(Fup-lastUP,Digits)>0) {UP[lastUPbar]=EMPTY_VALUE; UP[i]=Fup;}
                }
              }
            break;
            }
          case -1 : //ïðåäûäóùèé ýêñòðåìóì - âïàäèíà
            {
            if(NormalizeDouble(Fup-Fdn-MP,Digits)>0)
              {
              UP[i]=Fup;
              if(NormalizeDouble(lastDN-Fdn,Digits)>0 && iTime(NULL,0,lastDNbar)>TimeFirstExtBar) 
                {DN[lastDNbar]=EMPTY_VALUE; DN[i]=Fdn;}
              }
            else
              {
              if(NormalizeDouble(Fup-lastDN-MP,Digits)>0) UP[i]=Fup;
              else
                {
                if(NormalizeDouble(lastDN-Fdn,Digits)>0) {DN[lastDNbar]=EMPTY_VALUE; DN[i]=Fdn;}
                }
              }
            }
          } //switch LET
        break;
        }// case 2
      
      case -2 : //ïðåäïîëîæèòåëüíî ñíà÷àëà ñôîðìèðîâàëñÿ HIGH ïîòîì LOW (ìåäâåæèé áàð)
        {
        switch(LET)
          {
          case 1 : //ïðåäûäóùèé ýêñòðåìóì - ïèê
            {
            if(NormalizeDouble(Fup-Fdn-MP,Digits)>0)
              {
              DN[i]=Fdn;
              if(NormalizeDouble(Fup-lastUP,Digits)>0 && iTime(NULL,0,lastUPbar)>TimeFirstExtBar) 
                {UP[lastUPbar]=EMPTY_VALUE; UP[i]=Fup;}
              }
            else
              {
              if(NormalizeDouble(lastUP-Fdn-MP,Digits)>0) DN[i]=Fdn;
              else
                {
                if(NormalizeDouble(Fup-lastUP,Digits)>0) {UP[lastUPbar]=EMPTY_VALUE; UP[i]=Fup;}
                }
              }
            break;
            }
          case -1 : //ïðåäûäóùèé ýêñòðåìóì - âïàäèíà
            {
            if(NormalizeDouble(Fup-Fdn-MP,Digits)>0)
              {
              if(NormalizeDouble(Fup-lastDN-MP,Digits)>0) {UP[i]=Fup; DN[i]=Fdn;}
              else
                {
                if(NormalizeDouble(lastDN-Fdn,Digits)>0) {DN[lastDNbar]=EMPTY_VALUE; DN[i]=Fdn;}
                }
              }
            else
              {
              if(NormalizeDouble(Fup-lastDN-MP,Digits)>0) UP[i]=Fup;
              else
                {
                if(NormalizeDouble(Fdn-lastDN,Digits)>0) {DN[lastDNbar]=EMPTY_VALUE; DN[i]=Fdn;}
                }
              }
            }
          } //switch LET
        }// case -2 
      }
//----  
     BarsForRecalculation--;    
     } 
//========
    TimeOpen=Time[0];
    }
//----
  return(0);
  }
//+------------------------------------------------------------------+
//| ôóíêöèÿ îïðåäåëåíèÿ ôðàêòàëîâ                                    |
//+------------------------------------------------------------------+  
double Fractal(int mode, int i) 
  {
//----
  bool fr=true;
  int a,b,count;
  double res;
  
  switch(mode)
    {
    
    case 1 : //ïîèñê âåðõíèõ ôðàêòàëîâ
//ñïðàâà îò ôðàêòàëà äîëæíî áûòü 2 áàðà ñ áîëåå íèçêèìè ìàêñèìóìàìè
//ñëåâà îò ôðàêòàëà ïîæåò áûòü ãðóïïà áàðîâ, êîòîðóþ çàâåðøàò 2 áàðà ñ áîëåå íèçêèìè ìàêñèìóìàìè 
//ìàêñèìóì ëþáîãî áàðà èç ãðóïïû íå äîëæåí ïðåâûñèòü ìàêñèìóì ôðàêòàëüíîãî áàðà    
      {
      for(b=i-1;b>i-3;b--) 
        {
        if(High[i]<=High[b]) {fr=false; break;}
        }
      a=i+1; 
      while(count<2)
        {
        if(High[i]<High[a]) {fr=false; break;}
        else
          {
          if(High[i]>High[a]) count++;
          else count=0;
          }
        a++;
        }
      if(fr==true) res=High[i];
      break;
      }
      
    case 2 : //ïîèñê íèæíèõ ôðàêòàëîâ
//ñïðàâà îò ôðàêòàëà äîëæíî áûòü 2 áàðà ñ áîëåå âûñîêèìè ìèíèìóìàìè
//ñëåâà îò ôðàêòàëà ìîæåò áûòü ãðóïïà áàðîâ, êîòîðóþ çàâåðøàò 2 áàðà ñ áîëåå âûñîêèìè ìèíèìóìàìè 
//ìèíèìóì ëþáîãî áàðà èç ãðóïïû íå äîëæåí áûòü íèæå ìèíèìóìà ôðàêòàëüíîãî áàðà 
      {
      for(b=i-1;b>i-3;b--) 
        {
        if(Low[i]>=Low[b]) {fr=false; break;}
        }
      a=i+1; 
      while(count<2)
        {
        if(Low[i]>Low[a]) {fr=false; break;}
        else
          {
          if(Low[i]<Low[a]) count++;
          else count=0;
          }
        a++;
        }
      if(fr==true) res=Low[i];
      }
    }
//----
  return(res);  
  } 
//+------------------------------------------------------------------+
//| ôóíêöèÿ îïðåäåëåíèÿ ïîñëåäíåãî ýêñòðåìóìà                        |
//+------------------------------------------------------------------+  
int LastEType()
  {
//----
  int m,n,res;
  m=0; n=0;
  while(UP[lastUPbar]==EMPTY_VALUE) {if(lastUPbar>Bars-ExtPeriod) break; lastUPbar++;} 
  lastUP=UP[lastUPbar]; //âîçìîæíî íàøëè ïîñëåäíèé ïèê
  while(DN[lastDNbar]==EMPTY_VALUE) {if(lastDNbar>Bars-ExtPeriod) break; lastDNbar++;} 
  lastDN=DN[lastDNbar]; //âîçìîæíî íàøëè ïîñëåäíþþ âïàäèíó
  if(lastUPbar<lastDNbar) res=1;
  else
    {
    if(lastUPbar>lastDNbar) res=-1;
    else //lastUPbar==lastDNbar íàäî óçíàòü, êàêîé îäèíî÷íûé ýêñòðåìóì áûë ïîñëåäíèì:
      {
      m=lastUPbar; n=m;
      while(m==n)
        {
        m++; n++;
        while(UP[m]==EMPTY_VALUE) {if(m>Bars-ExtPeriod) break; m++;} //âîçìîæíî íàøëè ïîñëåäíèé ïèê
        while(DN[n]==EMPTY_VALUE) {if(n>Bars-ExtPeriod) break; n++;} //âîçìîæíî íàøëè ïîñëåäíþþ âïàäèíó
        if(MathMax(m,n)>Bars-ExtPeriod) break;
        }
      if(m<n) res=1;       //áàçîâûé îòñ÷åò - ïèê
      else if(m>n) res=-1; //áàçîâûé îòñ÷åò - âïàäèíà
      }
    }
//----    
  return(res); //åñëè res==0 - çíà÷èò ýòî íà÷àëî îòñ÷åòà èëè â ñàìîì íà÷àëå çàôèêñèðîâàí âíåøíèé áàð ñ 2 ýêñòðåìóìàìè
  }
//+------------------------------------------------------------------+
//| ôóíêöèÿ àíàëèçà òåêóùåé ñèòóàöèè                                 |
//+------------------------------------------------------------------+ 
int Comb(int i, double H, double L, double Fup, double Fdn)
  {
//----
  if(Fup==H && (Fdn==0 || (Fdn>0 && Fdn>L))) return(1);  //íà ðàñ÷åòíîì áàðå ïîòåíöèàëüíûé ïèê
  if(Fdn==L && (Fup==0 || (Fup>0 && Fup<H))) return(-1); //íà ðàñ÷åòíîì áàðå ïîòåíöèàëüíàÿ âïàäèíà
  if(Fdn==L && Fup==H)                                   //íà ðàñ÷åòíîì áàðå ïîòåíöèàëüíûé ïèê è ïîòåíöèàëüíàÿ âïàäèíà 
    {
    switch(GetOrderFormationBarHighLow(i))
      {//ïðåäïîëîæèòåëüíî ñíà÷àëà ñôîðìèðîâàëñÿ LOW ïîòîì HIGH (áû÷èé áàð)
      case -1 : return(2); break;
      //ïðåäïîëîæèòåëüíî ñíà÷àëà ñôîðìèðîâàëñÿ HIGH ïîòîì LOW (ìåäâåæèé áàð)
      case 1 : return(-2); 
      }
    }
//----  
  return(0);                                             //íà ðàñ÷åòíîì áàðå ïóñòî...
  }
//+------------------------------------------------------------------+
//| ôóíêöèÿ âîçâðàùàåò ïîðÿäîê ôîðìèðîâàíèÿ High Low äëÿ áàðà        |
//|  1: ñíà÷àëà High, çàòåì Low                                      |
//| -1: ñíà÷àëà Low, çàòåì High                                      |
//|  0: High = Low                                                   |
//+------------------------------------------------------------------+ 
int GetOrderFormationBarHighLow(int Bar)
  {
//---- Äëÿ íà÷àëà âñòðîèì ïðîñòåéøóþ ëîãèêó ïî Open / Close
  int res = 0;
  if(High[Bar]==Low[Bar]) return(res);
  if(Close[Bar]>Open[Bar]) res=-1;
  if(Close[Bar]<Open[Bar]) res=1;
   
  if(res==0) // Êîãäà Close = Open
    {
    double a1=High[Bar]-Close[Bar];
    double a2=Close[Bar]-Low[Bar];
    if(a1>a2) res=-1;
    if(a1<a2) res=1;
    if(res==0) res=1; // Êîãäà è ýòî ðàâíî  - áóäåì òàê ñ÷èòàòü! è áàñòà! - íàòÿæêà!
    }
//----
  return(res);
  } 
//+------------------------------------------------------------------+