Gráfico de montaña o gráfico de iceberg

Introducción

¿Qué tal si añadimos un nuevo tipo de gráfico a MetaTrader 5? Mucha gente dice que le faltan algunas cosas que ya están presentes en otras plataformas, pero lo cierto es que MetaTrader 5 es una plataforma muy práctica que nos permite hacer cosas que no es posible hacer en muchas otras plataformas, al menos no tan fácilmente.

Una de las quejas que más escucho es que en MetaTrader 5 sólo tenemos 3 tipos de gráficos, velas, barras y líneas. Pero, ¿es esto realmente cierto? ¿O se trata simplemente de una falta de conocimiento sobre el funcionamiento real de la plataforma o las posibilidades que se nos ofrecen con el lenguaje MQL5?

La mayoría de las veces, los que más se quejan son los que menos exploran la plataforma, muchos, de hecho, quieren que las cosas estén listas, y cuando no están ahí, en el lugar donde imaginan que deberían estar, ya empiezan a quejarse.

Pues bien, en este artículo, que no será muy largo, mostraré cómo crear un gráfico con un estilo diferente, pero extremadamente útil, para quienes gustan de hacer algunos tipos de trading, como swing trade, position trade e incluso montaje y seguimiento de una cartera.

El gráfico en cuestión es el gráfico de montaña, pero no nos limitaremos a un simple gráfico de montaña, iremos más allá de las posibilidades de este gráfico y aprenderemos un poco más sobre cómo trabajar con MQL5, a la vez que desarrollaremos un gráfico muy interesante para seguir nuestras posiciones, sin tener que quedarnos ahí intentando ver si nuestra operación nos está dando o no beneficios, ya que bastará con pegar nuestros ojos al gráfico, y podremos identificar si estamos con beneficios o pérdidas, en una posición determinada.

El gráfico de montaña es muy similar al gráfico de líneas, pero existen algunas diferencias menores. En el caso del gráfico de líneas, que se puede ver en la Figura 01, todo lo que se tiene es una simple indicación de si el precio está subiendo o bajando, nada más que esto, pero en el caso del gráfico de montaña, podremos hacer mucho más que esto, un gráfico de montaña se puede ver en la Figura 02.

Figura 01 - Gráfico de líneas típico

Figura 02 - Gráfico de montaña típico

Aunque la mayoría de las veces el gráfico de montaña más conocido es el que vemos en la figura 02, existen algunas variaciones del mismo, que en algunos casos pueden recibir nombres diferentes. Pero una de las variaciones más básicas es la que podemos ver en la figura 03.

Figura 03 - Gráfico de iceberg para posiciones de compra

Este tipo de gráfico, figura 03, es uno de los más fáciles de leer, en el caso concreto del gráfico visto en la figura 03 es para cuando estamos comprando, pero también podemos tener uno para posiciones de venta, y este tendrá el aspecto visto en la figura 04.

Figura 04 - Gráfico iceberg para posiciones de venta

Quizás ustedes no se den cuenta enseguida, pero observando estos gráficos iceberg, pueden saber inmediatamente si una posición les va a dar beneficios o pérdidas, simplemente observando la base cromática, es decir, simplemente variando el propio gráfico de montaña, podemos tener otro estilo, cuya lectura es bastante más sencilla, para aquellos que están empezando a estudiar el mercado, y que quieran establecer posiciones u operaciones a más largo plazo.

Lo interesante es que el sistema que les mostraré más adelante es tan sencillo y a la vez tan adaptable, que nos permite no sólo crear un gráfico de montaña o iceberg, sino también un gráfico de líneas, un poco más elaborado como puede verse en la figura 05.

Figura 05 - Gráfico de líneas de análisis de posición

Pero también podemos modificar el estilo de línea, no restringiéndonos sólo y únicamente al tipo sólido, por lo que podemos hacer un gráfico como el que se muestra en la figura 06.

Figura 06 - Gráfico de líneas para análisis de posiciones de compra

Quizá estén pensando: tendremos que crear algún tipo de código extremadamente complicado o muy difícil de hacer o de entender. Pero por increíble que parezca, el código que vamos a crear es bastante sencillo y muy, muy, muy fácil de entender, incluso para principiantes en el lenguaje MQL5, por lo que puede ser un buen punto de partida para aquellos que quieran aprender algunas cosas sobre el funcionamiento de la plataforma, y así generar cosas un poco más complejas.

Lo que hace nuestro código para crear el gráfico de montaña o iceberg es muy similar a lo que hace el indicador Heiken-Ashi, pero a diferencia del indicador Heiken-Ashi, nuestro sistema producirá un gráfico 100% limpio, como se puede ver en las imágenes de arriba, por lo que no tendremos ningún tipo de contaminación relacionada con los estilos de gráficos presentes por defecto en MetaTrader 5.

Pero el hecho de crear un gráfico diferente, no implica que no se puedan poner nuestros indicadores favoritos en él, se podrán utilizar todos los indicadores, EAs, Scripts o cualquier cosa que se utilizaba antes con este nuevo estilo de gráfico, sin tener que hacer ninguna adaptación o cambio en los códigos, lo cual es excelente, dada la cantidad de cosas que pueden surgir con el tiempo.

Así que basta de hablar y vamos a ver cómo implementar este nuevo sistema de gráficos para MetaTrader 5.

Implementación

Al observar las figuras vistas anteriormente, ya se deben estar preguntando, por lo menos, cómo será la creación del gráfico, por lo menos la parte referente y vista en la Figura 05 y Figura 06. Lo que me viene inmediatamente a la mente es que se trata de una media móvil. Y lo es, de hecho, tenemos el trazado de una media móvil tanto en la figura 05 como en la figura 06. Algo muy parecido a lo de la figura 01, pero con la única diferencia de que tenemos colores diferentes, por alguna razón. ¡¿Pero qué pasa con las otras figuras?!

¿Cuál es el secreto para producir el gráfico de la figura 02, la figura 03 y la figura 04? ¿Se les ocurre alguna forma de hacerlo para no sobrecargar la plataforma MetaTrader 5?

Bueno, de hecho todos los gráficos, a excepción de la figura 01 que es de hecho un gráfico de líneas, presente por defecto en la plataforma MetaTrader 5, todos los demás se crean de la misma manera, utilizando una media móvil, incluso los gráficos iceberg se hacen de la misma manera.

Para entenderlo, empecemos por ver el código, que es bastante sencillo y empieza con las siguientes líneas:

#property copyright "Daniel Jose"
#property icon "\\Images\\Icons\\Mountain Chart.ico"
#property description "This indicator allows you to create a mountain chart"
#property description "Whose average price can be indicated facilitating market analysis"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots 1

En esta línea, definimos dónde está el archivo de imagen que se utilizará como icono de nuestro sistema. También decimos que utilizaremos el indicador -sí el gráfico será un indicador- en la ventana principal del gráfico del activo.

Ahora viene una parte importante, usaremos 2 buffers, pero (y énfasis en esta palabra, PERO) no se usarán de la manera que ya se están imaginando, así que presten atención a este detalle, y trazaremos 1 indicador, y de nuevo las cosas no son exactamente como se están declarando aquí en este comienzo.

Recuerden lo siguiente, disponemos de 3 tipos de gráficos posibles, uno de líneas multicolores, otro de tipo iceberg y otro de tipo montaña... así que no te apegues demasiado a la información declarada en este inicio.

Justo después, tenemos algunas declaraciones sencillas, pero necesarias para que todo funcione correctamente:

double Buff1[], Buff2[];
//+------------------------------------------------------------------+
enum eType {Fill, Contour};
//+------------------------------------------------------------------+
input double    user01 = 0.0;   //Analysis price
input eType     user02 = Fill; //Type of Mountain
//+------------------------------------------------------------------+
struct st0
{
        long    id;
        color 	CandleBear,
                CandleBull,
                CandleLine,
                LineUp,
                LineDown;
}_memConfig;

Aquí declaramos los dos buffers que necesitamos y utilizaremos, luego creamos una enumeración para ayudarnos a elegir si el gráfico será de tipo línea, iceberg o montaña. Ahora viene la parte que trata precisamente de la interacción con el usuario, ésta dirá cómo se presentará el gráfico y qué tipo veremos en la pantalla. Tenemos las siguientes combinaciones:

Tipo de gráfico	Valor contenido en user01	Valor contenido en user02
Gráfico de línea de un solo color	Valor igual a 0	Valor que indica el contorno
Gráfico de líneas multicolores	Valor del precio de corte	Valor que indica el contorno
Gráfico de montaña	Valor igual a 0	Valor que indica relleno
Gráfico de iceberg	Valor del precio de la línea de flotación	Valor que indica relleno

Comprender esta tabla les ayudará a seleccionar el tipo de gráfico que verán en la pantalla. Pero para dejar las cosas bien claras, al final de este artículo, tendrán un video que muestra cada uno de los ajustes y el resultado obtenido.

Así ustedes podrán entender mejor, ya que sólo viendo el código, algunas cosas no se comprenderán bien a la primera. No dejen de ver el video, porque les ayudará mucho a entender cada una de las posibles combinaciones, ya que aquí no se muestra cómo cambiar los colores, pero en el video verán cómo hacer el cambio.

En cuanto a la estructura, no se preocupen, sólo sirve de memoria para almacenar cierta información, que ya verán más adelante.

Una vez hecho esto, pasemos a la primera función de nuestro sistema de gráficos:

int OnInit()
{
        IndicatorSetString(INDICATOR_SHORTNAME, "Mountain Chart");
        Init_MountainChart();
        
        return INIT_SUCCEEDED;
}

Esta función es super simple, simplemente indica un nombre para nuestro indicador y llama a una función para iniciar el gráfico, incluso podría poner el contenido de esta función llamada aquí, pero me gusta separar bien las cosas, y dejar el código siempre lo más organizado posible.

La siguiente función en la secuencia se ve a continuación:

int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
{       
        for (int c0 = (prev_calculated == 0 ? 0 : prev_calculated - 1); c0 < rates_total; c0++)
        {
                Buff1[c0] = price[c0];
                Buff2[c0] = (user02 == Fill ? user01 : (price[c0] > user01 ? 0 : 1));
        }

        return rates_total;
}

De nuevo, tenemos una función super simple, y realmente necesita ser muy simple, porque en cada ticket de precio o variación de precio, tendremos que ejecutarla, porque la plataforma MetaTrader 5 generará un evento, cuyo resultado es la llamada a la función OnCalculate, así que necesitamos que esta función se ejecute de una manera muy rápida.

Como no queremos y no tenemos que recalcular toda la serie de datos desde el principio, en cada llamada de la función, usamos este simple cálculo, que siempre ajustará las cosas de forma adecuada, de esta forma siempre tendremos la ejecución lo más rápida posible, teniendo solo un pequeño retraso al principio, pero después es extremadamente rápida.

Ahora preste atención al siguiente hecho: Aquí vamos a recibir de la plataforma MetaTrader 5 sólo y sólo un tipo de valor, esto se selecciona en la ventana de mensaje del indicador, los posibles valores que serán enviados por MetaTrader 5 a nuestro indicador se ven en la figura 08

Figura 08 - Tipos de valores enviados desde MetaTrader 5 al indicador

Así que este valor, cualquiera que sea, se utilizará en buffer01, este buffer es uno que necesitamos y utilizaremos. Buffer02 recibirá un valor que dependerá de lo que estemos creando, ¿y eso por qué?

La razón es que utilizaremos dos estilos de trazado diferentes. En un estilo, el buffer02 recibirá un valor que es el valor de corte o línea de flotación, cuando el valor de la línea de flotación es mayor que 0, y el cero, que es porque no se puede negociar ningún activo por debajo de este valor, y por no tener sentido un activo con un valor negativo, tendremos como resultado, si estamos utilizando el modo de relleno, una montaña como se ve en la imagen 02, ahora si todavía estamos utilizando el modo de relleno.

Pero si el valor de la línea de flotación es distinto de cero, tendremos modelado un gráfico de iceberg, muy similar a los vistos en las figuras 03 y 04, igualmente, si estamos utilizando el modo contorno y la línea de flotación es 0, tendremos un gráfico de líneas, pero diferente al gráfico de líneas por defecto en MetaTrader 5.

Podemos indicar el grosor y el estilo de línea que se trazará, de esta forma tendremos como resultado un gráfico similar a los de la figura 05 y figura 06, aunque en estos gráficos estamos utilizando un valor de línea de flotación diferente de cero, por ello tienen colores diferentes en cada tramo de línea.

La siguiente rutina de la secuencia se ve inmediatamente a continuación:

void OnDeinit(const int reason)
{
        ShowBars();
}

Ésta simplemente finaliza el indicador, haciendo que el gráfico vuelva a su estado original. Así que veamos la siguiente rutina que sí necesitará una explicación de cómo funciona.

void Init_MountainChart(void)
{
        _memConfig.id = ChartID();
        PlotIndexSetInteger(0, PLOT_DRAW_TYPE, (user02 == Fill ? DRAW_FILLING : DRAW_COLOR_LINE));
        SetIndexBuffer(0, Buff1, INDICATOR_DATA);
        SetIndexBuffer(1, Buff2, (user02 == Fill ? INDICATOR_DATA : INDICATOR_COLOR_INDEX));
        PlotIndexSetInteger(0, PLOT_COLOR_INDEXES, 2);
        PlotIndexSetString(0, PLOT_LABEL, "MidPoint");  
        PlotIndexSetInteger(0, PLOT_LINE_COLOR, 0, clrForestGreen);
        PlotIndexSetInteger(0, PLOT_LINE_COLOR, 1, clrFireBrick);       
        PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, 0);
        HideBars();
}

Una vez llamada esta rutina, capturaremos a qué identificador de gráfico se aplicará nuestro indicador. Esta captura es importante para las rutinas de limpieza y reinicio del gráfico, estas rutinas se verán más adelante. Ahora prestemos atención al siguiente detalle: Cuando el usuario nos indique que vamos a rellenar el gráfico, utilizaremos esta modelo de diseño, y cuando sólo vayamos a hacer el contorno, lo haremos utilizando este otro modelo de diseño.

Debido a esto, no todo parece como algunos pueden pensar, en cuanto ven el código al principio, y es que hay un detalle, ambos modelos utilizan dos buffers, pero el modelo DRAW_FILLING utiliza ambos buffers con datos, y el modelo DRAW_COLOR_LINE utiliza un buffer con datos y el otro con color, este hecho nos obliga a hacer esa variación en la rutina de cálculo, donde necesitamos hacer las cosas bien, ya que de lo contrario no tendrían realmente el trazado deseado.

Obligatoriamente, siempre se utilizará el buffer01 como sistema de datos, y así se indica aquí. El buffer02 se adaptará a lo que queramos y necesitemos graficar, pudiendo contener datos o índice de colores. Presten atención a esto, no estoy diciendo que el buffer02 contendrá el color utilizado, y NO deben tratar de poner un color en él, en realidad se debe poner un índice, que indica qué color se utilizará, por esto es que en la rutina de cálculo no he utilizado ninguna información de color y sí el valor 0 y 1, ya que vamos a trabajar sólo y únicamente con dos colores.

                Buff2[c0] = (user02 == Fill ? user01 : (price[c0] > user01 ? 0 : 1));

Pero continuemos, lo siguiente que haremos es exactamente esto, definir que estaremos usando una matriz de dos colores, ahora la etiqueta que estamos usando aquí se verá tanto en la línea de flotación, cuando posicionemos el mouse ahí, cuando estemos seleccionando y definiendo los colores, lo estoy usando solo para mostrar como podemos etiquetar la información, tal vez este conocimiento les ayude en el futuro.

Ahora definimos los colores por defecto a utilizar, estos no pueden ser cambiados por el usuario en un primer momento, primero tendrá que poner el indicador en el gráfico, y sólo entonces, cambiar estos colores, pero esto se muestra claramente en el vídeo disponible al final del artículo.

Y al final indicamos desde qué posición se trazará nuestro gráfico, aunque esto no sería necesario en este caso concreto, pero quiero que vean cómo se hace en realidad.

Con esto podemos pasar a las dos últimas rutinas de nuestro micro sistema de gráficos, la función HideBars es la encargada de hacer que se oculte la disposición de gráficos por defecto de MetaTrader 5, es decir, ocultaremos el esquema de gráficos presente en el MetaTrader 5, esto se hace de una forma super sencilla, pero no queremos que el usuario nos ponga el grito en el cielo en caso de que las cosas vayan mal, o dé por finalizado el uso del indicador, así que almacenaremos los datos originales para restaurarlos más tarde, cuando se elimine el indicador del gráfico del activo, de forma que podamos hacer que el esquema de colores original vuelva sin quebraderos de cabeza para el usuario.

void HideBars(void)
{
        _memConfig.CandleBear   = (color) ChartGetInteger(_memConfig.id, CHART_COLOR_CANDLE_BEAR);
        _memConfig.CandleBull   = (color) ChartGetInteger(_memConfig.id, CHART_COLOR_CANDLE_BULL);
        _memConfig.CandleLine   = (color) ChartGetInteger(_memConfig.id, CHART_COLOR_CHART_LINE);
        _memConfig.LineUp       = (color) ChartGetInteger(_memConfig.id, CHART_COLOR_CHART_UP);
        _memConfig.LineDown     = (color) ChartGetInteger(_memConfig.id, CHART_COLOR_CHART_DOWN);
        ChartSetInteger(_memConfig.id, CHART_COLOR_CANDLE_BEAR, clrNONE);
        ChartSetInteger(_memConfig.id, CHART_COLOR_CANDLE_BULL, clrNONE);
        ChartSetInteger(_memConfig.id, CHART_COLOR_CHART_LINE, clrNONE);
        ChartSetInteger(_memConfig.id, CHART_COLOR_CHART_UP, clrNONE);
        ChartSetInteger(_memConfig.id, CHART_COLOR_CHART_DOWN, clrNONE);
        ChartRedraw();
}
//+------------------------------------------------------------------+
void ShowBars(void)
{
        ChartSetInteger(_memConfig.id, CHART_COLOR_CANDLE_BEAR, _memConfig.CandleBear);
        ChartSetInteger(_memConfig.id, CHART_COLOR_CANDLE_BULL, _memConfig.CandleBull);
        ChartSetInteger(_memConfig.id, CHART_COLOR_CHART_LINE, _memConfig.CandleLine);
        ChartSetInteger(_memConfig.id, CHART_COLOR_CHART_UP, _memConfig.LineUp);
        ChartSetInteger(_memConfig.id, CHART_COLOR_CHART_DOWN, _memConfig.LineDown);
        ChartRedraw();
}

Al restablecer los datos se consigue que, al final, el usuario ni siquiera note o necesite reconfigurar las cosas, siempre es estupendo cuando esto ocurre, de esta forma uno se siente más cómodo al poder utilizar un sistema específico.

Es cierto que el usuario puede asustarse un poco cuando se retira el indicador de la pantalla, ya que el gráfico tarda un rato en volver a estar completamente pintado, pero, efectivamente, las cosas volverán a ser como antes de aplicar el indicador.

Video de demostración (IMPORTANTE VER)

Conclusión

Aquí en este artículo, he demostrado que tanto MQL5 como la propia plataforma MetaTrader 5 son capaces de producir muchas más cosas de lo que muchos realmente imaginan posible, y lo he hecho de una manera muy sencilla que puede ayudarles a entender varias otras cosas.

El gran problema es que mucha gente va por ahí diciendo esto o lo otro sobre la plataforma o sobre el lenguaje MQL5, cuando en realidad ni siquiera se toman la molestia de investigar realmente y tratar de explorar lo que de hecho es o no es posible hacer, simplemente siguen hablando y repitiendo lo que muchos dicen, sin saber realmente cómo hacer las cosas.

Cada vez que veas a alguien diciendo que la plataforma MetaTrader 5 o el lenguaje MQL5 es limitado, que no tiene ciertas características, muéstrenles que lo único que en realidad está limitado es su creatividad o sus conocimientos, y que en realidad lo dicen porque no saben nada de programación, y no entienden realmente el propósito de la plataforma MetaTrader5, que es ser una plataforma funcional, segura, rápida, pero sobre todo una plataforma donde el nivel de personalización se lleva a otro nivel, donde se puede hacer que la plataforma se adapte a cada uno de nosotros.