#SVM_b4_dd_pred3_

#SVM_b4_dd_pred3_

This script is designed as a visual technical analysis tool for the MetaTrader 4 platform. It transforms complex Relative Strength Index (RSI) data into a simplified, color-coded histogram that helps traders quickly identify market momentum and trends at a glance.

Core Functionality

The primary purpose of this tool is to interpret "strength" signals from another underlying indicator and translate them into a visual display of colored blocks. Instead of requiring you to analyze raw numerical values or multiple lines on a chart, the script categorizes market behavior into specific visual zones.

How the Logic Works

The script scans the price history and evaluates data points based on specific intensity levels. It then "paints" the chart using different colors to represent these states:

  • Bullish Momentum (Green Zones): When the underlying data indicates strong upward movement reaching specific high-intensity thresholds, the script activates various green blocks. Depending on how strong the signal is, it may fill different sections of the histogram to show the "depth" of the trend.
  • Bearish Momentum (Red Zones): Conversely, when the data identifies significant downward pressure reaching specific low-intensity thresholds, the script activates red blocks. Similar to the bullish signals, the placement and presence of these blocks change based on the severity of the downward move.
  • Neutral/Ranging Markets (White Zone): When the market is neither showing strong upward nor downward momentum—essentially moving sideways or "ranging"—the script identifies this middle ground and highlights it with a white block.

Visual Representation

The logic uses an 8-buffer system to manage different visual layers. By mapping specific numerical results (such as 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, and 7.1) to different "draw" commands, the script ensures that:

  1. The Trend Color is Immediate: You can instantly see if the market is biased toward the buy side (Green), the sell side (Red), or is currently flat (White).
  2. The Trend Strength is Scalable: By activating different blocks as the numbers increase, the script provides a visual "heat map" of how powerful the current price movement actually is.

Summary for the User

Essentially, this script acts as a translator. It takes a complex mathematical calculation (RSI-based strength), filters out the noise, and presents you with a clean, color-coded dashboard. It allows you to see the "mood" of the market: green for strength, red for weakness, and white for indecision.

Miscellaneous
Implements a curve of type %1
7 Views
0 Downloads
0 Favorites
#SVM_b4_dd_pred3_ 
//+------------------------------------------------------------------+
//|                                     multisymbol_color-RSI_1.0.mq4 |
//|                                                      Lq_sunshine |
//|                                         http://www.forex-tsd.com |
//+------------------------------------------------------------------+
//#property indicator_chart_window
#property indicator_separate_window
#property indicator_buffers 8
#property indicator_color1 C'162,208,162'
#property indicator_color2 C' 90,185, 90' 
#property indicator_color3 C' 23,139, 23' 
#property indicator_color4 C'255,255,255' 
#property indicator_color5 C'255,185,185' 
#property indicator_color6 C'255,115,115' 
#property indicator_color7 C'255, 76, 76' 
#property indicator_color8 C'255, 32, 32' 

string indicator1="#SVM_b4_dd_pred3";
//extern int    Periode=10;
//extern bool   invert_strength =  0;
//extern string CurrencyPair    = "";
//extern string NOTE0 = "enter currencypair in uppercase"; 
//extern string NOTE1 = "like EURUSD"; 
//extern string NOTE2 = "leave empty for current symbol"; 
//extern string NOTE3 = "if you have a mini account"; 
//extern string NOTE4 = "add a \"m\"  e.g EURUSDm "; 

//----------


//---- buffers
   double     ExtBuffer0[];   
   double     ExtBuffer1[];
   double     ExtBuffer2[];
   double     ExtBuffer3[]; 
   double     ExtBuffer4[];   
   double     ExtBuffer5[];
   double     ExtBuffer6[]; 
   double     ExtBuffer7[];
   double     ExtBuffer8[]; 


//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int init()
{
   SetIndexBuffer(0,ExtBuffer0);
   SetIndexBuffer(1,ExtBuffer1);
   SetIndexBuffer(2,ExtBuffer2);
   SetIndexBuffer(3,ExtBuffer3);
   SetIndexBuffer(4,ExtBuffer4);
   SetIndexBuffer(5,ExtBuffer5);
   SetIndexBuffer(6,ExtBuffer6);
   SetIndexBuffer(7,ExtBuffer7);
   
   SetIndexStyle(0,DRAW_HISTOGRAM, EMPTY, 5);
   SetIndexStyle(1,DRAW_HISTOGRAM, EMPTY, 5);
   SetIndexStyle(2,DRAW_HISTOGRAM, EMPTY, 5);
   SetIndexStyle(3,DRAW_HISTOGRAM, EMPTY, 5);
   SetIndexStyle(4,DRAW_HISTOGRAM, EMPTY, 5);
   SetIndexStyle(5,DRAW_HISTOGRAM, EMPTY, 5);
   SetIndexStyle(6,DRAW_HISTOGRAM, EMPTY, 5);
   SetIndexStyle(7,DRAW_HISTOGRAM, EMPTY, 5);
   
   //for (int i=0;i<indicator_buffers;i++) SetIndexLabel(i,NULL);   

   //if (CurrencyPair == "") CurrencyPair = Symbol();
   //if (iClose(CurrencyPair,0,0) == 0)
   //           CurrencyPair = Symbol();
   //IndicatorShortName(CurrencyPair+"("+Periode+")");
   return(1);
}

int deinit()
  {
   return(0);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int start()
  {
  
  
  
   int    counted_bars=IndicatorCounted();
   
//---- check for possible errors
   if (counted_bars<0) return(-1);
//---- last counted bar will be recounted
   if (counted_bars>0) counted_bars--;
   
   int    pos=Bars-counted_bars;
 
   
   double ddraw;

 

//---- main calculation loop
   while(pos>=0)
     {          
        ddraw= iCustom(Symbol(),0,indicator1,6,pos);    
         //if (invert_strength==1)            
         //    ddraw=ddraw-(ddraw-50)*2;             //---- Inversion of the RSI
          //   1     2     3     4    5    6    7
          //-2.9  -1.9  -0.9   0.1  1.1  2.1  3.1   
         if(ddraw==1.1 )           //---- RSI <= 48 draws RED blocks 
         {
                //Print("----> -0.9");
                //        1 2 3 4 5 6 7 8  
                drawblock(0,0,0,0,5,0,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,0,0,0,5,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,0,0,0,0,5,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,0,0,0,0,0,5,pos);
          }
          //   1     2     3     4    5    6    7
          //-2.9  -1.9  -0.9   0.1  1.1  2.1  3.1                                       
         else if(ddraw==2.1 )           //---- RSI <= 48 draws RED blocks 
         {
                //Print("----> -0.9");
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,0,0,5,0,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                drawblock(0,0,0,0,0,5,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,0,0,0,0,5,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,0,0,0,0,0,5,pos);
          }   
          //   1     2     3     4    5    6    7
          //-2.9  -1.9  -0.9   0.1  1.1  2.1  3.1                                            
         else if(ddraw==3.1 )           //---- RSI <= 48 draws RED blocks 
         {
                //Print("----> -0.9");
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,0,0,5,0,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,0,0,0,5,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                drawblock(0,0,0,0,0,0,5,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,0,0,0,0,0,5,pos);
          } 
          //   1     2     3     4    5    6    7
          //-2.9  -1.9  -0.9   0.1  1.1  2.1  3.1                                      
          else if(ddraw==5.1)     //---- RSI >= 52 draws green blocks
          { 
                //Print("----> 1.1");
                //        1 2 3 4 5 6 7 8  
                //drawblock(5,0,0,0,0,0,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,5,0,0,0,0,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                drawblock(0,0,5,0,0,0,0,0,pos);       
          } 
          //   1     2     3     4    5    6    7
          //-2.9  -1.9  -0.9   0.1  1.1  2.1  3.1                 
         else if(ddraw==6.1)     //---- RSI >= 52 draws green blocks
          { 
                //Print("----> 1.1");
                //        1 2 3 4 5 6 7 8  
                //drawblock(5,0,0,0,0,0,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                drawblock(0,5,0,0,0,0,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,5,0,0,0,0,0,pos);       
          }  
          //   1     2     3     4    5    6    7
          //-2.9  -1.9  -0.9   0.1  1.1  2.1  3.1                            
         else if(ddraw==7.1)     //---- RSI >= 52 draws green blocks
          { 
                //Print("----> 1.1");
                //        1 2 3 4 5 6 7 8  
                drawblock(5,0,0,0,0,0,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,5,0,0,0,0,0,0,pos);
                //        1 2 3 4 5 6 7 8  
                //drawblock(0,0,5,0,0,0,0,0,pos);       
          }
          //   1     2     3     4    5    6    7
          //-2.9  -1.9  -0.9   0.1  1.1  2.1  3.1         
          else  if(ddraw==4.1)
          {     
                //Print("----> 0.1");
                //---- draw white block if there chart is ranging
                //        1 2 3 4 5 6 7 8  
                drawblock(0,0,0,5,0,0,0,0,pos);     
          }     
             
   
         pos--;
     }
//----
   return(0);
  }
      
void drawblock(int a,int b,int c,int d,int e,int f,int g,int h,int pos)

{
         
               ExtBuffer0[pos]=a;    
               ExtBuffer1[pos]=b;
               ExtBuffer2[pos]=c;
               ExtBuffer3[pos]=d;
               ExtBuffer4[pos]=e;
               ExtBuffer5[pos]=f;
               ExtBuffer6[pos]=g;
               ExtBuffer7[pos]=h;
}

Similar scripts

#SVM_b4_dd_pred5_

This indicator captures and visualizes directional momentum by mapping specific Relative Strength Index (RSI) threshold levels into a multi-colored histogram grid.

#SVM_b4_dd_pred4_

This indicator decodes external SVM-based RSI data into a multi-layered color histogram to visualize trend momentum, strength, and ranging conditions simultaneously.

#SVM_b4_dd_pred2_

This indicator translates specific relative strength index thresholds into a multi-colored histogram to visually map bullish, bearish, and neutral market regimes.

#SVM_b4_dd_pred1_

A multi-layered visual analytics tool that decodes momentum intensity and directional bias by mapping external RSI data into a color-coded histogram grid.

#SVM_b4_dd_pred0_

This indicator visualizes momentum shifts by mapping specific RSI threshold values to a multi-layered color histogram, identifying bearish, bullish, and neutral market zones simultaneously.

multisymbol_color-RSI_LQ_1.0

multisymbol_color-RSI_LQ_1[1].0

This indicator visualizes relative strength momentum by mapping RSI values into a multi-colored histogram that distinguishes between bearish, bullish, and neutral trend intensities.

STO_multisymbol_color_STO_LQ_1.0M8

This indicator visualizes multi-layered sentiment by mapping Stochastic Oscillator main or signal lines into a color-coded histogram based on specific threshold zones.

multisymbol_color_Stochastic_LQ_1.0M6

This indicator visualizes momentum intensity by mapping Stochastic Oscillator values into color-coded histogram blocks that differentiate between bullish, bearish, and neutral market zones.

Heatmap_RSI

A multi-layered visual histogram that maps Relative Strength Index intensity into distinct color zones to identify oversold, overbought, and neutral market states.

Comments