Erkunden der Möglichkeiten mehrfarbige Kerzen zu erstellen

Einführung

In diesem Artikel gehe ich auf die Möglichkeiten ein, individuelle Indikatoren mit Kerzen-Charts zu erstellen und zeige deren Vor- und Nachteile auf. Ich werde dieses Thema in 4 Punkten behandeln:

1-Konstruktion von Kerzen mit nur einer Farbe ohne Unterscheidung zwischen Hoch- und Tief-Kerzen.

2-Konstruktion von mehrfarbigen Kerzen, die nach einer bestimmten Geschäftsregel gefärbt sind.

3-Konstruktion von Kerzen mit und ohne Füllung, mit einer Unterscheidung zwischen der Farbe der Füllung und der Farbe der Ränder der Kerzen.

4-Konstruktion von mehrfarbigen Kerzen mit und ohne Füllung.

Zunächst müssen wir die Gründe für die Anwendung von Färbungsregeln in Kerzencharts sowie die Bedeutung der richtigen Wahl für die Erstellung Ihres Indikators klären. Jede Methode hat ihre Besonderheiten, Vor- und Nachteile, die entweder auf die Interaktion des Nutzers mit dem Programm oder auf die Optimierung der Hardware-Nutzung durch das Programm zurückzuführen sind.

Besprechen wir zunächst ein Betriebsmodell, das mit 3 verschobenen Kurslinien arbeitet. Die erste Linie (schwarz) ist der Preis selbst, die zweite (blau) ist ein gleitender 1-Perioden-Durchschnitt, der 10 Perioden vorausgeschoben ist, und die dritte (rot) ist ein gleitender 1-Perioden-Durchschnitt, der 20 Perioden vorausgeschoben ist. Die Konstruktion des Modells auf einem Preisdiagramm ist unten zu sehen, wo ich zwei gleitende Durchschnitte eingefügt und das Preisdiagramm in eine Linie geändert habe.

Auf den ersten Blick ist dies ein unfreundliches Modell, das schwer zu interpretieren ist, da nicht nur die Farbe der Linie, sondern auch die Beziehung zwischen ihnen ermittelt werden muss. Dies führt oft zu Verwirrung und Fehlern bei der Entscheidungsfindung. Ein weiteres Modell, das zu Verwirrung und Fehlern führen kann, ist der Directional Movement Index Indikator, und zwar aus dem gleichen Grund, dass nicht nur die Farbe der Linien, sondern auch die Beziehung zwischen ihnen ermittelt werden muss.

Je mehr Variablen oder Indikatoren zu besprechen sind, desto häufiger kommt es zu Interpretationsfehlern, die zu widersprüchlichen Entscheidungen und Ergebnissen führen. Wir können so viele Indikatoren und Variablen verwenden, wie wir wollen, solange wir diese Daten in objektive und leicht verständliche Informationen umwandeln.

Die Verwendung von Färbungsregeln ist ein effizientes Mittel, um alle Informationen so zu verdichten, dass sie uns genau das sagen, was wir wissen wollen: wann wir kaufen oder verkaufen können und wann wir uns vom Markt fernhalten sollten. Wir können also die Informationen in 3 Farben zusammenfassen. Eine für den Kauf, eine für den Verkauf und eine für den Fall, dass es keine Bedingungen für den Kauf oder Verkauf gibt. In diesem Artikel werde ich mit Grün für den Kauf, Rot für den Verkauf und Gelb für die anderen Fälle arbeiten. Dies ist in der nachstehenden Tabelle zusammengefasst.

Farbe	Richtung
grün	Kauf
rot	Verkauf
gelb	neutral

Vergessen wir an dieser Stelle die Handelsregeln hinter der Farbgebung der Kerzen und schauen wir uns an, wie man in MQL5 Kerzengrafiken erstellt. Wenn Sie zum ersten Mal ein Programm für Metatrader 5 in MQL5 erstellen, empfehle ich Ihnen die Hilfe von MetaEditor, der Entwicklungsumgebung von Metatrader 5.

Aufbau eines Kerze-Charts

An dieser Stelle zeige ich, wie man einen einfachen Kerze-Chart erstellt und erkläre einige grundlegende Funktionen. Ein Kerzen-Chart besteht aus einer Reihe von Kerzen. Jede Kerze besteht aus vier Zahlen, dem Eröffnungs-, Höchst-, Tiefst- und Schlusskurs der Periode. Um festzustellen, ob es in der betreffenden Periode ein Hoch oder ein Tief gibt, wird geprüft, ob der Schlusskurs größer oder kleiner als der Eröffnungskurs ist. Wenn es sich um ein Hoch handelt, färben wir die Kerze grün, wenn es sich um ein Tief handelt, färben wir sie rot.

Beginnen wir mit der Erstellung eines Indikators mit dem MQL-Assistenten.

Wir geben unserem Indikator einen Namen und ändern die Copyright-Informationen, d.h. den Namen des Autors und die Adresse einer Webseite.

Wir verwenden die Funktion OnCalculate, die die Eröffnungs-, Höchst-, Tiefst- und Schlusskursreihen enthält.

Da es sich bei unserem Indikator um einen Kerzenchart handeln wird, wählen wir unter den Charttypen "Kerzenchart" aus und benennen das Label in Candles um. Dieser Name wird sowohl für die Nutzeroberfläche als auch für die Handhabung von Indikatorpuffern verwendet.

Dies ist der von unserem MQL-Assistenten erzeugte Code.

//+------------------------------------------------------------------+
//|                                                      Candles.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots   1
//--- plot Candle
#property indicator_label1  "Candle"
#property indicator_type1   DRAW_CANDLES
#property indicator_color1  clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- indicator buffers
double         CandleBuffer1[];
double         CandleBuffer2[];
double         CandleBuffer3[];
double         CandleBuffer4[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,CandleBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,CandleBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,CandleBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,CandleBuffer4,INDICATOR_DATA);

//---
   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[])
  {
//---

//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Jetzt müssen Sie nur noch den Code kompilieren und unser Kerzen-Indikator ist in unserem Dateibrowser in MetaTrader 5 verfügbar. Wenn Sie ihn jedoch auf dem Chart platzieren, wird er nicht korrekt angezeigt, da wir den Puffern des Indikators keine Werte zuweisen. Also holen wir das nach. In dieser ersten Methode haben wir 4 Puffer: CandleBuffer1[], CandleBuffer2[], CandleBuffer3[], CandleBuffer4[]. Die Verwendung dieser Puffer wird in der folgenden Tabelle erläutert.

Puffer	Preisreihen
CandleBuffer1	Eröffnungspreis
CandleBuffer2	Hoch
CandleBuffer3	Tief
CandleBuffer4	Schlusskurs

Die Anzahl der Puffer muss in unserem Code über die Eigenschaft indicator_buffers angegeben werden. Diese Arbeit wurde bereits vom MQL-Assistenten erledigt, aber Sie können die Anzahl der Puffer je nach Bedarf des Indikators ändern. Das werden wir später tun.

#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 4

Wir werden unseren Puffern in der Funktion OnCalculated Werte zuweisen, indem wir eine Schleife über die gesamte Preisspanne laufen lassen. Sobald jedoch ein Wert zugewiesen wurde, muss er nicht erneut zugewiesen werden, wenn die Größe der Reihe wächst. Das heißt, wenn wir in einem Funktionsaufruf n Kerzen haben und im nächsten Aufruf n + 1, brauchen wir nur die Werte für die letzte Kerze zu berechnen. In der Funktion OnCalcultate wird die Anzahl der Kerzen im Graphen durch den Parameter rates_total und die Anzahl der Kerzen, die beim letzten Aufruf der Funktion im Graphen waren, durch den Parameter prev_calculated bestimmt.

Dies ist das Ergebnis der Arbeit mit der Funktion OnCalculate.

//+------------------------------------------------------------------+
//| 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[])
  {
//---
   int start = prev_calculated;
   if(start>=rates_total)
      start = rates_total-1;

   for(int i = start; i<rates_total; i++)
     {
      CandleBuffer1[i]=open[i];
      CandleBuffer2[i]=high[i];
      CandleBuffer3[i]=low[i];
      CandleBuffer4[i]=close[i];
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }

Beachten Sie, dass in unserem Indikator alle Kerzen rot sind, was die Farbe ist, die wir im MQL-Assistenten definiert haben. Diese Farbe kann jedoch vom Nutzer geändert werden, ebenso wie sie in unserem Code über die Eigenschaft indicator_color1 geändert werden kann. Um mehr über das Definieren und Arbeiten mit Farben in MQL5 zu erfahren, lesen Sie die Dokumentation über Daten vom Typ Farbe.

//--- plot Candle
#property indicator_label1  "Candle"
#property indicator_type1   DRAW_CANDLES
#property indicator_color1  clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

Erstellung eines mehrfarbigen Kerze-Charts

Bisher haben wir die Erstellung eines Charts mit Kerzen ohne Unterscheidung von Farben oder Hoch- und Tiefpunktkerzen gesehen. Jetzt werden wir sehen, wie man mehrfarbige Kerzen nach einer bestimmten Geschäftsregel erstellt. Zunächst werden wir jedoch eine Regel verwenden, um hohe und niedrige Kerzen nur durch die Farbe zu unterscheiden.

Sie sehen, dass wir den Zeichnungstyp DRAW_CANDLES verwenden, der in den Indikatoreigenschaften unter indicator_type1 definiert ist. Wir können diese Eigenschaft in DRAW_COLOR_CANDLES ändern, um mit mehrfarbigen Kerzen zu arbeiten. Da der Zeichnungstyp DRAW_COLOR_CANDLES die Farben für jede Kerze speichern muss, haben wir einen zusätzlichen Puffer, den wir CandleColor nennen werden. Und die Anzahl der Puffer erhöht sich auf 5. Darüber hinaus müssen wir eine Farbe für die Eigenschaft indicator_color1 hinzufügen.

#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   1
//--- plot Candle
#property indicator_label1  "Candle"
#property indicator_type1   DRAW_COLOR_CANDLES
#property indicator_color1  clrGreen,clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- indicator buffers
double         CandleBuffer1[];
double         CandleBuffer2[];
double         CandleBuffer3[];
double         CandleBuffer4[];
double         CandleColor[];

Dann initialisieren wir den neuen CandleColor-Puffer, der die Farben der Kerzen speichern wird, indem wir den Compiler darüber informieren, dass wir diesen Puffer zum Speichern von Farben verwenden wollen. Wir tun dies mit der Funktion SetIndexBuffer und übergeben als Parameter INDICATOR_COLOR_INDEX . In unserem Fall mit zwei Farben, grün und rot, hat die erste Farbe den Index 0, die zweite den Index 1. Wenn wir n Farben in indicator_color1 definieren, haben wir die Farbindizes von 0 bis n-1;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,CandleBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,CandleBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,CandleBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,CandleBuffer4,INDICATOR_DATA);
   SetIndexBuffer(4,CandleColor,INDICATOR_COLOR_INDEX);

//---
   return(INIT_SUCCEEDED);
  }

Beachten Sie, dass diese Änderungen direkt im MQL-Assistenten vorgenommen werden können, der die Puffer sowie die Anzahl der benötigten Puffer definiert und initialisiert. Wir ändern einfach den Parameter des Zeichnungstyps auf DRAW_COLOR_CANDLES und seine Farben im Fenster des MQL-Assistenten. Dies ist ein sehr nützliches Verfahren, wenn Sie mit Indikatoren arbeiten wollen, die mehr als einen Zeichnungstyp auf dem Diagramm darstellen. Wir werden dies später sehen.

Jetzt müssen wir dem CandleColor-Puffer Werte zuweisen. Besprechen wir als Färbungsregel, dass der Abschluss größer ist als die Eröffnung der Kerze, also muss er grün sein, andernfalls muss er rot sein. Schauen wir uns an, wie das in der Funktion OnCalculate aussieht.

   for(int i = start; i<rates_total; i++)
     {
      CandleBuffer1[i]=open[i];
      CandleBuffer2[i]=high[i];
      CandleBuffer3[i]=low[i];
      CandleBuffer4[i]=close[i];

      //if the close price is higher than the open price we set the 
      //green color (index 0), otherwise, the red color (index 1)
      CandleColor[i]=(close[i]>open[i])?0:1;
 

Wie erwartet ist das Ergebnis ein Standard-Chart, der zwischen Auf- und Abwärtskerzen unterscheidet.

Ändern wir nun unsere Regel zur Farbgebung. Anstatt zwischen hohen und niedrigen Kerzen zu unterscheiden, werden wir eine sehr einfache Handelsregel verwenden, da wir im nächsten Thema eine andere Möglichkeit zur Unterscheidung von hohen und niedrigen Kerzen sehen werden.

Besprechen wir das zu Beginn des Artikels vorgestellte Geschäftsmodell. Wir haben als Handelsregel, dass wir kaufen wollen, wenn die schwarze Linie (Schlusskurs) größer ist als die blaue Linie (Schlusskurse, verschoben um 10 Balken) und die rote Linie (Schlusskurse, verschoben um 20 Balken). Wenn die schwarze Linie (Schlusskurs) kleiner ist als die blaue und die rote Linie, dann wollen wir verkaufen. In den anderen Fällen müssen wir auf eine Definition der Marktrichtung warten. Diese Regel ist in der folgenden Tabelle zusammengefasst.

Handelsregeln	Kerzenfarbe
close[0] > close[10] und close[0] > close[20]	grün
close[0] < close[10] und close[0] < close[20]	rot
close[0] > close[10] und close[0] < close[20]	gelb
close[0] < close[10] und close[0] > close[20]	gelb

Für dieses Modell müssen wir der Eigenschaft Indicator_color1 eine weitere Farbe hinzufügen.

#property indicator_color1 clrGreen,clrRed,clrYellow

Wir können nun unsere Regel in unserem Code definieren und entsprechend Werte zuweisen. Dies ist das Ergebnis in der Funktion OnCalculate;

  {
//---
   int start = prev_calculated;
   if(prev_calculated<20)
      start = 20;
   if(start>=rates_total)
      start = rates_total-1;

   for(int i = start; i<rates_total; i++)
     {
      CandleBuffer1[i]=open[i];
      CandleBuffer2[i]=high[i];
      CandleBuffer3[i]=low[i];
      CandleBuffer4[i]=close[i];

      //Close[0] > Close[10] and Close[0] > Close[20]
      bool buy = close[i]>close[i-10] && close[i]>close[i-20];

      //Close[0] < Close[10] and Close[0] < Close[20]
      bool sell  = close[i]<close[i-10] && close[i]<close[i-20];

      CandleColor[i]=(buy)?0:(sell)?1:2;
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }

Und so sieht nun unser neuer Indikator aus:

Schauen wir uns nun die Nutzeroberfläche des Indikator-Parameterfensters in Metatrader 5 an. Durch einen Doppelklick auf den Indikator im Chart wird das Parameterfenster geöffnet. In der Abbildung unten sehen wir, dass die Farben als Parameter übergeben werden, ohne dass angegeben wird, welche Farbe sich auf die Kauf-, Verkaufs- und neutrale Bedingung bezieht. Wenn wir mit mehr Farben arbeiten wollen, z. B. mit 6 Farben, kann dies für den Nutzer verwirrend sein. Daher müssen wir dem Nutzer erklären, was die einzelnen Farben bedeuten. Wir werden dies im letzten Thema dieses Artikels tun.

Konstruktion von Kerze-Charts mit und ohne Füllung

Kehren wir zu unserem ursprünglichen Code zurück, mit Kerzen einer einzigen Farbe. Erinnern Sie sich, dass wir den Entwurfstyp DRAW_CANDLES mit 4 Puffern verwendet haben. Wir können zwischen der Füllfarbe und der Farbe der Kerzenränder unterscheiden, indem wir einfach zwei Farben in unserer Eigenschaft indicator_color1 definieren. So wird die erste Farbe für die Ränder und die zweite für die Füllung der Kerzen verwendet. Zur Demonstration sehen wir uns das Ergebnis in Schwarz-Weiß an.

#property indicator_type1   DRAW_CANDLES
#property indicator_color1  clrBlack,clrWhite

Wenn wir in unserer Eigenschaft indicator_color1 3 Farben definieren, haben wir nun eine Unterscheidung zwischen Auf- und Abwärtskerzen. Diese Form der Konstruktion der Kerzen ersetzt die erste Färbungsregel, die wir in diesem Artikel erstellt haben. Der große Unterschied besteht darin, dass wir mit 4 Puffern fortfahren und die Farbe der Kanten definieren können. In diesem Fall wird die erste Farbe auf die Ränder der Kerzen angewendet, die zweite auf Aufwärtskerzen und die dritte auf die Abwärtskerzen. Diese Möglichkeit wird im Folgenden demonstriert, wobei die dritte Farbe als dunkelgrau definiert wurde, um sich von den Rändern zu unterscheiden.

#property indicator_type1   DRAW_CANDLES
#property indicator_color1  clrBlack,clrWhite,clrDarkGray

Konstruktion eines Charts mit mehrfarbigen Kerzen mit und ohne Füllung

Zum Abschluss unserer Studie über das Erstellen von mehrfarbigen Kerzen in MQL5 werden wir die Nutzeroberfläche im Parameterfenster des Indikators informativer gestalten. Dies ist ein Zwischenschritt zur Erstellung von mehrfarbigen Kerzen mit und ohne Füllung. Außerdem ist die Anzahl der benötigten Puffer für beide gleich, aber höher als die Anzahl der Puffer in den bisher gesehenen Versionen. Das liegt daran, dass wir nicht für alle Farben ein Muster zeichnen, sondern für jede Farbe ein Muster. In unserem Modell werden wir 3 Zeichnungen haben, eine für den Kauf, eine für den Verkauf und eine für die anderen Bedingungen, wie am Anfang des Artikels vorgeschlagen. Das heißt, wir werden 12 Puffer haben, um dieses Modell umzusetzen. Außerdem werden wir dieselbe Geschäftsregel verwenden, die auf den versetzten Preisen basiert, die wir zuvor gesehen haben.

Auch hier werden wir den MQL-Assistenten verwenden, um die Schritte zur Definition und Initialisierung der 12 Puffer zu überspringen. Anstelle des Kerzenmodells werden wir die Modelle Kaufen, Verkaufen und Neutral verwenden.

Wir wollen nicht, dass alle Zeichnungen gleichzeitig angezeigt werden. Wir wollen, dass gemäß der Geschäftsregel eine der Zeichnungen angezeigt wird und die anderen ausgeblendet werden. Dazu müssen die ausgeblendeten Kerzenpuffer mit einem leeren Wert gefüllt werden. Der erste Schritt besteht also darin, die Werte zu definieren, für die die Zeichnung ausgelassen werden soll. Dazu verwenden wir die Funktion PlotIndexSetDouble wie unten gezeigt.

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,BuyBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,BuyBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,BuyBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,BuyBuffer4,INDICATOR_DATA);
   SetIndexBuffer(4,SellBuffer1,INDICATOR_DATA);
   SetIndexBuffer(5,SellBuffer2,INDICATOR_DATA);
   SetIndexBuffer(6,SellBuffer3,INDICATOR_DATA);
   SetIndexBuffer(7,SellBuffer4,INDICATOR_DATA);
   SetIndexBuffer(8,NeutralBuffer1,INDICATOR_DATA);
   SetIndexBuffer(9,NeutralBuffer2,INDICATOR_DATA);
   SetIndexBuffer(10,NeutralBuffer3,INDICATOR_DATA);
   SetIndexBuffer(11,NeutralBuffer4,INDICATOR_DATA);

   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(2,PLOT_EMPTY_VALUE,0.0);

//---
   return(INIT_SUCCEEDED);
  }

In unserem Fall verwenden wir den Wert 0.0, um leere Werte in unseren Puffern zu definieren. Die Werte 0, 1 und 2, die als erster Parameter in der Funktion PlotIndexSetDouble übergeben werden, sind der Index der Zeichnung, die auf dem Preisdiagramm gezeichnet werden soll. Dieser Index ist derselbe, der bei der Deklaration der Eigenschaften unserer Indikatorentwürfe verwendet wird.

Jetzt müssen wir nur noch unsere Funktion OnCalculate bearbeiten und die zuvor erstellte Geschäftsregel anwenden. Da nur eine der Zeichnungen angezeigt werden muss, können wir alle Zeichnungen als nicht sichtbar definieren, indem wir allen Kerzen bei jedem Aufruf der OnCalculate-Funktion den Wert 0,0 zuweisen. Als Nächstes weisen wir den Kerzen in der Zeichnung, die wir gemäß der Geschäftsregel anzeigen wollen, die Werte für Öffnung, Maximum, Minimum und Schluss zu. Das Ergebnis der Arbeit ist unten dargestellt.

  {
//---
   int start = prev_calculated;
   if(prev_calculated<20)
      start = 20;
   if(start>=rates_total)
      start = rates_total-1;

   for(int i = start; i<rates_total; i++)
     {
      //initializing the candles data
      BuyBuffer1[i]=0.0;
      BuyBuffer2[i]=0.0;
      BuyBuffer3[i]=0.0;
      BuyBuffer4[i]=0.0;

      SellBuffer1[i]=0.0;
      SellBuffer2[i]=0.0;
      SellBuffer3[i]=0.0;
      SellBuffer4[i]=0.0;

      NeutralBuffer1[i]=0.0;
      NeutralBuffer2[i]=0.0;
      NeutralBuffer3[i]=0.0;
      NeutralBuffer4[i]=0.0;

      //Close[0] > Close[10] e Close[0] > Close[20]
      bool buy= close[i]>close[i-10] && close[i]>close[i-20];

      //Close[0] < Close[10] e Close[0] < Close[20]
      bool sell= close[i]<close[i-10] && close[i]<close[i-20];

      //Setting the values to the candles according to the trading rules
      if(buy)
        {
         BuyBuffer1[i]=open[i];
         BuyBuffer2[i]=high[i];
         BuyBuffer3[i]=low[i];
         BuyBuffer4[i]=close[i];
        }
      else
         if(sell)
           {
            SellBuffer1[i]=open[i];
            SellBuffer2[i]=high[i];
            SellBuffer3[i]=low[i];
            SellBuffer4[i]=close[i];
           }
         else
           {
            NeutralBuffer1[i]=open[i];
            NeutralBuffer2[i]=high[i];
            NeutralBuffer3[i]=low[i];
            NeutralBuffer4[i]=close[i];
           }

     }

//--- return value of prev_calculated for next call
   return(rates_total);
  }

Das visuelle Ergebnis ist genau dasselbe wie bei der Verwendung des Zeichnungstyps DRAW_COLOR_CANDLES. Der große Vorteil dieser letzten Methode besteht darin, dass wir eine informativere Nutzeroberfläche erhalten, obwohl die Anzahl der benötigten Puffer erheblich steigt. Wir können diesen Vorteil jedoch noch weiter ausbauen, indem wir dafür sorgen, dass unsere Färbungsregel nicht nur Informationen über Geschäftsregeln, sondern auch über die Unterscheidung zwischen bullischen und bearischen Kerzen liefert. Dies ist einfach möglich, indem wir mit den Randfarben und Füllungen der zuvor betrachteten Kerzen arbeiten. Für jedes Design wollen wir, dass die Ränder und die Füllung der niedrigen Kerzen dieselbe Farbe haben, während wir für die Füllung der hohen Kerzen die Farbe Weiß verwenden, um in einem Chart mit weißem Hintergrund die Illusion von ungefüllten Kerzen zu erzeugen. Dieses Farbmuster ist in der folgenden Tabelle vereinfacht dargestellt.

Handelsregeln	border	positive Füllung	negative Füllung
Kauf	grün	weiß	grün
Verkauf	rot	weiß	rot
neutral	gelb	weiß	gelb

Die Änderungen an unserem Code sind unten aufgeführt.

#property indicator_color1  clrGreen,clrWhite,clrGreen

#property indicator_color2  clrRed,clrWhite,clrRed

#property indicator_color3  clrYellow,clrWhite,clrYellow

Damit sind wir beim Ziel dieses Artikels angelangt, nämlich der Demonstration der Erstellung von Färbungsregeln gemäß einer Geschäftsregel, die auf einen Kerzenchart mit und ohne Füllung angewendet wird. Das Endergebnis unserer Arbeit ist in der folgenden Abbildung zu sehen.

Schlussfolgerung

Wir haben gesehen, dass wir Kerzendiagramme mit zwei Designtypen erstellen können, DRAW_CANDLES und DRAW_COLOR_CANDLES, wir haben gesehen, wie man eine Färbungsregel auf der Grundlage einer Handelsregel auf das Kerzendiagramm anwendet, und wie man Farben zwischen den Rändern und der Füllung der Kerzen unterscheidet, was uns erlaubt, die Kerzen zu färben und dabei die Unterscheidung zwischen Auf- und Abwärtskerzen beizubehalten. Es ist wichtig zu beachten, dass je nach Zweck des nutzerdefinierten Indikators, die Unterscheidung zwischen niedrigen und hohen Kerzen möglicherweise nicht relevant ist, sowie, wenn die Anzahl der Farben sehr groß ist, zum Beispiel, 10 Farben, kann es nicht bequem sein, die letzte Methode vorgestellt zu verwenden, da es die Anzahl der Puffer zu viel erhöhen würde, was zu einer größeren Nutzung der Hardware des Nutzers.

In diesem Fall gibt es zwei Möglichkeiten, die verwendet werden können, anstatt die Anwendbarkeit jeder Farbe im Parameterfenster des Indikators zu erklären. Sie können den Zeichnungstyp DRAW_COLOR_CANDLES verwenden, oder wir können den Zeichnungstyp DRAW_CANDLES verwenden, um die Illusion von ungefüllten Kerzen zu erzeugen, indem wir die Ränder und die Füllung der niedrigen Kerzen in diesem Zeichnungstyp transparent machen, während die Füllung der niedrigen Kerzen die Farbe der Unterseite des Preisdiagramms sein wird, wodurch die Unterscheidung zwischen Auf- und Abwärtskerzen, die der Zeichnung DRAW_COLOR_CANDLES überlagert sind, für die Anwendung der Färbung gemäß der Geschäftsregel.