MQL5'te Çok Renkli Göstergeler Oluşturma

Giriş

MetaTrader 5 geliştiricilerinin çabaları sayesinde MQL5 dili ortaya çıktı. Pek çok yenilik var ancak burada çok renkli göstergelerin oluşturulması olasılığını açıklayacağım ve değerlendireceğim. MQL4'te bir çizgi için renk belirtilebilir, tüm çizgi için aynıdır ve çok renkli göstergeler, uygun olmayan gösterge tamponlarının kısmi örtüşmesi kullanılarak oluşturulur.

MQL5 dilinin geliştiricileri, gösterge çizgisinin her bölümü (çizgiler) için bir renk ve ayrı nesnelerin (çubuklar, mumlar, histogramlar, oklar için) renklerini belirtmek için yeni bir olanak sağlamıştır. Bu makaleyi anlamak için MQL5 Referansına bakmak daha iyidir.

Bu makalede aşağıdaki konuları ele almaya çalışacağım:

• Göstergelerin temelleri
• Göstergenin veri tamponları
• Göstergenin renk indisi tamponları
• RSI göstergesi örneğinde tek renkli çizim modunu çok renkliye dönüştürme (DRAW_LINE öğesinin DRAW_COLOR_LINE çizim stillerine dönüştürülmesi)
• RSI göstergesinin değerlerine bağlı olarak mum grafiğin nasıl boyanacağı (DRAW_COLOR_CANDLES çizim stili kullanılarak)
• Renk indislerinin tamponlarından nasıl değer nasıl alınacağı

İki renkli çizim stilini ele alalım - DRAW_COLOR_LINE ve DRAW_COLOR_CANDLES, kalan çizim stilleri yalnızca tampon sayısında farklılık gösterir.

Neden renk göstergeleri kullanılmalı?

Renk göstergelerini kullanarak şunları yapabileceksiniz:

• Mumlarda ek bilgileri gösterme.
• Göstergelerin hibritlerini oluşturma (MACD rengi RSI değerlerine bağlıdır).
• Göstergenin önemli sinyallerini vurgulayın.
• Sadece istemci terminalinizi düzenleyin.
  

Sadece hayal gücünüzü serbest bırakın ve işlemlerinizi daha kullanışlı hale getirin.

MQL5 temelleri

Göstergenin ilkeleriyle başlayalım.

Genel olarak, gösterge girdi verilerini (fiyatlar, diğer göstergenin verileri) alır, bazı hesaplamalar yapar ve birkaç tamponu verilerle doldurur. İstemci terminali, çizim türüne göre gösterge tarafından sağlanan tamponlardan gelen bilgileri çizer.

Çizim stili geliştirici tarafından tanımlanır. Gösterge tamponları, global düzeyde bildirilen çift tür dizilerdir. Bir stil için birden fazla tampon gerekiyorsa birkaç tampon grafik çizimlerinde birleştirilebilir. Hiç özel göstergeler oluşturmadıysanız makaleleri okuyabilirsiniz (temel bilgiler burada iyi bir şekilde açıklanmıştır): "MQL5: Kendi Göstergenizi Yaratın" ve "Yeni Başlayanlar için MQL5'te Özel Göstergeler".

Renk göstergesinin minimum kodunun bileşenlerini burada anlatacağım:

//+------------------------------------------------------------------+
//|                                         test_color_indicator.mq5 |
//|                                                             ProF |
//|                                                          http:// |
//+------------------------------------------------------------------+
#property copyright "ProF"                      //Author
#property indicator_separate_window             //The indicator is plotted in a separate window
#property indicator_buffers 2                   //Number of indicator buffers
#property indicator_plots 1                     //Number of indicator plots
#property indicator_type1 DRAW_COLOR_HISTOGRAM  //Drawing style - Color Histogram
#property indicator_width1 3                    //Line width of a graphic plot (optional)
#property indicator_color1 Red,Green,BlueViolet //Specify 3 colors for a graphic plot

//Declaration of buffers
double buffer_line[]/*Data Buffer*/, buffer_color_line[]/*Color index buffer*/;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//Assign the data array with indicator's buffer
   SetIndexBuffer(0,buffer_line,INDICATOR_DATA);

//Assign the color indexes array with indicator's buffer
   SetIndexBuffer(1,buffer_color_line,INDICATOR_COLOR_INDEX);

//Specify the number of color indexes, used in the graphic plot
   PlotIndexSetInteger(0,PLOT_COLOR_INDEXES,2);

//Specify colors for each index
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,Blue);   //Zeroth index -> Blue
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,Orange); //First index  -> Orange
   return(0);
  }
//+------------------------------------------------------------------+
//| 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[])
  {
   //For each bar we fill the data buffer and index color buffer with values
   for(int i=prev_calculated;i<=rates_total-1;i++)
     {
      //Lets add a simple drawing condition -> If opening price is greater than closing price, then:
      if(open[i]>close[i])
        {   buffer_color_line[i]=0;   }       //Assign color with index=zero (0)
      else
        {  buffer_color_line[i]=1;   }       //Assign color with index=one (1)
      
      //Specify the data for plotting, in our case it's the opening price
      buffer_line[i]=open[i];
     }

   return(rates_total-1); //Return the number of calculated bars, 
                         //subtract 1 for the last bar recalculation
  }
//+------------------------------------------------------------------+

Renk göstergelerini yazmanın ayrıntılarını inceleyelim:

#property indicator_buffers 2 //Number of indicator's buffers
#property indicator_plots 1   //Number of graphic plots

İlk satırda gösterge tamponlarının sayısını belirtiyoruz, bizim durumumuzda iki tamponumuz var:

1. Bizim örneğimizde açılış fiyatları için gösterge verilerinin tamponu;
2. Renk indisleri için tampon.

İkinci satırda grafik sayısını belirtiyoruz. Grafikleri ve göstergenin tamponlarını ayırt etmek önemlidir. Grafik, göstergenin çizgisidir (mum, çubuk, ok vb.). Bir gösterge tamponu veri içeren bir dizidir, çizilmesi gerekir, renk indisli dizi veya göstergenin dahili hesaplamaları için bir dizidir (bu tür gösterge penceresinde çizilmez).

Grafiklerin sayısı, tamponların sayısına eşit veya bundan daha az olabilir, bu hesaplamaya yönelik çizim stiline ve tampon sayısına bağlıdır. Çizim stilleri ve her stil için gereken tampon sayısı tablosu, MQL5 Referansının Çizim Stilleri bölümünde mevcuttur.

"En ilginç" kısım burada başlıyor:

#property indicator_type1 DRAW_COLOR_HISTOGRAM  //Drawing style-color histogram
#property indicator_width1 3                    //Drawing line width (optional)
#property indicator_color1 Red,Green,BlueViolet //Specify 3 colors for a graphic plot

İlk satırda çizim stilini belirtiyoruz, bizim durumumuzda çizim stili sıfır çizgisinden bir histogramdır. Bu çizim stili, bir veri tamponu ve bir renk indisi tamponu gerektirir. "RENK" kelimesini içeren tüm çizim stilleri, renk indisleri için bir tampon gerektirir.

İkinci satırda, üç piksele eşit bir çizginin genişliğini belirtiriz, varsayılan olarak bir çizginin genişliği bir piksele ayarlanır.

Üçüncü satırda, grafiklerin indisleri için renkleri belirliyoruz, bu durumda "Kırmızı", "Yeşil" ve "Menekşe" olmak üzere üç renk belirledik. Renk indisleri sıfırdan başlıyor: 0-"Kırmızı", 1-"Yeşil", 2-"Menekşe". Grafiklerin renklerini ayarlamak için renkler gereklidir. Renkler birkaç şekilde belirtilebilir, "#property indicator_color1" bunlardan biridir. Bu "statik" bir yöntemdir, program derleme aşamasında kullanılır. İkinci yöntem aşağıda tartışılmaktadır.

double buffer_line[]/*Data buffer*/, buffer_color_line[]/*Color indexes buffer*/;

Burada tampon olarak kullanılacak iki dizi bildiriyoruz, ilki veri tamponu olarak kullanılacak, ikincisi renk indisleri için kullanılacak, her ikisi de çift tür diziler olarak bildirilecek.

Gösterge başlatma fonksiyonunu ele alalım:

SetIndexBuffer(0,buffer_line,INDICATOR_DATA);

Burada gösterge tamponunu bir dizi ile atadık, belirtilen "INDICATOR_DATA" tampon tipi, bu tamponun göstergenin değerlerini depolamak için kullanılacağı anlamına gelir (yani, göstergenin veri tamponudur). İlk parametrenin sıfır (0) olduğuna dikkat edin - bu, tampon indisidir.

SetIndexBuffer(1,buffer_color_line,INDICATOR_COLOR_INDEX);

Burada gösterge tamponunu bir dizi ile atarız ve tampon türü olarak "INDICATOR_COLOR_INDEX" belirtiriz - bu, bu tamponun göstergenin her çubuğu için renk indislerini depolamak için kullanılacağı anlamına gelir. İlk parametrenin (1)'e eşit olduğuna dikkat edin, bu tampon indisidir.

Tampon sıralaması özel olmalıdır: her şeyden önce gösterge veri tamponları, ardından renk indisi tamponları.

Son olarak, grafiklerin renklerini belirlemenin ikinci yolu (renk indislerini belirtmek için) şudur:

//Specify the number of color indexes, used in the graphics
PlotIndexSetInteger(0,PLOT_COLOR_INDEXES,2);

Burada renk indislerinin sayısını belirtiyoruz. Fonksiyonun ilk parametresi "0"a eşittir, bu grafik indisidir. Bu durumda renk indislerinin sayısını belirtmemiz gerektiğini unutmayın (ilk yöntemde derleyici bunu hesaplar).

PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,Blue);   //Zeroth index -> Blue
PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,Orange); //First index  -> Orange

Burada her indis için renkleri belirtiyoruz. Fonksiyonun ilk parametresi grafiğin indisi, üçüncü parametresi sıfırdan başlayan renk indisidir. Renk indislerini ayarlamanın ikinci yolu şu şekilde farklılık gösterir: renklerin sayısı ve bunların indisleri, örneğin fonksiyon kullanılarak dinamik olarak belirlenebilir. Her iki yöntemi de kullanıyorsanız, dinamik yöntemin statik yöntemi (birinci yöntem) geçersiz kılacağını unutmayın.

Ardından, OnCalculate fonksiyonunu düşünün, göstergenin grafikleri için tampon değerlerini hesaplıyoruz. Histogram için renk seçimimde en basit kuralları seçiyoruz, eğer açılış fiyatı kapanış fiyatından yüksekse renk indisi ("buffer_color_line" dizisinde) sıfır (0) değerine eşit olan mevcut tampon elemanını atarız. Sıfıra (0) eşit renk indisi, yukarıda belirtilen "Mavi" renge karşılık gelir.

Açılış fiyatı kapanış fiyatından düşükse Turuncu renge karşılık gelen 1'e eşit renk indisini atarız. Basit bir örneği sunuyoruz:

Gördüğünüz gibi bu kolaydır, sadece biraz hayal gücüne ihtiyacımız var.

Renk Ayarlama Yöntemleri

Şimdi renk ayarının ayrıntılarını ele alalım.

MQL5 Referansına göre renk, farklı yöntemler kullanılarak belirlenebilir:

• Kelime bazında;
• Sayısal olarak;
• Renk adlarını kullanarak.

Hepsini inceleyelim.

Kelime bazında

color color_var = C'10,20,255';
color color_var = C'0x0A,0x14,0xFF';

Renkler RGB'ye (Red - Kırmızı, Green - Yeşil, Blue - Mavi) göre tanımlanır, herhangi bir renk bu üç rengin toplamı olarak sunulabilir. Buna göre ilk sayı Kırmızı renk bileşenine karşılık gelmektedir. İkincisi Yeşil'e, üçüncüsü Mavi renk bileşenine karşılık gelir. Sayılar (ondalık biçimde) 0 ile 255 arasında olabilir. On altılık tabanda değerler 00 ile FF arasında olabilir.

Birinci ve ikinci satırlar eşittir: color_var değişkenine Mavi rengi atarız. Fark, belirtilen sayı sistemlerinde bir sayının temsilidir, ilk satırda ondalık ve ikinci satırda on altılık. Hiçbir fark yoktur, size uygun olan yolu seçebilirsiniz. Küçük sayı daha koyu renklere karşılık gelir, beyaz renk: "C'255,255,255'" veya "C'0xFF,0xFF,0xFF'", siyah renk: "C'0,0,0'” veya "C'0x00,0x00,0x00'".

Sayısal olarak

color color_var = 0xFFFFFF;  // white
color color_var = 0x0000FF;  // red
color color_var = 16777215   // white
color color_var = 0x008000   // green
color color_var = 32768      // green

Renkler on altılık ve ondalık sayı sistemlerinde temsil edilir. Örneğin, "0x0000FF" değeri "C'0xFF,0x00,0x00'" değerine eşittir, gördüğümüz gibi sayıların ilk ve son çiftleri değiştirilir.

Ondalık sayı sisteminde 16777215 değerini elde etmek için FFFFFF sayısını on altılıktan ondalık sayı sistemine dönüştürmemiz gerekir.

Renk isimleri

color color_var = Red;    //red
color color_var = Blue;   //blue
color color_var = Orange; //orange

Bu en basit yoldur ancak yalnızca web renkleri setinden renkleri belirtebilirsiniz.

Renkleri nasıl belirleyebileceğimizi özetleyelim.

Her üç yöntem de eşittir, örneğin:

color color1 = C'255,0,0';
color color2 = C'0xFF,0x00,0x00';
color color3 = 0x0000FF;
color color4 = 255;
color color5 = Red;

Alert((color1==color2)
       && (color1==color2)
       && (color1==color4)
       && (color1==color5)); //prints true

Uygulama

Temelleri öğrendik, şimdi diğer gösterge değerlerine, örneğin RSI değerlerine bağlı olarak, grafik mumlarını farklı renklerle nasıl boyayacağımızı düşünelim. Grafikte renkli mumlar oluşturmak için grafikte uygulanan renkli mumları çizecek bir gösterge yazmamız gerekiyor.

Göstergenin kodu şöyledir, RSI değerleri %50'nin altındaysa Mavi mumları çizer, aksi takdirde mumlar Turuncu renkle çizilir.

Okuyucunun kafasını karıştırmamak için verilerin doğruluğunu ve hata işlemeyi kontrol etme yoktur. Ancak göstergenin çalışma kodu yazılırken bu ayrıntılar dikkate alınmalıdır.

//+------------------------------------------------------------------+
//|                                                   cand_color.mq5 |
//|                                                             ProF |
//|                                                          http:// |
//+------------------------------------------------------------------+
#property copyright "ProF"                      //Author
#property indicator_chart_window                //Indicator in separate window

                                          //Specify the number of buffers of the indicator
//4 buffer for candles + 1 color buffer + 1 buffer to serve the RSI data
#property indicator_buffers 6

//Specify the names in the Data Window
#property indicator_label1 "Open;High;Low;Close"

#property indicator_plots 1                     //Number of graphic plots
#property indicator_type1 DRAW_COLOR_CANDLES    //Drawing style - color candles
#property indicator_width1 3                    //Width of the graphic plot (optional)

                                          //Declaration of buffers
double buffer_open[],buffer_high[],buffer_low[],buffer_close[]; //Buffers for data
double buffer_color_line[];    //Buffer for color indexes
double buffer_tmp[1];           //Temporary buffer for RSI data copying
double buffer_RSI[];            //Indicator buffer for RSI
int handle_rsi=0;               //Handle for the RSI indicator
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
/**
        *       The order of the buffers assign is VERY IMPORTANT!
        *  The data buffers are first
        *       The color buffers are next
        *       And finally, the buffers for the internal calculations.
        */
//Assign the arrays with the indicator's buffers
   SetIndexBuffer(0,buffer_open,INDICATOR_DATA);
   SetIndexBuffer(1,buffer_high,INDICATOR_DATA);
   SetIndexBuffer(2,buffer_low,INDICATOR_DATA);
   SetIndexBuffer(3,buffer_close,INDICATOR_DATA);

//Assign the array with color indexes with the indicator's color indexes buffer
   SetIndexBuffer(4,buffer_color_line,INDICATOR_COLOR_INDEX);

//Assign the array with the RSI indicator data buffer
   SetIndexBuffer(5,buffer_RSI,INDICATOR_CALCULATIONS);

//Define the number of color indexes, used for a graphic plot
   PlotIndexSetInteger(0,PLOT_COLOR_INDEXES,2);

//Set color for each index
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,Blue);   //Zeroth index -> Blue
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,Orange); //First index  -> Orande
   
//Get handle of RSI indicator, it's necessary to get the RSI indicator values
   handle_rsi=iCustom(_Symbol,_Period,"Examples\\RSI");
   return(0);
  }
//+------------------------------------------------------------------+
//| 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[])
  {
//In the loop we fill the data buffers and color indexes buffers for each bar
   for(int i=prev_calculated;i<=rates_total-1;i++)
     {
      //Copying the RSI indicator's data to the temporary buffer - buffer_tmp
      CopyBuffer(handle_rsi,0,BarsCalculated(handle_rsi)-i-1,1,buffer_tmp);
      //Copying the values from the temporary buffer to the indicator's buffer
      buffer_RSI[i]=buffer_tmp[0];

      //Set data for plotting
      buffer_open[i]=open[i];  //Open price
      buffer_high[i]=high[i];  //High price
      buffer_low[i]=low[i];    //Low price
      buffer_close[i]=close[i];//Close price

                               //Add a simple condition -> If RSI less 50%:
      if(buffer_RSI[i]<50)
        {   buffer_color_line[i]=0;   } //Assign the bar with color index, equal to 0
      else
        {  buffer_color_line[i]=1;   }  //Assign the bar with color index, equal to 1
     }
   return(rates_total-1); //Return the number of calculated bars, 
                         //Subtract 1 for the last bar recalculation
  }
//+------------------------------------------------------------------+

Şöyle görünür:

İyi görünüyor ama devam edeceğiz.

Gradyan dolgu denilen birçok rengi kullanarak mumları RSI değerlerine göre boyayalım.

Renkler manuel olarak belirlenebilir ancak 30-40 rengi belirtmek pratik ve kolay değildir. Şunları yapacağız: iki fonksiyon yazacağız, birincisi renk indisleri için olacak, ikincisi de fonksiyonun argümanlarına bağlı olarak rengi almak için olacaktır. Fikir yorumlarda yazılmıştır.

//+------------------------------------------------------------------+
//|                                               cand_color_RSI.mq5 |
//|                                                             ProF |
//|                                                          http:// |
//+------------------------------------------------------------------+
#property copyright "ProF"                      //Author
#property indicator_chart_window                //Indicator in a separate window

//Specify the number of indicator's buffers
//4 buffers for candles + 1 buffer for color indexes + 1 buffer to store the data of RSI
#property indicator_buffers 6

//Specify the names, shown in the Data Window
#property indicator_label1 "Open;High;Low;Close"

#property indicator_plots 1                     //Number of graphic plots
#property indicator_type1 DRAW_COLOR_CANDLES    //Drawing style - colored candles
#property indicator_width1 3                    //Width of a line (optional)

                                          //Declaration of buffers
double buffer_open[],buffer_high[],buffer_low[],buffer_close[];//Buffers for data
double buffer_color_line[];     //Buffer for color indexes
double buffer_tmp[1];          //Temporary buffer for RSI values
double buffer_RSI[];            //Indicator buffer for RSI
int handle_rsi=0;               //Handle of the RSI indicator
//+------------------------------------------------------------------+
//|    Set colors for a graphic plot                          |
//+------------------------------------------------------------------+
/*
*       The function sets colors for a graphic plot 
*       50 colors from Green to Blue.
*       The index of a graphic plot is passed to the function.

void setPlotColor(int plot)
  {
   PlotIndexSetInteger(plot,PLOT_COLOR_INDEXES,50); //Specify the number of colors

                                               //In the loops we specify the colors
   for(int i=0;i<=24;i++)
     {
      PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i,StringToColor("\"0,175,"+IntegerToString(i*7)+"\""));
     }
   for(int i=0;i<=24;i++)
     {
      PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i+25,StringToColor("\"0,"+IntegerToString(175-i*7)+",175\""));
     }
  }
//+------------------------------------------------------------------+
//|  Get index of the color                                          |
//+------------------------------------------------------------------+
/*
*       The function returns the index of the color
*       The first parameter is the current value of the indicator
*       The second parameter is the minimal value of the indicator
*       The third parameter is the maximal value of the indicator
*/
int getPlotColor(double current,double min,double max)
  {
   return((int)NormalizeDouble((50/(max-min))*current,0));
  }
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
/**
        *       The order of the indicator's buffers is VERY IMPORTANT!
        *  The data buffers are first
        *       The color buffers are next
        *       And finally, the buffers for the internal calculations.
        */
//Assign the arrays with the indicator buffers
   SetIndexBuffer(0,buffer_open,INDICATOR_DATA);
   SetIndexBuffer(1,buffer_high,INDICATOR_DATA);
   SetIndexBuffer(2,buffer_low,INDICATOR_DATA);
   SetIndexBuffer(3,buffer_close,INDICATOR_DATA);

//Assign the array with the color indexes buffer
   SetIndexBuffer(4,buffer_color_line,INDICATOR_COLOR_INDEX);

//Assign the array with RSI indicator buffer
   SetIndexBuffer(5,buffer_RSI,INDICATOR_CALCULATIONS);

//Specify color indexes
   setPlotColor(0);

//Get handle of the RSI indicator, it's necessary get its values
   handle_rsi=iCustom(_Symbol,_Period,"Examples\\RSI",6);
   return(0);
  }
//+------------------------------------------------------------------+
//| 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[])
  {
//For each bar we fill the data buffers and buffer with color indexes using the loop
   for(int i=prev_calculated;i<=rates_total-1;i++)
     {
      //Copying the RSI indicator data to the temporary buffer buffer_tmp
      CopyBuffer(handle_rsi,0,BarsCalculated(handle_rsi)-i-1,1,buffer_tmp);
      //Then copying the data from the temporary buffer
      buffer_RSI[i]=buffer_tmp[0];

      //Specify the data for plotting
      buffer_open[i]=open[i];  //Open price
      buffer_high[i]=high[i];  //High price
      buffer_low[i]=low[i];    //Low price
      buffer_close[i]=close[i];//Close price

      //Paint the candles depending on RSI indicator values
      //RSI = 0     - candle is Green
      //RSI = 100   - candle is Blue
      //0<RSI<100   - candle color is between Green and Blue 
      buffer_color_line[i]=getPlotColor(buffer_RSI[i],0,100);

     }
   return(rates_total-1); //Return the number of calculated bars, 
                         //Subtract 1 for the last bar recalculation
  }
//+------------------------------------------------------------------+

Şöyle görünür:

Bunu örnek olarak kullanarak diğer renkleri ayarlayın. RSI'yi başka bir göstergeyle değiştirmeyi deneyin.

Pratik her zaman önemlidir.

Çizim Stilleri: Geleneksel ve Çok Renkli

Mevcut bir göstergeyi boyayabilirsiniz, aşağıdakileri yapmanız gerekir: çizim stilini çok renkli olarak değiştirin, tamponlar ekleyin, bunları gösterge tamponlarıyla atayın ve boyama ayrıntılarını belirtin.

Geleneksel çizim stilleri ve karşılık gelen çok renkli (boyalı) çizim stilleri tablosu şu şekildedir:

Önce	Sonra
DRAW_LINE	DRAW_COLOR_LINE
DRAW_SECTION	DRAW_COLOR_SECTION
DRAW_HISTOGRAM	DRAW_COLOR_HISTOGRAM
DRAW_HISTOGRAM2	DRAW_COLOR_HISTOGRAM2
DRAW_ARROW	DRAW_COLOR_ARROW
DRAW_ZIGZAG	DRAW_COLOR_ZIGZAG (örnek)
DRAW_CANDLES	DRAW_COLOR_CANDLES

Kendi değerlerine bağlı olarak boyanmış değiştirilmiş RSI’nin kodu böyledir.

Tüm değişiklikler yorumlanır.

//+------------------------------------------------------------------+
//|                                                          RSI.mq5 |
//|                        Copyright 2009, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright   "2009, MetaQuotes Software Corp."
#property link        "http://www.mql5.com"
#property description "Relative Strength Index"
//--- indicator settings
#property indicator_separate_window
#property indicator_minimum 0
#property indicator_maximum 100
#property indicator_level1 30
#property indicator_level2 70
/////////////////////////////////////////////////////////////////////
#property indicator_buffers 4 //The number of buffers has increased by 1
#property indicator_width1 5  //The line width has set to 4 pixels
/////////////////////////////////////////////////////////////////////
#property indicator_plots   1
/////////////////////////////////////////////////////////////////////
//Drawing style has been changed from DRAW_LINE to DRAW_COLOR_LINE
#property indicator_type1   DRAW_COLOR_LINE
/////////////////////////////////////////////////////////////////////
#property indicator_color1  DodgerBlue
//--- input parameters
input int InpPeriodRSI=14; // Period
//--- indicator buffers
double    ExtRSIBuffer[];
double    ExtPosBuffer[];
double    ExtNegBuffer[];
//--- global variable
int       ExtPeriodRSI;

//////////////////////////////////////////////////////////////////////
double buffer_color[]; //Declare an array for color indexes

//Added two functions
//+------------------------------------------------------------------+
//|    Set color for a graphic plot                                  |
//+------------------------------------------------------------------+
/*
*       The function specify the color for a graphic plot 
*       50 colors from Green to Blue are available.
*       The index of a graphic plot is passed to the function.
*/
void setPlotColor(int plot)
  {
   PlotIndexSetInteger(plot,PLOT_COLOR_INDEXES,50); //Set number of colors

                                                    //Specify colors in loop
   for(int i=0;i<=24;i++)
     {
      PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i,StringToColor("\"0,175,"+IntegerToString(i*7)+"\""));
     }
   for(int i=0;i<=24;i++)
     {
      PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i+25,StringToColor("\"0,"+IntegerToString(175-i*7)+",175\""));
     }
  }
//+------------------------------------------------------------------+
//|  Get index of the color                                           |
//+------------------------------------------------------------------+
/*
*       The function returns the color index
*       The first parameter is the current value of the indicator
*       The second parameter is the minimal value of the indicator
*       The third parameter is the maximal value of the indicator
*/
int getPlotColor(double current,double min,double max)
  {
   return((int)NormalizeDouble((50/(max-min))*current,0));
  }
//////////////////////////////////////////////////////////////////////


//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
void OnInit()
  {
//--- check for input
   if(InpPeriodRSI<1)
     {
      ExtPeriodRSI=12;
      Print("Incorrect value for input variable InpPeriodRSI =",InpPeriodRSI,
            "Indicator will use value =",ExtPeriodRSI,"for calculations.");
     }
   else ExtPeriodRSI=InpPeriodRSI;
//--- indicator buffers mapping
   SetIndexBuffer(0,ExtRSIBuffer,INDICATOR_DATA);
   
/////////////////////////////////////////////////////////////////////
//Assign the array with buffer of color indexes
        SetIndexBuffer(1,buffer_color,INDICATOR_COLOR_INDEX);
//The order of buffers is changed!
        SetIndexBuffer(2,ExtPosBuffer,INDICATOR_CALCULATIONS);
   SetIndexBuffer(3,ExtNegBuffer,INDICATOR_CALCULATIONS);
//Set colors
   setPlotColor(0);
/////////////////////////////////////////////////////////////////////

//--- set accuracy
   IndicatorSetInteger(INDICATOR_DIGITS,2);
//--- sets first bar from what index will be drawn
   PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,ExtPeriodRSI);
//--- name for DataWindow and indicator subwindow label
   IndicatorSetString(INDICATOR_SHORTNAME,"RSI("+string(ExtPeriodRSI)+")");
//--- initialization done
  }
//+------------------------------------------------------------------+
//| Relative Strength Index                                          |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[])
  {
   int    i;
   double diff;
//--- check for rates count
   if(rates_total<=ExtPeriodRSI)
      return(0);
//--- preliminary calculations
   int pos=prev_calculated-1;
   if(pos<=ExtPeriodRSI)
     {
      //--- first RSIPeriod values of the indicator are not calculated
      ExtRSIBuffer[0]=0.0;
      ExtPosBuffer[0]=0.0;
      ExtNegBuffer[0]=0.0;
      double SumP=0.0;
      double SumN=0.0;
      for(i=1;i<=ExtPeriodRSI;i++)
        {
         ExtRSIBuffer[i]=0.0;
         ExtPosBuffer[i]=0.0;
         ExtNegBuffer[i]=0.0;
         diff=price[i]-price[i-1];
         SumP+=(diff>0?diff:0);
         SumN+=(diff<0?-diff:0);
        }
      //--- calculate first visible value
      ExtPosBuffer[ExtPeriodRSI]=SumP/ExtPeriodRSI;
      ExtNegBuffer[ExtPeriodRSI]=SumN/ExtPeriodRSI;
      ExtRSIBuffer[ExtPeriodRSI]=100.0-(100.0/(1.0+ExtPosBuffer[ExtPeriodRSI]/ExtNegBuffer[ExtPeriodRSI]));
      //--- prepare the position value for main calculation
      pos=ExtPeriodRSI+1;
     }
//--- the main loop of calculations
   for(i=pos;i<rates_total;i++)
     {
      diff=price[i]-price[i-1];
      ExtPosBuffer[i]=(ExtPosBuffer[i-1]*(ExtPeriodRSI-1)+(diff>0.0?diff:0.0))/ExtPeriodRSI;
      ExtNegBuffer[i]=(ExtNegBuffer[i-1]*(ExtPeriodRSI-1)+(diff<0.0?-diff:0.0))/ExtPeriodRSI;
      ExtRSIBuffer[i]=100.0-100.0/(1+ExtPosBuffer[i]/ExtNegBuffer[i]);
/////////////////////////////////////////////////////////////////////
//Paint it
                buffer_color[i] = getPlotColor(ExtRSIBuffer[i],0,100);
/////////////////////////////////////////////////////////////////////
     }
//--- OnCalculate done. Return new prev_calculated.
   return(rates_total);
  }
//+------------------------------------------------------------------+

İşte burada mumların rengini ve RSI'yi karşılaştırabilirsiniz.

Uzman Danışmandan/Göstergeden/Komut Dosyasından Göstergenin Renk Değeri Nasıl Alınır?

Çoğu zaman bir Uzman Danışmanda otomatik alım satım veya başka amaçlar için bir çizginin rengini elde etmek gerekir.

Uygulaması basittir, bir komut dosyası düşünelim.

//+------------------------------------------------------------------+
//|                                                         test.mq5 |
//|                                                             ProF |
//|                                                          http:// |
//+------------------------------------------------------------------+
#property copyright "ProF"
#property link      "http://"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
        int handle = 0; //handle of the indicator
        double tmp[1];  //temporary array for color index buffer.
        //Get the handle of our modified RSI
        handle = iCustom(_Symbol,_Period,"Examples\\RSI",6);
        
        //Let's remember, that values are stored in the buffer 1 of our modified RSI
        //The color indexes are stored in the buffer 0
        //Copying the data from the buffer "1" of the RSI indicator.
        CopyBuffer(handle,1,0,1,tmp);
        
        //Show alert with last color index, returned by RSI
        Alert(tmp[0]); //For example, if returned 0, it means that RSI
        //is painted with Green color and its current level is near 0.
  }
//+-----------------------------------------------------------------+

Rengin kendisinin değil, renk indisinin değerini elde edebileceğimizi unutmayın!

Renk indisleri ile renk değerleri arasındaki uyumu bilmelisiniz. Ayrıca, renk indislerinin tamponunu da bilmelisiniz.

Bunu bulmak için renk indisi ayarının kriterlerini anlamanız veya bu komut dosyasıyla veya başka yöntemlerle bunları deneysel olarak belirlemeniz gerekir.

Sonuç

Aşağıdaki MQL5 çizim stillerini inceledik: DRAW_COLOR_LINE, DRAW_COLOR_CANDLES. Mumları boyadık ve RSI göstergesinin nasıl boyanacağını öğrendik (DRAW_LINE -> DRAW_COLOR_LINE). Ek olarak, renk tamponu indislerinin değerinin nasıl elde edileceğini öğrendik.

MQL5 dilinin birçok çizim stili vardır, tek sınır hayal gücünüzdür. Renkli çizgilerin kullanılması piyasanın daha iyi görülmesini sağlar.

Daha rahat alım satım için yeni fırsatları kullanın.