Explorando opciones para crear velas multicolores

Introducción

En este artículo, abordaremos las distintas posibilidades de crear indicadores personalizados con gráficos de velas, señalando sus correspondientes ventajas y desventajas. Abordaremos este tema desde 4 perspectivas:

1-La construcción de velas con un solo color sin distinguir entre velas altas y bajas.

2-La construcción de velas multicolores, coloreadas según alguna regla comercial.

3-La construcción de velas con y sin relleno, distinguiendo entre el color del relleno y el color de los bordes de las velas.

4-La construcción de velas multicolores con y sin relleno.

En primer lugar, deberemos aclarar las razones de la implementación de las reglas de coloreado en los gráficos de velas, así como la importancia de la elección adecuada para la creación de nuestro indicador. Cada método tiene sus peculiaridades, ventajas y desventajas, ya sea por la interacción del usuario con el programa, o por la optimización del uso del hardware por parte del programa.

Vamos a considerar primero un modelo operativo que funciona con 3 líneas de precio desplazadas. La primera línea (negra) es el precio en sí, la segunda (azul) es una media móvil de 1 periodo desplazada 10 periodos hacia adelante, y la tercera (roja) es una media móvil de 1 periodo desplazada 20 periodos hacia adelante. A continuación, podemos ver la construcción del modelo en un gráfico de precios, donde insertamos dos medias móviles y cambiamos el gráfico de precios a una línea.

A primera vista, este es un modelo poco amigable y difícil de interpretar, ya que necesitamos identificar no solo el color de las líneas sino también la relación entre ellas. Con frecuencia, esto provoca confusión y errores en la toma de decisiones. Otro modelo que puede generar confusión y errores es el indicador de Índice de Movimiento Direccional, por el mismo motivo: la necesidad de identificar no solo el color de las líneas sino también la relación entre ellas.

De hecho, cuanto mayor sea el número de variables o indicadores a considerar, más frecuentes serán los errores de interpretación, haciendo que las decisiones y los resultados resulten inconsistentes. Podemos usar tantos indicadores y variables como queramos, siempre que convirtamos estos datos en información objetiva y fácil de entender.

El uso de reglas de coloreado es una forma eficaz de condensar toda la información capaz de decirnos exactamente lo que queremos saber: cuándo podemos comprar y vender, y cuándo deberíamos estar fuera del mercado. Entonces, podemos sintetizar la información en 3 colores. Uno para la compra, otro para la venta y otro para cuando no se dan las condiciones de compra o venta. En este artículo, trabajaremos con el verde para la compra, el rojo para la venta y el amarillo para los otros casos. Esto se resume en el siguiente recuadro.

Color	Dirección
verde	comprar
rojo	vender
amarillo	neutro

En este punto, debemos olvidar las reglas comerciales detrás de la norma de coloreado de las velas y ver cómo construir gráficos de velas en MQL5. Si es la primera vez que usted crea un programa para Metatrader 5 en MQL5, le recomendamos consultar la guía de ayuda del MetaEditor, el entorno de desarrollo de Metatrader 5.

Creando un gráfico de velas

En este punto, demostraremos cómo construir un gráfico de velas sencillo y explicaremos algunas características básicas. Los gráficos de velas constan de una serie de velas. Cada vela está formada por cuatro valores: apertura, máximo, mínimo y cierre del periodo. Para saber si existe un máximo o mínimo en el periodo en cuestión, se comprueba si el cierre es mayor o menor que el precio de apertura. Si se trata de una vela alta, la colorearemos de verde, y si es una vela baja, la colorearemos de rojo.

Vamos a comenzar creando un indicador con el Wizard MQL.

Para ello, le daremos a nuestro indicador un nombre y cambiaremos la información de copyright, es decir, el nombre del autor y la dirección de la página web.

Usaremos la función OnCalculate que contiene las series de precios de apertura, máximo, mínimo y cierre.

Como nuestro indicador será un gráfico de velas, escogeremos el gráfico de VELAS en "tipo", y cambiaremos el nombre de la etiqueta por Velas. Este nombre se usa tanto para la interfaz de usuario como para manejar los búferes de indicador.

Este es el código generado por nuestro Wizard MQL.

//+------------------------------------------------------------------+
//|                                                      Candles.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots   1
//--- plot Candle
#property indicator_label1  "Candle"
#property indicator_type1   DRAW_CANDLES
#property indicator_color1  clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- indicator buffers
double         CandleBuffer1[];
double         CandleBuffer2[];
double         CandleBuffer3[];
double         CandleBuffer4[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,CandleBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,CandleBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,CandleBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,CandleBuffer4,INDICATOR_DATA);

//---
   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[])
  {
//---

//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Ahora, solo tenemos que compilar el código y nuestro indicador de velas estará disponible en nuestro explorador de archivos en MetaTrader 5. No obstante, cuando lo coloquemos en el gráfico de precios, no se mostrará correctamente, ya que no hemos asignado los valores a los búferes de indicador. Así que vamos a hacer esto. En este primer método tenemos 4 búferes: CandleBuffer1 [], CandleBuffer2 [], CandleBuffer3 [] y CandleBuffer4 []. El uso de estos búferes se explica en el siguiente recuadro.

búferes	series de precio
CandleBuffer1	Precios de apertura
CandleBuffer2	Precios altos
CandleBuffer3	Precios bajos
CandleBuffer4	Precios de cierre

El número de búferes debe indicarse en nuestro código a través de la propiedad indicator_buffers. Este trabajo ya ha sido realizado por el Wizard MQL; no obstante, podemos cambiar el número de búferes según las necesidades del indicador. Lo haremos más tarde.

#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 4

Vamos a asignar los valores a nuestros búferes en la función OnCalculated, usando para ello un ciclo que ejecutará todo el rango de precios. Sin embargo, una vez que hayamos asignado un valor, no será necesario reasignarlo cuando aumente el tamaño de la serie. Es decir, si en una llamada de función tenemos n velas y en la siguiente llamada tenemos n + 1, solo necesitaremos calcular los valores de la última vela. En la función OnCalcultate, el número de velas en el gráfico es comunicado por el parámetro rates_total, mientras que el número de velas que se encontraban en el gráfico en la última llamada de la función es comunicado por el parámetro prev_calculated.

Este es el resultado del trabajo en la función OnCalculate.

//+------------------------------------------------------------------+
//| 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[])
  {
//---
   int start = prev_calculated;
   if(start>=rates_total)
      start = rates_total-1;

   for(int i = start; i<rates_total; i++)
     {
      CandleBuffer1[i]=open[i];
      CandleBuffer2[i]=high[i];
      CandleBuffer3[i]=low[i];
      CandleBuffer4[i]=close[i];
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }

Tenga en cuenta que en nuestro indicador todas las velas están en rojo, que es el color que hemos definido en el Wizard MQL. Sin embargo, el usuario puede cambiar este color. Asimismo, el color se puede cambiar en nuestro código a través de la propiedad indicator_color1. Para obtener más información sobre cómo definir colores y trabajar con ellos en MQL5, consulte la documentación sobre los datos de Type Color.

//--- plot Candle
#property indicator_label1  "Candle"
#property indicator_type1   DRAW_CANDLES
#property indicator_color1  clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

Construyendo un gráfico de velas multicolores

Hasta ahora, hemos visto la creación de un gráfico de velas sin colores distintivos, ni velas altas o bajas. Ahora, veremos cómo se crean las velas multicolores y de colores siguiendo alguna regla comercial. Pero primero, usaremos una regla para distinguir las velas altas y bajas solo por su color.

Podemos ver que estamos usando el tipo de dibujado DRAW_CANDLES, definido en las propiedades del indicador en indicator_type1. Podemos cambiar esta propiedad a DRAW_COLOR_CANDLES para trabajar con velas multicolores. Como el tipo de dibujo DRAW_COLOR_CANDLES necesita guardar los colores de cada vela, disponemos de un búfer adicional que llamaremos CandleColor. Y nuestro número de búferes aumentará a 5. Además, necesitaremos añadir un color para la propiedad indicator_color1.

#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   1
//--- plot Candle
#property indicator_label1  "Candle"
#property indicator_type1   DRAW_COLOR_CANDLES
#property indicator_color1  clrGreen,clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- indicator buffers
double         CandleBuffer1[];
double         CandleBuffer2[];
double         CandleBuffer3[];
double         CandleBuffer4[];
double         CandleColor[];

A continuación, inicializaremos el nuevo búfer CandleColor, que guardará los colores de las velas, informando al compilador de que queremos usar este búfer para almacenar colores. Esto lo haremos a través de la función SetIndexBuffer, transmitiendo como parámetro INDICATOR_COLOR_INDEX. En nuestro caso, al tener dos colores (verde y rojo), el primer color tendrá índice 0, y el segundo, el índice 1. Si definimos n colores en indicator_color1, tendremos los índices de color de 0 a n-1;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,CandleBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,CandleBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,CandleBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,CandleBuffer4,INDICATOR_DATA);
   SetIndexBuffer(4,CandleColor,INDICATOR_COLOR_INDEX);

//---
   return(INIT_SUCCEEDED);
  }

Tenga en cuenta que estos cambios se pueden realizar directamente en el Wizard MQL que define e inicializa los búferes, además del número de búferes necesarios. Solo tenemos que cambiar el parámetro de tipo de dibujado a DRAW_COLOR_CANDLES y sus colores en la ventana del Wizard MQL. Este es un procedimiento muy útil cuando queremos trabajar con indicadores que trazan más de un tipo de dibujado en el gráfico. Veremos esto más tarde.

Ahora necesitamos asignar los valores al búfer CandleColor. Vamos a considerar como regla de coloreado que el cierre es mayor que la apertura de la vela, por lo que deberá tener color verde; en caso contrario, deberá ser rojo. Veamos cómo se ve esto dentro de la función OnCalculate.

   for(int i = start; i<rates_total; i++)
     {
      CandleBuffer1[i]=open[i];
      CandleBuffer2[i]=high[i];
      CandleBuffer3[i]=low[i];
      CandleBuffer4[i]=close[i];

      //if the close price is higher than the open price we set the 
      //green color (index 0), otherwise, the red color (index 1)
      CandleColor[i]=(close[i]>open[i])?0:1;
 

Como era de esperar, el resultado es un gráfico estándar que diferencia velas alcistas y bajistas.

Cambiemos nuestra regla de coloreado. En lugar de diferenciar velas altas y bajas, usaremos una regla comercial muy simple: así veremos otra forma de distinguir velas altas y bajas en el siguiente tema.

Vamos a analizar el modelo operativo presentado al comienzo del artículo. Como reglas comerciales, tendremos que si la línea negra (precio de cierre) es mayor que la línea azul (turno de cierre en 10 periodos) y la línea roja (turno de cierre en 20 periodos), entonces querremos comprar. Si la línea negra (precio de cierre) es menor que la línea azul y la línea roja, entonces querremos vender. En otros casos, deberemos esperar a que la dirección del mercado se defina. Esta regla se resume en el siguiente recuadro.

reglas comerciales	Color de la vela
close[0] > close[10] y close[0] > close[20]	verde
close[0] < close[10] y close[0] < close[20]	rojo
close[0] > close[10] y close[0] < close[20]	amarillo
close[0] < close[10] y close[0] > close[20]	amarillo

Para este modelo, necesitaremos añadir un color más a la propiedad indicator_color1.

#property indicator_color1  clrGreen,clrRed,clrYellow

Ahora, podremos definir nuestra regla en nuestro código y asignar los valores de acuerdo con ella. Este es el resultado dentro de la función OnCalculate;

  {
//---
   int start = prev_calculated;
   if(prev_calculated<20)
      start = 20;
   if(start>=rates_total)
      start = rates_total-1;

   for(int i = start; i<rates_total; i++)
     {
      CandleBuffer1[i]=open[i];
      CandleBuffer2[i]=high[i];
      CandleBuffer3[i]=low[i];
      CandleBuffer4[i]=close[i];

      //Close[0] > Close[10] and Close[0] > Close[20]
      bool buy = close[i]>close[i-10] && close[i]>close[i-20];

      //Close[0] < Close[10] and Close[0] < Close[20]
      bool sell  = close[i]<close[i-10] && close[i]<close[i-20];

      CandleColor[i]=(buy)?0:(sell)?1:2;
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }

Este es el resultado de nuestro nuevo indicador.

Ahora, echaremos un vistazo a la interfaz de usuario en la ventana de parámetros del indicador en Metatrader 5. Al clicar dos veces en el indicador dentro del gráfico de precios, se abrirá la ventana de parámetros. Podemos ver en la imagen de abajo que los colores se transmiten como parámetro sin informar sobre qué color hace referencia a la condición de compra, la condición de venta y la condición neutra. Si queremos trabajar con más colores, digamos 6, esto puede resultar confuso para el usuario. Por consiguiente, necesitaremos explicarle al usuario a qué se refiere cada color. Haremos esto en el último tema de este artículo.

Construcción del gráfico de velas con y sin relleno

Volvamos a nuestro código inicial, con las velas de un solo color. Recordemos que estamos usando el tipo de diseño DRAW_CANDLES con 4 búferes. Podemos distinguir entre el color de rellenado y el color de los bordes de la vela simplemente definiendo los dos colores en nuestra propiedad indicator_color1. Entonces, el primer color se usará para los bordes y el segundo para rellenar las velas. Para una demostración más visual, echemos un vistazo al resultado en blanco y negro.

#property indicator_type1   DRAW_CANDLES
#property indicator_color1  clrBlack,clrWhite

Si definimos 3 colores en nuestra propiedad indicator_color1, ahora dispondremos de una distinción entre velas alcistas y bajistas. Esta forma de construcción de las velas sustituye la primera regla de coloreado que creamos en este artículo. La gran diferencia es que continuamos con 4 búferes y podemos definir el color de los bordes. En este caso, el primer color se aplicará a los bordes de las velas; el segundo, para rellenar las velas alcistas, y el tercero, para rellenar las bajistas. Esta posibilidad se muestra a continuación: el tercer color se ha definido como gris oscuro para diferenciarlo de los bordes.

#property indicator_type1   DRAW_CANDLES
#property indicator_color1  clrBlack,clrWhite,clrDarkGray

Construcción de un gráfico de velas multicolores con y sin relleno

Para finalizar nuestro estudio sobre la creación de velas multicolores en MQL5, vamos a hacer más informativa la interfaz de usuario en la ventana de parámetros del indicador. Este es un paso intermedio para crear velas multicolores con y sin relleno. Además, el número de búferes necesarios para ambos es el mismo, pero superior al número de búferes en las versiones vistas hasta ahora. Esto se debe a que no dibujaremos un diseño para todos los colores, sino más bien para cada uno de ellos. En nuestro modelo tendremos 3 dibujos, uno para la compra, otro para la venta y otro para las demás condiciones, como dijimos al inicio del artículo. Es decir, tendremos 12 búferes para implementar este modelo. Además, usaremos la misma regla comercial basada en los precios desplazados vistos anteriormente.

Nuevamente, utilizaremos el Wizard MQL para saltarnos los pasos para definir e inicializar los 12 búferes. En lugar del diseño tipo Vela, usaremos los diseños: Comprar, Vender y Neutro.

No queremos que todos los dibujos se muestren simultáneamente. Queremos que, de acuerdo con la regla comercial, se muestre uno de los dibujos y se oculten los demás. Para ello, deberemos rellenar con un valor vacío los búferes de velas ocultos. El primer paso entonces será definir los valores para los cuales se deberá omitir el dibujado. Haremos esto usando la función PlotIndexSetDouble como se muestra a continuación.

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,BuyBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,BuyBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,BuyBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,BuyBuffer4,INDICATOR_DATA);
   SetIndexBuffer(4,SellBuffer1,INDICATOR_DATA);
   SetIndexBuffer(5,SellBuffer2,INDICATOR_DATA);
   SetIndexBuffer(6,SellBuffer3,INDICATOR_DATA);
   SetIndexBuffer(7,SellBuffer4,INDICATOR_DATA);
   SetIndexBuffer(8,NeutralBuffer1,INDICATOR_DATA);
   SetIndexBuffer(9,NeutralBuffer2,INDICATOR_DATA);
   SetIndexBuffer(10,NeutralBuffer3,INDICATOR_DATA);
   SetIndexBuffer(11,NeutralBuffer4,INDICATOR_DATA);

   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(2,PLOT_EMPTY_VALUE,0.0);

//---
   return(INIT_SUCCEEDED);
  }

En nuestro caso, usaremos el valor 0.0 para definir los valores vacíos en nuestros búferes. Los valores 0, 1 y 2 transmitidos como primer parámetro en la función PlotIndexSetDouble serán el índice del dibujo que se trazará en el gráfico de precios. Este índice es el mismo que usamos para declarar las propiedades de nuestros diseños de indicador.

Todo lo que tenemos que hacer ahora es trabajar en nuestra función OnCalculate, aplicando la regla comercial creada anteriormente. Como solo debemos mostrar uno de los dibujos, podemos definir todos los dibujos como no visibles asignando el valor 0.0 a todas las velas, cada vez que se llame a la función OnCalculate. A continuación, asignaremos los valores de apertura, máximo, mínimo y cierre a las velas en el dibujo que queremos mostrar según la regla comercial. El resultado del trabajo se muestra abajo.

  {
//---
   int start = prev_calculated;
   if(prev_calculated<20)
      start = 20;
   if(start>=rates_total)
      start = rates_total-1;

   for(int i = start; i<rates_total; i++)
     {
      //initializing the candles data
      BuyBuffer1[i]=0.0;
      BuyBuffer2[i]=0.0;
      BuyBuffer3[i]=0.0;
      BuyBuffer4[i]=0.0;

      SellBuffer1[i]=0.0;
      SellBuffer2[i]=0.0;
      SellBuffer3[i]=0.0;
      SellBuffer4[i]=0.0;

      NeutralBuffer1[i]=0.0;
      NeutralBuffer2[i]=0.0;
      NeutralBuffer3[i]=0.0;
      NeutralBuffer4[i]=0.0;

      //Close[0] > Close[10] e Close[0] > Close[20]
      bool buy= close[i]>close[i-10] && close[i]>close[i-20];

      //Close[0] < Close[10] e Close[0] < Close[20]
      bool sell= close[i]<close[i-10] && close[i]<close[i-20];

      //Setting the values to the candles according to the trading rules
      if(buy)
        {
         BuyBuffer1[i]=open[i];
         BuyBuffer2[i]=high[i];
         BuyBuffer3[i]=low[i];
         BuyBuffer4[i]=close[i];
        }
      else
         if(sell)
           {
            SellBuffer1[i]=open[i];
            SellBuffer2[i]=high[i];
            SellBuffer3[i]=low[i];
            SellBuffer4[i]=close[i];
           }
         else
           {
            NeutralBuffer1[i]=open[i];
            NeutralBuffer2[i]=high[i];
            NeutralBuffer3[i]=low[i];
            NeutralBuffer4[i]=close[i];
           }

     }

//--- return value of prev_calculated for next call
   return(rates_total);
  }

El resultado visual es exactamente igual al que hemos visto anteriormente al usar el tipo de dibujado DRAW_COLOR_CANDLES. La gran ventaja de este último método es que dispondremos de una interfaz de usuario más informativa, a pesar de que con ello aumentará significativamente el número de búferes necesarios. No obstante, podemos ampliar esta ventaja haciendo que nuestra regla de coloreado nos ofrezca no solo información sobre las reglas comerciales, sino también la distinción entre las velas alcistas y bajistas. Podemos hacer esto simplemente trabajando con los colores de los bordes y los rellenos de las velas que hemos visto anteriormente. Para cada diseño, querremos que los bordes y el relleno de las velas bajas sean del mismo color, mientras que para el relleno de las velas altas, usaremos el blanco para un recuadro de precios con fondo blanco, dando la así la ilusión de tener velas vacías. Este patrón de color se simplifica en el siguiente recuadro.

reglas comerciales	borde	relleno positivo	relleno negativo
comprar	verde	blanco	verde
vender	rojo	blanco	rojo
neutro	amarillo	blanco	amarillo

A continuación, mostramos los cambios en nuestro código.

#property indicator_color1  clrGreen,clrWhite,clrGreen

#property indicator_color2  clrRed,clrWhite,clrRed

#property indicator_color3  clrYellow,clrWhite,clrYellow

Así, hemos alcanzado el objetivo de este artículo; es decir, hemos demostrado cómo crear reglas de coloreado según alguna regla comercial, aplicando esta a un gráfico de velas con y sin relleno. El resultado final de nuestro trabajo se muestra en la siguiente imagen.

Conclusión

Hemos visto que podemos crear gráficos de velas usando dos tipos de diseño, DRAW_CANDLES y DRAW_COLOR_CANDLES, y también cómo aplicar al gráfico de velas una regla de coloreado basada en una regla comercial. Asimismo, hemos visto cómo diferenciar los colores entre los bordes y el relleno de las velas, lo cual nos permite colorear las velas manteniendo la distinción entre velas alcistas y bajistas. Es importante tener considerar que, según el propósito del indicador personalizado, la distinción entre velas altas y bajas puede no resultar relevante, además, si el número de colores es muy grande, por ejemplo, 10 o más, puede que no sea conveniente usar el último método presentado, ya que haría el número de búferes demasiado alto, lo que redundaría en un mayor uso del hardware de los usuarios.

En este caso, hay dos opciones que se pueden utilizar en lugar de explicar la aplicabilidad de cada color en la ventana de parámetros del indicador. Podemos usar el tipo de diseño DRAW_COLOR_CANDLES, o podemos usar el diseño DRAW_CANDLES para crear la ilusión de velas sin rellenar haciendo transparentes los bordes y el relleno de velas bajas en ese diseño, mientras que el relleno de las velas bajas será del color del plano inferior del gráfico de precios, provocando la distinción entre velas alcistas y bajistas superpuestas en el dibujo de DRAW_COLOR_CANDLES, para la aplicación del coloreado según la regla comercial.