Création d'indicateurs multicolores dans MQL5

Introduction

Grâce aux efforts des développeurs de MetaTrader 5, le langage MQL5 est apparu. Il y a beaucoup d'innovations, mais ici, je vais décrire et envisager la possibilité de créer des indicateurs multicolores. Dans MQL4, la couleur peut être spécifiée pour une ligne, c'est la même pour toute la ligne, et les indicateurs multicolores sont créés en utilisant le chevauchement partiel des tampons de l'indicateur, ce qui n'est pas pratique.

Les développeurs du langage MQL5 ont fourni une nouvelle possibilité - de spécifier une couleur pour chaque section de la ligne de l'indicateur (pour les lignes) et les couleurs d’objets séparés (pour les barres, les bougies, les histogrammes, les flèches). Pour comprendre cet article, il vaut mieux jeter un œil à MQL5 Reference.

Dans cet article, je vais essayer de considérer les sujets suivants :

• Types d'Indicateurs
• Tampons de données de l'indicateur
• Tampons d'indice de couleur de l'indicateur
• Comment convertir le mode de dessin unicolore en multicolore sur l'exemple de l'indicateur RSI (conversion des styles de dessin DRAW_LINE en DRAW_COLOR_LINE)
• Comment peindre le graphique en chandeliers (en utilisant le style de dessin DRAW_COLOR_CANDLES) en fonction des valeurs de l'indicateur RSI
• Comment obtenir la valeur du tampon des indices de couleur

Considérons deux styles de dessin en couleur - DRAW_COLOR_LINE et DRAW_COLOR_CANDLES, les styles de dessin restants ne diffèrent que par le nombre de tampons.

Pourquoi des indicateurs de couleur ?

A l'aide des indicateurs de couleur, vous pourrez :

• Masquer/afficher des informations supplémentaires
• Créer des hybrides d'indicateurs (la couleur MACD dépend des valeurs de RSI).
• Mettre en évidence les signaux importants de l'indicateur.
• Décorer simplement votre terminal client.
  

Illuminer simplement votre imagination et rendre votre trade plus pratique.

Les principes fondamentaux de MQL5

Commençons par les principes de l'indicateur.

Généralement, l'indicateur obtient des données d'entrée (prix, données de l'autre indicateur), effectue certains calculs et remplit plusieurs tampons avec les données. Le terminal client trace les informations des tampons, fournies par l'indicateur en fonction de son type de dessin.

Le style de dessin est défini par le développeur. Les tampons d'indicateur sont des tableaux de type double, déclarés au niveau global. Plusieurs tampons peuvent être combinés dans les tracés graphiques, si plusieurs tampons sont nécessaires pour un style. Si vous n'avez jamais créé d'indicateurs personnalisés, vous pouvez lire les articles (les principes fondamentaux y sont bien décrits) : « MQL5 : Créez votre propre indicateur » et « Indicateurs personnalisés dans MQL5 pour débutants ».

Voici le code minimal de l'indicateur de couleur, je vais décrire ses composants :

//+------------------------------------------------------------------+
//|                                         test_color_indicator.mq5 |
//|                                                             ProF |
//|                                                          http:// |
//+------------------------------------------------------------------+
#property copyright "ProF"                      //Author
#property indicator_separate_window             //The indicator is plotted in a separate window
#property indicator_buffers 2                   //Number of indicator buffers
#property indicator_plots 1                     //Number of indicator plots
#property indicator_type1 DRAW_COLOR_HISTOGRAM  //Drawing style - Color Histogram
#property indicator_width1 3                    //Line width of a graphic plot (optional)
#property indicator_color1 Red,Green,BlueViolet //Specify 3 colors for a graphic plot

//Declaration of buffers
double buffer_line[]/*Data Buffer*/, buffer_color_line[]/*Color index buffer*/;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//Assign the data array with indicator's buffer
   SetIndexBuffer(0,buffer_line,INDICATOR_DATA);

//Assign the color indexes array with indicator's buffer
   SetIndexBuffer(1,buffer_color_line,INDICATOR_COLOR_INDEX);

//Specify the number of color indexes, used in the graphic plot
   PlotIndexSetInteger(0,PLOT_COLOR_INDEXES,2);

//Specify colors for each index
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,Blue);   //Zeroth index -> Blue
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,Orange); //First index  -> Orange
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   //For each bar we fill the data buffer and index color buffer with values
   for(int i=prev_calculated;i<=rates_total-1;i++)
     {
      //Lets add a simple drawing condition -> If opening price is greater than closing price, then:
      if(open[i]>close[i])
        {   buffer_color_line[i]=0;   }       //Assign color with index=zero (0)
      else
        {  buffer_color_line[i]=1;   }       //Assign color with index=one (1)
      
      //Specify the data for plotting, in our case it's the opening price
      buffer_line[i]=open[i];
     }

   return(rates_total-1); //Return the number of calculated bars, 
                         //subtract 1 for the last bar recalculation
  }
//+------------------------------------------------------------------+

Examinons les détails de l'écriture des indicateurs de couleur :

#property indicator_buffers 2 //Number of indicator's buffers
#property indicator_plots 1   //Number of graphic plots

Dans la première ligne, nous spécifions le nombre de tampons d’indicateur, dans notre cas, nous avons deux tampons :

1. Le tampon pour les données de l'indicateur, dans notre cas, pour les cours d'ouverture ;
2. Le tampon pour les indices de couleur.

Dans la deuxième ligne, nous spécifions le nombre de graphiques. Il est important de distinguer les graphiques et les tampons de l'indicateur. Le graphique est la ligne (bougie, barre, flèche, etc.) de l'indicateur. Un tampon d'indicateur est un tableau avec des données, nécessaires pour tracer, un tableau avec des indices de couleurs ou un tableau pour les calculs internes de l'indicateur (ce type n'est pas dessiné dans la fenêtre de l'indicateur).

Le nombre de tracés peut être égal ou inférieur au nombre de tampons, cela dépend du style de dessin et du nombre de tampons pour le calcul. Le tableau avec les styles de dessin et le nombre de tampons nécessaires pour chaque style est disponible dans le chapitre Styles de dessin de MQL5 Reference.

Le « plus intéressant » commence ici :

#property indicator_type1 DRAW_COLOR_HISTOGRAM  //Drawing style-color histogram
#property indicator_width1 3                    //Drawing line width (optional)
#property indicator_color1 Red,Green,BlueViolet //Specify 3 colors for a graphic plot

Dans la première ligne, nous spécifions le style de dessin, dans notre cas le style de dessin est un histogramme à partir d'une ligne zéro. Ce style de dessin nécessite un tampon de données et un tampon d'indice de couleur. Tous les styles de dessin contenant le mot « COLOR » nécessitent un tampon pour les indices de couleur.

Dans la deuxième ligne, nous spécifions la largeur d'une ligne égale à trois pixels, par défaut, la largeur d'une ligne est fixée à un pixel.

Dans la troisième ligne, nous spécifions les couleurs pour les indices des graphiques, dans ce cas, nous avons spécifié trois couleurs « Rouge », « Vert » et « BleuViolet ». Les indices de couleurs partent de zéro : 0-« Red », 1-« Green », 2-« BleuViolet ». Les couleurs sont nécessaires pour configurer les couleurs des graphiques. Les couleurs peuvent être spécifiées de plusieurs manières, le « #property Indicator_color1 » est l'une d'entre elles. C'est une méthode « statique », elle est utilisée au stade de la compilation du programme. La deuxième méthode est discutée ci-dessous.

double buffer_line[]/*Data buffer*/, buffer_color_line[]/*Color indexes buffer*/;

Ici, nous déclarons deux tableaux qui seront utilisés comme tampons, le premier sera utilisé comme tampon de données, le second sera utilisé pour les indices de couleurs, tous deux déclarés comme tableaux de type double.

Considérons la fonction d'initialisation de l'indicateur :

SetIndexBuffer(0,buffer_line,INDICATOR_DATA);

Ici, nous assignons un tableau au tampon de l'indicateur, le type de tampon "INDICATOR_DATA" spécifié signifie que ce tampon sera utilisé pour stocker les valeurs de l'indicateur (c'est-à-dire que c'est le tampon de données de l'indicateur). Notez que le premier paramètre est égal à zéro (0) - c'est l'indice du tampon.

SetIndexBuffer(1,buffer_color_line,INDICATOR_COLOR_INDEX);

Ici, nous assignons un tableau au tampon de l'indicateur et spécifions "INDICATOR_COLOR_INDEX" comme type de tampon - cela signifie que ce tampon sera utilisé pour stocker les indices de couleur pour chaque barre de l'indicateur. Notez que le premier paramètre est égal à (1), c'est l'indice du tampon.

L'ordre des tampons doit être spécial : tout d'abord, les tampons de données d'indicateur, puis les tampons d'indice de couleurs.

Et enfin, la deuxième façon de spécifier les couleurs des graphiques (pour spécifier les indices de couleurs) :

//Specify the number of color indexes, used in the graphics
PlotIndexSetInteger(0,PLOT_COLOR_INDEXES,2);

Ici, nous spécifions le nombre d'indices de couleur. Le premier paramètre de la fonction est égal à « 0 », c'est l'indice graphique. Notez que dans ce cas, nous devons spécifier le nombre d'indices de couleur (dans la première méthode, le compilateur le calcule).

PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,Blue);   //Zeroth index -> Blue
PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,Orange); //First index  -> Orange

Ici, nous spécifions les couleurs pour chaque indice. Le premier paramètre de la fonction est l'indice des graphiques, le troisième paramètre est l'indice de couleur, en partant de zéro. La deuxième manière de configurer les indices de couleur diffère de la suivante : le nombre de couleurs et leurs indices peuvent être spécifiés dynamiquement, par exemple, à l'aide de la fonction . Si vous utilisez les deux méthodes, n'oubliez pas que la méthode dynamique remplace la méthode statique (première méthode).

Ensuite, considérons la fonction OnCalculate, nous calculons les valeurs de tampon pour les graphiques de l'indicateur. Nous choisissons les règles les plus simples pour la sélection de couleur pour l'histogramme, si le prix d'ouverture est supérieur au prix de clôture, nous assignons l'élément tampon courant avec l'indice de couleur (dans le tableau « buffer_color_line ») égal à zéro (0). L'indice de couleur, égal à zéro (0) correspond à la couleur « Bleue », précisée ci-dessus.

Si le prix d'ouverture est inférieur au prix de clôture, nous attribuons l'indice de couleur, égal à 1, qui correspond à la couleur Orange. Voici cet exemple simple :

On voit, c'est facile, il suffit d'un peu d'imagination.

Les méthodes de configuration des couleurs

Considérons maintenant les détails de configuration des couleurs.

Selon la référence MQL5, la couleur peut être spécifiée à l'aide de différentes méthodes :

• Littéralement ;
• Numériquement ;
• Utiliser des noms de couleurs.

Considérons-les tous.

Littéralement

color color_var = C'10,20,255';
color color_var = C'0x0A,0x14,0xFF';

Les couleurs sont définies selon le RVB (Rouge, Vert, Bleu), n'importe quelle couleur peut être présentée comme une somme de ces trois couleurs. Par conséquent, le premier nombre correspond à la composante de couleur rouge. La seconde correspond au Vert, la troisième correspond à la composante Bleue. Les nombres (sous forme décimale) peuvent aller de 0 à 255. En base hexadécimale, les valeurs peuvent être de 00 à FF.

Les première et deuxième lignes sont égales : nous attribuons la couleur Bleue à la variable color_var. La différence est la représentation d'un nombre dans des systèmes numériques spécifiés, le nombre décimal sur la première ligne et l'hexadécimal sur la deuxième ligne. Il n'y a pas de différence, vous pouvez choisir le mode qui vous convient. Le plus petit nombre correspond aux couleurs les plus foncées, la couleur blanche est : "C'255,255,255'" ou "C'0xFF,0xFF,0xFF'", la couleur noire est : "C'0,0,0'" ou "C'0x00,0x00,0x00'".

Numériquement

color color_var = 0xFFFFFF;  // white
color color_var = 0x0000FF;  // red
color color_var = 16777215   // white
color color_var = 0x008000   // green
color color_var = 32768      // green

Les couleurs sont représentées dans les systèmes de chiffres hexadécimaux et décimaux. Par exemple, la valeur "0x0000FF" est égale à "C'0xFF,0x00,0x00'", comme on le voit, la première et la dernière paire de nombres sont permutées.

Pour obtenir la valeur 16777215 dans le système numérique décimal, nous devons convertir le nombre FFFFFF de l'hexadécimal au système numérique décimal.

Noms de couleur

color color_var = Red;    //red
color color_var = Blue;   //blue
color color_var = Orange; //orange

C'est la méthode la plus simple, mais vous ne pouvez spécifier que les couleurs du jeu de couleurs Web.

Résumons comment nous pouvons spécifier les couleurs.

Les trois méthodes sont égales, par exemple :

color color1 = C'255,0,0';
color color2 = C'0xFF,0x00,0x00';
color color3 = 0x0000FF;
color color4 = 255;
color color5 = Red;

Alert((color1==color2)
       && (color1==color2)
       && (color1==color4)
       && (color1==color5)); //prints true

Une pratique

Nous avons appris les principes fondamentaux, voyons maintenant comment peindre les bougies du graphique avec différentes couleurs, en fonction des autres valeurs de l'indicateur, par exemple, en fonction des valeurs RSI. Pour créer les chandeliers de couleur sur le graphique, nous devons écrire un indicateur qui tracera les bougies de couleur imposées sur le graphique.

Voici le code de l'indicateur, si les valeurs de RSI sont inférieures à 50 %, il trace des bougies bleues, sinon les bougies sont tracées avec la couleur orange.

Pour éviter la confusion d'un lecteur, il n'y a pas de vérification de l'exactitude des données et du traitement des erreurs. Mais ces détails doivent être pris en compte lors de l'écriture du code de travail de l'indicateur.

//+------------------------------------------------------------------+
//|                                                   cand_color.mq5 |
//|                                                             ProF |
//|                                                          http:// |
//+------------------------------------------------------------------+
#property copyright "ProF"                      //Author
#property indicator_chart_window                //Indicator in separate window

                                          //Specify the number of buffers of the indicator
//4 buffer for candles + 1 color buffer + 1 buffer to serve the RSI data
#property indicator_buffers 6

//Specify the names in the Data Window
#property indicator_label1 "Open;High;Low;Close"

#property indicator_plots 1                     //Number of graphic plots
#property indicator_type1 DRAW_COLOR_CANDLES    //Drawing style - color candles
#property indicator_width1 3                    //Width of the graphic plot (optional)

                                          //Declaration of buffers
double buffer_open[],buffer_high[],buffer_low[],buffer_close[]; //Buffers for data
double buffer_color_line[];    //Buffer for color indexes
double buffer_tmp[1];           //Temporary buffer for RSI data copying
double buffer_RSI[];            //Indicator buffer for RSI
int handle_rsi=0;               //Handle for the RSI indicator
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
/**
        *       The order of the buffers assign is VERY IMPORTANT!
        *  The data buffers are first
        *       The color buffers are next
        *       And finally, the buffers for the internal calculations.
        */
//Assign the arrays with the indicator's buffers
   SetIndexBuffer(0,buffer_open,INDICATOR_DATA);
   SetIndexBuffer(1,buffer_high,INDICATOR_DATA);
   SetIndexBuffer(2,buffer_low,INDICATOR_DATA);
   SetIndexBuffer(3,buffer_close,INDICATOR_DATA);

//Assign the array with color indexes with the indicator's color indexes buffer
   SetIndexBuffer(4,buffer_color_line,INDICATOR_COLOR_INDEX);

//Assign the array with the RSI indicator data buffer
   SetIndexBuffer(5,buffer_RSI,INDICATOR_CALCULATIONS);

//Define the number of color indexes, used for a graphic plot
   PlotIndexSetInteger(0,PLOT_COLOR_INDEXES,2);

//Set color for each index
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,Blue);   //Zeroth index -> Blue
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,Orange); //First index  -> Orande
   
//Get handle of RSI indicator, it's necessary to get the RSI indicator values
   handle_rsi=iCustom(_Symbol,_Period,"Examples\\RSI");
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//In the loop we fill the data buffers and color indexes buffers for each bar
   for(int i=prev_calculated;i<=rates_total-1;i++)
     {
      //Copying the RSI indicator's data to the temporary buffer - buffer_tmp
      CopyBuffer(handle_rsi,0,BarsCalculated(handle_rsi)-i-1,1,buffer_tmp);
      //Copying the values from the temporary buffer to the indicator's buffer
      buffer_RSI[i]=buffer_tmp[0];

      //Set data for plotting
      buffer_open[i]=open[i];  //Open price
      buffer_high[i]=high[i];  //High price
      buffer_low[i]=low[i];    //Low price
      buffer_close[i]=close[i];//Close price

                               //Add a simple condition -> If RSI less 50%:
      if(buffer_RSI[i]<50)
        {   buffer_color_line[i]=0;   } //Assign the bar with color index, equal to 0
      else
        {  buffer_color_line[i]=1;   }  //Assign the bar with color index, equal to 1
     }
   return(rates_total-1); //Return the number of calculated bars, 
                         //Subtract 1 for the last bar recalculation
  }
//+------------------------------------------------------------------+

Voici à quoi cela ressemble :

Ça a l'air bien, mais on va aller de l'avant.

Peignons les bougies en fonction des valeurs de RSI en utilisant de nombreuses couleurs, ce que l'on appelle le remplissage en dégradé.

Les couleurs peuvent être spécifiées manuellement, mais il n'est pas pratique et facile de spécifier 30 à 40 couleurs. Nous allons procéder comme suit : nous allons écrire deux fonctions, la première pour les indices de couleur, la seconde pour obtenir la couleur en fonction des arguments de la fonction. L'idée est écrite dans les commentaires.

//+------------------------------------------------------------------+
//|                                               cand_color_RSI.mq5 |
//|                                                             ProF |
//|                                                          http:// |
//+------------------------------------------------------------------+
#property copyright "ProF"                      //Author
#property indicator_chart_window                //Indicator in a separate window

//Specify the number of indicator's buffers
//4 buffers for candles + 1 buffer for color indexes + 1 buffer to store the data of RSI
#property indicator_buffers 6

//Specify the names, shown in the Data Window
#property indicator_label1 "Open;High;Low;Close"

#property indicator_plots 1                     //Number of graphic plots
#property indicator_type1 DRAW_COLOR_CANDLES    //Drawing style - colored candles
#property indicator_width1 3                    //Width of a line (optional)

                                          //Declaration of buffers
double buffer_open[],buffer_high[],buffer_low[],buffer_close[];//Buffers for data
double buffer_color_line[];     //Buffer for color indexes
double buffer_tmp[1];          //Temporary buffer for RSI values
double buffer_RSI[];            //Indicator buffer for RSI
int handle_rsi=0;               //Handle of the RSI indicator
//+------------------------------------------------------------------+
//|    Set colors for a graphic plot                          |
//+------------------------------------------------------------------+
/*
*       The function sets colors for a graphic plot 
*       50 colors from Green to Blue.
*       The index of a graphic plot is passed to the function.

void setPlotColor(int plot)
  {
   PlotIndexSetInteger(plot,PLOT_COLOR_INDEXES,50); //Specify the number of colors

                                               //In the loops we specify the colors
   for(int i=0;i<=24;i++)
     {
      PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i,StringToColor("\"0,175,"+IntegerToString(i*7)+"\""));
     }
   for(int i=0;i<=24;i++)
     {
      PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i+25,StringToColor("\"0,"+IntegerToString(175-i*7)+",175\""));
     }
  }
//+------------------------------------------------------------------+
//|  Get index of the color                                          |
//+------------------------------------------------------------------+
/*
*       The function returns the index of the color
*       The first parameter is the current value of the indicator
*       The second parameter is the minimal value of the indicator
*       The third parameter is the maximal value of the indicator
*/
int getPlotColor(double current,double min,double max)
  {
   return((int)NormalizeDouble((50/(max-min))*current,0));
  }
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
/**
        *       The order of the indicator's buffers is VERY IMPORTANT!
        *  The data buffers are first
        *       The color buffers are next
        *       And finally, the buffers for the internal calculations.
        */
//Assign the arrays with the indicator buffers
   SetIndexBuffer(0,buffer_open,INDICATOR_DATA);
   SetIndexBuffer(1,buffer_high,INDICATOR_DATA);
   SetIndexBuffer(2,buffer_low,INDICATOR_DATA);
   SetIndexBuffer(3,buffer_close,INDICATOR_DATA);

//Assign the array with the color indexes buffer
   SetIndexBuffer(4,buffer_color_line,INDICATOR_COLOR_INDEX);

//Assign the array with RSI indicator buffer
   SetIndexBuffer(5,buffer_RSI,INDICATOR_CALCULATIONS);

//Specify color indexes
   setPlotColor(0);

//Get handle of the RSI indicator, it's necessary get its values
   handle_rsi=iCustom(_Symbol,_Period,"Examples\\RSI",6);
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//For each bar we fill the data buffers and buffer with color indexes using the loop
   for(int i=prev_calculated;i<=rates_total-1;i++)
     {
      //Copying the RSI indicator data to the temporary buffer buffer_tmp
      CopyBuffer(handle_rsi,0,BarsCalculated(handle_rsi)-i-1,1,buffer_tmp);
      //Then copying the data from the temporary buffer
      buffer_RSI[i]=buffer_tmp[0];

      //Specify the data for plotting
      buffer_open[i]=open[i];  //Open price
      buffer_high[i]=high[i];  //High price
      buffer_low[i]=low[i];    //Low price
      buffer_close[i]=close[i];//Close price

      //Paint the candles depending on RSI indicator values
      //RSI = 0     - candle is Green
      //RSI = 100   - candle is Blue
      //0<RSI<100   - candle color is between Green and Blue 
      buffer_color_line[i]=getPlotColor(buffer_RSI[i],0,100);

     }
   return(rates_total-1); //Return the number of calculated bars, 
                         //Subtract 1 for the last bar recalculation
  }
//+------------------------------------------------------------------+

Voici à quoi cela ressemble :

En l'utilisant comme exemple, configurez d'autres couleurs. Essayez de remplacer le RSI par un autre indicateur.

La pratique est toujours importante.

Styles de dessin : Conventionnel et multicolore

Pour peindre un indicateur existant, vous devez faire les choses suivantes : changer le style de dessin en multicolore, ajouter des tampons, les affecter avec les tampons d'indicateur et spécifier les détails de la peinture.

Voici un tableau des styles de dessin conventionnels et des styles de dessin multicolores (peints) correspondants :

Avant	Après
DRAW_LINE	DRAW_COLOR_LINE
DRAW_SECTION	DRAW_COLOR_SECTION
DRAW_HISTOGRAM	DRAW_COLOR_HISTOGRAM
DRAW_HISTOGRAM2	DRAW_COLOR_HISTOGRAM2
DRAW_ARROW	DRAW_COLOR_ARROW
DRAW_ZIGZAG	DRAW_COLOR_ZIGZAG (exemple)
DRAW_CANDLES	DRAW_COLOR_CANDLES

Voici le code du RSI modifié, peint en fonction de ses propres valeurs.

Toutes les modifications sont commentées.

//+------------------------------------------------------------------+
//|                                                          RSI.mq5 |
//|                        Copyright 2009, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright   "2009, MetaQuotes Software Corp."
#property link        "http://www.mql5.com"
#property description "Relative Strength Index"
//--- indicator settings
#property indicator_separate_window
#property indicator_minimum 0
#property indicator_maximum 100
#property indicator_level1 30
#property indicator_level2 70
/////////////////////////////////////////////////////////////////////
#property indicator_buffers 4 //The number of buffers has increased by 1
#property indicator_width1 5  //The line width has set to 4 pixels
/////////////////////////////////////////////////////////////////////
#property indicator_plots   1
/////////////////////////////////////////////////////////////////////
//Drawing style has been changed from DRAW_LINE to DRAW_COLOR_LINE
#property indicator_type1   DRAW_COLOR_LINE
/////////////////////////////////////////////////////////////////////
#property indicator_color1  DodgerBlue
//--- input parameters
input int InpPeriodRSI=14; // Period
//--- indicator buffers
double    ExtRSIBuffer[];
double    ExtPosBuffer[];
double    ExtNegBuffer[];
//--- global variable
int       ExtPeriodRSI;

//////////////////////////////////////////////////////////////////////
double buffer_color[]; //Declare an array for color indexes

//Added two functions
//+------------------------------------------------------------------+
//|    Set color for a graphic plot                                  |
//+------------------------------------------------------------------+
/*
*       The function specify the color for a graphic plot 
*       50 colors from Green to Blue are available.
*       The index of a graphic plot is passed to the function.
*/
void setPlotColor(int plot)
  {
   PlotIndexSetInteger(plot,PLOT_COLOR_INDEXES,50); //Set number of colors

                                                    //Specify colors in loop
   for(int i=0;i<=24;i++)
     {
      PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i,StringToColor("\"0,175,"+IntegerToString(i*7)+"\""));
     }
   for(int i=0;i<=24;i++)
     {
      PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i+25,StringToColor("\"0,"+IntegerToString(175-i*7)+",175\""));
     }
  }
//+------------------------------------------------------------------+
//|  Get index of the color                                           |
//+------------------------------------------------------------------+
/*
*       The function returns the color index
*       The first parameter is the current value of the indicator
*       The second parameter is the minimal value of the indicator
*       The third parameter is the maximal value of the indicator
*/
int getPlotColor(double current,double min,double max)
  {
   return((int)NormalizeDouble((50/(max-min))*current,0));
  }
//////////////////////////////////////////////////////////////////////


//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
void OnInit()
  {
//--- check for input
   if(InpPeriodRSI<1)
     {
      ExtPeriodRSI=12;
      Print("Incorrect value for input variable InpPeriodRSI =",InpPeriodRSI,
            "Indicator will use value =",ExtPeriodRSI,"for calculations.");
     }
   else ExtPeriodRSI=InpPeriodRSI;
//--- indicator buffers mapping
   SetIndexBuffer(0,ExtRSIBuffer,INDICATOR_DATA);
   
/////////////////////////////////////////////////////////////////////
//Assign the array with buffer of color indexes
        SetIndexBuffer(1,buffer_color,INDICATOR_COLOR_INDEX);
//The order of buffers is changed!
        SetIndexBuffer(2,ExtPosBuffer,INDICATOR_CALCULATIONS);
   SetIndexBuffer(3,ExtNegBuffer,INDICATOR_CALCULATIONS);
//Set colors
   setPlotColor(0);
/////////////////////////////////////////////////////////////////////

//--- set accuracy
   IndicatorSetInteger(INDICATOR_DIGITS,2);
//--- sets first bar from what index will be drawn
   PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,ExtPeriodRSI);
//--- name for DataWindow and indicator subwindow label
   IndicatorSetString(INDICATOR_SHORTNAME,"RSI("+string(ExtPeriodRSI)+")");
//--- initialization done
  }
//+------------------------------------------------------------------+
//| Relative Strength Index                                          |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[])
  {
   int    i;
   double diff;
//--- check for rates count
   if(rates_total<=ExtPeriodRSI)
      return(0);
//--- preliminary calculations
   int pos=prev_calculated-1;
   if(pos<=ExtPeriodRSI)
     {
      //--- first RSIPeriod values of the indicator are not calculated
      ExtRSIBuffer[0]=0.0;
      ExtPosBuffer[0]=0.0;
      ExtNegBuffer[0]=0.0;
      double SumP=0.0;
      double SumN=0.0;
      for(i=1;i<=ExtPeriodRSI;i++)
        {
         ExtRSIBuffer[i]=0.0;
         ExtPosBuffer[i]=0.0;
         ExtNegBuffer[i]=0.0;
         diff=price[i]-price[i-1];
         SumP+=(diff>0?diff:0);
         SumN+=(diff<0?-diff:0);
        }
      //--- calculate first visible value
      ExtPosBuffer[ExtPeriodRSI]=SumP/ExtPeriodRSI;
      ExtNegBuffer[ExtPeriodRSI]=SumN/ExtPeriodRSI;
      ExtRSIBuffer[ExtPeriodRSI]=100.0-(100.0/(1.0+ExtPosBuffer[ExtPeriodRSI]/ExtNegBuffer[ExtPeriodRSI]));
      //--- prepare the position value for main calculation
      pos=ExtPeriodRSI+1;
     }
//--- the main loop of calculations
   for(i=pos;i<rates_total;i++)
     {
      diff=price[i]-price[i-1];
      ExtPosBuffer[i]=(ExtPosBuffer[i-1]*(ExtPeriodRSI-1)+(diff>0.0?diff:0.0))/ExtPeriodRSI;
      ExtNegBuffer[i]=(ExtNegBuffer[i-1]*(ExtPeriodRSI-1)+(diff<0.0?-diff:0.0))/ExtPeriodRSI;
      ExtRSIBuffer[i]=100.0-100.0/(1+ExtPosBuffer[i]/ExtNegBuffer[i]);
/////////////////////////////////////////////////////////////////////
//Paint it
                buffer_color[i] = getPlotColor(ExtRSIBuffer[i],0,100);
/////////////////////////////////////////////////////////////////////
     }
//--- OnCalculate done. Return new prev_calculated.
   return(rates_total);
  }
//+------------------------------------------------------------------+

Voilà, vous pouvez comparer la couleur des bougies et le RSI.

Comment obtenir la valeur de couleur de l'indicateur à partir de l'Expert Advisor/Indicator/Script

Il est souvent nécessaire d'obtenir la couleur d'une ligne pour le trading automatisé dans un Expert Advisor ou à d'autres fins.

La mise en œuvre est simple, considérons un script.

//+------------------------------------------------------------------+
//|                                                         test.mq5 |
//|                                                             ProF |
//|                                                          http:// |
//+------------------------------------------------------------------+
#property copyright "ProF"
#property link      "http://"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
        int handle = 0; //handle of the indicator
        double tmp[1];  //temporary array for color index buffer.
        //Get the handle of our modified RSI
        handle = iCustom(_Symbol,_Period,"Examples\\RSI",6);
        
        //Let's remember, that values are stored in the buffer 1 of our modified RSI
        //The color indexes are stored in the buffer 0
        //Copying the data from the buffer "1" of the RSI indicator.
        CopyBuffer(handle,1,0,1,tmp);
        
        //Show alert with last color index, returned by RSI
        Alert(tmp[0]); //For example, if returned 0, it means that RSI
        //is painted with Green color and its current level is near 0.
  }
//+-----------------------------------------------------------------+

Notez que nous pouvons obtenir la valeur de l'indice de couleur, pas la couleur elle-même !

Vous devez connaître la correspondance entre les indices de couleurs et les valeurs de couleurs. De plus, vous devez connaître le tampon des indices de couleurs.

Pour le découvrir, vous devez comprendre les critères de configuration de l'indice de couleur ou les déterminer empiriquement par ce script ou en utilisant d'autres méthodes.

Conclusion

Nous avons pris en compte les styles de dessin MQL5 suivants : DRAW_COLOR_LINE, DRAW_COLOR_CANDLES. Nous avons peint les bougies et appris à peindre l'indicateur RSI (DRAW_LINE -> DRAW_COLOR_LINE). De plus, nous avons appris à obtenir la valeur des indices de tampon de couleur.

Le langage MQL5 a beaucoup de styles de dessin, la seule limite est votre imagination. L'utilisation de lignes colorées permet de mieux voir le marché.

Utilisez les nouvelles opportunités pour un trading plus confortable.