xigxag
Download scriptThis script is designed to identify and visualize significant price fluctuations on a financial chart, creating a simplified "path" of the market's movements. By filtering out minor market noise, it helps traders see the primary direction of price action—moving from peak to peak and trough to trough.
How the Logic Works
1. Filtering the Noise The script does not record every single price change. Instead, it uses three specific parameters to decide what qualifies as a "significant" move:
- Depth: This defines how many candles the script looks back to find the highest highs or lowest lows.
- Deviation: This acts as a minimum threshold. The price must move by a specific amount before the script recognizes it as a new point in the trend.
- Backstep: This ensures that points aren't placed too close together, effectively "smoothing" the line so it doesn't jitter during periods of sideways movement.
2. Identifying Highs and Lows The internal logic scans the historical data to build a map of potential peaks (Highs) and valleys (Lows). It continuously compares the current price against these maps. If a new low is found that is significantly lower than the previous one, it marks that spot as a candidate. Conversely, if a new high is found that is significantly higher, it captures that as well.
3. Constructing the ZigZag Path Once the significant highs and lows are identified, the script applies a "switching" logic to connect them:
- Directional Tracking: The script remembers whether the last major point was a High or a Low.
- Continuous Flow: If it just recorded a Low, it ignores subsequent minor lows and focuses on finding a new High. Once a new High is confirmed, it connects the dots to create a "zig" in the line. It then switches its focus back to looking for the next Low to create the "zag."
- Dynamic Updating: The script is smart enough to realize that a previous point might no longer be the absolute highest or lowest. If a newer, more extreme point appears before the path is finalized, the script can retract the old point and update the line to reflect the new extreme.
Summary for the User
Essentially, this script acts as an automated "trend mapper." It scans your price history, ignores the small "wiggles" of daily trading, and draws a clear, continuous line connecting the most important structural points of the market. It provides a visual summary of the market's skeleton, making it easier to identify support levels, resistance levels, and overall momentum.
//+------------------------------------------------------------------+
//| ProjectName |
//| Copyright 2012, CompanyName |
//| http://www.companyname.net |
//+------------------------------------------------------------------+
#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Red
extern int ExtDepth=12;
extern int ExtDeviation=5;
extern int ExtBackstep=3;
double ZigzagBuffer[];
double HighMapBuffer[];
double LowMapBuffer[];
int level=3;
bool downloadhistory=false;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int init()
{
IndicatorBuffers(3);
SetIndexStyle(0,DRAW_SECTION);
SetIndexBuffer(0,ZigzagBuffer);
SetIndexBuffer(1,HighMapBuffer);
SetIndexBuffer(2,LowMapBuffer);
SetIndexEmptyValue(0,0.0);
IndicatorShortName("ZigZag("+ExtDepth+","+ExtDeviation+","+ExtBackstep+")");
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)
{
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<level && 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;
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;
}
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:
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:
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:
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 ( false );
}
}
return(0);
}
//+------------------------------------------------------------------+
Comments