ZigZag_Pointer_alert_only at turning points

Download script
Author: dr_richard_gaines
ZigZag_Pointer_alert_only at turning points

This tool is designed to identify and highlight significant structural turning points in a financial market’s price movement. By filtering out minor market noise, it helps traders visualize the primary "peaks" (highs) and "troughs" (lows) of a trend, creating a clear visual path of the price action.

Core Logic and Filtering

The script operates by scanning historical price data to find extreme points based on three main user-defined criteria:

  • Depth: This determines how far back the tool looks to find a peak or trough. A larger depth ensures the tool ignores small fluctuations and only identifies major movements.
  • Deviation: This acts as a sensitivity threshold. The script will only mark a new point if the price moves significantly enough from the previous point to be considered a "meaningful" change. If the movement is too small, it is ignored as market noise.
  • Backstep: This ensures that the points identified are distinct and not clustered too closely together, providing a cleaner visual representation of the trend.

Dynamic Adjustment

The logic is designed to be proactive. As new price data enters the chart, the script constantly evaluates whether a newly formed high or low "overtakes" a previous one. If a higher peak or a lower trough is detected within a specific timeframe, the tool automatically updates the most recent point to ensure the displayed line reflects the most extreme reality of the current market structure.

Trend Recognition and Alerts

Beyond simply drawing points on the chart, the script possesses an intelligent "direction tracking" mechanism. It monitors the sequence of these peaks and troughs to identify structural shifts in the market:

  1. Sequence Tracking: The tool keeps track of the positions of the two most recent significant turning points.
  2. Directional Change Detection: By comparing the current sequence of highs and lows against previous data, the script can determine if the market's primary structure is shifting (for example, moving from an uptrend to a downtrend).
  3. Real-time Notifications: When the logic detects a definitive shift in these structural markers—indicating that the price may be changing direction—it triggers an automated alert. This allows traders to react to potential trend reversals immediately without having to manually monitor every price tick.

In summary, this script functions as a sophisticated "map" of market structure, automatically filtering out minor volatility to show you the true path of price movement and notifying you when that path begins to change direction.

Miscellaneous
Implements a curve of type %1It issuies visual alerts to the screen
14 Views
1 Downloads
0 Favorites
ZigZag_Pointer_alert_only at turning points 
//+------------------------------------------------------------------+
//|                                               ZigZag Pointer.mq4 |
//|                                    zigzag modified by Dr. Gaines |
//|                                      dr_richard_gaines@yahoo.com |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "dr_richard_gaines"
#property link      "http://www.metaquotes.net/"

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Lime
#property indicator_width1 1
#property indicator_color2 Red
#property indicator_width2 1 
//---- indicator parameters
extern int ExtDepth=100;
extern int ExtDeviation=75;
extern int ExtBackstep=15;
//---- indicator buffers
double ExtMapBuffer[];
double ExtMapBuffer2[];
int OldLastZigZag, OldPreviousZigZag;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   IndicatorBuffers(2);
//---- drawing settings
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0, 233);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1, 234);  
//---- indicator buffers mapping
   SetIndexBuffer(0,ExtMapBuffer);
   SetIndexBuffer(1,ExtMapBuffer2);
   SetIndexEmptyValue(0,0.0);
   
//---- indicator short name
   IndicatorShortName("ZigZag("+ExtDepth+","+ExtDeviation+","+ExtBackstep+")");
//---- initialization done
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   int    shift, back,lasthighpos,lastlowpos;
   double val,res;
   double curlow,curhigh,lasthigh,lastlow;

   for(shift=Bars-ExtDepth; shift>=0; shift--)
     {
      val=Low[Lowest(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=ExtMapBuffer[shift+back];
               if((res!=0)&&(res>val)) ExtMapBuffer[shift+back]=0.0; 
              }
           }
        } 
      ExtMapBuffer[shift]=val;
      //--- high
      val=High[Highest(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=ExtMapBuffer2[shift+back];
               if((res!=0)&&(res<val)) ExtMapBuffer2[shift+back]=0.0; 
              } 
           }
        }
      ExtMapBuffer2[shift]=val;
     }

   // final cutting 
   lasthigh=-1; lasthighpos=-1;
   lastlow=-1;  lastlowpos=-1;

   for(shift=Bars-ExtDepth; shift>=0; shift--)
     {
      curlow=ExtMapBuffer[shift];
      curhigh=ExtMapBuffer2[shift];
      if((curlow==0)&&(curhigh==0)) continue;
      //---
      if(curhigh!=0)
        {
         if(lasthigh>0) 
           {
            if(lasthigh<curhigh) ExtMapBuffer2[lasthighpos]=0;
            else ExtMapBuffer2[shift]=0;
           }
         //---
         if(lasthigh<curhigh || lasthigh<0)
           {
            lasthigh=curhigh;
            lasthighpos=shift;
           }
         lastlow=-1;
        }
      //----
      if(curlow!=0)
        {
         if(lastlow>0)
           {
            if(lastlow>curlow) ExtMapBuffer[lastlowpos]=0;
            else ExtMapBuffer[shift]=0;
           }
         //---
         if((curlow<lastlow)||(lastlow<0))
           {
            lastlow=curlow;
            lastlowpos=shift;
           } 
         lasthigh=-1;
        }
     }
  
   for(shift=Bars-1; shift>=0; shift--)
     {
      if(shift>=Bars-ExtDepth) ExtMapBuffer[shift]=0.0;
      else
        {
         res=ExtMapBuffer2[shift];
         if(res!=0.0) ExtMapBuffer2[shift]=res;
        }
  	int i=0;
  	int LastZigZag, PreviousZigZag;
   
   int h=0;
   while ( ExtMapBuffer[h]==0 && ExtMapBuffer2[h]==0) {
   	h++;
   }
   
   LastZigZag=h;
   
   h++;
   while(ExtMapBuffer[h]==0 && ExtMapBuffer2[h]==0) {
   	h++;
   }
   
   PreviousZigZag=h;
   
   if (OldLastZigZag!=LastZigZag || OldPreviousZigZag!=PreviousZigZag) {
   	if ((OldLastZigZag>LastZigZag)&& (OldPreviousZigZag>PreviousZigZag)) Alert("Possible change in direction... (M",Period()," ",Symbol(),")");
    	OldLastZigZag=LastZigZag;
   	OldPreviousZigZag=PreviousZigZag;
   	//ObjectDelete("Fibo");
   	//ObjectCreate("Fibo", OBJ_FIBO, 0, Time[PreviousZigZag], ExtMapBuffer[LastZigZag], Time[LastZigZag], ExtMapBuffer[PreviousZigZag]);
  }
   if (OldLastZigZag!=LastZigZag || OldPreviousZigZag!=PreviousZigZag) {
   	if((OldLastZigZag<LastZigZag)&& (OldPreviousZigZag<PreviousZigZag)) Alert("Possible change in direction... (M",Period()," ",Symbol(),")");
   	OldLastZigZag=LastZigZag;
   	OldPreviousZigZag=PreviousZigZag;
   	//ObjectDelete("Fibo");
   	//ObjectCreate("Fibo", OBJ_FIBO, 0, Time[PreviousZigZag], ExtMapBuffer[LastZigZag], Time[LastZigZag], ExtMapBuffer[PreviousZigZag]);
   }
     }
  }
  
  //end//

Similar scripts

[i] ZigZag_Pointer_alert_only at turning points

This indicator identifies key price swing points by filtering local extrema through depth, deviation, and backstep parameters to detect structural trend reversals.

[i] =x=ZigZag_Pointer_alert

This indicator identifies structural price swings by filtering local extrema and triggering real-time alerts upon detected polarity reversals in market momentum.

ZigZag_Pointer_alert_only at turning points_002

This indicator identifies key structural swing points by filtering price extrema through depth, deviation, and backstep constraints to detect trend reversals.

ZigZag_Pointer_alert

This indicator identifies significant price extrema and structural swing points by filtering market noise through depth, deviation, and backstep parameters to detect directional shifts.

ZigZag_Pointer_alert_email

This indicator identifies structural market turning points by filtering local price peaks and troughs based on user-defined depth, deviation, and backstep parameters to detect trend reversals.

ZigZag_Fibo_NoAlert

This script identifies structural swing points to render an automated Fibonacci retracement level between the most recent and previous local extrema.

ZigZag_Fibo_v1beta

This algorithm identifies significant price extremes by filtering local fluctuations through a multi-stage recursive peak and valley elimination process to map structural pivots.

ZigZag_Fibo_v1beta_v1

This indicator identifies structural price reversals by isolating local highs and lows through recursive deviation filtering and peak pruning to automatically plot Fibonacci retracement levels.

ICWR+HISTORY

This indicator autonomously identifies significant market price swings using a custom zigzag algorithm to project automated Fibonacci retracement levels and structural zones.

ZigZag_Fibo_v2beta_001

This indicator identifies sequential structural extremes to automatically render Fibonacci retracement levels based on the most recent significant swing highs and lows.

ZigZag_Fibo_Alert

Identifies significant structural price swings by filtering local highs and lows to automatically project Fibonacci retracement levels.

Comments