InstTrendLine_v1

Download script
Author: Copyright � 2009, TrendLaboratory
InstTrendLine_v1

This tool is a sophisticated trend-following indicator designed to filter out "market noise" and identify the core underlying direction of price movement. It achieves this by using a multi-layered mathematical process to smooth out erratic price fluctuations, making it easier for traders to distinguish between temporary volatility and meaningful trends.

Core Operational Logic

1. Data Input Customization The script allows you to choose which specific price data points to analyze. You can select standard metrics like the Closing price or High/Low prices, but it also includes advanced options such as Median Prices, Weighted Closes, or Heiken Ashi calculations. This flexibility ensures the tool can be tuned to different trading styles.

2. Multi-Timeframe Analysis A key feature of this script is its ability to look at "higher" timeframes while you are viewing a smaller one. It can calculate trends on hourly or daily charts and project those results onto your current screen, helping you ensure that your short-term trades align with the broader market direction.

3. Advanced Signal Processing (The "Filtering" Pipeline) Rather than simply drawing a straight line over price, the script puts the data through several mathematical filters:

  • Smoothing: It starts by taking a weighted average of recent prices to create a stable foundation.
  • Detrending & Cycle Analysis: It uses complex calculations to identify "cycles" in the market (repeating patterns of highs and lows).
  • Notch Filtering: It specifically targets and removes certain frequencies of noise—essentially "cleaning" the data so that only the most significant trend remains visible.
  • Dynamic Period Adjustment: The tool automatically adjusts its internal calculation period based on how fast or slow the market is moving, ensuring it doesn't become too "laggy" during fast moves or too "jittery" during slow ones.

4. Visual Indicators and Signals The script outputs several visual elements on your chart:

  • Trend Lines: These represent the primary filtered direction of the price.
  • Smoother Line: A secondary reference line that helps visualize the relationship between current price momentum and the long-term trend.
  • Buy/Sell Signals: When enabled, the script identifies specific "crossover" moments where the trend shifts. It marks these with arrows on the chart. These signals appear when the moving average moves from one side of the trend line to the other, often accompanied by an automated alert sound or notification.

Summary for the User

In simple terms, this script acts like a high-tech "lens" for your charts. It takes the messy, jagged movements of the market and processes them through several layers of math to produce a smooth, readable trend line. It tells you what the "true" direction of the price is by stripping away the distractions, and it notifies you when that direction undergoes a significant change.

Price Data Components
Series array that contains open time of each barSeries array that contains close prices for each barSeries array that contains open prices of each barSeries array that contains the highest prices of each barSeries array that contains the lowest prices of each bar
Indicators Used
Moving average indicatorIndicator of the average true range
Miscellaneous
Implements a curve of type %1It plays sound alerts
11 Views
0 Downloads
0 Favorites
InstTrendLine_v1 
//+------------------------------------------------------------------+
//|                                             InstTrendLine_v1.mq4 |
//|                                Copyright © 2009, TrendLaboratory |
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |
//|                                   E-mail: igorad2003@yahoo.co.uk |
//+------------------------------------------------------------------+
// List of Prices:
// Price    = 0 - Close  
// Price    = 1 - Open  
// Price    = 2 - High  
// Price    = 3 - Low  
// Price    = 4 - Median Price   = (High+Low)/2  
// Price    = 5 - Typical Price  = (High+Low+Close)/3  
// Price    = 6 - Weighted Close = (High+Low+Close*2)/4
// Price    = 7 - Heiken Ashi Close  
// Price    = 8 - Heiken Ashi Open
// Price    = 9 - Heiken Ashi High
// Price    =10 - Heiken Ashi Low

#property copyright "Copyright © 2009, TrendLaboratory"
#property link      "http://finance.groups.yahoo.com/group/TrendLaboratory"

#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1  Yellow
#property indicator_width1  1  
#property indicator_color2  SkyBlue
#property indicator_width2  1
#property indicator_color3  SkyBlue
#property indicator_width3  2
#property indicator_color4  Tomato
#property indicator_width4  2 
//---- 
extern int     TimeFrame         =     0;   //Time Frame in min
extern int     Price             =     4;   //Price Mode (0...10)
extern int     MinPeriod         =     6;   //Min Period of ITrend
extern int     MaxPeriod         =    50;   //Max Period of ITrend
extern int     SignalMode        =     0;   //Switch of Signal mode(0-off,1-on)
extern int     AlertMode         =     0;   //Sound Alert switch(0...2) 
extern int     WarningMode       =     0;   //Warning Mode (0-off,1-on)
//---- 
double ITrend[];
double MA[];
double UpSignal[];
double DnSignal[];
double sig[];
//----
double haClose[], haOpen[], haHigh[], haLow[];
int    draw_begin, pBars, mcnt_bars, per; 
string short_name1, short_name2;
datetime pTime;
bool   UpTrendAlert=false, DnTrendAlert=false;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
//---- 
   SetIndexStyle(0,DRAW_LINE);
   SetIndexStyle(1,DRAW_LINE);
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexArrow(2,159);
   SetIndexStyle(3,DRAW_ARROW);
   SetIndexArrow(3,159);
   
   if(TimeFrame == 0 || TimeFrame < Period()) TimeFrame = Period();
   per = MaxPeriod;   
   draw_begin=2*per*TimeFrame/Period();
//---- 
   switch(TimeFrame)
   {
   case 1     : string TF = "M1"; break;
   case 5     : TF = "M5"; break;
   case 15    : TF = "M15"; break;
   case 30    : TF = "M30"; break;
   case 60    : TF = "H1"; break;
   case 240   : TF ="H4"; break;
   case 1440  : TF="D1"; break;
   case 10080 : TF="W1"; break;
   case 43200 : TF="MN1"; break;
   default    : TF="Current";
   } 
   short_name1 = "InstTrendLine";
   short_name2 = "Smoother";
   IndicatorShortName(short_name1+"("+MinPeriod+","+MaxPeriod+")"+" "+TF);
   SetIndexLabel(0,short_name1+"("+MinPeriod+","+MaxPeriod+")"+" "+TF);
   SetIndexLabel(1,short_name2+"("+MinPeriod+","+MaxPeriod+")"+" "+TF);
   SetIndexLabel(2,"UpSignal");
   SetIndexLabel(3,"DnSignal");
   
   SetIndexDrawBegin(0,draw_begin);
   SetIndexDrawBegin(1,draw_begin);
   SetIndexDrawBegin(2,draw_begin);
   SetIndexDrawBegin(3,draw_begin);
   
//---- 
   IndicatorBuffers(5);
   SetIndexBuffer(0,ITrend);
   SetIndexBuffer(1,MA);   
   SetIndexBuffer(2,UpSignal);
   SetIndexBuffer(3,DnSignal);
   SetIndexBuffer(4,sig);
//---- 
   return(0);
}
//+------------------------------------------------------------------+
//| MAMA_v1                                              |
//+------------------------------------------------------------------+
int start()
{
   int limit, y, i, shift, cnt_bars=IndicatorCounted(); 
   double price[], mITrend[], mMA[], Smooth[], Detrender[], Q1[], I1[], JL[], JQ[], I2[], Q2[], 
          Re[], Im[], period[], mUpsig[], mDnsig[], trend[], SmoothPeriod[], Value1[], Value2[];
    
   if(TimeFrame!=Period()) int mBars = iBars(NULL,TimeFrame); else mBars = Bars;   
   
   if(mBars != pBars)
   {
   ArrayResize(price,mBars);
   ArrayResize(mITrend,mBars);
   ArrayResize(mMA,mBars);
   ArrayResize(Smooth,mBars);
   ArrayResize(Detrender,mBars);
   ArrayResize(Q1,mBars);
   ArrayResize(I1,mBars);
   ArrayResize(JL,mBars);
   ArrayResize(JQ,mBars);
   ArrayResize(I2,mBars);
   ArrayResize(Q2,mBars);
   ArrayResize(Re,mBars);
   ArrayResize(Im,mBars);
   ArrayResize(period,mBars);
   ArrayResize(SmoothPeriod,mBars);
   ArrayResize(Value1,mBars);
   ArrayResize(Value2,mBars);
   
      if(Price > 6 && Price <= 10)
      {
      ArrayResize(haClose,mBars);
      ArrayResize(haOpen,mBars);
      ArrayResize(haHigh,mBars);
      ArrayResize(haLow,mBars);
      }
  
      if(SignalMode>0)
      {
      ArrayResize(trend,mBars);
      ArrayResize(mUpsig,mBars);
      ArrayResize(mDnsig,mBars);
      }
   pBars = mBars;
   }  
   
   if(cnt_bars<1)
   {
      for(i=Bars-1;i>0;i--) 
      {
      ITrend[i]=EMPTY_VALUE;
      MA[i]=EMPTY_VALUE;
      UpSignal[i]=EMPTY_VALUE;
      DnSignal[i]=EMPTY_VALUE;
      }
   mcnt_bars = 0;
   }
//---- 
   if(mcnt_bars > 0) mcnt_bars--;
   
   for(y=mcnt_bars;y<mBars;y++)
   {
      if(Price <= 6) price[y] = iMA(NULL,TimeFrame,1,0,0,Price,mBars-y-1);   
      else
      if(Price > 6 && Price <= 10) price[y] = HeikenAshi(TimeFrame,Price-7,mBars-y-1);
   
   if(y >= 3) Smooth[y] = (4*price[y] + 3*price[y-1] + 2*price[y-2] + price[y-3])/10.0;
   Detrender[y] = (0.0962*Smooth[y] + 0.5769*Smooth[y-2] - 0.5769*Smooth[y-4] - 0.0962*Smooth[y-6])*(0.075*period[y-1] + 0.54);
   
   Q1[y] = (0.0962*Detrender[y] + 0.5769*Detrender[y-2] - 0.5769*Detrender[y-4] - 0.0962*Detrender[y-6])*(0.075*period[y-1] + 0.54);
	I1[y] = Detrender[y-3];     
     
   JL[y] = (0.0962*I1[y] + 0.5769*I1[y-2] - 0.5769*I1[y-4] - 0.0962*I1[y-6])*(0.075*period[y-1] + 0.54);
	JQ[y] = (0.0962*Q1[y] + 0.5769*Q1[y-2] - 0.5769*Q1[y-4] - 0.0962*Q1[y-6])*(0.075*period[y-1] + 0.54);
    
   I2[y] = I1[y] - JQ[y];
	Q2[y] = Q1[y] + JL[y];     
        
   I2[y] = 0.2*I2[y] + 0.8*I2[y-1];
	Q2[y] = 0.2*Q2[y] + 0.8*Q2[y-1];
	
	Re[y] = I2[y]*I2[y-1] + Q2[y]*Q2[y-1];
	Im[y] = I2[y]*Q2[y-1] - Q2[y]*I2[y-1];
	
	Re[y] = 0.2*Re[y] + 0.8*Re[y-1];
	Im[y] = 0.2*Im[y] + 0.8*Im[y-1];

	double rad2Deg = 45.0/MathArctan(1);
   
   if(Im[y] != 0 && Re[y] != 0) period[y] = 360.0/MathArctan(Im[y]/Re[y])/rad2Deg;
   
	if(period[y] > 1.5 *period[y-1]) period[y] = 1.5*period[y-1];
	if(period[y] < 0.67*period[y-1]) period[y] = 0.67*period[y-1];
	if(period[y] < MinPeriod) period[y] = MinPeriod;
	if(period[y] > MaxPeriod) period[y] = MaxPeriod;
	
	period[y] = 0.2*period[y] + 0.8*period[y-1];
	SmoothPeriod[y] = 0.33*period[y] + 0.67*SmoothPeriod[y-1];

	int DCPeriod = MathFloor(SmoothPeriod[y] + 0.5);
//Lowpass Filter is Ellip(3,.8,30,.22)
	Value1[y] = 0.0542*price[y] + 0.021*price[y-1] + 0.021*price[y-2] + 0.0542*price[y-3] + 1.9733*Value1[y-1] - 1.6067*Value1[y-2] + 0.4831*Value1[y-3];
//Notch Filter at a 10 bar cycle
	Value2[y] = 0.8*(Value1[y] - 2*MathCos(360.0/10.0/rad2Deg)*Value1[y-1] + Value1[y-2]) + 1.6*MathCos(360.0/10.0/rad2Deg)*Value2[y-1] - 0.6*Value2[y-2];
//Notch Filter the Dominant Cycle
	
	if(y <= 5) mITrend[y] = price[y];
	else
	{ 
	if(DCPeriod != 0)	
	mITrend[y] = 0.9*(Value2[y] - 2.0*MathCos(360.0/DCPeriod/rad2Deg)*Value2[y-1] + Value2[y-2]) + 1.8*MathCos(360.0/DCPeriod/rad2Deg)*mITrend[y-1] - 0.8*mITrend[y-2];
   }
   
   mMA[y] = (4*price[y] + 3*price[y-1] + 2*price[y-2] + price[y-3])/10;
      
      if(SignalMode > 0)
      {
      trend[y] = trend[y-1];
      if(mMA[y]-mITrend[y] > 0 && trend[y-1]<=0) trend[y]= 1; 
      if(mMA[y]-mITrend[y] < 0 && trend[y-1]>=0) trend[y]=-1;  
                 
         if(trend[y] > 0)
         {  
            if(trend[y-1] <= 0)
            { 
            mUpsig[y] = mMA[y] - 0.5*iATR(NULL,TimeFrame,10,mBars-y-1);
            if (WarningMode>0 && y==mBars-1) PlaySound("alert2.wav");
            }
            else
            mUpsig[y]= EMPTY_VALUE; 
         mDnsig[y]= EMPTY_VALUE;
         }
         else
         if (trend[y] < 0) 
         {
            if(trend[y-1] >= 0) 
            {
            mDnsig[y] = mMA[y] + 0.5*iATR(NULL,TimeFrame,10,mBars-y-1);
            if (WarningMode>0 && y==mBars-1) PlaySound("alert2.wav");  
            }
            else
            mDnsig[y]= EMPTY_VALUE; 
         mUpsig[y]= EMPTY_VALUE;
         }
      }                               
      
      if(TimeFrame == Period()) 
      {
      ITrend[mBars-y-1] = mITrend[y];
      MA[mBars-y-1] = mMA[y];
            
         if(SignalMode > 0)
         {
         UpSignal[mBars-y-1] = mUpsig[y];
         DnSignal[mBars-y-1] = mDnsig[y];
         }
      }
      mcnt_bars = mBars-1;
   }
   
   if(TimeFrame > Period())
   { 
      if(cnt_bars>0) cnt_bars--;
      limit = Bars-cnt_bars+TimeFrame/Period()-1;
      
      for(shift=0,y=0;shift<limit;shift++)
      {
      if (Time[shift] < iTime(NULL,TimeFrame,y)) y++; 
      ITrend[shift] = mITrend[mBars-y-1];
      MA[shift] = mMA[mBars-y-1];   
         if(SignalMode > 0)
         {
         UpSignal[shift] = mUpsig[mBars-y-1];
         DnSignal[shift] = mDnsig[mBars-y-1];
         sig[mBars-y-1] = trend[y];
         }
      }
   }
//----------   
   string Message;
   
   if (trend[mBars-2]<0 && trend[mBars-1]>0 && !UpTrendAlert && AlertMode == 1)
	{
	Message = " "+Symbol()+" M"+Period()+":MAMA Signal for BUY";
	if (isNewBar()) Alert (Message); 
	UpTrendAlert=true; DnTrendAlert=false;
	} 
	else 	  
	if (trend[mBars-2]>0 && trend[mBars-1]<0 && !DnTrendAlert && AlertMode == 1)
	{
	Message = " "+Symbol()+" M"+Period()+":MAMA Signal for SELL";
	if (isNewBar()) Alert (Message); 
	DnTrendAlert=true; UpTrendAlert=false;
	} 	         
   return(0);
}


double HeikenAshi(int tf,int price,int bar)
{ 
   if(bar == iBars(NULL,TimeFrame)- 1) 
   {
   haClose[bar] = iClose(NULL,tf,bar);
   haOpen[bar]  = iOpen(NULL,tf,bar);
   haHigh[bar]  = iHigh(NULL,tf,bar);
   haLow[bar]   = iLow(NULL,tf,bar);
   }
   else
   {
   haClose[bar] = (iOpen(NULL,tf,bar)+iHigh(NULL,tf,bar)+iLow(NULL,tf,bar)+iClose(NULL,tf,bar))/4;
   haOpen[bar]  = (haOpen[bar+1]+haClose[bar+1])/2;
   haHigh[bar]  = MathMax(iHigh(NULL,tf,bar),MathMax(haOpen[bar], haClose[bar]));
   haLow[bar]   = MathMin(iLow(NULL,tf,bar),MathMin(haOpen[bar], haClose[bar]));
   }
   
   switch(price)
   {
   case 0: return(haClose[bar]);break;
   case 1: return(haOpen[bar]);break;
   case 2: return(haHigh[bar]);break;
   case 3: return(haLow[bar]);break;
   }
}     

bool isNewBar()
{
   bool res=false;
   if (iTime(NULL,TimeFrame,0)!=pTime)
   {
   res=true;
   pTime=iTime(NULL,TimeFrame,0);
   }   
   return(res);
}

Similar scripts

MAMA_v1mtf_alert_001

This indicator utilizes a dual-layer moving average system derived from Laguerre functions to dynamically calculate price momentum and provide adaptive trend identification based on phase changes.

MAMA_v1

This indicator utilizes a recursive detrending algorithm to calculate an adaptive moving average that dynamically adjusts its smoothing factor based on the instantaneous cycle period and phase of price action.

MAMA_v1MTFsig_alert

This indicator utilizes a complex detrending algorithm and adaptive alpha smoothing to generate dynamic trend lines that adjust to market periodicity and velocity.

CounterInEAExample

This script identifies and increments a global counter every time a new candle opens on the specified timeframe.

PZ_ReversalTrendFollowingEA

Stat_Euclidean_Metric (Modified)

SupDem_v1.0_Dezil

The code identifies and plots support and resistance zones on a chart based on the location of the nearest fractals, extending those zones to the current time.

Stat_Euclidean_Metric

MAMA_v1_osc_MTF_alert

This indicator employs an adaptive filtering mechanism that utilizes a multi-stage detrending process and dynamic phase calculations to identify momentum shifts across diverse price types, including Heiken Ashi dynamics.

Directed_Movement_Alert

Emily_v8

This expert advisor uses RSIOMA, MACD and trend following techniques to open and manage trades, implementing a martingale-like strategy with increasing lot sizes and account protection mechanisms.

Comments