MetaTrader 5 herunterladen

Bibliothek für die Erstellung von Diagrammen über die Google Chart API

9 März 2016, 13:23
Евгений
0
251

Einleitung

Mit Google Chart können 11 verschiedene Typen von Diagrammen erstellt werden. Diese sind:
  1. Liniendiagramme
  2. Balkendiagramme
  3. Punktdiagramme
  4. Radardiagramme
  5. Kerzendiagramme
  6. Venn-Diagramme
  7. QR-Codes
  8. Karten
  9. Formeln
  10. Graphen
  11. Kreisdiagramme 

Eine zum Arbeiten völlig ausreichende Sammlung. Wie in der Beschreibung des Beitrags bemerkt, ist alles, was Sie tun müssen, um ein fertiges Diagramm abzurufen, eine speziell aufgebaute Anfrage an den Google-Server zu senden. Ein einfaches Beispiel dafür, wie dies bewerkstelligt wird, wird im Beitrag Erstellen einer Anzeigetafel unter Verwendung der Klassen aus der Standardbibliothek und Google Chart API beschrieben, doch das ist nicht einmal ein Zehntel dessen, was der Service noch zu bieten hat. Um eine Anfrage ordentlich zusammenzustellen, müssen wir natürlich ihre Struktur und ihre Schlüsselwörter untersuchen. Deshalb versuchen wir in diesem Beitrag, eine Klassenbibliothek zu erstellen, die es dem Benutzer ermöglichen wird, das gewünschte Diagramm schnell zu erstellen und dieses in seinem eigenen Diagramm zu platzieren, sowie die Daten, auf deren Basis das Diagramm konstruiert wurde, dynamisch zu aktualisieren.

Es muss von vorneherein klargestellt werden, dass in diesem Beitrag keine massiven Berechnungen des Bibliothekscodes stattfinden. Stattdessen wurde ein mithilfe von Doxygen (Details im Beitrag Automatisch generierte Dokumentation für MQL5-Code) erstelltes Zertifikat angehängt. Darin finden Sie Beschreibungen öffentlicher Methoden von Bibliotheksklassen und Dokumentationen zu Aufzählungen und Ausnahmen, die während der Erstellung des Diagramms entstehen. 

1. Beschreibung der Mittel zum Abrufen und Darstellen von Diagrammen

Fangen wir am Ende an. Nehmen wir an, dass wir die Anfrage korrekt formuliert haben. Nun müssen Sie sie an den Server senden, die Antwort in einer Datei aufzeichnen und die Datei an ein grafisches Objekt auf dem Diagramm anhängen, um das Diagramm anzuzeigen. Für die Arbeit mit dem Internet nutzen wir die Funktionen, die im Beitrag Nutzung von WinInet.dll für den Datenaustausch zwischen Terminals über das Internet beschrieben werden.

Es gibt auch einen kleinen Haken: Die Komponenten, die für die Darstellung von Bildern gedacht sind (Bild und Grafikbeschriftung) funktionieren nur mit Bildern im BMP-Format, während man von Google Chart nur PNG oder GIF erhält. Also müssen Sie das Bild konvertieren. Dies wird mit der Funktion Convert_PNG() bewerkstelligt. Der Code der Funktion zum Abrufen des Diagramms sieht so aus:

bool CDiagram::GetChart()
{
   if(!ObjExist()) {SetUserError(DIAGRAM_ERR_OBJ_NOT_EXIST); return false;}
   string request=CreateRequest();
   //Print(request);
   if(StringLen(request)>2048) {SetUserError(DIAGRAM_ERR_TOO_LARGE_REQUEST); return false;}
   //try to establish a connection
   int rv=InternetAttemptConnect(0);
   if(rv!=0) {SetUserError(DIAGRAM_ERR_INTERNET_CONNECT_FAILED); return false;}
   //initialize the structures
   int hInternetSession=InternetOpenW("Microsoft Internet Explorer", 0, "", "", 0);
   if(hInternetSession<=0) {SetUserError(DIAGRAM_ERR_INTERNET_CONNECT_FAILED); return false;}
   //send request
   int hURL=InternetOpenUrlW(hInternetSession, request, "", 0, 0, 0);
   if(hURL<=0) SetUserError(DIAGRAM_ERR_INTERNET_CONNECT_FAILED);
   //prepare the paths for conversion 
   CString src;
   src.Assign(TerminalInfoString(TERMINAL_PATH));
   src.Append("\MQL5\Files\\"+name+".png");
   src.Replace("\\","\\\\");
   CString dst;
   dst.Assign(TerminalInfoString(TERMINAL_PATH));
   dst.Append("\MQL5\Images\\"+name+".bmp");
   dst.Replace("\\","\\\\");
   DeleteFileW(dst.Str());
   DeleteFileW(src.Str());
   CFileBin chart_file;//file into which the results are recorded
                       //create it
   chart_file.Open(name+".png",FILE_BIN|FILE_WRITE);
   //****************************   
   int dwBytesRead[1];// number of recorded documents
   char readed[1000];//the actual data
                    //read the data, received from the server after the request
   while(InternetReadFile(hURL,readed,1000,dwBytesRead))
     {
      if(dwBytesRead[0]<=0) break;//no data - exit
      chart_file.WriteCharArray(readed,0,dwBytesRead[0]);//record the data into the file
     }
   InternetCloseHandle(hInternetSession);//terminate the connection
   chart_file.Close();//and file
   //convert the file
   if(!Convert_PNG(src.Str(), dst.Str())) SetUserError(DIAGRAM_ERR_IMAGE_CONVERSION_FAILED);
   //attach the file to the graphic object
   switch (obj_type)
   {
      case OBJ_BITMAP: 
      {
         ObjectSetString(chart_ID, name, OBJPROP_BMPFILE, name+".bmp"); 
         return true;
      }
      case OBJ_BITMAP_LABEL:
      {
         ObjectSetString(chart_ID, name, OBJPROP_BMPFILE, 0, name+".bmp"); 
         ObjectSetString(chart_ID, name, OBJPROP_BMPFILE, 1, name+".bmp"); 
         return true;
      }
      default: return false;
   }
   //redraw the chart   
   ChartRedraw();
}
Beachten Sie, dass ich während der Erstellung der Google-Charts-Bibliothek ausgiebig Klassen der Standardbibliothek nutze. Dafür möchte ich ihren Entwicklern besonders danken.

2. Übersicht der Komponenten der Google-Charts-Bibliothek

Die Serveranfrage sollte beginnen, wie folgt: http://chart.apis.google.com/chart?cht=, im Weiteren müssen Sie den Diagrammtyp und erst daraufhin alle anderen Parameter angeben. Abgesehen von der Kopfzeile, besteht die Anfrage aus Befehlen und deren Parametern. Die Befehle werden durch das Zeichen "&" voneinander getrennt. Beispielsweise legt der Befehl &Chtt=Title das Wort "Title" in der Kopfzeile des Diagramms fest.

Fahren wir also fort. 

2.1 Liniendiagramme

Das ist das wahrscheinlich am häufigsten verwendete Diagramm, das über die größte Menge an Eigenschaften verfügt. Das Diagramm wird durch die Klasse CLineXYChart konstruiert. Beispiel:

CLineXYChart chart;
chart.Attach(0, "test diagram");
chart.SetSize(200,200);
double Y[10]={-50, -40, -25, -35, 10, 50, 70, 40, 15, 80};
chart.AddLine(Y, Red, 0, "Test line");
chart.GetChart();

Als Ergebnis sehen Sie in der Komponente "Test diagram" das folgende Bild:

  Abbildung 1. Einfaches Beispiel für die Konstruktion eines Liniendiagramms

Denken Sie daran, dass ein Zertifikat von Klassenmethoden im angehängten Zertifikat gefunden werden kann. Hier sehen Sie einige Beispiele für seine Verwendung.

Machen Sie das Diagramm durch Hinzufügen einer weiteren Linie, einer Achse und eines Gitters komplexer:

//create a copy of the class
CLineXYChart chart;
//attach it to the object constructed earlier
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(200,200);
//prepare the data
double Y2[10]={-70, -5, 6, 8, 10, 20, 100, 130, 90, 60};
double Y[10]={-50, -40, -25, -35, 10, 50, 70, 40, 15, 80};
//add lines
chart.AddLine(Y, Red, 0, "Test line");
chart.AddLine(Y2, Blue, 0, "Test line 2");
//axis
chart.SetAxis(DIAGRAM_AXIS_BOTTOM|DIAGRAM_AXIS_LEFT, -1, 0, 0, 10, 0);
//and grid
chart.SetGrid();
//obtain the chart
chart.GetChart();

Das Diagramm sieht nun aus, wie in der folgenden Abbildung dargestellt. Eine Besonderheit sollte beachtet werden: Die Methode GetChart() muss nach den anderen Methoden aufgerufen werden, da es sich dabei um die Methode handelt, die das Diagramm abruft.

  Abbildung 2. Komplexeres Beispiel für ein Liniendiagramm

Doch das ist noch nicht alles. Fügen Sie die Marker, den Titel, die Legende und die Füllung hinzu:

//create a class copy
CLineXYChart chart;
//attach it to the object created earlier
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(500,300);
//prepare the data
double Y2[10]={-70, -5, 6, 8, 10, 20, 100, 130, 90, 60};
double Y[10]={-50, -40, -25, -35, 10, 50, 70, 40, 15, 80};
//add lines
int first_line=chart.AddLine(Y, Red, 0, "Test line");
int second_line=chart.AddLine(Y2, Blue, 0, "Test line 2");
//axis
chart.SetAxis(DIAGRAM_AXIS_BOTTOM|DIAGRAM_AXIS_LEFT, -1, 0, 0, 10, 0);
//grid
chart.SetGrid();
//legend
chart.ShowLegend();
//title
chart.SetTitle("My Chart", Green, 15);
//filling
chart.SetFill(Linen);
//markers
chart.SetLineMarker(first_line, DIAGRAM_LINE_MARKERS_DIAMOND, BlueViolet, 10);
chart.SetLineMarker(second_line, DIAGRAM_LINE_MARKERS_CROSS, YellowGreen, 15);
//obtain the chart
chart.GetChart();

Für die Konfiguration der Eigenschaften, die jeweils zu einer bestimmten Linie gehören, nutzen wir Identifikatoren (first_line und second_line), die dann an die jeweiligen Methoden übergeben werden. 

Abbildung 3. Ein noch komplexeres Beispiel für ein Liniendiagramm

Doch auch das ist noch nicht alles. Man kann der Linie Beschriftungen hinzufügen, den Bereich unter der Linie und zwischen den Linien ausfüllen, die Linien skalieren und eine Linie zur sekundären Achse hinzufügen:

//create a class copy
CLineXYChart chart;
//attach it to the object created earlier
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(700,400);
//prepare the data
double Y3[10]={1000, 1200, 1800, 1700, 1300, 900, 700, 750, 800, 600};
double X3[10]={2, 4, 5, 6, 10, 15, 17, 20, 21, 23};
double Y2[10]={-70, -5, 6, 8, 10, 20, 100, 130, 90, 60};
double Y[10]={-50, -40, -25, -35, 10, 50, 70, 40, 15, 80};
//add lines
int first_line=chart.AddLine(Y, Red, 0, "Test line");
int second_line=chart.AddLine(Y2, Blue, 0, "Test line 2");
int third_line=chart.AddLine(Y3, X3, Green, 0, "Test line 3");
//major axis
chart.SetAxis(DIAGRAM_AXIS_BOTTOM|DIAGRAM_AXIS_LEFT, -1, 0, 0, 10, 0);
//minor axis 
chart.SetAxis(DIAGRAM_AXIS_RIGHT|DIAGRAM_AXIS_TOP, third_line, 0, Red, 15, 2);
//grid
chart.SetGrid();
//legend
chart.ShowLegend(DIAGRAM_LEGEND_POSITION_BOTTOM_HORIZONTAL);
//title
chart.SetTitle("My Chart", Green, 15);
//filling in the chart
chart.SetFill(Linen, Silver);
//markers
chart.SetLineMarker(first_line, DIAGRAM_LINE_MARKERS_DIAMOND, BlueViolet, 10);
chart.SetLineMarker(second_line, DIAGRAM_LINE_MARKERS_CROSS, YellowGreen, 15);
//set the filling between the two lines
chart.SetLineFilling(first_line, Lime , second_line);
//add tags
chart.AddLabel(first_line, DIAGRAM_LABEL_TYPE_FLAG, 5, "Flag", Red, 15); 
chart.AddLabel(second_line, DIAGRAM_LABELS_TYPE_ANNOTATION, 3, "annotation", Blue, 25);
//slightly compress the lines (by 20%)
chart.SetLineScaling(second_line, false, 20);
//attach the third line to the minor axis
chart.SetLineScaling(third_line, true, 20);
//obtain the chart
chart.GetChart();

  Abbildung 4. Alle Merkmale des Liniendiagramms

Wenn Sie die Daten des Diagramms dynamisch aktualisieren möchten, können Sie die Methode SetLineData() nutzen oder die Linie mit alten Daten mithilfe von DeleteLine() vollständig entfernen und eine neue erstellen. Die erstgenannte Methode ist allerdings vorzuziehen.

2.2 Balkendiagramme

Diese Art von Diagramm wird auch "Histogramm" genannt. Dieser Diagrammtyp wird durch die Klasse CBarChart erstellt. Aufgrund der fehlenden Marker, der Notwendigkeit, einen Datensatz für die X-Achse zu definieren, und des Vorhandenseins bestimmter Merkmale, die für Diagramme dieses Typen charakteristisch sind, unterscheidet er sich von CLineXYChart. In allen anderen Belangen funktioniert er genauso wie CLineXYChart.

Beispiel:

CBarChart chart;
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(700,400);
//prepare the data
double Y3[10]={100, 120, 18, 17, 13, 9, 70, 75, 80, 60};
double Y2[10]={70, 5, 6, 8, 10, 20, 100, 130, 90, 60};
double Y[10]={50, 40, 25, 35, 10, 50, 70, 40, 15, 80};
//add lines
int first_line=chart.AddLine(Y, Red, 0, "Test bar 1");
int second_line=chart.AddLine(Y2, Blue, 0, "Test bar 2");
int third_line=chart.AddLine(Y3, Green, 0, "Test bar 3");
//major axis
chart.SetAxis(DIAGRAM_AXIS_BOTTOM|DIAGRAM_AXIS_LEFT, -1, 0, 0, 10, 0);
//grid
chart.SetGrid();
//legend
chart.ShowLegend();
//title
chart.SetTitle("My Chart", Green, 15);
//chart filling
chart.SetFill(Linen, Silver);
//obtain the chart
chart.GetChart(); 

 

Abbildung 5. Beispiel eines Balkendiagramms

Beachten Sie, dass wir über drei Datensätze verfügen und die Balken in einer für die Anzeige optimierten Reihenfolge übereinander angeordnet sind. Allerdings können die Säulen auch auf eine andere Art gruppiert werden. Diese wird mithilfe der Methode SetGrouped() festgelegt:

 / / Set the grouping  chart.SetGrouped (true);

  Abbildung 6. Beispiel eines Balkendiagramms mit einer anderen Art der Gruppierung der Säulen

Wie Sie sehen können, befinden sich die Säulen nun nicht übereinander, sondern sind nach der Reihenfolge ihrer Erstellung angeordnet.

2.3 Kreisdiagramme

Die Klasse CPieChart konstruiert ein Kreisdiagramm. Sie können ein zweidimensionales sowie ein dreidimensionales Diagramm erstellen:

CPieChart chart;
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(300,200);
//add sections
chart.AddPieSlice(10, 0, Red, 0, "Test slice 1");
chart.AddPieSlice(20, 0, Green, 0, "Test slice 2");
chart.AddPieSlice(30, 0, Blue, 0, "Test slice 3");
//legends
chart.ShowLegend();
//title
chart.SetTitle("My Chart", Green, 15);
//display mode - 2D
chart.SetPieType(true);
//obtain the chart
chart.GetChart();  

Abbildung 7. 2- und 3-dimensionale Beispiele von Kreisdiagrammen

Abbildung 7. 2- und 3-dimensionale Beispiele von Kreisdiagrammen

Die Darstellungsart (2D oder 3D) wird durch den Aufruf der Methode SetPieType() festgelegt. Ein weiteres nützliches Merkmal ist die Möglichkeit, mehrere Ringe festzulegen. In diesem Fall ist allerdings nur die 2-dimensionale Darstellung möglich. Für die Festlegung des zweiten Rings definieren Sie den Parameter dimensional der Methode AddPieSlice() als ungleich Null:

//add the second ring
chart.AddPieSlice(50, 1, YellowGreen, 0, "Test ring 1");
chart.AddPieSlice(20, 1, Magenta, 0, "Test ring 2");
chart.AddPieSlice(70, 1, Maroon, 0, "Test ring 3");

  Abbildung 8. Konzentrisches Kreisdiagramm

Beachten Sie, dass das oben abgebildete Diagramm ausgelagerte Sektorbeschriftungen aufweist. Diese werden durch die Methode SetPieLabels() festgelegt und können eine Legende ersetzen. Es gibt allerdings einen Nachteil: Die Größe der Beschriftungen wird nicht automatisch an die Größe des Diagramms angepasst, was dazu führen kann, dass sie über die Grenzen des Diagramms hinausgehen. In diesem Fall müssen Sie die Breite des Diagramms erhöhen. Für diesen Diagrammtyp können keine Gitter, Achsen, Marker oder Skalen festgelegt werden. Sektoren können durch die Methode DeleteLine() entfernt werden.

2.4 Radardiagramme

Die Klasse CRadarChart konstruiert Radardiagramme. Es gibt keinen Unterschied zur Klasse CLineXYChart. Alle ihre Methoden sind in CRadarChart verfügbar:

CRadarChart chart;
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(300,300);
//add lines
double Y3[10]={100, 120, 18, 17, 13, 9, 70, 75, 80, 60};
double Y2[10]={70, 5, 6, 8, 10, 20, 100, 130, 90, 60};
double Y[10]={50, 40, 25, 35, 10, 50, 70, 40, 15, 80};
int first_line=chart.AddLine(Y, Red, 0, "Test line");
int second_line=chart.AddLine(Y2, Blue, 0, "Test line 2");
int third_line=chart.AddLine(Y3, Green, 0, "Test line 3");
//set the filling between the two lines
chart.SetLineFilling(first_line, Lime , second_line);
//markers
chart.SetLineMarker(first_line, DIAGRAM_LINE_MARKERS_CIRCLE, BlueViolet, 10);
chart.SetLineMarker(second_line, DIAGRAM_LINE_MARKERS_DIAMOND, YellowGreen, 15);
//title
chart.SetTitle("My Chart", Green, 15);
//grid
chart.SetGrid();
//legend
chart.ShowLegend(DIAGRAM_LEGEND_POSITION_BOTTOM_HORIZONTAL);
//obtain the chart
chart.GetChart();

Abbildung 9. Radardiagramme

2.5 Kerzendiagramme

Die Klasse CCandleChart konstruiert das Kerzendiagramm. Die Kerzen werden durch die Methode AddCandles() hinzugefügt:

CCandleChart chart;
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(300,300);
//add 10 candlesticks to the current chart
double Open[10], Close[10], High[10], Low[10];
CopyOpen(Symbol(), PERIOD_CURRENT, 0, 10, Open);
CopyClose(Symbol(), PERIOD_CURRENT, 0, 10, Close);
CopyHigh(Symbol(), PERIOD_CURRENT, 0, 10, High);
CopyLow(Symbol(), PERIOD_CURRENT, 0, 10, Low);
chart.AddCandles(Open, Close, High, Low);
//title
chart.SetTitle(Symbol(), Green, 15);
//grid
chart.SetGrid();
//major axis
chart.SetAxis(DIAGRAM_AXIS_LEFT, -1, 0, 0, 10, 4);
//obtain the chart
chart.GetChart();

  Abbildung 10. Kerzendiagramm

Für diesen Diagrammtyp sind keine Marker, Legenden oder Beschriftungen verfügbar. 

2.6 Formeln

Mit der Klasse CFormulaChart können Sie eine Formel erstellen. Die Formel wird in Form einer Zeile in der Sprache TeX an die Methode SetFormulaString() übergeben:

CFormulaChart chart;
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(300,75);
//add the formula
chart.SetFormulaString("x=-b\pm\sqrt{b^2-4ac}\over(2a)");
//its color
chart.SetFormulaColor(Blue);
//title
chart.GetChart();

Abbildung 11. Formeln

Die Füllung kann ebenso mithilfe der Methode SetFill() festgelegt werden. Es werden keine weiteren Funktionen unterstützt.

2.7 Graphen

Das Diagramm wird durch die Klasse CGraphChart konstruiert. Die Methoden AddNode() und AddEdge() fügen Knoten und Kanten zum Diagramm hinzu:

CGraphChart chart;
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(300,220);
//add nodes and edges
int A=chart.AddNode("A");
int B=chart.AddNode("B");
int C=chart.AddNode("C");
int D=chart.AddNode("D");
chart.AddEdge(A,B);
chart.AddEdge(B,C);
chart.AddEdge(C,D);
chart.AddEdge(A,C);
//set the engine
chart.SetEngine(DIAGRAM_GRAPH_ENGINE_NEATO);
//and arrows
chart.SetGraphType(false);
//title
chart.GetChart();

  

Abbildung 11. Graphen

Die Methode SetEngine() legt einen bestimmten Typen von Grafik-Engine fest, die für die Konstruktion des Graphen genutzt wird. Sie können selbst frei damit experimentieren. Die Methoden DeleteNode() und DeleteEdge() entfernen die Knoten und Kanten aus dem Diagramm. 

2.8 Venn-Diagramme

Die Klasse CVennChart konstruiert ein Venn-Diagramm.

Die Methode SetCircleSizes() bestimmt die Größe der Mengen, SetCircleColors() deren Farben, SetVennLegend() die Signaturen und SetIntersections() die Abmessungen der Schnittpunkte:

CVennChart chart;
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(300,220);
//add sets(set their sizes)
chart.SetCircleSizes(100, 90, 80);
//color
chart.SetCircleColors(Yellow, Lime, Maroon);
//signatures
chart.SetVennLegend("EURUSD", "USDJPY", "EURJPY");
//dimensions of intersections
chart.SetIntersections(30,30,30,10);
//legend
chart.ShowLegend();
//title
chart.SetTitle("Venn", Green, 15);
//title
chart.GetChart();

Abbildung 11. Venn-Diagramme

2.9 QR-Codes 

Mit der Klasse CQRCode können Sie einen QR-Code erstellen:

CQRCode chart;
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(300,220);
//add data
chart.SetData("test data");
//set the level of error correction during coding
chart.SetErrCorrection(DIAGRAM_QRCODE_ERROR_CORRECTION_LOW);
//and the coding
chart.SetEncoding(DIAGRAM_QRCODE_ENCODING_UTF_8);
//title
chart.GetChart();

  Abbildung 11. QR-Code  

Die Methode SetData() legt die Daten fest, auf deren Basis der Code erstellt wird. Die Methoden SetErrCorrection() und SetEncoding() bestimmen die Fehlerkorrektur beim Kodieren und die Kodierung.

2.10 Karten

Die Klasse CMapChart erstellt eine Karte der Welt oder eines Kontinents und bietet die Möglichkeit, die erforderlichen Länder auszuwählen:

CMapChart chart;
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(440,220);
//set the region
chart.SetZoomArea(DIAGRAM_MAP_AREA_AFRICA);
//and the country
chart.SetCountries("DZEGMGAOBWNGCFKECGCVSNDJTZGHMZZM");
//color
chart.SetColors(White, Red, Blue);
//color of the ocean - blue (2nd parameter)
chart.SetFill(Gray, Blue);
//title
chart.GetChart();

Abbildung 11. Karte von Afrika

Die Codes der erforderlichen Länder werden im Format ISO 3166-1-alpha-2 an die Methode SetCountries() übertragen. Mit SetZoomArea() wird der Kontinent auf der Karte bestimmt und mit SetColors() die Farben der Länder.

2.11 Punktdiagramme

Die Klasse CScatterChart konstruiert Punktdiagramme. Der einzige Unterschied zu CLineXYChart ist die Art, auf die die Daten festgelegt werden.

Zum Festlegen der Daten nutzen wir hier die Methode AddLineScatter(), in der die Koordinaten der Punkte und deren Abmessungen übertragen werden:

//create a class copy
CScatterChart chart;
//attach it to the object created earlier
chart.Attach(0, "test diagram");
//set the size
chart.SetSize(300,300);
//prepare the data
double Y2[10]={70, 5, 6, 8, 10, 20, 100, 130, 90, 60};
double X2[10]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
double Z2[10]={90, 80, 75, 90, 10, 700, 80, 90, 90, 88};
double Y[10]={50, 40, 25, 35, 10, 50, 70, 40, 105, 80};
double X[10]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
double Z[10]={60, 90, 90, 80, 70, 90, 73, 80, 77, 100};
//add the scatters
int first_line=chart.AddLineScatter(Y, X, Z, Red, 0, "scatters 1");
int second_line=chart.AddLineScatter(Y2, X2, Z2, Blue, 0, "scatters 2");
//major axis
chart.SetAxis(DIAGRAM_AXIS_BOTTOM|DIAGRAM_AXIS_LEFT, -1, 0, 0, 10, 0);
//grid
chart.SetGrid();
//legend
chart.ShowLegend(DIAGRAM_LEGEND_POSITION_BOTTOM_HORIZONTAL);
//title
chart.SetTitle("My Chart", Green, 15);
//filling the chart
chart.SetFill(Linen, Silver);
//obtain the chart
chart.GetChart();

 

  Abbildung 11. Punktdiagramm

Fazit

Werter Leser, ich hoffe, dass diese Bibliothek Ihnen das Leben als Händler erleichtern wird. Ich möchte hinzufügen, dass die Nutzung der OOP die Erstellung großer Projekte deutlich erleichtert und sie flexibler und benutzerfreundlicher macht.

Viel Erfolg.

Anhänge:

Nr.
Dateiname
Beschreibung
1
 google_charts.mqh Bibliothek, abzulegen in MQL5\Include
2
 google_charts_test.mq5 Testscript, abzulegen in MQL5\Script
3
 google_charts_help.zip Archiv mit einer in Doxygen generierten Dokumentation zu den Bibliotheksklassen
4 Libraries.zip Archiv mit Bibliotheken und deren Quellcodes, zu entpacken in MQL5\Libraries (im C++ Builder geschriebene Bibliotheken)

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/114

Beigefügte Dateien |
google_charts.mqh (122.64 KB)
libraries.zip (184.93 KB)
Die Verwendung von ORDER_MAGIC für den Handel mit unterschiedlichen Expert Advisors mit einem Instrument Die Verwendung von ORDER_MAGIC für den Handel mit unterschiedlichen Expert Advisors mit einem Instrument

Dieser Beitrag beschreibt die Kodierung von Informationen mithilfe der magischen Identifikation sowie die Trennung, den Aufbau und die Synchronisierung des automatischen Handelns verschiedener Expert Advisors. Dieser Beitrag ist für Neueinsteiger ebenso interessant wie für erfahrenere Händler, weil er das Thema virtuelle Positionen behandelt, die bei der Implementierung komplexer Synchronisierungssysteme von Expert Advisors und diverser Strategien hilfreich sind.

Prinzipien der wirtschaftlichen Berechnung von Indikatoren Prinzipien der wirtschaftlichen Berechnung von Indikatoren

Aufrufe von benutzerdefinierten und technischen Indikatoren nehmen im Programmcode von automatisierten Handelssystemen nur wenig Platz ein. Oft sind es nur ein paar Codezeilen. Doch oft sind es genau diese paar Codezeilen, die die meiste Zeit beim Testen des Expert Advisors benötigen. Deshalb muss alles, was mit der Berechnung von Daten in einem Indikator zusammenhängt, viel eingehender betrachtet werden, als es auf den ersten Blick als nötig erscheint. Genau das ist das Thema dieses Beitrags.

Einen Expert Advisor mit Hilfe des MQL5 Objekt-orientierten Programmieransatzes schreiben Einen Expert Advisor mit Hilfe des MQL5 Objekt-orientierten Programmieransatzes schreiben

Dieser Beitrag beschäftigt sich mit dem Objekt-orientierten Ansatz, um das zu machen, was wir bereits im Artikel "Schrittweiser Leitfaden zum Schreiben eines Expert Advisors in MQL5 für Anfänger" getan haben - einen einfachen Expert Advisor erstellen. Die meisten Menschen glauben, das sei schwer, doch ich darf Ihnen versichern: wenn Sie diesen Beitrag gelesen haben, dann können Sie Ihren eigenen Objekt-orientierten Expert Advisor schreiben.

Eine DLL-freie Lösung für die Kommunikation zwischen Terminals von MetaTrader 5 mithilfe von Named Pipes Eine DLL-freie Lösung für die Kommunikation zwischen Terminals von MetaTrader 5 mithilfe von Named Pipes

Dieser Beitrag beschreibt die Umsetzung der Interprozesskommunikation zwischen Client Terminals von MetaTrader 5 mithilfe von Named Pipes. Für die Nutzung von Named Pipes wird die Klasse CNamedPipes entwickelt. Um sie zu testen und um den Durchsatz der Verbindung zu messen, werden die Scripts für den Tick-Indikator, den Server und den Client vorgestellt. Die Nutzung von Named Pipes ist für Echtzeitgebote geeignet.