[i] ZigZag

Download script
Author: Copyright � 2007, MetaQuotes Software Corp.
[i] ZigZag

This script is designed to identify and visualize the significant "peaks" and "valleys" in a price chart, commonly referred to as a ZigZag line. Instead of showing every minor fluctuation in price, the logic filters out the noise to highlight the primary direction of the market trend.

Core Logic and Behavior

The script operates by scanning historical price data to identify major turning points based on three specific user-defined criteria: Depth, Deviation, and Backstep.

  1. Filtering Noise (Depth & Deviation): The logic first looks back over a set number of candles (the Depth) to find the highest highs and lowest lows. To ensure it doesn't react to tiny, insignificant price movements, it uses a "Deviation" threshold. A new point is only considered significant if the price change exceeds a certain percentage or amount. This prevents the chart from becoming cluttered with minor vibrations.

  2. Refining the Peaks (Backstep): The script uses a "Backstep" mechanism to ensure that once a high or low point is identified, it is the most accurate one in its immediate vicinity. It essentially checks a small window of candles to confirm that the point chosen is truly the highest or lowest in that specific area, rather than just a local outlier.

  3. Trend Tracking (State Management): The script maintains an internal "memory" of whether it is currently looking for a new high (a peak) or a new low (a valley).

    • If the market moves significantly downward, the logic identifies a potential "low" and begins searching for the next significant high.
    • If the market moves significantly upward, it identifies a "high" and begins searching for the next significant low.

  4. Dynamic Updating (The "Cutting" Logic): One of the most important features of this logic is its ability to "rewrite" history as new data arrives. If the market continues to move higher than a previously identified peak, the script will "cut" the old peak and relocate it to the new, higher price point. This ensures that the ZigZag line always accurately represents the most extreme points reached during a trend until the market successfully reverses direction.

Summary of Visual Output

The result is a clean, connected line on your chart that ignores minor price movements and only connects the most significant structural highs and lows. It allows a viewer to quickly identify the "skeleton" of the market trend, making it easier to see the overarching structure of price action without being distracted by intraday noise.

Miscellaneous
Implements a curve of type %1
13 Views
0 Downloads
0 Favorites
[i] ZigZag 
//+------------------------------------------------------------------+
//|                                                       Zigzag.mq4 |
//|                 Copyright © 2005-2007, MetaQuotes Software Corp. |
//|                                       http://www.metaquotes.net/ |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net/"

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Red
//---- indicator parameters
extern int ExtDepth=12;
extern int ExtDeviation=5;
extern int ExtBackstep=3;
//---- indicator buffers
double ZigzagBuffer[];
double HighMapBuffer[];
double LowMapBuffer[];
int level=3; // recounting's depth 
bool downloadhistory=false;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   IndicatorBuffers(3);
//---- drawing settings
   SetIndexStyle(0,DRAW_SECTION);
//---- indicator buffers mapping
   SetIndexBuffer(0,ZigzagBuffer);
   SetIndexBuffer(1,HighMapBuffer);
   SetIndexBuffer(2,LowMapBuffer);
   SetIndexEmptyValue(0,0.0);

//---- indicator short name
   IndicatorShortName("ZigZag("+ExtDepth+","+ExtDeviation+","+ExtBackstep+")");
//---- initialization done
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   int i, counted_bars = IndicatorCounted();
   int limit,counterZ,whatlookfor;
   int shift,back,lasthighpos,lastlowpos;
   double val,res;
   double curlow,curhigh,lasthigh,lastlow;

   if (counted_bars==0 && downloadhistory) // history was downloaded
     {
      ArrayInitialize(ZigzagBuffer,0.0);
      ArrayInitialize(HighMapBuffer,0.0);
      ArrayInitialize(LowMapBuffer,0.0);
     }
   if (counted_bars==0) 
     {
      limit=Bars-ExtDepth;
      downloadhistory=true;
     }
   if (counted_bars>0) 
     {
      while (counterZ<3 && i<100)
        {
         res=ZigzagBuffer[i];
         if (res!=0) counterZ++;
         i++;
        }
      i--;
      limit=i;
      if (LowMapBuffer[i]!=0) 
        {
         curlow=LowMapBuffer[i];
         whatlookfor=1;
        }
      else
        {
         curhigh=HighMapBuffer[i];
         whatlookfor=-1;
        }
      for (i=limit-1;i>=0;i--)  
        {
         ZigzagBuffer[i]=0.0;  
         LowMapBuffer[i]=0.0;
         HighMapBuffer[i]=0.0;
        }
     }
      
   for(shift=limit; shift>=0; shift--)
     {
      val=Low[iLowest(NULL,0,MODE_LOW,ExtDepth,shift)];
      if(val==lastlow) val=0.0;
      else 
        { 
         lastlow=val; 
         if((Low[shift]-val)>(ExtDeviation*Point)) val=0.0;
         else
           {
            for(back=1; back<=ExtBackstep; back++)
              {
               res=LowMapBuffer[shift+back];
               if((res!=0)&&(res>val)) LowMapBuffer[shift+back]=0.0; 
              }
           }
        } 
      if (Low[shift]==val) LowMapBuffer[shift]=val; else LowMapBuffer[shift]=0.0;
      //--- high
      val=High[iHighest(NULL,0,MODE_HIGH,ExtDepth,shift)];
      if(val==lasthigh) val=0.0;
      else 
        {
         lasthigh=val;
         if((val-High[shift])>(ExtDeviation*Point)) val=0.0;
         else
           {
            for(back=1; back<=ExtBackstep; back++)
              {
               res=HighMapBuffer[shift+back];
               if((res!=0)&&(res<val)) HighMapBuffer[shift+back]=0.0; 
              } 
           }
        }
      if (High[shift]==val) HighMapBuffer[shift]=val; else HighMapBuffer[shift]=0.0;
     }

   // final cutting 
   if (whatlookfor==0)
     {
      lastlow=0;
      lasthigh=0;  
     }
   else
     {
      lastlow=curlow;
      lasthigh=curhigh;
     }
   for (shift=limit;shift>=0;shift--)
     {
      res=0.0;
      switch(whatlookfor)
        {
         case 0: // look for peak or lawn 
            if (lastlow==0 && lasthigh==0)
              {
               if (HighMapBuffer[shift]!=0)
                 {
                  lasthigh=High[shift];
                  lasthighpos=shift;
                  whatlookfor=-1;
                  ZigzagBuffer[shift]=lasthigh;
                  res=1;
                 }
               if (LowMapBuffer[shift]!=0)
                 {
                  lastlow=Low[shift];
                  lastlowpos=shift;
                  whatlookfor=1;
                  ZigzagBuffer[shift]=lastlow;
                  res=1;
                 }
              }
             break;  
         case 1: // look for peak
            if (LowMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]==0.0)
              {
               ZigzagBuffer[lastlowpos]=0.0;
               lastlowpos=shift;
               lastlow=LowMapBuffer[shift];
               ZigzagBuffer[shift]=lastlow;
               res=1;
              }
            if (HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]==0.0)
              {
               lasthigh=HighMapBuffer[shift];
               lasthighpos=shift;
               ZigzagBuffer[shift]=lasthigh;
               whatlookfor=-1;
               res=1;
              }   
            break;               
         case -1: // look for lawn
            if (HighMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0)
              {
               ZigzagBuffer[lasthighpos]=0.0;
               lasthighpos=shift;
               lasthigh=HighMapBuffer[shift];
               ZigzagBuffer[shift]=lasthigh;
              }
            if (LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]==0.0)
              {
               lastlow=LowMapBuffer[shift];
               lastlowpos=shift;
               ZigzagBuffer[shift]=lastlow;
               whatlookfor=1;
              }   
            break;               
         default: return; 
        }
     }

   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

ZigZag_002

This indicator identifies significant market inflection points by filtering local extrema based on depth, deviation, and backstep parameters to visualize price swings.

ZigZag

This algorithm identifies and connects significant local price extrema by filtering out minor fluctuations through multi-step depth, deviation, and backstep validation.

ZigZagLastLeg_

This algorithm identifies local market extrema by filtering price fluctuations based on depth, deviation, and backstep parameters to map sequential structural oscillations.

ZigZagClose

This algorithm identifies structural price reversals by filtering local extrema through depth, deviation, and backstep parameters to highlight significant trend fluctuations.

ZigZag_R_

An enhanced price action oscillator that minimizes computational overhead by utilizing dynamic recalculation depth and eliminating ghost extrema from sub-minute timeframes.

ZigZag_R

This indicator identifies price structural pivots by efficiently recalculating only the necessary historical depth to reduce computational overhead during real-time execution.

ZigZagHistory

This indicator identifies structural market extrema by filtering price fluctuations through depth and deviation constraints to map sequential swing highs and lows.

Post-zigzag

This indicator identifies significant market structural pivots by dynamically filtering price extrema based on depth, deviation, and backstep parameters to delineate swing points.

Zigzag2_v2

Post-zigzag_v1

ZigZagHistoryLL

This indicator identifies structural swing points by calculating significant price oscillations and filtering noise through recursive high-low mapping.

Comments