Descargar MetaTrader 5

DRAW_COLOR_ZIGZAG

El estilo DRAW_COLOR_ZIGZAG dibuja segmentos de diferentes colores, usando valores de dos búfers indicadores. Este estilo es la versión de colores del estilo DRAW_ZIGZAG. Es decir, permite fijar para cada segmento su propio color desde un conjunto de colores predefinido previamente. Los segmentos se trazan desde un valor en el primer búfer indicador hasta un valor en el segundo. Ninguno de los dos búferes puede contener sólo valores vacíos. Si es así, no se dibuja nada.

El grosor, color y el estilo de la línea se puede establecer de la misma manera como para el estilo DRAW_ZIGZAG — con las directivas del compilador, o bien dinámicamente, utilizando 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.

Los segmentos se trazan desde un valor no vacío de un búfer hasta otro valor no vacío de otro búfer indicador. 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_ZIGZAG,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_ZIGZAG – 3:

  • dos búfers para almacenar los valores de los extremos de un segmento del zigzag;
  • un búfer para almacenar el índice de color con el que se colorea el segmento (tiene sentido establecer sólo para los valores no vacíos).

Aquí tenemos un ejemplo del indicador que traza la sierra a base de los precios High y Low. El color, grosor y el estilo de la línea del zigzag se cambian de forma aleatoria cada N tics.

Ejemplo del estilo DRAW_COLOR_ZIGZAG

Fíjense, inicialmente para la construcción gráfica plot1 con el estilo DRAW_COLOR_ZIGZAG se establecen 8 colores mediante la directiva del compilador #property, y luego en la función OnCalculate() el color se elige aleatoriamente de 14 colores que se guardan en el array colors[].

El parámetro N está pasado 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).

//+------------------------------------------------------------------+
//|                                            DRAW_COLOR_ZIGZAG.mq5 |
//|                        Copyright 2011, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
 
#property description "Indicador para demostrar DRAW_COLOR_ZIGZAG"
#property description "Dibuja una línea quebrada con segmentos de colores, el color depende del número del día de la semana"
#property description "El color, grosor y el estilo de segmentos se cambia de forma aleatoria"
#property description " dentro de cada N tics"
 
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_plots   1
//--- plot Color_Zigzag
#property indicator_label1  "Color_Zigzag"
#property indicator_type1   DRAW_COLOR_ZIGZAG
//--- estableceremos 8 colores para colorear los segmentos (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ámetro input
input int      N=5;              // número de tics a cambiar 
int            color_sections;
//--- búfers de valores de los extremos de segmentos
double         Color_ZigzagBuffer1[];
double         Color_ZigzagBuffer2[];
//--- búfer de los índices de color para los extremos de los segmentos
double         Color_ZigzagColors[];
//--- el array para almacenar colores tiene 14 elementos
color colors[]=
  {
   clrRed,clrBlue,clrGreen,clrChocolate,clrMagenta,clrDodgerBlue,clrGoldenrod,
   clrIndigo,clrLightBlue,clrAliceBlue,clrMoccasin,clrWhiteSmoke,clrCyan,clrMediumPurple
  };
//--- array para almacenar estilos de trazado de la línea
ENUM_LINE_STYLE styles[]={STYLE_SOLID,STYLE_DASH,STYLE_DOT,STYLE_DASHDOT,STYLE_DASHDOTDOT};
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,Color_ZigzagBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,Color_ZigzagBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,Color_ZigzagColors,INDICATOR_COLOR_INDEX);
//---- número de colores para colorear el zigzag
   color_sections=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=0;
//--- contamos los tics para el cambio del estilo, color y grosor de la línea
   ticks++;
//--- si tenemos acumulado un número suficiente de tics
   if(ticks>=N)
     {
      //--- cambiamos las propiedades de la línea
      ChangeLineAppearance();
      //--- cambiamos colores con los que se dibujan segmentos
      ChangeColors(colors,color_sections);
      //--- actualizamos el contador de tics pasándolo a cero
      ticks=0;
     }
 
//--- necesitaremos una estructura de tiempo para obtener el día de la semana de cada barra
   MqlDateTime dt;
      
//--- posición de inicio del cálculo
   int start=0;
//--- si el indicador se calcula en el tic anterior, empezamos el cálculo a partir del penúltimo
   if(prev_calculated!=0) start=prev_calculated-1;
//--- ciclo de cálculos
   for(int i=start;i<rates_total;i++)
     {
      //--- apuntaremos en la estructura la hora de apertura de la barra
      TimeToStruct(time[i],dt);
 
      //--- si el número de la barra es par
      if(i%2==0)
        {
         //---  escribimos en el 1-r búfer High, en el 2-do Low
         Color_ZigzagBuffer1[i]=high[i];
         Color_ZigzagBuffer2[i]=low[i];
         //--- color del segmento
         Color_ZigzagColors[i]=dt.day_of_year%color_sections;
        }
      //--- el número de la barra es impar
      else
        {
         //--- llenamos la barra en sentido inverso
         Color_ZigzagBuffer1[i]=low[i];
         Color_ZigzagBuffer2[i]=high[i];
         //--- color del segmento
         Color_ZigzagColors[i]=dt.day_of_year%color_sections;         
        }
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//|  cambia el color de segmentos del zigzag
//+------------------------------------------------------------------+
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("ZigzagColorIndex[%d]=%s \r\n",plot_color_ind,ColorToString(cols[i],true));
      ChartSetString(0,CHART_COMMENT,comm);
     }
//---
  }
//+------------------------------------------------------------------+
//| cambia la apariencia de segmentos en el zigzag                   |
//+------------------------------------------------------------------+
void ChangeLineAppearance()
  {
//--- cadena para formar la información sobre las propiedades de Color_ZigZag
   string comm="";
//--- bloque de cambio del grosor de la línea
   int number=MathRand();
//--- obtenemos el grosor como el remanente de la división de números enteros
   int width=number%5;   // el grosor puede ser de 0 a 4
//--- estableceremos el color como la propiedad PLOT_LINE_WIDTH
   PlotIndexSetInteger(0,PLOT_LINE_WIDTH,width);
//--- apuntaremos el grosor de la línea
   comm=comm+"\r\nWidth="+IntegerToString(width);
 
//--- bloque de cambio del estilo de la línea
   number=MathRand();
//--- el divisor del número es igual al tamaño del array styles
   int size=ArraySize(styles);
//--- obtenemos el índice para seleccionar nuevo estilo como el remanente de la división de números enteros
   int style_index=number%size;
//--- estableceremos el color como la propiedad PLOT_LINE_COLOR
   PlotIndexSetInteger(0,PLOT_LINE_STYLE,styles[style_index]);
//--- apuntaremos el estilo de la línea
   comm="\r\n"+EnumToString(styles[style_index])+""+comm;
//--- mostraremos la información en el gráfico a través del comentario
   Comment(comm);
  }

 


Actualizado: 2015.12.03