Pretty_T3_RSI_LK_V1.1

Download script
Author: Copyright � 2009, Leif Karlsson
Pretty_T3_RSI_LK_V1.1

This tool is a customized technical analysis indicator designed to help traders identify momentum and trend directions more smoothly than standard moving averages or oscillators. It combines two sophisticated mathematical concepts—the RSI (Relative Strength Index) and the T3 Moving Average—to create a visual aid that filters out "market noise."

Core Logic Overview

1. The Foundation: RSI Adjustment The indicator starts by looking at the RSI, a common tool used to measure the speed and change of price movements. However, instead of using the raw RSI value, this script subtracts 50 from the result. This centers the data around a "zero line," making it easier to see whether the momentum is shifting toward a positive or negative bias relative to the midpoint.

2. The Smoothing Engine: T3 Calculation To prevent the indicator from being too jumpy or erratic, the script applies a "T3" moving average logic. Unlike a simple moving average (which gives equal weight to all data points) or an exponential moving average (which favors recent data), the T3 is designed to be much smoother while still reacting quickly to real price changes. It uses a multi-layered calculation process, essentially passing the data through several "filters" to strip away minor fluctuations while preserving the integrity of the main trend.

3. Trend Strength & Dynamic Coloring One of the unique features of this script is how it calculates "Trend Strength." Beyond just showing the direction of the price, it calculates how aggressive that move is based on the rate of change and volatility.

The script then uses this strength value to handle the visual display in two different ways:

  • RGB Mode: If enabled, the indicator changes color dynamically. It blends colors (typically shifting between shades of Red and Blue) based on the trend strength. This allows a trader to see not just where the price is going, but how strong that movement feels at any given moment.
  • Standard Mode: If RGB mode is turned off, the script separates the data into distinct "Up" and "Down" lines, providing a clear binary view of whether the trend is currently ascending or descending.

Summary for the User

In plain terms, this script takes the momentum of the market (RSI), smooths it out significantly to remove "fake" signals (T3), and then colors it based on how powerful that momentum is. It is designed for traders who want a clean, visual representation of the trend that highlights where the market is heading without the clutter of constant, minor price fluctuations.

Indicators Used
Relative strength index
Miscellaneous
Implements a curve of type %1
10 Views
0 Downloads
0 Favorites
Pretty_T3_RSI_LK_V1.1 
//+------------------------------------------------------------------+
//|                                        Pretty_t3_RSI_LK_V1.0.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_separate_window
#property  indicator_buffers 2
#property  indicator_color1  Blue
#property  indicator_color2  Red
#property  indicator_width1  2
#property  indicator_width2  2
#property  indicator_maximum 55
#property  indicator_minimum -55
#property  indicator_level1 30
#property  indicator_level2 -30
#property  indicator_levelcolor Yellow
//+------------------------------------------------------------------+
extern int RSIPeriod = 7;
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;
extern int RGBLineWidth = 2;
//+------------------------------------------------------------------+
// 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 RSI: " + T3Period + ", " + T3Amp + ", " + RSIPeriod + ", " + 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;
	
	static int WindowNr = -1;
	if(WindowNr <= 0) WindowNr = WindowFind(IndiName);
	
	if(WindowNr <= 0) {
		Print("Error->Draw(): Can\'t find indicator Window! WindowNr = " + WindowNr);
		return;
	}
	
      ObjectDelete(ObjName);
      ObjectCreate(ObjName, OBJ_TREND, WindowNr, 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, RGBLineWidth);
}
//+------------------------------------------------------------------+
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] = iRSI(NULL, 0, RSIPeriod, AppliedPrice,i+PriceShift)-50.0;
		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 = iRSI(NULL, 0, RSIPeriod, AppliedPrice,i+PriceShift)-50.0;
		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] = MathSqrt(T3Period)*(t3[i]-t3[i+1])/(T3Amp*10.0);
		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_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_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 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.2_001

This indicator utilizes a multi-stage recursive moving average combined with an Inverse Fisher Transform and ATR normalization to visualize real-time momentum shifts via dynamic color-coded gradients.

#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.

StepMA_v7_002

This indicator tracks price action by creating a discrete, staircase-like movement that filters market noise through volatility-adjusted step thresholds and trend-switching logic.

StepMA_v7

This indicator calculates a quantized price trajectory by determining dynamic step sizes based on average range volatility and applying trend-dependent price boundaries.

StepMA_v7EA

This indicator tracks market direction by establishing price boundaries based on weighted average ranges and dynamic step increments to filter out minor noise.

StepMA_v7[1].1

This indicator generates a staircase-style trend line by calculating price movement thresholds based on the relative range of historical volatility.

StepMA_v7.1

This indicator calculates a quantized staircase moving average that filters market noise by locking price movements into discrete volatility-adjusted steps.

stepma

This indicator utilizes a volatility-adjusted step mechanism to filter market noise and identify structural trend shifts through discrete price level transitions.

Comments