Gráfico de montanha ou gráfico Iceberg

Introdução

Que tal adicionar um novo tipo de gráfico, ao nosso amado MetaTrader 5 ? Muita gente diz, que ele carece de algumas coisas, que já estão presentes em outras plataformas, mas a verdade, é que o MetaTrader 5, é uma plataforma muito prática, que nos permite fazer coisas, que em muitas das outras, não é possível de ser feita, pelo menos, não com tanta facilidade.

Uma das queixas que mais ouço, é que no MetaTrader 5 temos apenas 3 tipos de gráficos, CandleSticks, Barras e Linha. Mas será mesmo verdade ?!?! Ou será que tudo não passa de uma falta de conhecimento, sobre como de fato a plataforma funciona, ou as possibilidades que nos são dadas com a linguagem MQL5 ?!

Na maior parte das vezes, as pessoas que mais reclamam, são as que menos exploram a plataforma, muitas na verdade, querem a coisa pronta, e quando não está lá, no local onde imaginam que deveria estar, já começam a reclamar.

Pois bem, neste artigo, que não será muito longo, irei mostrar como você faz para criar um gráfico de estilo diferente, porém extremamente útil, para quem gosta de fazer alguns tipos de operação, como Swing Trade, Position Trade e até mesmo montagem e acompanhamento de uma carteira.

O gráfico em questão é o de montanha, mas não vamos nos restringir a um simples gráfico de montanha, vamos ir além das possibilidades deste gráfico, e aprender um pouco mais sobre como trabalhar com o MQL5, ao mesmo tempo que desenvolveremos um gráfico muito interessante para acompanhar nossas posições, isto sem precisar ficar ali tentando ver se a nossa operação está ou não nos dando lucro, pois bastará bater os olhos no gráfico, e você conseguirá identificar se esta no lucro ou prejuízo, em uma dada posição.

O gráfico de montanha, é muito parecido com o gráfico de linha, mas existem algumas pequenas diferenças aqui. No caso do gráfico de linha, que pode ser visto na Figura 01, tudo que você tem é uma indicação simples, de que se o preço está subindo ou descendo, nada mais além disto, mas no caso do gráfico de montanha, poderemos fazer muito mais do que isto, mas basicamente um gráfico de montanha pode ser visto na Figura 02.

Figura 01 - Típico gráfico de linha

Figura 02 - Gráfico de montanha típico.

Apesar de na maior parte das vezes, o gráfico de montanha mais conhecido ser o que vemos na figura 02, existem algumas variações do mesmo, que pode em alguns casos receber denominações diferentes. Mas uma das variações das mais básicas é o que podemos ver na figura 03.

Figura 03 - Gráfico Iceberg para posições compradas ...

Este tipo de gráfico da figura 03, é um dos mais fáceis de se ler, no caso especifico do gráfico visto na figura 03 é para quando estamos comprados, mas também podemos ter um para posições vendidas, e este irá ter uma aparência do visto na figura 04.

Figura 04 - Gráfico Iceberg para posições vendidas.

Talvez vocês não percebem logo de cara, mas ao observar estes gráficos Icebergs, você pode imediatamente saber se uma posição estará lhe dando lucro ou prejuízo, apenas observando a base de cores, ou seja apenas variando o próprio gráfico de montanha, podemos ter um outro estilo, cuja leitura é consideravelmente mais simples, para quem esta começando a estudar o mercado, e que gostaria de montar posições ou operações de prazo mais longo.

A parte interessante, é que o sistema que irei mostrar logo mais, é tão simples e ao mesmo tempo tão adaptativo, que nos permite não somente criar um gráfico do tipo montanha, ou iceberg, mas também um gráfico de linha, um pouco mais elaborado como pode ser visto na figura 05.

Figura 05 - Gráfico de linha de analise de posições

Mas também podemos modificar o estilo de linha, não ficando restritos apenas e somente ao tipo solido, assim podemos fazer um gráfico como mostrado na figura 06.

Figura 06 - Gráfico de linha para analise de posições compradas

Você deve estar pensando: Teremos que criar algum tipo de código extremamente complicado, ou muito difícil de ser feito ou compreendido. Mas por mais incrível que possa parecer, o código que iremos criar, é bastante simples e muito, mas muito fácil de ser entendido, mesmo por iniciantes na linguagem MQL5, por conta disto pode ser um bom ponto de partida, para quem deseja aprender algumas coisas sobre como a plataforma trabalha, e desta forma gerar coisas um pouco mais complexas.

O que nosso código de criação do gráfico, estilo montanha ou iceberg faz, é muito similar ao que o gráfico, ou melhor dizendo indicador Heiken-Ashi faz, mas diferente deste indicador heiken-Ashi, o nosso sistema irá produzir um gráfico 100% limpo, como você podem ver nas imagens acima, com isto não teremos nenhum tipo de contaminação, com base em alguma coisa relacionada aos estilos gráficos presentes por padrão no MetaTrader 5.

Mas o fato de criamos um gráfico diferente, não implica que você ficará impossibilitado de colocar os seus indicadores favoritos nele, você poderá utilizar todos os indicadores, EAs, Scripts ou qualquer coisa que era utilizada antes, neste novo estilo gráfico, sem precisar fazer nenhuma adaptação ou mudança nos códigos, o que é excelente, dada a quantidade de coisas que podem vim a aparecer com o tempo.

Então chega de conversa e vamos ver a forma de implementar este novo sistema gráfico para o MetaTrader 5.

Implementação

Ao observar as figuras vistas acima, você já deve estar imaginando, pelo menos, como será a criação do gráfico, pelo menos a parte referente e vista na figura 05 e na figura 06. O que vem logo na mente é: Tratasse de uma média móvel. É, de fato temos a plotagem de uma média móvel tanto na figura 05, quanto na figura 06. Algo muito parecido com o da figura 01, mas com apenas a diferença de que temos cores diferentes, por algum motivo qualquer. Mas e quanto as demais figuras ?!?!

Qual é o segredo para produzir o gráfico da figura 02, figura 03 e figura 04 ?!?! Você consegue imaginar uma forma de fazer isto, de maneira a não sobrecarregar a plataforma MetaTrader 5 ?!?!

Pois bem, na verdade todas as figuras, com exceção da figura 01 que de fato tratasse do gráfico de linha, presente por padrão, na plataforma MetaTrader 5, todos os demais são criados da mesma forma, utilizando uma média móvel, mesmo os gráficos icebergs, são feitos da mesma forma.

Para entender, vamos começar vendo o código, e ele é bastante simples e começa com as seguintes linhas:

#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

Nesta linha, definimos onde está o arquivo de imagem que será utilizado como sendo o ícone do nosso sistema. Também dizemos, que iremos utilizar o indicador, sim o gráfico será um indicador, na janela principal do gráfico do ativo.

Agora vem uma parte importante, nos vamos utilizar 2 buffers, mas ( e ênfase nesta palavra MAS ) eles não serão utilizados da forma como você já deve estar imaginando, então prestem atenção a este detalhe, e iremos plotar 1 indicador, e novamente as coisas não são exatamente como estão sendo declaradas, aqui neste inicio.

Lembre-se do seguinte: Temos 3 tipos de gráficos possíveis : Um do tipo linha multicolorida, um do tipo Iceberg e outro do tipo Montanha ...então não se apegue muito as informações declaradas neste começo.

Logo depois, temos algumas declarações simples, no entanto necessárias para que tudo funcione corretamente:

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;

Aqui declaramos de fato os dois buffers que precisamos e iremos utilizar, logo depois criamos uma enumeração para nos ajudar a escolher se o gráfico será do tipo linha, iceberg ou montanha. Agora vem a questão que trata justamente da interação com o usuário, esta irá dizer como o gráfico será apresentado e qual o tipo que veremos na tela. Temos as seguintes combinações:

Tipo de gráfico	Valor contido em user01	Valor contido em user02
Gráfico de linha de cor única	Valor igual a 0	Valor indicando contorno
Gráfico de linha multicolorida	Valor do preço de corte	Valor indicando contorno
Gráfico de montanha	Valor igual a 0	Valor indicando preenchimento
Gráfico de Iceberg	Valor do preço da linha d'agua	Valor indicando preenchimento

Entender esta tabela acima, irá ajudar a você a selecionar o tipo de gráfico que você irá ver na tela. Mas para deixar as coisas bem claras, no final deste artigo, você terá um video que mostra, cada uma das configurações e o resultado obtido.

Assim você poderá entender melhor, já que apenas observando o código, algumas coisas não serão devidamente entendidas logo de inicio. Não deixe de ver o video, pois ele irá lhe ajudar muito a entender cada uma das possíveis combinações, já que aqui, não é mostrado como mudar as cores, mas no video você verá como fazer a mudança.

Já a estrutura, não se preocupe com ela, ela serve apenas como memória para armazenarmos algumas informações, que você irão ver do que se trata mais a frente.

Feito isto, passemos a primeira função do nosso sistema gráfico:

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

Esta função é super simples, ela simplesmente indica um nome para o nosso indicador e chama uma função para iniciar o gráfico, até poderia colocar o conteúdo desta função chamada aqui, mas gosto de separar bem as coisa, e deixar o código sempre, o mais organizado possível.

A próxima função na sequencia, é vista logo abaixo:

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;
}

Novamente, temos uma função super simples, e ela de fato precisa ser bem simples, já que a cada ticket de preço, ou variação do mesmo, iremos ter que executá-la, isto por que a plataforma MetaTrader 5 irá gerar um evento, cujo resultado é a chamada da função OnCalculate, então precisamos que esta função execute de forma muito rápida.

Por conta que não queremos e não devemos recalcular toda a serie de dados desde o inicio, a cada chamada da função, utilizamos este calculo simples, que irá sempre ajustar as coisas de forma adequada, desta forma iremos sempre ter a execução o mais rápido quanto for possível fazer, tendo apenas uma pequena demora no começo, mas depois a coisa é extremamente rápida.

Agora prestem atenção ao seguinte fato: Aqui iremos receber da plataforma MetaTrader 5 apenas e somente um único tipo de valor, este é selecionado na caixa de mensagem do indicador, os possíveis valores que serão enviados pelo MetaTrader 5 para nosso indicador são visto na figura 08

Figura 08 - Tipos de valores enviados do MetaTrader 5 para o indicador.

Então este valor, seja ele qual for, será utilizado no buffer01, este buffer é um dos que precisamos e faremos uso. Já o buffer02 irá receber um valor que irá depender do que estamos criando, e por que disto ?!?!

O motivo é que iremos utilizar dois estilos diferentes de desenho. Em um estilo, o buffer02, irá receber um valor que é o valor de corte ou linha d'agua, quando o valor de linha d'agua for maior que 0, e o zero é pelo motivo que nenhum ativo pode ser negociado abaixo deste valor, por não fazer sentido um ativo com valor negativo, teremos como resultado, caso estejamos usando a forma de preenchimento, uma montanha igual é visto na figura 02, agora se ainda assim estivermos utilizando o modo de preenchimento.

Mas se o valor da linha d'agua for diferente de zero, teremos a modelagem de um gráfico iceberg, muito parecido com os vistos nas figura 03 e 04, da mesma forma, se estivermos utilizando o modo contorno, e a linha d'agua for 0 teremos um gráfico de linha, mas diferente do gráfico de linha presente por padrão no MetaTrader 5.

Poderemos indicar a espessura e o estilo de linha que será plotado, desta forma teremos como resultado um gráfico parecido com os da figura 05 e figura 06, se bem que nestes gráficos estamos utilizando um valor de linha d'agua diferente de zero, por conta disto que eles tem cores distintas em cada trecho de linha.

A próxima rotina na sequencia é vista logo a seguir:

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

Esta simplesmente encerra o indicador, fazendo com que o gráfico volte ao seu estado original. Então vamos ver a próxima rotina que de fato precisará de uma explicação de como 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();
}

Assim que esta é chamada, iremos capturar qual o identificador do gráfico no qual o nosso indicador irá ser aplicado. Esta captura é importante para as rotinas de limpeza e reposição do gráfico, estas rotinas serão vistas depois. Agora prestem muita, mas muita atenção ao seguinte fato: Quando o usuário indica que estaremos preenchendo o gráfico, iremos utilizar este modelo de desenho, e quando iremos fazer apenas o contorno, faremos isto utilizando este outro modelo de desenho.

Por conta disto é que nem tudo se parece como alguns podem achar, logo que veem o código no inicio, mas tem um detalhe, ambos modelos utilizam 2 buffers, mas o modelo DRAW_FILLING utiliza ambos buffers com dados, e o modelo DRAW_COLOR_LINE utiliza um buffer com dados e o outro com cor, este fato nos força a fazermos aquela variação na rotina de calculo, onde precisamos acertas as coisas, caso contrário não iriam de fato ter o desenho desejado.

Obrigatoriamente, o buffer01 irá ser sempre utilizado, como um sistema de dados, e isto é indicado aqui. Já o buffer02, irá se adaptar ao que queremos e precisamos plotar, podendo conter dados ou index de cor. Prestem atenção a isto, não estou dizendo, que o buffer02 irá conter a cor utilizada, e você NÃO deve tentar colocar uma cor nele, você na verdade deverá colocar um index, indicado qual será a cor utilizada, por conta disto que na rotina de calculo, não usei nenhuma informação de cor e sim o valor 0 e 1, já que iremos trabalhar apenas e somente com duas cores.

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

mas vamos continuar, a próxima coisa que faremos, é justamente isto, definir que estaremos utilizando uma matriz de duas cores, agora o rotulo que estamos utilizando aqui, será visto tanto na linha d'agua, quando você posicionar o mouse ali, quando no momento que estiver selecionando e definindo as cores, estou utilizando ele apenas para mostrar como você pode rotular as informações, pode ser que este conhecimento lhe ajude em algum momento do futuro.

Agora fazemos a definição default das cores a serem utilizadas, estas não poderão ser mudadas pelo usuário no primeiro momento, ele terá que primeiro colocar o indicador no gráfico, para somente depois fazer a mudança destas cores, mas isto está demonstrado claramente no video disponível no final do artigo.

E no final indicados a partir de qual posição o nosso gráfico será desenhado, se bem que isto não seria necessário neste caso especifico, mas quero que vocês vejam como isto é feito de fato.

Com isto podemos passar para as duas ultimas rotinas utilitárias do nosso micro sistema de gráfico, a função HideBars é a responsável por fazer com que o esquema padrão do MetaTrader 5 seja ocultado, ou seja iremos ocultar o padrão gráfico presente no MetaTrader 5, isto é feito de uma forma super simples, mas não queremos que o usuário nos xingue caso as coisas deem errado, ou ele encerre o uso do indicador, então armazenamos os dados originais para depois repor eles, quando o indicador for retirado do gráfico do ativo, assim conseguimos fazer com que o padrão de cores original, retorne sem nenhuma dor de cabeça para o usuário.

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();
}

A reposição dos dados de volta, faz com que no final, o usuário nem perceba ou precise reconfigurar as coisas, é sempre muito bom quando isto acontece, desta forma você se sente mais confortável para poder utilizar um sistema especifico.

É bem verdade que o usuário pode assustar um pouco quando o indicador for retirado da tela, já que demora um pouco para que o gráfico seja totalmente repintado, mas as coisas de fato irão voltar ao original, da forma como era antes da aplicação do indicador.

Video de demonstração de uso ( IMPORTANTE SER VISTO )

Conclusão

Aqui neste artigo, demonstrei que tanto o MQL5, quanto a própria plataforma MetaTrader 5, é capaz de produzir muito mais coisas do que muitos de fato imaginam ser possível, e fiz isto de uma maneira bastante simples, e que pode lhe ajudar a entender diversas outras coisas.

A grande questão é que muita gente, fica por ai dizendo isto ou aquilo sobre a plataforma, ou a linguagem MQL5, quando na verdade nem se dão ao trabalho de realmente pesquisar, e tentar explorar o que de fato é ou não possível ser feito, apenas ficam falando e repetindo o que muitos falam, sem de fato saber como fazer as coisas.

Sempre que você ver alguém dizendo que a plataforma MetaTrader 5, ou a linguagem MQL5 é limitada, não tendo certos recurso, mostrem para eles, que a única coisa de fato limitada, é a criatividade ou o conhecimento deles, e que na verdade eles dizem isto por não saber nada de programação, e se quer entendem de fato qual a proposta da plataforma MetaTrader T5, que é ser uma plataforma funcional, segura, rápida, mas principalmente uma plataforma onde o nível de customização é levada a um outro patamar, onde você consegue fazer com que a plataforma venha a ficar com a sua cara.