#SVM_b4_dd_pred0_

Download script
#SVM_b4_dd_pred0_

This tool is designed as a visual price action indicator for the MetaTrader platform. It functions by transforming complex data from a Relative Strength Index (RSI) calculation into a clear, color-coded visual system on your chart. Instead of requiring you to interpret raw numbers or fluctuating lines, it simplifies market conditions into a distinct set of visual blocks.

How the Logic Works

The script continuously monitors the "strength" of price momentum. It looks at specific thresholds in the underlying data and translates them into different visual signals:

  • Bullish Momentum (Green Signals): When the data suggests strong upward pressure, the script identifies specific intensity levels. Depending on how high that momentum reaches, it activates various green blocks across the indicator window. The more significant the strength, the more "filled" or prominent the green visual becomes.
  • Bearish Momentum (Red Signals): Conversely, when the data indicates significant downward pressure, the script triggers red blocks. Similar to the bullish signals, these change based on the intensity of the move, helping you quickly identify the depth of a downtrend.
  • Neutral/Ranging Markets (White Signals): The script is programmed to recognize periods where price action lacks a clear direction. When the data falls into a "middle ground" or neutral zone, it produces white blocks. This serves as a visual cue that the market may be consolidating or ranging, signaling caution for trend-following strategies.

Key Features for the User

  • Visual Simplification: By converting numerical RSI values into colored blocks, the tool allows you to see "at a glance" whether the current environment is bullish, bearish, or sideways.
  • Multi-Level Intensity: The logic doesn't just offer a simple "up or down" signal; it distinguishes between different degrees of strength, providing a more nuanced view of market behavior.
  • Automated Scanning: The script automatically processes historical and real-time data, updating the visual blocks instantly as new price information arrives.

In summary, this tool acts as a visual filter, stripping away the noise of raw data to provide a clear, color-coded map of market sentiment and momentum.

Miscellaneous
Implements a curve of type %1
7 Views
0 Downloads
0 Favorites
#SVM_b4_dd_pred0_
//+------------------------------------------------------------------+
//|                                     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_pred0";
//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;
} 

Comments