rvmGann_sv8_n_v1

Download script
Author: Copyright � 2005, MetaQuotes Software Corp.
rvmGann_sv8_n_v1

This script is a specialized technical analysis tool designed to identify and map significant price structure points, such as peaks (highs) and valleys (lows), on a trading chart. It functions by analyzing historical price movement to filter out market "noise" and highlight meaningful structural shifts.

Core Logic Overview

The indicator operates by scanning each price candle to determine if it establishes a new boundary for the current price range. It employs several layers of logic to ensure that only significant structural changes are recorded:

1. Boundary Tracking The script continuously monitors the highest and lowest prices reached during a specific period. It maintains a memory of these levels to distinguish between minor fluctuations and actual breakthroughs. If a new candle exceeds the previous high or drops below the previous low, the script updates its internal boundaries to reflect this new market range.

2. Trend and Extremum Detection A significant portion of the logic is dedicated to identifying "Extremums"—the specific points where the price turns around.

  • Sequence Analysis: The tool evaluates how the price interacts with these boundaries. It looks at the relationship between the opening, closing, and high/low prices of each candle.
  • Contextual Awareness: By comparing current price action against historical highs and lows, the script decides whether a move is a continuation of an existing trend or the start of a new structural phase.

3. Dynamic Counting and Filtering The logic includes a "tendency" system (controlled by the GSv_tend parameter). This allows the user to define how many consecutive price movements are required before a structural point is confirmed.

  • If the market is moving in one direction, the script keeps a running count of those moves.
  • If a reversal occurs—specifically, if the price breaks against the current trend—the counters reset. This helps prevent the indicator from "drawing" a new peak or valley during small pullbacks within a larger trend.

4. Visual Mapping (ZigZag Logic) Once the internal logic confirms that a significant high or low has been reached:

  • The script plots these points as a "ZigZag" line on the chart.
  • It manages "State Switching": The indicator knows whether it is currently looking for an upward move or a downward move. For example, after a confirmed high is plotted, the logic shifts its primary focus to identifying the next significant low.

Summary of Behavior

Essentially, this script acts as an automated "structural mapper." Instead of showing every small wiggle in the price, it waits for the market to demonstrate a sustained shift in direction based on established boundaries and specific candle behavior. It then connects these major turning points to provide a clear visual representation of the market's skeletal structure.

Miscellaneous
Implements a curve of type %1It issuies visual alerts to the screen
15 Views
0 Downloads
0 Favorites
rvmGann_sv8_n_v1 
/*-----------------------------+
|			       |
| Shared by www.Aptrafx.com    |
|			       |
+------------------------------*/

//+------------------------------------------------------------------+
//|                                                  rvmGann_sv8.mq4 |
//|                      Copyright © 2005, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net"

#property indicator_chart_window
#property indicator_buffers 8
#property indicator_color1 DeepSkyBlue
#property indicator_color2 DeepSkyBlue
//#property indicator_color3 DeepSkyBlue
//#property indicator_color4 DeepSkyBlue
//#property indicator_color5 DeepSkyBlue
//#property indicator_color6 DeepSkyBlue
//#property indicator_color7 DeepSkyBlue
//#property indicator_color8 DeepSkyBlue
//---- input parameters
extern int GSv_tend=2;
//---- buffers
double Upz[];
double Dnz[];
double sH[];
double sL[];
double aH[];
double aL[];
double fB[];
double lB[];
//----------
double CurH,CurL;
int lb,sp,lbars;
bool draw_up,draw_dn;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(8);
   SetIndexStyle(0,DRAW_ZIGZAG,STYLE_SOLID);
   SetIndexStyle(1,DRAW_ZIGZAG,STYLE_SOLID);
   SetIndexStyle(2,DRAW_NONE);
   SetIndexStyle(3,DRAW_NONE);
   SetIndexStyle(4,DRAW_NONE);
   SetIndexStyle(5,DRAW_NONE);
   SetIndexStyle(6,DRAW_NONE);
   SetIndexStyle(7,DRAW_NONE);
   SetIndexBuffer(0,Upz);
   SetIndexBuffer(1,Dnz);
   SetIndexBuffer(2,sH);
   SetIndexBuffer(3,sL);
   SetIndexBuffer(4,aH);
   SetIndexBuffer(5,aL);
   SetIndexBuffer(6,fB);
   SetIndexBuffer(7,lB);
   SetIndexEmptyValue(0,0);
   SetIndexEmptyValue(1,0);
   SetIndexEmptyValue(2,0);
   SetIndexEmptyValue(3,0);
   SetIndexEmptyValue(4,-1);
   SetIndexEmptyValue(5,-1);
   SetIndexEmptyValue(6,-1);
   SetIndexEmptyValue(7,-1);
   SetIndexLabel(0,"z1");
   SetIndexLabel(1,"z2");
   SetIndexLabel(2,"sH");
   SetIndexLabel(3,"sL");
   SetIndexLabel(4,"aH");
   SetIndexLabel(5,"aL");
   SetIndexLabel(6,"fB");
   SetIndexLabel(7,"lB");
//----
   return(0);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int counted_bars=IndicatorCounted();
   int cb,index,limit,ai,i;
//---- 
   if( !counted_bars<0 )
   {
      index=Bars-1;
      if( index-counted_bars<2 )
      {
         limit=0;
      }
      else
      {
         limit=index-counted_bars-1;
      }
   }
   else
   {
      Alert("Ñáîé ðàñ÷åòà èíäèêàòîðà rvmGSv_mt");
      return(-1);
   }
//----
for( cb=limit; cb>=0; cb-- )
{
   ai=index-cb;
   if( lbars!=Bars && lb==ai )
   {
      lbars=Bars;
      continue;
   }
   if( lb!=ai )
   {
      lb=ai;
      if( Upz[cb+1]>0 || Dnz[cb+1]>0 )
      {
         aH[cb]=High[cb+1];
         aL[cb]=Low[cb+1];
      }
      else
      {
         if( High[cb+1]<=aH[cb+1] && Low[cb+1]>=aL[cb+1] )
         {
            aH[cb]=aH[cb+1];
            aL[cb]=aL[cb+1];
            sH[cb]=sH[cb+1];
            sL[cb]=sL[cb+1];
         }
         else
         {
            if( High[cb+1]>aH[cb+1] )
            {
               aH[cb]=High[cb+1];
            }
            else
            {
               aH[cb]=aH[cb+1];
            }
            if( aL[cb+1]>0 )
            {
               if( Low[cb+1]<aL[cb+1] )
               {
                  aL[cb]=Low[cb+1];
               }
               else
               {
                  aL[cb]=aL[cb+1];
               }
            }
            else
            {
               aL[cb]=Low[cb+1];
            }
         }
      }
      if( draw_up!=0 )
      {
         if( fB[cb+1]==1 )
         {
            sH[cb]=sH[cb+1]+1;
            if( lB[cb+1]==0 )
            {
               sH[cb]=0;
               sL[cb]=1;
            }
         }
         else
         {
            if( fB[cb+1]==0 )
            {
               sL[cb]=sL[cb+1]+1;
               if( lB[cb+1]==1 )
               {
                  sH[cb]=1;
                  sL[cb]=0;
               }
            }
         }
      }
      else
      {
         if( draw_dn!=0 )
         {
            if( fB[cb+1]==0 )
            {
               sL[cb]=sL[cb+1]+1;
               if( lB[cb+1]==1 )
               {
                  sH[cb]=1;
                  sL[cb]=0;
               }
            }
            else
            {
               if( fB[cb+1]==1 )
               {
                  sH[cb]=sH[cb+1]+1;
                  if( lB[cb+1]==0 )
                  {
                     sH[cb]=0;
                     sL[cb]=1;
                  }
               }
            }
         }
         else
         {
            if( fB[cb+1]==1 )
            {
               sH[cb]=sH[cb+1]+1;
               sL[cb]=sL[cb+1];
               if( lB[cb+1]==0 )
               {
                  sL[cb]++;
               }
            }
            else
            {
               if( fB[cb+1]==0 )
               {
                  sH[cb]=sH[cb+1];
                  sL[cb]=sL[cb+1]+1;
                  if( lB[cb+1]==1 )
                  {
                     sH[cb]++;
                  }
               }
            }
         }
      }
      if( GSv_tend>1 )
      {
         //åñëè íà ïðåäûäóùåé ñâå÷å áûëî ïðåëîìëåíèå ââåðõ è îíà âíåøíÿÿ ïî îòíîøåíèþ ê ïðåäûäóùåé + ïîñëåäíèé ìèíèìóì
         if( sH[cb]==GSv_tend && Upz[cb+1]>0 && High[cb+1]>High[cb+2] && Low[cb+1]<Low[cb+2] && fB[cb+1]==1 )
         {
            sL[cb]=1;
         }
         else //èíà÷å åñëè íà ïðåäûäóùåé ñâå÷å ñ÷åò÷èê áûëî ïðåëîìëåíèå ââåðõ
         {
            //åñëè íà ïðåäûäóùåé ñâå÷å áûëî ïðåëîìëåíèå âíèç è îíà âíåøíÿÿ ïî îòíîøåíèþ ê ïðåäûäóùåé + ïîñëåäíèé ìàêñèìóì
            if( sL[cb]==GSv_tend && Dnz[cb+1]>0 && High[cb+1]>High[cb+2] && Low[cb+1]<Low[cb+2] && fB[cb+1]==0 )
            {
               sH[cb]=1;
            }
         }
      }
      //îáíóëÿåì
      CurH=0;
      CurL=Low[cb];
   }
   if( High[cb]<=aH[cb] && Low[cb]>=aL[cb] )
   {
      continue;
   }
   if( High[cb]<=CurH && Low[cb]>=CurL )
   {
      continue;
   }
   if( High[cb]>CurH ) CurH=High[cb];
   if( Low[cb] <CurL ) CurL=Low[cb];
   Extr_seq(cb);
   //åñëè ñâèíã äâóõ è áîëåå áàðîâûé, òî åñëè ïåðâûé õàé-îáíóëÿåì ñ÷åò÷èê ìèíìóìîâ, à åñëè ïåðâûé-ëîó, îáíóëÿåì ñ÷åò÷èê ìàêñèìóìîâ
   if( GSv_tend>1 )
   {
      if( fB[cb]>0 && sH[cb]==GSv_tend-1 && sL[cb]>0 )
      {
         sL[cb]=0;
      }
      else
      {
         if( fB[cb]>-1 && sL[cb]==GSv_tend-1 && sH[cb]>0 )
         {
            sH[cb]=0;
         }
      }
   }
   if( draw_up!=0 )
   {
      if( fB[cb]==1 )
      {
         if( sp!=ai )
         {
            Upz[index-sp]=0;
            sp=ai;
         }
         Upz[cb]=High[cb];
         if( lB[cb]==0 && (sL[cb]+1)>=GSv_tend && GSv_tend<2 )
         {
            Dnz[cb]=Low[cb];
            draw_up=0;
            draw_dn=1;
         }
      }
      else
      {
         if( fB[cb]==0 )
         {
            if( (sL[cb]+1)>=GSv_tend )
            {
               Dnz[cb]=Low[cb];
               sp=ai;
               draw_up=0;
               draw_dn=1;
               if( lB[cb]==1 && (sH[cb]+1)>=GSv_tend )
               {
                  Upz[cb]=High[cb];
                  draw_up=1;
                  draw_dn=0;
               }
            }
            else
            {
               if( lB[cb]==1 )
               {
                  Upz[index-sp]=0;
                  sp=ai;
                  Upz[cb]=High[cb];
               }
            }
         }
      }
   }
   else
   {
      if( draw_dn!=0 )
      {
         if( fB[cb]==1 )
         {
            if( (sH[cb]+1)>=GSv_tend )
            {
               Upz[cb]=High[cb];
               sp=ai;
               draw_up=1;
               draw_dn=0;
               if( lB[cb]==0 && (sL[cb]+1)>=GSv_tend )
               {
                  Dnz[cb]=Low[cb];
                  draw_up=0;
                  draw_dn=1;
               }
            }
            else
            {
               if( lB[cb]==0 )
               {
                  Dnz[index-sp]=0;
                  sp=ai;
                  Dnz[cb]=Low[cb];
               }
            }
         }
         else
         {
            if( fB[cb]==0 )
            {
               if( sp!=ai )
               {
                  Dnz[index-sp]=0;
                  sp=ai;
               }
               Dnz[cb]=Low[cb];
               if( lB[cb]==1 && (sH[cb]+1)>=GSv_tend && GSv_tend<2 )
               {
                  Upz[cb]=High[cb];
                  draw_up=1;
                  draw_dn=0;
               }
            }
         }
      }
      else
      {
         if( fB[cb]==1 && (sH[cb]+1)>=GSv_tend )
         {
            Dnz[index]=Low[index];
            Upz[cb]=High[cb];
            draw_up=1;
            sp=ai;
            if( lB[cb]==0 && (sL[cb]+1)>=GSv_tend )
            {
               Dnz[cb]=Low[cb];
               draw_up=0;
               draw_dn=1;
            }
         }
         else
         {
            if( fB[cb]==0 && (sL[cb]+1)>=GSv_tend )
            {
               Upz[index]=High[index];
               Dnz[cb]=Low[cb];
               draw_dn=1;
               sp=ai;
               if( lB[cb]==1 && (sH[cb]+1)>=GSv_tend )
               {
                  Upz[cb]=High[cb];
                  draw_up=1;
                  draw_dn=0;
               }
            }
         }
      }
   }
}
//----
   return(0);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Ôóíêöèÿ îïðåäåëÿåò ïîñëåäîâàòåëüíîñòü ïîÿâëåíèÿ ýêñòðåìóìîâ      |
//+------------------------------------------------------------------+
void Extr_seq(int curb)
  {
//---- 
   if( fB[curb]<0 )
   {
      //åñëè áàð ïðîñ÷èòûâàåòñÿ ïî èñòîðèè è îí ñðàçó âíåøíèé
      if( High[curb]>aH[curb] && Low[curb]<aL[curb] )
      {
         //åñëè îòêðûòèå íà íîâîì ìàêñèìóìå
         if( Open[curb]>aH[curb] )
         {
            fB[curb]=1;
            lB[curb]=0;
         }
         else //èíà÷å åñëè îòêðûòèå íà íîâîì ìàêñèìóìå
         {
            //åñëè îòêðûòèå íà íîâîì ìèíèìóìå
            if( Open[curb]<aL[curb] )
            {
               fB[curb]=0;
               lB[curb]=1;
            }
            else
            {
               //åñëè çàêðûòèå íà íîâîì ìàêñèìóìå è îíî âûøå èëè ðàâíî îòêðûòèÿ
               if( Close[curb]>aH[curb] && Close[curb]>=Open[curb] )
               {
                  fB[curb]=0;
                  lB[curb]=1;
               }
               else //èíà÷å åñëè çàêðûòèå íà íîâîì ìàêñèìóìå è îíî âûøå èëè ðàâíî îòêðûòèÿ
               {
                  //åñëè çàêðûòèå íà íîâîì ìèíèìóìå è íèæå èëè ðàâíî îòêðûòèþ
                  if( Close[curb]>aL[curb] && Close[curb]<=Open[curb] )
                  {
                     fB[curb]=1;
                     lB[curb]=0;
                  }
                  else //èíà÷å åñëè çàêðûòèå íà íîâîì ìèíèìóìå è íèæå èëè ðàâíî îòêðûòèþ
                  {
                     //åñëè êëîç âûøå îïåíà
                     if( Close[curb]>Open[curb] )
                     {
                        fB[curb]=0;
                        lB[curb]=1;
                     }
                     else //èíà÷å åñëè êëîç âûøå îïåíà
                     {
                        //åñëè êëîç íèæå îïåíà
                        if( Close[curb]<Open[curb] )
                        {
                           fB[curb]=1;
                           lB[curb]=0;
                        }
                        else //èíà÷å åñëè êëîç íèæå îïåíà
                        {
                           //åñëè îïåí áëèæå ê àêòèâíîìó ìèíèìóìó
                           if( MathAbs(Open[curb]-aL[curb])<MathAbs(Open[curb]-aH[curb]) )
                           {
                              fB[curb]=0;
                              lB[curb]=1;
                           }
                           else //èíà÷å åñëè îïåí áëèæå ê àêòèâíîìó ìèíèìóìó
                           {
                              //åñëè îïåí áëèæå ê àêòèâíîìó ìàêñèìóìó
                              if( MathAbs(Open[curb]-aL[curb])>MathAbs(Open[curb]-aH[curb]) )
                              {
                                 fB[curb]=1;
                                 lB[curb]=0;
                              }
                              else //èíà÷å èíà÷å åñëè îïåí áëèæå ê àêòèâíîìó ìàêñèìóìó
                              {
                                 //åñëè îïåí áëèæå èëè ðàâíîóäàëåí îò ìèíèìóìà
                                 if( MathAbs(Open[curb]-Low[curb])>=MathAbs(Open[curb]-High[curb]) )
                                 {
                                    fB[curb]=0;
                                    lB[curb]=1;
                                 }
                                 else
                                 {
                                    fB[curb]=1;
                                    lB[curb]=0;
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            }
         }
      }
      else
      {
         if( High[curb]>aH[curb] )
         {
            fB[curb]=1;
         }
         else
         {
            fB[curb]=0;
         }
      }
   }
   else
   {
      //åñëè òåêóùàÿ öåíà ðàâíà ìàêñèìóìó íà áàðå èëè íåò ìèíèìóìà è ïðè ýòîì ìàêñèìóì-íîâûé
      if( (Low[curb]>=aL[curb] || Close[curb]==High[curb] ) && High[curb]>aH[curb] )
      {
         lB[curb]=1;
      }
      else //èíà÷å åñëè öåíà ðàâíà ìàêñèìóìó íà áàðå
      {
         //åñëè öåíà ðàâíà ìèíèìóìó íà áàðå èëè íåò íîâîãî ìàêñèìóìà è ïðè ýòîì ìèíèìóì - íîâûé
         if( (High[curb]<=aH[curb] || Close[curb]==Low[curb]) && Low[curb]<aL[curb] )
         {
            lB[curb]=0;
         }
      }
   }
//----
   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

MyLineOrder_version_2_1

RCFMA

This indicator quantifies market momentum by calculating the spread between medium and long-term moving averages while tracking the instantaneous rate of change for short-term price velocity.

CloseOnTheLimit_Reverse

Identifies price action reversals by detecting breaches of previous highs and lows while projecting entry targets based on half the Average True Range volatility.

HiLo_Activator_Profi

This indicator identifies institutional supply and demand zones by calculating the arithmetic mean of historical highs and lows across specific session intervals, triggering alerts when price breaches these structural boundaries.

Parabolic_mailalert

This indicator identifies trend reversals by tracking the Parabolic SAR across higher timeframes and visually segregating upward and downward momentum channels.

Normalizer

This indicator transforms raw oscillator data into a bounded range by calculating a rolling root mean square deviation and applying a hyperbolic tangent transformation.

BandsLSMA_v1

This indicator calculates a linear regression-based moving average as the baseline to generate volatility bands based on standard deviation variance.

WoodiesCCI_v1

This indicator quantifies momentum dynamics by calculating the differential between a fast and slow Commodity Channel Index (CCI) based on typical price data.

wlxBWAOsig

Identifies bullish and bearish trend reversals by detecting zero-line crossovers and momentum shifts within the Awesome Oscillator.

Atr_3v1_3

This indicator identifies high-intensity market activity by correlating relative Average True Range expansions with normalized volume spikes to highlight significant price momentum shifts.

33_M3

The logic calculates a weighted multi-layered momentum average using recursive smoothing and coefficient-based transformations to identify divergent price velocity trends.

Comments