MTF_MACD_HOH_v3M

Download script
Author: Copyright � 2006, Keris2112
MTF_MACD_HOH_v3M

This script is designed to display a specialized version of the Moving Average Convergence Divergence (MACD) indicator on your trading platform. Its primary purpose is to allow traders to view MACD data from higher timeframes while remaining on a lower timeframe chart, combined with an automated scaling system to ensure the visual lines are always clearly visible and properly sized.

Core Functionality

Multi-Timeframe Integration The script enables "Multi-Timeframe" (MTF) analysis. This means if you are looking at a 5-minute chart, you can use this tool to see the MACD trends of a 1-hour or daily chart simultaneously. It automatically synchronizes the data so that the historical lines align correctly with the current price action on your screen.

Dynamic Scaling Logic (The "Auto-Multiplier") One of the main challenges with MTF indicators is that they can sometimes appear as flat, tiny lines or jump off the screen because the numerical values of a higher timeframe are much larger than those of a lower one. This script solves this using two methods:

  • Automatic Mode: The script scans a specific number of historical bars to identify the highest peaks and lowest valleys of the MACD data. It then calculates a mathematical "multiplier" to shrink or stretch the lines so they fit perfectly within your indicator window without losing their shape.
  • Manual Mode: If you prefer total control over the visual size, the script allows you to bypass the automation and set a fixed multiplier to manually adjust how large the lines appear.

Visual Behavior

Unlike standard MACD indicators that often use a histogram (vertical bars) and a signal line, this script is optimized for a clean visual experience:

  • Line-Based Display: It focuses on drawing two distinct lines rather than bars, making it easier to track trend direction at a glance.
  • Simplified Labeling: The display is streamlined to show the specific timeframe being analyzed, helping you keep track of which data set you are looking at (e.g., "H1", "D1", etc.).
  • Precision: It rounds the visual output to two decimal places to maintain a professional and uncluttered appearance.

Summary for the User

In short, this tool acts as a "smart lens." It pulls in high-level trend data from larger timeframes and automatically resizes those trends so they are visually balanced and easy to read on your current chart, regardless of how different the timeframes might be.

Miscellaneous
Implements a curve of type %1
13 Views
0 Downloads
0 Favorites
MTF_MACD_HOH_v3M 
//+------------------------------------------------------------------+
//|                   calls iCustom-MACD        #MTF_zlagMACD_v3.mq4 |
//|                                            www.forex-tsd.com ik  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, Keris2112"
#property link      "http://www.forex-tsd.com"
#property link      "HOH CHEE YEN"
/* version 3 (HCY)
| Set Auto_Multiplier to true and Auto_Multiplier_LEVEL to 0.2~0.9 for
| automatic multiplier. Or set Auto_Multiplier to false and increase
| Manual_Multiplier for manual adjustment of MACD lines.
*/

#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 OrangeRed
#property indicator_color2 OrangeRed
#property indicator_level1 0
// Added (HCY)
#property indicator_width1 1
#property indicator_style2 2
// Set window range for proper line display (HCY)
#property indicator_maximum 1
#property indicator_minimum -1

//---- input parameters
/* Settings for different periods (Own preferences): (HCY)
MN,WK,D1:22,11,8 -- D1:11,22,8
WK,D1,H4:30,13,10 -- H4:13,30,10
D1,H4,H1:24,11,8 -- H1:11,24,8
H4,H1,M15:15,7,5 -- M15:7,15,5
H1,M15,M5:12(or 13),6,4 -- M5:6,12,4
M15,M5,M1:15,7,5 -- M1:7,15,5
*/
extern int TimeFrame=0;
extern int FastEMA=12;
extern int SlowEMA=26;
extern int SignalEMA=9;
// For automatic Multiplier (HCY)
extern int CountBars=300;
// Automatic adjust Multiplier for proper line display (HCY)
extern bool Auto_Multiplier=true;
// Level is between 0.2 - 0.9 when indicator maximum level is 1 (HCY)
extern double Auto_Multiplier_LEVEL=0.7;
double AutoMultiplierLEVEL=0.0;
double AutoMultiplier=5.0;
// Manually increase this number to enlarge its lines when Auto_Multiplier is off (HCY)
extern double Manual_Multiplier=5;
double Max_Multiplier_Level=0.9;
double Min_Multiplier_Level=0.2;
double Max_Signal=0.0;
datetime Max_Signal_Time=0;
//---- indicator buffers
double ExtMapBuffer1[];
double ExtMapBuffer2[];

//---- input parameters
/*************************************************************************
PERIOD_M1   1
PERIOD_M5   5
PERIOD_M15  15
PERIOD_M30  30 
PERIOD_H1   60
PERIOD_H4   240
PERIOD_D1   1440
PERIOD_W1   10080
PERIOD_MN1  43200
You must use the numeric value of the timeframe that you want to use
when you set the TimeFrame' value with the indicator inputs.
**************************************************************************/
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   string short_name;
//---- indicator line
   SetIndexBuffer(0,ExtMapBuffer1);
   SetIndexBuffer(1,ExtMapBuffer2);
//   SetIndexStyle(0,DRAW_SECTION,STYLE_SOLID,1);
//   SetIndexStyle(1,DRAW_SECTION,STYLE_SOLID,1);
   // Draw lines only (HCY)
   SetIndexStyle(0,DRAW_LINE);
   SetIndexStyle(1,DRAW_LINE);
/* Original settings (HCY) 
   SetIndexStyle(0,DRAW_HISTOGRAM,EMPTY,2);
   SetIndexStyle(1,DRAW_LINE,EMPTY,2);
*/
   SetIndexDrawBegin(0,SlowEMA);
   SetIndexDrawBegin(1,SlowEMA);
   // No value displayed at left corner (HCY)
   SetIndexLabel(0,NULL);
   SetIndexLabel(1,NULL);
/* Original settings (HCY)
   SetIndexLabel(0,"MACD");
   SetIndexLabel(1,"Signal");
*/
   // Show only 2 decimal points (HCY)
   IndicatorDigits(2);

//---- name for DataWindow and indicator subwindow label
   int TF=TimeFrame;
   if (TimeFrame==0) TF=Period();
   switch(TF)
   {
      case 1 : string TimeFrameStr="M1"; break;
      case 5 : TimeFrameStr="M5"; break;
      case 15 : TimeFrameStr="M15"; break;
      case 30 : TimeFrameStr="M30"; break;
      case 60 : TimeFrameStr="H1"; break;
      case 240 : TimeFrameStr="H4"; break;
      case 1440 : TimeFrameStr="D1"; break;
      case 10080 : TimeFrameStr="W1"; break;
      case 43200 : TimeFrameStr="MN1"; break;
      default : TimeFrameStr="CUR";
   } 

   // Set shorter indicator name (HCY)
//   short_name="MzM";
   // Show only TimeFrame (HCY)
   IndicatorShortName(TimeFrameStr);
/* Original settings (HCY) 
   short_name="MTF ZeroLag MACD";
   IndicatorShortName(short_name+ " " + TimeFrameStr+ " | " +FastEMA + ", " + SlowEMA + ", " + SignalEMA+" |  ");  
*/
   // Initialize variable (HCY)
   AutoMultiplierLEVEL=Auto_Multiplier_LEVEL;
   Max_Multiplier_Level=indicator_maximum*0.9;
   Min_Multiplier_Level=indicator_maximum*0.2;
   Max_Signal_Time=Time[CountBars];
//----
   return(0);
  }

// For automatic multiplier (HCY)
void GetBufferMax(double ExtMapBuffer[],int& Max,double& MaxSignal) {
   int max1,max2;
   double max_1,max_2;
   max1=ArrayMaximum(ExtMapBuffer,CountBars,1);
   max2=ArrayMinimum(ExtMapBuffer,CountBars,1);
   max_1=MathAbs(ExtMapBuffer[max1]);
   max_2=MathAbs(ExtMapBuffer[max2]);
   if (max_1>max_2) {
      Max=max1;
      MaxSignal=max_1;
      }
   else if (max_1==max_2) {
      Max=MathMin(max1,max2);
      MaxSignal=max_1;
      }
   else {
      Max=max2;
      MaxSignal=max_2;
      }
   }

//+------------------------------------------------------------------+
//| MTF Moving Average                                   |
//+------------------------------------------------------------------+
int start()
  {
   datetime TimeArray[];
   int    i,limit,y=0,counted_bars=IndicatorCounted();
   // For automatic multiplier (HCY)
   int old_y=-1,Max1=0,Max2=0;
   double Max_1=0.0,Max_2=0.0;
    
// Plot defined timeframe on to current timeframe   
   ArrayCopySeries(TimeArray,MODE_TIME,Symbol(),TimeFrame); 

   // Modified (HCY)
   limit=Bars-counted_bars+TimeFrame/Period();
//   limit=Bars-counted_bars;

   for(i=0,y=0;i<limit;i++)
   {
   if (Time[i]<TimeArray[y]) y++; 
   
 /***********************************************************   
   Add your main indicator loop below.  You can reference an existing
      indicator with its iName  or iCustom.
   Rule 1:  Add extern inputs above for all neccesary values   
   Rule 2:  Use 'TimeFrame' for the indicator timeframe
   Rule 3:  Use 'y' for the indicator's shift value
 **********************************************************/  

   // For automatic multiplier (HCY)
   if (Auto_Multiplier) {
      if (i==0) {
         if (counted_bars==0) {
            Max_Signal=0.0;
            }
         else if (Time[CountBars]>Max_Signal_Time) {
            GetBufferMax(ExtMapBuffer1,Max1,Max_1);
            GetBufferMax(ExtMapBuffer2,Max2,Max_2);
            if (Max_1>Max_2) {
               Max_Signal_Time=Time[Max1];
               Max_Signal=Max_1;
               }
            else if (Max_1==Max_2) {
               if (Max1<Max2)
                  Max_Signal_Time=Time[Max1];
               else
                  Max_Signal_Time=Time[Max2];
               Max_Signal=Max_1;
               }
            else {
               Max_Signal_Time=Time[Max2];
               Max_Signal=Max_2;
               }
            }
         }
      ExtMapBuffer1[i]=(iCustom(NULL,TimeFrame,"MACD",FastEMA,SlowEMA,SignalEMA,0,y)*AutoMultiplier);
      ExtMapBuffer2[i]=(iCustom(NULL,TimeFrame,"MACD",FastEMA,SlowEMA,SignalEMA,1,y)*AutoMultiplier);
      if (i<=CountBars && old_y!=y) {
         old_y++;
         double Signal=MathMax(MathAbs(ExtMapBuffer1[i]),MathAbs(ExtMapBuffer2[i]));
         if (Signal>Max_Signal) {
            Max_Signal=Signal;
            Max_Signal_Time=Time[i];
            }
         }
      if (i==limit-1) {
       if (Max_Signal>indicator_maximum || Max_Signal<AutoMultiplierLEVEL) {
         if (Auto_Multiplier_LEVEL>Max_Multiplier_Level)
            AutoMultiplierLEVEL=Max_Multiplier_Level;
         else if (Auto_Multiplier_LEVEL<Min_Multiplier_Level)
            AutoMultiplierLEVEL=Min_Multiplier_Level;
         else
            AutoMultiplierLEVEL=Auto_Multiplier_LEVEL;
         double OldAutoMultiplier=AutoMultiplier;
         AutoMultiplier=AutoMultiplierLEVEL/Max_Signal;
         Max_Signal=Max_Signal*AutoMultiplier;
         for(int j=0;j<Bars-1;j++) {
            ExtMapBuffer1[j]=ExtMapBuffer1[j]*AutoMultiplier;
            ExtMapBuffer2[j]=ExtMapBuffer2[j]*AutoMultiplier;
            }
         AutoMultiplier=AutoMultiplier*OldAutoMultiplier;
         }
       }
      }
   else {
      // For proper line display (HCY)
      ExtMapBuffer1[i]=(iCustom(NULL,TimeFrame,"MACD",FastEMA,SlowEMA,SignalEMA,0,y)*Manual_Multiplier);
      ExtMapBuffer2[i]=(iCustom(NULL,TimeFrame,"MACD",FastEMA,SlowEMA,SignalEMA,1,y)*Manual_Multiplier);
/* Original (HCY)
   ExtMapBuffer1[i]=iCustom(NULL,TimeFrame,"zlagmacd",FastEMA,SlowEMA,SignalEMA,0,y);
   ExtMapBuffer2[i]=iCustom(NULL,TimeFrame,"zlagmacd",FastEMA,SlowEMA,SignalEMA,1,y);
*/
      }
   }  
     
/* Disabled (HCY)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   if (TimeFrame>Period()) {
     int PerINT=TimeFrame/Period()+1;
     datetime TimeArr[]; ArrayResize(TimeArr,PerINT);
     ArrayCopySeries(TimeArr,MODE_TIME,Symbol(),Period()); 
     for(i=0;i<PerINT+1;i++) {if (TimeArr[i]>=TimeArray[0]) {
//----
 /************************************************ by Raff   
    Refresh buffers:         buffer[i] = buffer[0];
 ********************************************************/  

/* Disabled (HCY)
   ExtMapBuffer1[i]=ExtMapBuffer1[0];
   ExtMapBuffer2[i]=ExtMapBuffer2[0];

//----
   } } }
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*/

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

Dependencies

MACD

This indicator calculates the instantaneous difference between two exponential moving averages and overlays a smoothed simple moving average signal line to identify trend shifts.

Similar scripts

#MTF_zlagMACD_v3

This indicator synchronizes a zero-lag MACD from higher timeframes onto the current chart while utilizing an automated scaling algorithm to normalize line amplitude.

_2523MTF_MovingAverage_Ugrade_Example

MTF_Waddah_Attar_ADXxBollinger

MTF_Hull_HAMA

MTF_CCI_T3

_2523MTF_ATR

MTF_AMA

MTF_RSIOMA_v2LOnly

RSI_x2_mtf

_2523MTF_5_34_5

#MTF NMO

This indicator synchronizes and projects high-timeframe Nonlinear Moving Average (NMA) values onto the current chart for multi-temporal trend analysis.

Comments