Faulheit ist der Reiz zum Fortschritt. Halbautomatische Markierung einer Vorlage

Einführung

Jede Markierung bestimmt die Extremums auf einem Chart und setzt einige benutzerdefinierte Figuren oder Linien auf Grundlage dieser Punkte zusammen. Die Elliot-Wellen Anhänger müssen bestimmte Wellen und die Schlussfolgerungen markieren (welche Welle es ist), bestimmen die Anzahl, usw. Die Wolfs-Wellen Jünger müssen Trendlinien zeichnen und Ziele bezeichnen. Die "Butterfliers" brauchen Punkte und Ebenen für die Bestimmung der potenziellen Schmetterlinge, Krebse und die Zahlen, die durch Gartley formalisiert wurden.

Murrey Ebenen sind für diejenigen erforderlich, die diese Methode bevorzugen. Die automatische Berechnung erlaubt uns nicht, Hunderte, oder vielleicht Tausende von Formationen einzubinden, wenn es keine spezielle Software ist. Auf der anderen Seite kann jeder die Nachteile der automatischen Markierung erkennen, in der Folge der Bedingung-Formalisierungsmethoden. Und nicht jede Software erlaubt uns in den Prozess der Markierung einzugreifen. Also, die Anwendung der manuellen Markierung und die Zuweisung der weiteren Verarbeitung der Daten auf den Computer erweitern die Fähigkeiten des Benutzers.

Halbautomatische Markierung eine Trading-Vorlage

Betrachten wir als Beispiel die Markierung von Wolfs Wellen. (Die Beschreibung ist entnommen aus Linda Raschkes berühmten Buch «Street Smarts»).

Bills Theorie der Wellen-Struktur basiert auf Newtons erstem Gesetz der Physik: auf jede Aktion gibt es eine gegenteilige Reaktion. Diese Bewegung erzeugt ene Welle mit wertvollen, herausragenden Fähigkeiten. Die Welle baut sich am deutlichsten auf, wenn es eine gute Volatilität gibt.

Indem wir mit einer Spitze oder Boden im Balken-Chart anfangen, sind wir sicher unsere Zählung am Anfang einer neuen Welle zu starten. Diese Zählung ist für ein Buy Setup. Wir beginnen die Zählung bei einer Spitze. (Die Wellen-Zählung wäre umgekehrt, würden wir an einem Boden anfangen, auf der Suche nach einem Sell Setup).

1. Nummer 2 Welle ist eine Spitze.
2. Nummer 3 Welle ist der Boden des ersten Rückgangs.
3. Nummer 1 Welle ist der Boden vor Welle 2 (Spitze). Punkt 3 muss niedriger sein als Punkt 1.
4. Nummer 4 Welle ist die Spitze von Welle 3. Welle 4 sollte höher sein als der Welle 1 Boden.
5. Eine Trendlinie wird von Punkt 1 zu Punkt 3 gezogen. Die Erweiterung dieser Linie reicht zu dem angenommenen Umkehrpunkt, den wir Welle 5 nennen werden. Dies ist der Einstiegspunkt für einen Ritt zur EPA Linie (1 zu 4).
6. Der Erwartete Preis bei Ankunft (EPA) ist die die von Punkt 1 zu Punkt 4 gezogene Trendlinie. Diese stellt das erwartete Kursziel dar. Unser anfänglicher Stop wird knapp unter der neu gebildeten Umkehr an punkt 5 platziert. Er kann dann schnell auf Breakeven gezogen werden.

WICHTIGER PUNKT: Sie können nicht anfangen nach Wolfe Wellen zu suchen, bis die Punkte 1, 2, 3 und 4 gebildet wurden.

Denken Sie daran, das Punkt 3 niedriger sein muss als Punkt 1 für ein Buy Setup. Er muss höher als Punkt 1 sein für ein Sell Setup. Außerdem, auf den besten Wellen wird Punkt 4 höher als Punkt 1 sein für ein Buy Setup und niedriger als 1 für ein Sell Setup. Dies stellt sicher, dass absolute Ausreißer-Marktbedingungen nicht existieren. Nun studieren Sie das Beispiel und sehen Sie, ob Sie Ihre Augen zum Erkennen des Wolfe Setup trainieren können.

Die Abbildungen illustrieren wie eine Wolfe Welle aussieht, wenn sie beginnt sich zu bilden. Punkt 1, 2 und 3 müssen sich bereits gebildet haben. Punkt 2 muss ein deutliches Swing Hoch oder Tief sein. Eine Trendlinie wird dann zwischen den Punkten 1 und 3 gezogen. Diese zeigt an, wo wir Punkt erwarten können.

Punkt 5 ist gebildet. Wir werden die Umkehr aus diesem Bereich kaufen und einen engen Stop darunter. Wenn wir eine Trendlinie von Punkt 1 u Punkt 4 ziehen, sollte sie uns eine Kursprognose geben.

Punkt 2 ist der anfängliche Startpunkt für das Muster. Ich finde es immer am einfachsten das Zählen an diesem Punkt zu starten. Dann zurückziehen und Punkt 1 und 3 finden. Vergessen Sie nicht, dass Punkt 4 höher als Punkt 1 sein muss. Unsere Trendlinie ist zum prognostizierten Punkt 5 gezogen. Der Markt findet auf dieser Ebene Unterstützung, also geben wir eine Long-Position am Markt ein und platzieren den Stop knapp unter Punkt 5. Der Markt handelt zu seinem Ziel.

Entsprechend der angehangenen Beschreibung, müssen wir die Markierung mit Sonderzeichen bereitstellen (Ziffern 1 bis 5) bereitstellen und dann die Trendlinie von Punkt 1 ziehen, die Punkt 4 und 5 passiert.)

In der maunellen Methode werden die Text-Objekte erstellt und den angegebenen Punkten auf dem Chart zugewiesen, dann werden die Trendlinien erstellt und auf das Chart gelegt. Die Funktionen der Programmiersprache ermöglichen den Prozess zu vereinfachen, ausgenommen die Erzeugung von Objekten und das ziehen von Trendlinien von dem Prozess. In diesem Ansatz bleibt es bei dem Benutzer die Markierung zu den bestimmten Punkten im Chart zuweisen und die fertige Zeichnung der Trendlinie erhalten.

Wir erinnern daran, das zwei Wege gibt die Informationen auf das Chart zu legen.

Der erste ist, wenn ein erstelltes Text-Objekt zu einem bestimmten Punkt auf dem Chart zugewiesen wird, und die zweite ist, wenn die Bindung einem bestimmten Punkt im Fenster des Charts zugewiesen ist.

Nutzen wir diese Funktionen zum Erstellen verschiedener Objekte. Wir erstellen die "OnOff" Schaltfläche um bereits angewendete Objekte und bereits gezeichnete Linien zu entfernen, und binden Sie an einen bestimmten Punkt im Fenster. Und wir erstellen Objekte, die an den angegebenen Punkt im Chart gebunden werden. Da das Chart skaliert werden kann, und die Objekte dabei mit dem Chart zusammengeschoben werden bestimmen wir die anfängliche Position der Knotenpunkte auf der rechten Seite des Null-Balkens des Charts. Wir werden diese Position verwenden zum Aktivieren und Deaktivieren der Funktion zum Zeichnen der Trendlinien.

// Check the presence of the "OnOff" button, create it in case of absence
int    obj_total=ObjectsTotal();
  string index;
  for( i=0;i<obj_total;i++)
    {
     index=ObjectName(i);
      string Lbl = StringSubstr (index, 0, 12);
            if (Lbl == "Lable_On_Off") string LblOnOff=index;
     }
if (LblOnOff!="Lable_On_Off") OnOff(Red, 10);

wobei

OnOff(Red, 10);

ist die Funktion zum Erstellen und Positionieren der "OnOff" Schaltfläche.

void OnOff (color clr_, int h)
         {                                      
         ObjectCreate("Lable_On_Off",OBJ_LABEL,0,0,0);// Creation of the "OnOff" button
         ObjectSetText("Lable_On_Off",CharToStr(204) , 12, "Wingdings", clr_);
         ObjectSet(   "Lable_On_Off", OBJPROP_CORNER, 3);     // The angle of displaying on the chart
         ObjectSet(   "Lable_On_Off", OBJPROP_XDISTANCE, 10);
         ObjectSet(   "Lable_On_Off", OBJPROP_YDISTANCE, h);
         } 
return;

Eingebettete Funktion

CharToStr()

ermöglicht das Anzeigen aller Objekte auf dem Chart

"Wingdings"

einfach durch die Eingabe des Codes des Symbols.

Wir führen die Aktivierung des Indikators durch Auswahl und Verschieben der "OnOff" Schaltfläche nach oben durch. Nach dem Verschieben und dem Eintreffen des ersten Tick auf dem Chart, wird die Schaltfläche der anderen Position zugeordnet und ändert ihre Farbe in Grün, und wir zeigen die Objekte rechts von dem ersten Balken an: Ziffern für die Nummerierung auf dem Chart durch die Funktion.

Wir verwalten die Objekte auf dem Chart abhängig von der Position der Schaltfläche.

// Check if the "OnOff" button is at its place
   
if (ObjectGet("Lable_On_Off",OBJPROP_XDISTANCE)>70||
    ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)<20)// if it is not there then
       { 
          OnOff(Red, 10);// we move the "OnOff" button to its place and delete all marks, channel, trend line
         for ( i=0; i<point_kol; i++)
            ObjectDelete("Lable_"+i);
            ObjectDelete("TRDLine");
            ObjectDelete("FIBOCanal");
         return;
         }  
                                               
if (ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)>10 && 
    ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)!=40) //If the button is moved upwards then
       {  
         OnOff(Green, 40); // we fix it up there
         CreatePoint();   // Create points
       }

wobei

CreatePoint();

ist die Funktion der anfänglichen Positionierung der berechneten Punkte auf dem Chart.

void CreatePoint ()
      {
      double shcala=(WindowPriceMax()-WindowPriceMin());
      for( i = 0; i < point_kol; i++) // Create points
               {                                      
      ObjectCreate("Lable_"+i, OBJ_ARROW, 0,Time[Bars-1],Bid);
      ObjectSet("Lable_"+i,OBJPROP_ARROWCODE,140+i);
      ObjectSet("Lable_"+i,OBJPROP_WIDTH,2);
      ObjectSet("Lable_"+i,OBJPROP_COLOR,Green);
      ObjectMove("Lable_"+i, 0,(Time[0]+Period()*720), (WindowPriceMin()+shcala/2)-shcala/12*i);
               } 
      }

Hier möchte ich Ihre Aufmerksamkeit darauf ziehen, das nur drei Punkte aktiv sind, wenn dieses Markieren verwendet wird, also habe ich eine externe Variable hinzugefügt, um die Auswahl der Anzahl der Punkte zu ermöglichen, 3 oder 5. Der Standardwert ist 5, aber ich verwende 3 für die visuelle Darstellung der dazwischen liegenden Punkte für mich selbst.

extern int point_kol=5;

Wir verwenden Fibo-Ebenen anstelle der Trendlinie, ausgerichtet nach der angenommenen Kursbewegung. Es bietet die erweiterte Anleitung im Chart. Der Channel bietet die Leitlinien für Support und Resistance Linien auf den Fibo-Ebenen. In dieser Darstellung können wir die Ziele an den Schnittpunkten der Trendlinie und der Fibo-Ebenen beobachten, es erlaubt die Zuordnung der bestimmten Handelstaktiken.

Hier st wie es aussehen wird:

Wir drehen den Indikator und verschieben die Schaltfläche aufwärts.

Das Tages-Chart. Wir haben die Punkte platziert und der Indikator hat die Trendlinie und die Fibo-Channels erstellt.

Fazit

Diese Art der Darstellung auf dem Chart ermöglicht es, zum Beispiel, die Analyse durch Elliot Wellen zu implementieren. Da wir zwei Extremum Punkte manuell bestimmt haben, können wir die internen Wellen mit einem Zeitrahmen einer kleineren Periode neu berechnen, und erhalten ein Ergebnis für eine weitere Analyse im Vergleich mit den angegebenen Bedingungen. Dabei kann der Benutzer einen expliziten Wert für die Neuberechnung angeben (Impuls oder Berichtigend).

Hier möchte ich außerdem von den Entwicklern der MQL4 Sprache wünschen, die Funktion zur Neuberechnung der Fensterpositionierung von Objekten in Pixel zur direkte Anbindung an das Chart hinzuzufügen. Der Punkt ist, dass die vorgeschlagene Methode des Zugriffs auf die user32.dll Bibliothek und aufrufen der Parameter des aktuellen Fensters die Nachricht zeigt, dass die user32.dll fehlt. Das bedeutet, dass es keine solche Funktion in einer typischen Auslieferung von Windows XP und MetaTrader 4 gibt. Ich musste bei dieser Umsetzung von der Implementierung einer Analyse über das ganze Chart Abstand nehmen, wenn die Punkte nur manuell zu verschieben sind.

Der Indikator selbst (Quellcode):

//|                                                 0_CTL.mq4 |
//|                                   Copyright © 2008, [e-mail] |
//|                                             http://www.fibook.ru |
//+------------------------------------------------------------------+
#property copyright "[e-mail]"
#property link      "http://www.fibook.ru"
#property indicator_chart_window
extern int point_kol=5;
string mon[]={"january", 
              "february", 
              "march", 
              "april", 
              "may", 
              "june", 
              "july", 
              "august", 
              "september", 
              "october", 
              "november", 
              "december"};
int i;
double coordinatsT[5], coordinatsP[5];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
  string info="Marking"+ Symbol()+" by "+Day()+""+mon[Month()-1]+""+Year()+" г."; 
   CreateUp (info);
 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
//----
 
// Check the presence of the "OnOff" button, create it in case of absence
int    obj_total=ObjectsTotal();
  string index;
  for( i=0;i<obj_total;i++)
    {
     index=ObjectName(i);
      string Lbl = StringSubstr (index, 0, 12);
            if (Lbl == "Lable_On_Off") string LblOnOff=index;
     }
if (LblOnOff!="Lable_On_Off") OnOff(Red, 10);  
// Check if the "OnOff" button is at its place
   
if (ObjectGet("Lable_On_Off",OBJPROP_XDISTANCE)>70||
    ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)<20)// if it is not there then
       { 
          OnOff(Red, 10);// we move the "OnOff" button to its place and delete all marks, channel, trend line
         for ( i=0; i<point_kol; i++)
            ObjectDelete("Lable_"+i);
            ObjectDelete("TRDLine");
            ObjectDelete("FIBOCanal");
         return;
         }  
                                               
if (ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)>10 && 
    ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)!=40) //If the button is moved upwards then
       {  
         OnOff(Green, 40); // Fix it up there
         CreatePoint();   // Create points
       }  
         
           for (i=0; i<point_kol; i++)
               {   
                 coordinatsT[i]=ObjectGet("Lable_"+i,OBJPROP_TIME1); // Read the coordinates
                 coordinatsP[i]=ObjectGet("Lable_"+i,OBJPROP_PRICE1);
               }   
     
         // if all points are carried to the chart then we draw the additional objects
         if  ((coordinatsT[0]<Time[0])&&
              (coordinatsT[1]<Time[0])&&
              (coordinatsT[2]<Time[0])&&
              (coordinatsT[3]<Time[0])&&
              (coordinatsT[4]<Time[0]))  
            {
            ObjectCreate("TRDLine", OBJ_TREND, 0,0,0);
            ObjectCreate("FIBOCanal", OBJ_FIBOCHANNEL, 0,0,0);
            ObjectMove ("TRDLine", 0,coordinatsT[0],coordinatsP[0]);
            ObjectMove ("TRDLine", 1,coordinatsT[point_kol-2],coordinatsP[point_kol-2]);
            ObjectMove ("FIBOCanal", 0,coordinatsT[0],coordinatsP[0]);
            ObjectMove ("FIBOCanal", 2,coordinatsT[point_kol-2],coordinatsP[point_kol-2]);
            ObjectMove ("FIBOCanal", 1,coordinatsT[point_kol-1],coordinatsP[point_kol-1]);
            }
   return(0);
  }
//+------------------------------------------------------------------+
 
void OnOff (color clr_, int h)
         {                                      
         ObjectCreate("Lable_On_Off",OBJ_LABEL,0,0,0);// Creation of the "OnOff" button
         ObjectSetText("Lable_On_Off",CharToStr(204) , 12, "Wingdings", clr_);
         ObjectSet(   "Lable_On_Off", OBJPROP_CORNER, 3);     // The angle of displaying on the chart
         ObjectSet(   "Lable_On_Off", OBJPROP_XDISTANCE, 10);
         ObjectSet(   "Lable_On_Off", OBJPROP_YDISTANCE, h);
         } 
return;          
 
void CreatePoint ()
      {
      double shcala=(WindowPriceMax()-WindowPriceMin());
      for( i = 0; i < point_kol; i++) // Create points
               {                                      
      ObjectCreate("Lable_"+i, OBJ_ARROW, 0,Time[Bars-1],Bid);
      ObjectSet("Lable_"+i,OBJPROP_ARROWCODE,140+i);
      ObjectSet("Lable_"+i,OBJPROP_WIDTH,2);
      ObjectSet("Lable_"+i,OBJPROP_COLOR,Green);
      ObjectMove("Lable_"+i, 0,(Time[0]+Period()*720), (WindowPriceMin()+shcala/2)-shcala/12*i);
               } 
      } 
 void CreateUp(string info) 
               {
                  ObjectCreate("TextAlerts", OBJ_LABEL, 0, 0, 0);  
                  ObjectSetText("TextAlerts",info , 16, "Times New Roman", Green);
                  ObjectSet("TextAlerts", OBJPROP_CORNER, 0);
                  ObjectSet("TextAlerts", OBJPROP_XDISTANCE, 20);
                  ObjectSet("TextAlerts", OBJPROP_YDISTANCE, 10);       
               }