Ind-NRTR

Download script
Author: Copyright � 2006, LeonSi
Ind-NRTR

This script is designed as a visual trading indicator that helps identify market trends and potential reversal points by monitoring price volatility and "breakout" behaviors. It uses a combination of price action analysis and the Average True Range (ATR) to establish dynamic boundaries on your chart.

Core Logic Overview

The indicator operates by identifying whether the market is in an upward or downward trend. Instead of just looking at where the price is currently, it calculates specific "thresholds" based on how much the price has been moving lately.

1. Trend Identification and Dynamic Boundaries

The script tracks the direction of the market to create two types of limits:

  • Ceilings (Upper Limits): When the market is in an uptrend, the script establishes a "ceiling." This represents a point where the price might face resistance or need to consolidate.
  • Floors (Lower Limits): When the market is in a downtrend, the script establishes a "floor," representing a base level from which the price might bounce.

2. Volatility-Based Buffers

To make these limits more accurate, the script incorporates an ATR (Average True Range) calculation. By multiplying this volatility factor by a user-defined constant, the indicator creates a "buffer zone." This helps ensure that minor price fluctuations don't trigger false signals, while significant moves are still captured.

3. Breakout Mechanics

The intelligence of the script lies in how it reacts to price movement relative to these boundaries:

  • Trend Continuation: If the price moves significantly against a buffer (e.g., pushing higher in an uptrend), the indicator recognizes this as a continuation of momentum and refreshes the boundaries.
  • Trend Reversals: The script constantly monitors for "breakdowns" or "breakups." If the price closes beyond a specific threshold, the logic triggers a trend flip. For example, if an established uptrend's floor is breached downward, the script switches its internal logic to a downtrend, flipping the visual markers and calculating new sell-side boundaries.

Visual Representation

The indicator provides real-time visual feedback on the chart:

  • Directional Arrows: It places specific symbols on the chart to highlight when significant trend changes or breakouts occur.
  • Dynamic Tracking: As the market moves, the "Ceiling" and "Floor" markers are updated. They aren't static lines; they evolve as new price data arrives, moving with the market's current momentum.

Summary for the User

In simple terms, this tool acts like a smart "boundary tracker." It measures how much the market typically breathes (volatility) and draws invisible lines based on that movement. When the price finally pushes through one of these lines with enough force, the indicator signals a trend change or a significant momentum shift, helping you see the structure of the market more clearly.

Indicators Used
Indicator of the average true range
Miscellaneous
Implements a curve of type %1
12 Views
0 Downloads
0 Favorites
Ind-NRTR 
//+------------------------------------------------------------------+
//|                                                     Ind-NRTR.mq4 |
//|                                         Copyright © 2006, LeonSi |
//|                                      http://www.expert-mt4.nm.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, LeonSi"
#property link      "http://www.expert-mt4.nm.ru"

#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1 Tomato
#property indicator_color2 DeepSkyBlue
#property indicator_color3 DeepSkyBlue
#property indicator_color4 Tomato
//---- input parameters
extern int       PerATR=40;
extern double    kATR=2.0;
//---- buffers
double SellBuffer[];
double BuyBuffer[];
double Ceil[];
double Floor[];
double Trend[];
int sm_Bars;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(5);

   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,251);
   SetIndexBuffer(0,SellBuffer);
   SetIndexEmptyValue(0,0.0);

   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,251);
   SetIndexBuffer(1,BuyBuffer);
   SetIndexEmptyValue(1,0.0);

   SetIndexStyle(2,DRAW_ARROW);
   SetIndexArrow(2,159);
   SetIndexBuffer(2,Ceil);
   SetIndexEmptyValue(2,0.0);

   SetIndexStyle(3,DRAW_ARROW);
   SetIndexArrow(3,159);
   SetIndexBuffer(3,Floor);
   SetIndexEmptyValue(3,0.0);

   SetIndexBuffer(4,Trend);   
   SetIndexEmptyValue(4,0);
   //----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
//----
   return(0);
  }
//+------------------------------------------------------------------+
bool BreakDown(int shift)
  {
   bool result=false;
   if (Close[shift]>SellBuffer[shift+1]) result=true;
   return(result);
  }
//+------------------------------------------------------------------+
bool BreakUp(int shift)
  {
   bool result=false;
   if (Close[shift]<BuyBuffer[shift+1]) result=true;
   return(result);
  }
//+------------------------------------------------------------------+
bool BreakFloor(int shift)
  {
   bool result=false;
   if (High[shift]<Floor[shift+1]) result=true;
   return(result);
  }
//+------------------------------------------------------------------+
bool BreakCeil(int shift)
  {
   bool result=false;
   if (Low[shift]>Ceil[shift+1]) result=true;
   return(result);
  }
//+------------------------------------------------------------------+
bool Uptrend(int shift)
  {
   bool result=false;
   if (Trend[shift+1]==1) result=true;
   if (Trend[shift+1]==-1) result=false;
   if ((Trend[shift+1]!=1)&&(Trend[shift+1]!=-1)) Print("Warning=",(Bars-shift));
   return(result);
  }
//+------------------------------------------------------------------+
double ATR(int iPer,int shift)
  {
   double result;
   result=iATR(NULL,0,iPer,shift);
   return(result);
  }
//+------------------------------------------------------------------+
void NewCeil(int shift)
  {
   Ceil[shift]=Close[shift];
   Floor[shift]=0.0;
  }
//+------------------------------------------------------------------+
void NewFloor(int shift)
  {
   Floor[shift]=Close[shift];
   Ceil[shift]=0.0;
  }
//+------------------------------------------------------------------+
void SetBuyBuffer(int shift)
  {
   BuyBuffer[shift]=Close[shift]-kATR*ATR(PerATR,shift);
   SellBuffer[shift]=0.0;
  }
//+------------------------------------------------------------------+
void SetSellBuffer(int shift)
  {
   SellBuffer[shift]=Close[shift]+kATR*ATR(PerATR,shift);
   BuyBuffer[shift]=0.0;
  }
//+------------------------------------------------------------------+
void NewTrend(int shift)
  {
   if (Trend[shift+1]==1) 
      {
      Trend[shift]=-1;
      NewFloor(shift);
      SetSellBuffer(shift);
      }
   else 
      {
      Trend[shift]=1;
      NewCeil(shift);
      SetBuyBuffer(shift);
      }
   if ((Trend[shift+1]!=1)&&(Trend[shift+1]!=-1)) Print("Warning",(Bars-shift));
  }
//+------------------------------------------------------------------+
void CopyLastValues(int shift)
  {
   SellBuffer[shift]=SellBuffer[shift+1];
   BuyBuffer[shift]=BuyBuffer[shift+1];
   Ceil[shift]=Ceil[shift+1];
   Floor[shift]=Floor[shift+1];
   Trend[shift]=Trend[shift+1];
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
   int limit;
   if (counted_bars>0) limit=Bars-counted_bars;
   if (counted_bars<0) return(0);
   if (counted_bars==0) 
      {
      limit=Bars-PerATR-1;
      if (Close[limit+1]>Open[limit+1]) {Trend[limit+1]=1;Ceil[limit+1]=Close[limit+1];BuyBuffer[limit+1]=Close[limit+1]-kATR*ATR(PerATR,limit+1);}
      if (Close[limit+1]<Open[limit+1]) {Trend[limit+1]=-1;Floor[limit+1]=Close[limit+1];SellBuffer[limit+1]=Close[limit+1]+kATR*ATR(PerATR,limit+1);}
      if (Close[limit+1]==Open[limit+1]) {Trend[limit+1]=1;Ceil[limit+1]=Close[limit+1];BuyBuffer[limit+1]=Close[limit+1]-kATR*ATR(PerATR,limit+1);}
      }
//----
   for (int cnt=limit;cnt>=0;cnt--)
      {
      if (Uptrend(cnt))
         {
         if (BreakCeil(cnt))
            {
            NewCeil(cnt);
            SetBuyBuffer(cnt);
            Trend[cnt]=1;
            continue;
            }
         if (BreakUp(cnt))
            {
            NewTrend(cnt);
            continue;
            }   
         CopyLastValues(cnt);
         }
      else
         {
         if (BreakFloor(cnt))
            {
            NewFloor(cnt);
            SetSellBuffer(cnt);
            Trend[cnt]=-1;
            continue;
            }
         if (BreakDown(cnt))
            {
            NewTrend(cnt);
            continue;
            }   
         CopyLastValues(cnt);
         }
      } 

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

Similar scripts

Ind-NRTR-1

This indicator identifies trend shifts by monitoring price breaches of ATR-based volatility boundaries and dynamically updates support/resistance levels.

NRTR Rosh v2_v2

This indicator detects structural market shifts by monitoring price breaches against volatility-adjusted ceiling and floor levels derived from the Average True Range.

NRTR_Rosh_v2e_mtf[1]

NRTR Rosh

This indicator identifies market directional shifts by dynamically recalculating support and resistance levels based on Average True Range volatility to signal trend reversals.

NRTR Gator

This indicator combines NRTR (Nick Rypock Trailing Reverse) with the Alligator indicator to generate buy/sell signals based on trend reversals and volatility-adjusted price levels.

NRTR Rosh v2_v1

This indicator identifies trend shifts and volatility-adjusted price levels by monitoring structural breaks relative to ATR-based dynamic buffers.

SupertrendLX

This indicator identifies directional shifts by monitoring CCI crossovers against a threshold while smoothing the trend boundaries using an ATR-based trailing stop mechanism.

NRTR_Rosh_v2eAlert_mtf

ScalperSignal_v1.01

Identifies short-term reversal opportunities by validating consecutive high or low price structure trends against specific volatility thresholds.

Change_v1

Supertrend_v1

This indicator identifies trend reversals by monitoring Commodity Channel Index (CCI) crossovers relative to a dynamic price floor and ceiling established using Average True Range (ATR) volatility buffers.

Comments