Manual de referencia de MQL5Indicadores personalizadosEstilos de indicadores en ejemplosDRAW_COLOR_CANDLES

DRAW_COLOR_CANDLES

El estilo DRAW_COLOR_CANDLES, igual que el DRAW_CANDLES, dibuja las velas japonesas basándose en los valores de cuatro búfers indicadores que contienen los precios Open, High, Low y Close. Pero además de eso, este estilo permite establecer un color para cada vela desde un conjunto predefinido. Para eso, en el estilo ha sido agregado un búfer especial de colores que guarda los índices de los colores para cada barra. Se utiliza para crear sus propios indicadores personalizados en forma de velas japonesas, también en otra subventana del gráfico y para otros instrumentos financieros.

Usted puede establecer el número de colores para colorear las velas a través de las directivas del compilador, o dinámicamente a través de la función PlotIndexSetInteger(). El cambio dinámico de las propiedades de la construcción gráfica permite "vivificar" los indicadores, para que cambien su apariencia en función de la situación actual.

El indicador se dibuja sólo para las barras que tienen establecidos los valores no vacíos en los cuatro búfers de precios. Para indicar qué valor se debe considerar "vacío", establezca este valor en la propiedad PLOT_EMPTY_VALUE:

//--- el valor 0 (valor vacío) no va a participar en el proceso de trazado
PlotIndexSetDouble(índice_ de_construcción_DRAW_COLOR_CANDLES,PLOT_EMPTY_VALUE,0);

Rellene siempre los búfers indicadores con valores de forma explícita, para las barras que se ignoran indique en el búfer un valor vacío.

El número de búfers requeridos para construir DRAW_COLOR_CANDLES – 5:

cuatro búfers para almacenar los valores Open, High, Low y Close;
un búfer para almacenar el índice de color con el que se dibuja la vela (tiene sentido establecerlo sólo para las velas a dibujar).

Todos los búfers que se utilizan para la construcción deben ir en serie uno detrás del otro en orden establecido: Open, High, Low, Close y el búfer de color. Ninguno de los búfers de precios puede contener sólo los valores vacíos, porque en este caso no se dibuja nada.

Aquí tenemos un ejemplo del indicador que dibuja en una ventana separada las velas japonesas para el instrumento financiero especificado. El color de las velas se cambia aleatoriamente cada N tics. El parámetro N está sacado a los parámetros externos del indicador para que exista la posibilidad de establecerlo manualmente (pestaña "Parámetros" en la ventana de propiedades del indicador).

Ejemplo del estilo DRAW_COLOR_CANDLES

Fíjense en que inicialmente para la construcción gráfica plot1 el color se establece mediante la directiva del compilador #property, y luego en la funciónOnCalculate() se elige aleatoriamente un nuevo color desde la lista previamente preparada.

//+------------------------------------------------------------------+
//|                                           DRAW_COLOR_CANDLES.mq5 |
//|                         Copyright 2000-2024, MetaQuotes Ltd. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2000-2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

#property description "Indicador para demostrar DRAW_COLOR_CANDLES."
#property description "Dibuja en la ventana separada las velas para el símbolo seleccionado al azar desde MarketWatch."
#property description " "
#property description "El color y el grosor de las velas, igual que el estilo, se cambian"
#property description "de forma aleatoria cada N tics."

#property indicator_separate_window
#property indicator_buffers 5
#property indicator_plots   1
//--- plot ColorCandles
#property indicator_label1  "ColorCandles"
#property indicator_type1   DRAW_COLOR_CANDLES
//--- estableceremos 8 colores para colorear las velas (se guardan en un array especial)
#property indicator_color1  clrRed,clrBlue,clrGreen,clrYellow,clrMagenta,clrCyan,clrLime,clrOrange
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

//--- parámetros input
input int      N=5;              // número de tics para el cambio de apariencia
input int      bars=500;         // número de velas a mostrar
input bool     messages=false;   // mostrar mensajes en el log "Asesores Expertos"
//--- búfers indicadores
double         ColorCandlesBuffer1[];
double         ColorCandlesBuffer2[];
double         ColorCandlesBuffer3[];
double         ColorCandlesBuffer4[];
double         ColorCandlesColors[];
int            candles_colors;
//--- nombre del símbolo
string symbol;
//--- el array para almacenar colores tiene 14 elementos
color colors[]=
  {
   clrRed,clrBlue,clrGreen,clrChocolate,clrMagenta,clrDodgerBlue,clrGoldenrod,
   clrIndigo,clrLightBlue,clrAliceBlue,clrMoccasin,clrMagenta,clrCyan,clrMediumPurple
  };
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- si bars es muy pequeño - finalizamos el trabajo antes de tiempo
   if(bars<50)
     {
      Comment("¡Por favor, indique el número más grande de barras! El trabajo del indicador ha sido finalizado");
      return(INIT_PARAMETERS_INCORRECT);
     }
//--- indicator buffers mapping
   SetIndexBuffer(0,ColorCandlesBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,ColorCandlesBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,ColorCandlesBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,ColorCandlesBuffer4,INDICATOR_DATA);
   SetIndexBuffer(4,ColorCandlesColors,INDICATOR_COLOR_INDEX);
//--- valor vacío
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0);
//--- nombre del símbolo para el que se dibujan las barras
   symbol=_Symbol;
//--- estableceremos la visualización del símbolo
   PlotIndexSetString(0,PLOT_LABEL,symbol+" Open;"+symbol+" High;"+symbol+" Low;"+symbol+" Close");
   IndicatorSetString(INDICATOR_SHORTNAME,"DRAW_COLOR_CANDLES("+symbol+")");
//---- número de colores para colorear las velas
   candles_colors=8;     //  ver comentario para la propiedad #property indicator_color1
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| 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[])
  {
   static int ticks=INT_MAX-100;
//--- contamos los tics para el cambio del estilo y color
   ticks++;
//--- si tenemos acumulado un número suficiente de tics
   if(ticks>=N)
     {
      //--- escogeremos nuevo símbolo en la ventana "Observación del mercado"
      symbol=GetRandomSymbolName();
      //--- cambiamos la apariencia
      ChangeLineAppearance();
      //--- cambiamos los colores con los que se dibujan las barras
      ChangeColors(colors,candles_colors);

      int tries=0;
      //--- haremos 5 intentos de llenar el búfer plot1 con los precios desde symbol
      while(!CopyFromSymbolToBuffers(symbol,rates_total,0,
            ColorCandlesBuffer1,ColorCandlesBuffer2,ColorCandlesBuffer3,
            ColorCandlesBuffer4,ColorCandlesColors,candles_colors)
            && tries<5)
        {
         //--- contador de llamadas a la función CopyFromSymbolToBuffers()
         tries++;
        }
      //--- actualizamos el contador de tics pasándolo a cero
      ticks=0;
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//|  Llena la vela indicada                                          |
//+------------------------------------------------------------------+
bool CopyFromSymbolToBuffers(string name,
                             int total,
                             int plot_index,
                             double &buff1[],
                             double &buff2[],
                             double &buff3[],
                             double &buff4[],
                             double &col_buffer[],
                             int    cndl_colors
                             )
  {
//--- vamos a copiar los precios Open, High, Low y Close al array rates[]
   MqlRates rates[];
//--- contador de intentos
   int attempts=0;
//--- cantidad que se ha copiado ya
   int copied=0;
//--- hacemos 25 intentos de obtener la serie temporal para el símbolo necesario
   while(attempts<25 && (copied=CopyRates(name,_Period,0,bars,rates))<0)
     {
      Sleep(100);
      attempts++;
      if(messages) PrintFormat("%s CopyRates(%s) attempts=%d",__FUNCTION__,name,attempts);
     }
//--- si no se ha podido copiar la cantidad suficiente de barras
   if(copied!=bars)
     {
      //--- formaremos la cadena del mensaje
      string comm=StringFormat("Para el símbolo %s se ha logrado obtener sólo %d barras de %d solicitadas",
                               name,
                               copied,
                               bars
                               );
      //--- mostraremos el mensaje en un comentario en la ventana principal del gráfico
      Comment(comm);
      //--- mostramos el mensaje
      if(messages) Print(comm);
      return(false);
     }
   else
     {
      //--- estableceremos la visualización del símbolo
      PlotIndexSetString(plot_index,PLOT_LABEL,name+" Open;"+name+" High;"+name+" Low;"+name+" Close");
      IndicatorSetString(INDICATOR_SHORTNAME,"DRAW_COLOR_CANDLES("+symbol+")");
     }
//--- inicializaremos los búfers con valores vacíos
   ArrayInitialize(buff1,0.0);
   ArrayInitialize(buff2,0.0);
   ArrayInitialize(buff3,0.0);
   ArrayInitialize(buff4,0.0);
//--- en cada tic copiamos los precios a los búfers
   for(int i=0;i<copied;i++)
     {
      //--- calcularemos el índice correspondiente para los búfers
      int buffer_index=total-copied+i;
      //--- escribimos los precios en los búfers
      buff1[buffer_index]=rates[i].open;
      buff2[buffer_index]=rates[i].high;
      buff3[buffer_index]=rates[i].low;
      buff4[buffer_index]=rates[i].close;
      //--- estableceremos el color de la vela
      int color_index=i%cndl_colors;
      col_buffer[buffer_index]=color_index;
     }
   return(true);
  }
//+------------------------------------------------------------------+
//| devuelve aleatoriamente el símbolo desde Market Watch            |
//+------------------------------------------------------------------+
string GetRandomSymbolName()
  {
//--- número de símbolos mostrados en la ventana "Observación del mercado"
   int symbols=SymbolsTotal(true);
//--- posición del símbolo en la lista - un número aleatorio de 0 a symbols
   int number=MathRand()%symbols;
//--- devolvemos el nombre del símbolo sobre la posición indicada
   return SymbolName(number,true);
  }
//+------------------------------------------------------------------+
//|  cambia el color de segmentos de las velas
//+------------------------------------------------------------------+
void  ChangeColors(color  &cols[],int plot_colors)
  {
//--- número de colores
   int size=ArraySize(cols);
//---
   string comm=ChartGetString(0,CHART_COMMENT)+"\r\n\r\n";

//--- definimos de forma aleatoria un color nuevo para cada índice de colores
   for(int plot_color_ind=0;plot_color_ind<plot_colors;plot_color_ind++)
     {
      //--- obtendremos un número aleatorio
      int number=MathRand();
      //--- obtendremos un índice en el array col[] como el remanente de la división de números enteros
      int i=number%size;
      //--- estableceremos el color para cada índice como la propiedad PLOT_LINE_COLOR
      PlotIndexSetInteger(0,                    //  número del estilo gráfico
                          PLOT_LINE_COLOR,      //  identificador de la propiedad
                          plot_color_ind,       //  índice del color donde escribiremos el color
                          cols[i]);             //  nuevo color
      //--- apuntaremos los colores
      comm=comm+StringFormat("CandleColorIndex[%d]=%s \r\n",plot_color_ind,ColorToString(cols[i],true));
      ChartSetString(0,CHART_COMMENT,comm);
     }
//---
  }
//+------------------------------------------------------------------+
//| cambia la apariencia de las velas                                |
//+------------------------------------------------------------------+
void ChangeLineAppearance()
  {
//--- cadena para formar la información sobre las propiedades de las velas
   string comm="";
//--- apuntamos el nombre del símbolo
   comm="\r\n"+symbol+comm;
//--- mostraremos la información en el gráfico a través del comentario
   Comment(comm);
  }

DRAW_COLOR_BARS

Relación entre propiedades de indicador y funciones