DRAW_COLOR_ZIGZAG

Lo stile DRAW_COLOR_ZIGZAG disegna segmenti di colori diversi, utilizzando i valori di due buffer indicatori. Questo stile è una versione colorata di DRAW_ZIGZAG, cioè permette di specificare per ogni segmento un singolo colore dal set predefinito di colori. I segmenti vengono tracciati da un valore nel primo buffer di un valore nel secondo buffer indicatore. Nessuno dei buffer può contenere solo valori vuoti, perché in questo caso nulla è tracciato.

La larghezza, il colore e lo stile della linea possono essere specificati come per lo stile DRAW_ZIGZAG - utilizzando le direttive del compilatore o in modo dinamico utilizzando la funzione PlotIndexSetInteger(). Cambiamenti dinamici delle proprietà di plotting permettono di "animare" gli indicatori, in modo che il loro aspetto cambi a seconda della situazione attuale.

Le sezioni vengono disegnate da un valore non vuoto di un buffer ad un valore non vuoto di un altro buffer indicatore. Per specificare quale valore deve essere considerato come "vuoto", impostare questo valore nella proprietà PLOT_EMPTY_VALUE:

/ / --- Il valore 0 (vuoto) parteciperà al disegno
   PlotIndexSetDouble(index_of_plot_DRAW_COLOR_ZIGZAG,PLOT_EMPTY_VALUE,0);

Sempre riempire esplicitamente i valori dei buffer indicatori, impostando un valore vuoto in un buffer per saltare le sbarre.

Il numero di buffer necessari per tracciare DRAW_COLOR_ZIGZAG è 3:

  • due buffer per memorizzare i valori delle estremità delle sezioni zigzag;
  • un buffer per memorizzare l'indice del colore, che viene utilizzato per elaborare la sezione (ha senso impostare solo valori non vuoti).

Un esempio di indicatore che traccia una sega sulla base dei prezzi High e Low. Il colore, la larghezza e lo stile delle linee a zig-zag cambiano in modo casuale ogni N ticks.

Un esempio di DRAW_COLOR_ZIGZAG

Si prega di notare che per Plot1 con lo stile DRAW_COLOR_ZIGZAG, 8 colori vengono impostati utilizzando la direttiva del compilatore #property, e poi nella funzione OnCalculate() il colore è scelto a caso dai 14 colori memorizzati nell'array colors[].

Il parametro N è impostato in parametri esterni dell'indicatore per la possibilità di configurazione manuale (la scheda Parametri nella finestra Proprietà del indicatore).

//+--------------------------------------------------------------------------------+
//|                                                          DRAW_COLOR_ZIGZAG.mq5 |
//|                                      Copyright 2011, MetaQuotes Software Corp. | 
//|                                                           https://www.mql5.com |
//+--------------------------------------------------------------------------------+
#property copyright "Copyright 2000-2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
 
#property description "Un indicatore per dimostrare DRAW_COLOR_ZIGZAG"
#property description "Traccia una linea spezzata come una sequenza di sezioni colorate, il colore dipende dal numero del giorno della settimana"
#property description "Il colore, spessore e stile dei segmenti vengono cambiati in modo casuale"
#property description " ogni N ticks"
 
#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
//--- Definisce 8 colori per la colorazione delle sezioni selezione (vengono conservate in uno speciale array)
#property indicator_color1  clrRed,clrBlue,clrGreen,clrYellow,clrMagenta,clrCyan,clrLime,clrOrange
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- parametri input
input int      N=5;              // Numero di ticks da cambiare 
int            color_sections;
//--- Buffer dei valori delle fini del segmento
double         Color_ZigzagBuffer1[];
double         Color_ZigzagBuffer2[];
//--- Buffer degli indici dei colori delle fini del segmento
double         Color_ZigzagColors[];
//--- Un array per memorizzare i colori contiene 14 elementi
color colors[]=
  {
   clrRed,clrBlue,clrGreen,clrChocolate,clrMagenta,clrDodgerBlue,clrGoldenrod,
   clrIndigo,clrLightBlue,clrAliceBlue,clrMoccasin,clrWhiteSmoke,clrCyan,clrMediumPurple
  };
//--- Un array per memorizzare gli stili di linea
ENUM_LINE_STYLE styles[]={STYLE_SOLID,STYLE_DASH,STYLE_DOT,STYLE_DASHDOT,STYLE_DASHDOTDOT};
//+--------------------------------------------------------------------------------+
//| Funzione di inizializzazione Indicatore Personalizzato                         |
//+--------------------------------------------------------------------------------+
int OnInit()
  {
//--- mappatura buffers indicatore
   SetIndexBuffer(0,Color_ZigzagBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,Color_ZigzagBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,Color_ZigzagColors,INDICATOR_COLOR_INDEX);
//---- Numero di colori per colorare il zigzag
   color_sections=8;   //  mostra un commento in #property indicator_color1 property
//---
   return(INIT_SUCCEEDED);
  }
//+--------------------------------------------------------------------------------+
//| Funzione di iterazione indicatore personalizato                                |
//+--------------------------------------------------------------------------------+
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;
//--- Calcola i ticks per cambiare lo stile, il colore e lo spessore della linea
   ticks++;
//--- Se un numero sufficiente di ticks è stato accumulato
   if(ticks>=N)
     {
      //--- Cambia le proprietà della linea
      ChangeLineAppearance();
      //--- Cambia colori usati per tracciare le sezioni
      ChangeColors(colors,color_sections);
      //--- Resetta il contatore dei ticks a zero
      ticks=0;
     }
 
//--- La struttura del tempo è richiesta per ottenere il giorno della settimana di ogni barra
   MqlDateTime dt;
      
//--- La posizione di partenza dei calcoli
   int start=0;
//--- Se l'indicatore è stato calcolato sulla tick precedente, allora avviare il calcolo con il penultimo tick
   if(prev_calculated!=0) start=prev_calculated-1;
//--- Ciclo del calcolo
   for(int i=start;i<rates_total;i++)
     {
      //--- Scrive il tempo di apertura della barra nella struttura
      TimeToStruct(time[i],dt);
 
      //--- Se il numero è pari
      if(i%2==0)
        {
         //--- Scrive High nel 1° buffer e Low nel 2°
         Color_ZigzagBuffer1[i]=high[i];
         Color_ZigzagBuffer2[i]=low[i];
         //--- Il colore dei segmenti
         Color_ZigzagColors[i]=dt.day_of_year%color_sections;
        }
      //--- il numero della barra è dispari
      else
        {
         //--- Riempie la barra in ordine inverso
         Color_ZigzagBuffer1[i]=low[i];
         Color_ZigzagBuffer2[i]=high[i];
         //--- Il colore dei segmenti
         Color_ZigzagColors[i]=dt.day_of_year%color_sections;         
        }
     }
//--- restituisce il valore di prev_calculated per la prossima chiamata
   return(rates_total);
  }
//+--------------------------------------------------------------------------------+
//| Cambia il colore dei segmenti zigzag                                           |
//+--------------------------------------------------------------------------------+
void  ChangeColors(color  &cols[],int plot_colors)
  {
//--- Il numero dei colori
   int size=ArraySize(cols);
//--- 
   string comm=ChartGetString(0,CHART_COMMENT)+"\r\n\r\n";
 
//--- Per ogni indice colore definisce un nuovo colore casualmente
   for(int plot_color_ind=0;plot_color_ind<plot_colors;plot_color_ind++)
     {
      //--- Ottiene un valore casuale
      int number=MathRand();
      //--- Ottiene un indice nell'array col[] come resto della divisione dell'intero
      int i=number%size;
      //--- Imposta il colore per ogni indice che ha proprietà PLOT_LINE_COLOR
      PlotIndexSetInteger(0,                    //  Il numero di stili grafici
                          PLOT_LINE_COLOR,      //  Identificatore proprietà
                          plot_color_ind,       //  Lìindice del colore, dove scriviamo il colore
                          cols[i]);             //  Un nuovo colore
      //--- Scrivi i colori
      comm=comm+StringFormat("ZigzagColorIndex[%d]=%s \r\n",plot_color_ind,ColorToString(cols[i],true));
      ChartSetString(0,CHART_COMMENT,comm);
     }
//---
  }
//+--------------------------------------------------------------------------------+
//| Modifica l'aspetto dei segmenti a zig-zag                                      |
//+--------------------------------------------------------------------------------+
void ChangeLineAppearance()
  {
//--- Una stringa per la formazione di informazioni sulle proprietà di Color_ZigZag
   string comm="";
//--- Un blocco per modificare la larghezza della linea
   int number=MathRand();
//--- Ottiene la larghezza del resto della divisione intera
   int width=number%5;   // La larghezza è impostata da 0 a 4
//--- Imposta il colore come proprietà PLOT_LINE_WIDTH
   PlotIndexSetInteger(0,PLOT_LINE_WIDTH,width);
//--- Scrive lo spessore della linea
   comm=comm+"\r\nWidth="+IntegerToString(width);
 
//--- Un blocco per cambiare lo stile della linea
   number=MathRand();
//--- Il divisore è uguale alla grandezza dell'array styles
   int size=ArraySize(styles);
//--- Ottiene l'indice per selezionare un nuovo stile, come resto della divisione intera
   int style_index=number%size;
//--- Imposta il colore come la proprietà PLOT_LINE_COLOR
   PlotIndexSetInteger(0,PLOT_LINE_STYLE,styles[style_index]);
//--- Scrive lo stile della linea
   comm="\r\n"+EnumToString(styles[style_index])+""+comm;
//--- Imposta le informazioni del grafico usando un commento
   Comment(comm);
  }