#Pretty_t3_LK_V1.2_001

Download script
Author: Copyright � 2009, Leif Karlsson
#Pretty_t3_LK_V1.2_001

This script is designed to provide traders with a smoothed visual representation of price movements, helping to identify the underlying trend of a financial instrument more clearly. By filtering out "market noise"—the small, erratic price fluctuations that can often mislead short-term traders—this tool provides a cleaner picture of where the market is heading.

Core Functionality

The T3 Smoothing Logic At the heart of this script is the T3 calculation. Unlike standard moving averages which can sometimes lag significantly behind current prices, the T3 algorithm uses a specific mathematical weight system. It processes price data through several layers of calculations to balance two competing goals: keeping the indicator smooth enough to be readable while ensuring it remains responsive enough to react quickly when the market actually changes direction.

Trend Strength Analysis The script does more than just draw a line; it also calculates the "momentum" or strength of the current move. It takes the rate of change from the T3 calculation and compares it against the volatility of the market (the Average True Range). By doing this, the script can determine if a trend is gaining strength, losing steam, or staying stable.

Dynamic Visual Feedback Depending on your settings, the script provides two different ways to visualize these trends:

  • RGB Mode (Color Shifting): When enabled, the indicator changes color dynamically based on the strength of the trend. Instead of a simple line, it uses a gradient effect where the colors shift in real-time to reflect whether the momentum is bullish or bearish and how aggressive that move is.
  • Standard Trend Tracking: If you prefer a more traditional look, the script can be set to display distinct lines for upward and downward movements. This makes it easier to see exactly when the trend flipped from one direction to another.

User Customization Options

The script includes several "input parameters" that allow users to tailor the tool to different assets (like Forex, Stocks, or Commodities) and different timeframes:

  • Period: Determines how much historical data is considered; a higher number makes the line smoother but slower to react.
  • Amplitude: Adjusts the weighting of the calculation to fine-tune the responsiveness of the T3 logic.
  • Price Type: Allows you to choose which price data to base the calculations on (such as Close, Open, High, Low, or Median prices).
  • Shift: Options to move the visual indicator forward or backward on the chart for different perspective views.
Indicators Used
Moving average indicatorIndicator of the average true range
Miscellaneous
Implements a curve of type %1
7 Views
0 Downloads
0 Favorites
#Pretty_t3_LK_V1.2_001 
//+------------------------------------------------------------------+
//|                                            Pretty_t3_LK_V1.2.mq4 |
//|                         Orginal T3 calculation by Tim Tillson in |
//|     Technical Analysis of Stocks and Commodities - January 1998. |
//|                     Source code Copyright © 2009, Leif Karlsson. |
//|                                        Leffemannen1973@telia.com |
//+------------------------------------------------------------------+
//| Please feel free to copy, modify and / or redistribute this      |
//| software / source code in any way you see fit.                   |
//+------------------------------------------------------------------+
//+ ********************* Shameless Ad. **************************** +
//+ * I do custom programing jobs in Java, C, X86 Assembler & MQL4 * +
//+ ***** Pleace do not hesitate to get in contact if you nead ***** +
//+ ***** something special: EA, indicator or somthing else. ******* +
//+ ****************** Leffemannen1973@telia.com ******************* +
//+ **************************************************************** +
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Leif Karlsson"
#property link      "mailto://Leffemannen1973@telia.com"
//+------------------------------------------------------------------+
#property  indicator_chart_window
#property  indicator_buffers 2
#property  indicator_color1  Blue
#property  indicator_color2  Red
#property  indicator_width1  5
#property  indicator_width2  5
//+------------------------------------------------------------------+
extern int T3Period = 7;
extern double T3Amp = 1.3;
extern string AppliedPriceText1 = "Close: 0, Open: 1, High: 2, Low: 3";
extern string AppliedPriceText2 = "Median: 4, Typical: 5, Weighted: 6";
extern int AppliedPrice = 4;
extern int PriceShift = 0;
extern int MaxBars = 1000;
extern bool RGBMode = true;
//+------------------------------------------------------------------+
// Index Buffers
double UpBuffer[];	// Up trend buffer (only used then RGBMode = false)
double DwBuffer[];	// Down trend buffer (only used then RGBMode = false)
double t3[]; 		// Main T3 value (always used)
double Trend[]; 		// Primitive trend filter (max 1, min -1): InvFisher(0.5*Sqrt(T3Period)*[T3 Rate of change] / ATR) (always used)

// Used for T3 calc
double c1;
double c2;
double c3;
double c4;

// "Fake" Index Buffers, advance forward using ArrayCopy
double p1[];
double p2[];
double p3[];
double p4[];
double p5[];
double p6[];

// T3 Alpha (weight)
double Alpha;

string IndiName;
bool FirstRun;
datetime LastTime = 0;
//+------------------------------------------------------------------+
int deinit() {

	int i = MaxBars;
	while(i >= 0 && RGBMode) {
		ObjectDelete(IndiName + i);
		i--;
	}
	return(0);
}
//+------------------------------------------------------------------+
int init() {
	// Index Buffers
	IndicatorBuffers(4);	
			
   	SetIndexStyle(0, DRAW_LINE);
   	SetIndexStyle(1, DRAW_LINE);
	
   	SetIndexBuffer(0, UpBuffer);
   	SetIndexBuffer(1, DwBuffer);	
   	SetIndexBuffer(2, t3);	
   	SetIndexBuffer(3, Trend);
   	// 
   	
   	// "Fake" Index Buffers   	
	ArrayResize(p1, MaxBars+1);
	ArrayResize(p2, MaxBars+1);
	ArrayResize(p3, MaxBars+1);
	ArrayResize(p4, MaxBars+1);
	ArrayResize(p5, MaxBars+1);
	ArrayResize(p6, MaxBars+1);
		
	ArraySetAsSeries(p1, true);
	ArraySetAsSeries(p2, true);
	ArraySetAsSeries(p3, true);
	ArraySetAsSeries(p4, true);
	ArraySetAsSeries(p5, true);
	ArraySetAsSeries(p6, true); 
	//
	
	IndiName = "T3, T3Period: " + T3Period + ", T3Amp: " + T3Amp + ", PriceShift: " + PriceShift + " ";
   	IndicatorShortName(IndiName);
   	
   	Alpha = 2.0/(T3Period + 1.0);  

	// Pre calc some T3 values   	
   	double a = T3Amp;
   	c1 = -a*a*a;
	c2 = 3.0*a*a + 3.0*a*a*a;
	c3 = -6.0*a*a - 3.0*a - 3.0*a*a*a;
	c4 = 1.0 + 3.0*a + a*a*a + 3.0*a*a;
	//

	FirstRun = true;
   	 	
   	return(0);
}
//+------------------------------------------------------------------+
void Draw(double Val[], int i, color c) {
	
	string ObjName = IndiName + (Time[i]/(60*Period())) % MaxBars;
	
      ObjectDelete(ObjName);
      ObjectCreate(ObjName, OBJ_TREND, 0, Time[i+1], Val[i+1], Time[i], Val[i]);
      ObjectSet(ObjName, OBJPROP_RAY, false);
      ObjectSet(ObjName, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSet(ObjName, OBJPROP_COLOR, c);        
      ObjectSet(ObjName, OBJPROP_WIDTH, 5);
}
//+------------------------------------------------------------------+
int start() {

	int i = IndicatorCounted();
	if(i < 0) return(-1);
	i = Bars - i;
	if(i > MaxBars) i = MaxBars;
	if(FirstRun || i == MaxBars) {
		FirstRun = false;
		LastTime = Time[0];
						
		p1[i] = iMA(NULL, 0, 1, 0, 0, AppliedPrice, i+PriceShift);
		p2[i] = p1[i];
		p3[i] = p1[i];
		p4[i] = p1[i];
		p5[i] = p1[i];
		p6[i] = p1[i];
		t3[i] = p1[i];
		i--;
	} 
	else {
		int j = ArrayBsearch(Time, LastTime, MaxBars, 0, MODE_DESCEND);
		if(j > 0) {
			ArrayCopy(p1, p1, j, 0, ArraySize(p1)-j);
			ArrayCopy(p2, p2, j, 0, ArraySize(p2)-j);
			ArrayCopy(p3, p3, j, 0, ArraySize(p3)-j);
			ArrayCopy(p4, p4, j, 0, ArraySize(p4)-j);
			ArrayCopy(p5, p5, j, 0, ArraySize(p5)-j);
			ArrayCopy(p6, p6, j, 0, ArraySize(p6)-j);
		}
		LastTime = Time[0];
	}
					
	while(i >= 0) {
		
		// Main T3 calc
		double p0 = iMA(NULL, 0, 1, 0, 0, AppliedPrice, i+PriceShift);				
		p1[i] = p1[i+1] + Alpha*(p0 - p1[i+1]);
		p2[i] = p2[i+1] + Alpha*(p1[i] - p2[i+1]);
		p3[i] = p3[i+1] + Alpha*(p2[i] - p3[i+1]);
		p4[i] = p4[i+1] + Alpha*(p3[i] - p4[i+1]);
		p5[i] = p5[i+1] + Alpha*(p4[i] - p5[i+1]);
		p6[i] = p6[i+1] + Alpha*(p5[i] - p6[i+1]);
						
		t3[i] = c1*p6[i] + c2*p5[i] + c3*p4[i] + c4*p3[i];
		//
		
		// Trend strength calc
		Trend[i] = 0.5*MathSqrt(T3Period)*(t3[i]-t3[i+1]) / iATR(NULL, 0, T3Period, i+PriceShift);
		Trend[i] = ((1.0-MathExp(-2.0*Trend[i]))/(1.0+MathExp(-2.0*Trend[i])));
		//
		
		if(RGBMode) {
			int b = 127.0 + 127.0*Trend[i];
			int r = 127.0 - 127.0*Trend[i];
			Draw(t3, i, b << 16 + r);
		} 
		if(!RGBMode && t3[i] > t3[i+1]) {
			UpBuffer[i] = t3[i];
			DwBuffer[i] = EMPTY_VALUE;
			if(UpBuffer[i+1] == EMPTY_VALUE) UpBuffer[i+1] = t3[i+1];
		}
		if(!RGBMode && t3[i] < t3[i+1]) {
			DwBuffer[i] = t3[i];
			UpBuffer[i] = EMPTY_VALUE;
			if(DwBuffer[i+1] == EMPTY_VALUE) DwBuffer[i+1] = t3[i+1];
		}
						
		i--;
	}	

   	return(0);
}

Similar scripts

Pretty_t3_LK_V1.2

This indicator calculates a high-order smoothing moving average using the Tim Tillson T3 algorithm, augmented by an Inverse Fisher Transform of the rate of change normalized by ATR to determine dynamic trend momentum.

Pretty_t3_LK_V1.3

This indicator calculates a high-order smoothed moving average using the Tillson T3 algorithm combined with a Fisher Transform filter to visualize trend velocity and momentum intensity via dynamic color shifting.

#Pretty_t3_LK_V1.2

This indicator utilizes a triple-smoothed T3 moving average combined with an inverse Fisher transform on the rate of change to identify trend direction and intensity via a responsive RGB color shift.

Pretty_T3_RSI_LK_V1.0

This indicator calculates a smoothed momentum signal by applying the T3 moving average algorithm to a centered Relative Strength Index, complemented by an Inverse Fisher Transform trend filter.

Pretty_T3_RSI_LK_V1.1

This indicator applies a triple exponential moving average (T3) smoothing algorithm to the Relative Strength Index (RSI) to identify momentum trends with reduced lag and dynamic color-coded visual feedback.

dex_HeLMA_v2.0

This indicator calculates a multi-period volatility average to project price channels and filters directional momentum shifts using an EMA-weighted signal.

PVD$FL

RSIFilter_v1_v3

This indicator identifies directional bias by capturing RSI extremes and validating trend persistence through specific overbought/oversold corridor thresholds.

StepMA_v6.2

This algorithm captures trend direction by enforcing quantized price movements based on average range volatility and sensitivity offsets.

NonLagMA_v4_v1

This indicator utilizes trigonometric weighting and cosine-based coefficients to calculate a responsive moving average that minimizes temporal lag while preserving trend integrity.

NonLagDot71

This indicator calculates a zero-lag moving average by applying a cosine-based weighting coefficient to price data, incorporating an optional standard deviation filter to smooth trend transitions.

Comments