Entwicklung eines Toolkits zur Price-Action-Analyse (Teil 64): Manuell gezeichnete Trendlinien mit der automatisierten Überwachung synchronisieren

Inhalt

• Einführung
• Das zugrunde liegende Konzept
• MQL5-Implementierung
• Tests
• Schlussfolgerung

Einführung

Sie zeichnen Trendlinien bereits manuell und vertrauen Ihrem visuellen Urteilsvermögen mehr als einer vollautomatischen Erkennung. Das praktische Problem ist jedoch ein anderes: Wenn man mehrere Linien über ein oder mehrere Charts legt, kann man physisch unmöglich jedes Niveau ständig im Blick behalten. Entscheidende Momente – wenn sich der Kurs einer manuell eingezeichneten Trendlinie nähert, diese berührt, durchbricht oder abprallt – treten oft auf, während Sie den Zeitrahmen wechseln, sich vom Terminal entfernen oder andere Positionen verwalten. Der Artikel befasst sich genau mit diesem Problem: Wie kann man die manuelle Chartanalyse als analytische Grundlage beibehalten und gleichzeitig die sich wiederholende Aufgabe der Überwachung dieser Trendlinien automatisieren?

Technisch gesehen fehlen noch die Möglichkeit, ein handgezeichnetes OBJ_TREND-Objekt an die Logik und den Lebenszyklus (Erstellung, Änderung, Löschung) des Expert Advisors zu binden, dessen momentanen Kurs im Zeitverlauf zu berechnen und zuverlässige Benachrichtigungen auszulösen, wenn vordefinierte Interaktionsbedingungen eintreten. Die vorgestellte Lösung ermöglicht weiterhin das freie manuelle Einzeichnen von Linien: Sie wählen die für Sie relevanten Linien aus und synchronisieren sie, und MetaTrader 5 (über einen EA) wertet diese synchronisierten Linien kontinuierlich aus und macht Sie auf relevante Ereignisse aufmerksam, sodass Sie nicht mehr jeden Chart im Auge behalten müssen.

 In den folgenden Abschnitten wird das Konzept hinter der Synchronisierung manuell gezeichneter Trendlinien mit der automatisierten Überwachung erläutert, die Umsetzung des Systems in MQL5 beschrieben und der Testprozess vorgestellt, mit dem dessen Verhalten in einer Live-Chart-Umgebung überprüft wird.

Das zugrunde liegende Konzept

In früheren Beiträgen der Reihe Entwicklung des Price-Action-Analyse-Toolkits wurde die Automatisierung des Zeichnens und der Überwachung von Trendlinien in MQL5 vorgestellt. Bei dieser Annäherung ermittelt das Programm potenzielle Wendepunkte und erstellt automatisch Trendlinien auf der Grundlage vordefinierter Regeln. Zwar ist diese Automatisierung für eine systematische Analyse nützlich, doch ziehen es viele Trader nach wie vor vor, Trendlinien manuell zu zeichnen.

Das manuelle Zeichnen ermöglicht es dem Trader, bei der Auswahl der Pivot-Punkte nach eigenem Ermessen vorzugehen. Anstatt sich ausschließlich auf die algorithmische Erkennung zu verlassen, können Trader den Chart visuell interpretieren und feststellen, welche Swing-Hochs und -Tiefs die zugrunde liegende Marktstruktur am besten widerspiegeln. Diese menschliche Einschätzung ist besonders wertvoll bei der Analyse komplexer Kursverläufe, bei denen starre Regeln subtile strukturelle Details möglicherweise nicht erfassen können.

Das manuelle Einzeichnen von Trendlinien bei der Kursanalyse bietet mehrere Vorteile. Einige der wichtigsten Vorteile sind in der folgenden Tabelle zusammengefasst.

Vorteil	Beschreibung
Strukturelle Interpretation	Trader können die Marktstruktur interpretieren und Pivot-Punkte auswählen, die den Trend am besten widerspiegeln, anstatt sich ausschließlich auf eine mechanische Erkennung zu verlassen.
Flexibilität	Das manuelle Zeichnen ermöglicht schnelle Anpassungen an sich ändernde Marktbedingungen oder neu auftretende Kursschwankungen.
Berücksichtigung des Marktumfelds	Trader können bei der Platzierung der Linie zusätzliche Chartelemente wie Unterstützungs-, Widerstands- oder Konsolidierungszonen berücksichtigen.
Strategieausrichtung	Der Trader kann Trendlinien an die spezifische Logik seiner Handelsstrategie anpassen, anstatt sich an ein allgemeingültiges Regelwerk zu halten.
Visuelle Klarheit	Manuell eingezeichnete Linien spiegeln oft die analytische Sichtweise des Traders wider und erleichtern so die Interpretation des Kursverhaltens bei der Entscheidungsfindung.

Trotz dieser Vorteile zeigt sich schnell eine praktische Einschränkung, sobald mehrere Trendlinien im Chart eingezeichnet werden. Um zu beobachten, wie sich der Kurs im Zusammenspiel mit den einzelnen Linien verhält, ist ständige Aufmerksamkeit erforderlich. In einem aktiven Handelsumfeld, in dem möglicherweise mehrere Charts gleichzeitig geöffnet sind, ist es schwierig, dieses Maß an Aufmerksamkeit während der gesamten Handelssitzung aufrechtzuerhalten.

Infolgedessen können wichtige Wechselwirkungen zwischen Kurs und Trendlinien leicht übersehen werden. Es kann vorkommen, dass ein Trader sich für kurze Zeit vom Chart abwendet und bei seiner Rückkehr feststellt, dass der Kurs bereits eine sorgfältig gezogene Trendlinie berührt oder durchbrochen hat. Häufig stellen diese Wechselwirkungen wertvolle Handelsmöglichkeiten dar, die genutzt werden könnten, um Positionen effektiver zu eröffnen oder zu verwalten. Das Kernproblem liegt nicht in der Analyse selbst, sondern in der Fähigkeit, die sich ständig verändernde Beziehung zwischen dem Kurs und den manuell eingezeichneten Linien kontinuierlich zu beobachten.

Das in diesem Artikel vorgestellte Konzept überwindet diese Einschränkung, indem es die manuelle Chartanalyse mit einer automatisierten Überwachung kombiniert. Das zugrunde liegende Prinzip ist einfach: Der Trader ist weiterhin dafür verantwortlich, aussagekräftige Niveaus im Chart zu identifizieren, während das Programm die sich wiederholende Aufgabe übernimmt, das Kursverhalten im Umfeld dieser Niveaus zu beobachten.

Sobald eine Trendlinie mit dem Überwachungssystem synchronisiert ist, beginnt das Programm damit, das Kursverhalten im Verhältnis zu dieser Linie zu analysieren. Verschiedene Arten von Interaktionen können dann automatisch erkannt werden. Dazu gehören Situationen, in denen sich der Markt der Linie nähert, sie berührt, sie durchbricht oder nach dem Kontakt mit ihr die Richtung umkehrt. Jede dieser Interaktionen liefert nützliche Informationen über die Stärke des Trends und die Wahrscheinlichkeit einer Fortsetzung oder Umkehr.

System-Workflow

Um zu verstehen, wie der Überwachungsmechanismus in der Praxis funktioniert, ist es hilfreich, den vom System durchlaufenen Arbeitsablauf zu betrachten. Der Prozess ist so konzipiert, dass die manuelle Analyse beibehalten wird, während das Programm gleichzeitig die kontinuierliche Beobachtung des Kursverhaltens übernimmt.

1. Die Trendlinie zeichnen

Der Vorgang beginnt damit, dass der Trader mithilfe der in MetaTrader 5 verfügbaren Standard-Zeichenwerkzeuge direkt im Chart eine Trendlinie einzeichnet. In dieser Phase ermittelt der Trader aussagekräftige Wendepunkte wie Swing-Hochs oder Swing-Tiefs und verbindet diese miteinander, um die Trendlinie zu bilden. Dieser Schritt bewahrt den Ermessenscharakter der Kursanalyse. Anstatt sich ausschließlich auf die algorithmische Erkennung zu verlassen, wertet der Trader das Chart visuell aus und ermittelt, welche Pivot-Punkte die zugrunde liegende Marktstruktur am besten widerspiegeln.

2. Synchronisieren der Trendlinie

Sobald die Trendlinie eingezeichnet wurde, muss sie mit dem Überwachungssystem synchronisiert werden. Die Synchronisation dient als Bestätigungsschritt, der angibt, dass die betreffende Trendlinie vom Programm überwacht werden soll. In dieser Phase wird die Trendlinie vom System intern erfasst und in die Liste der überwachten Chart-Objekte aufgenommen. Von diesem Moment an behandelt das Programm die Linie als analytischen Referenzwert, der einer kontinuierlichen Beobachtung bedarf.

3. Kontinuierliche Kursbewertung

Sobald die Synchronisierung abgeschlossen ist, beginnt das Programm damit, die Beziehung zwischen dem aktuellen Marktkurs und der Position der Trendlinie kontinuierlich zu analysieren. Im Gegensatz zu horizontalen Unterstützungs- oder Widerstandsniveaus stellt eine Trendlinie ein dynamisches Niveau dar, dessen Wert sich im Laufe der Zeit verändert. Aus diesem Grund berechnet das System bei jedem Auswertungszyklus den genauen Wert bzw. Kurs der Linie zum aktuellen Zeitpunkt und vergleicht ihn mit dem aktuellen Marktkurs. Anhand dieser Berechnung kann das Programm feststellen, ob sich der Kurs der Linie nähert, sie berührt oder sich von ihr entfernt.

4. Erkennung von Interaktionen und Warnmeldungen

Sobald der Kurs mit der überwachten Trendlinie interagiert, erkennt das System dieses Ereignis und generiert entsprechende Benachrichtigungen.

Es lassen sich mehrere Interaktionszustände unterscheiden. Dazu zählen insbesondere Annäherung, Berührung, Ausbruch und Umkehr.

Wenn solche Ereignisse eintreten, werden Benachrichtigungen generiert, um den Trader zu informieren. Darüber hinaus zeigt das Überwachungsfeld im Chart Statusaktualisierungen in Echtzeit an, die die zuletzt erkannte Interaktion für jede synchronisierte Linie darstellen.

5. Automatisierte Überwachung mit manueller Steuerung

Durch diesen Arbeitsablauf werden manuell eingezeichnete Trendlinien zu kontinuierlich überwachten Referenzniveaus.

Diese Kombination schafft eine Analyseumgebung, in der die manuelle Analyse der Kursentwicklung erhalten bleibt, die sich wiederholende Aufgabe der Überwachung von Trendlinien-Interaktionen jedoch automatisch übernommen wird. Dadurch kann sich der Trader auf die Interpretation des Marktverhaltens konzentrieren, anstatt ständig jeden Chart im Auge behalten zu müssen.

MQL5-Implementierung

In diesem Abschnitt wird erläutert, wie das Überwachungskonzept mithilfe von MQL5 in MetaTrader 5 in ein funktionsfähiges System umgesetzt wird. Das Ziel besteht darin, dass manuell eingezeichnete Trendlinien vom Programm erkannt und im Verlauf der Kursentwicklung auf dem Chart kontinuierlich überwacht werden.

Der Expert Advisor führt mehrere aufeinander abgestimmte Aufgaben aus. Er erkennt vom Trader erstellte Trendlinienobjekte, synchronisiert ausgewählte Linien mit dem Überwachungssystem, sorgt für eine übersichtliche interne Struktur der überwachten Linien, berechnet den dynamischen Wert jeder Trendlinie im Zeitverlauf, wertet Kursinteraktionen mit diesen Linien aus und meldet erkannte Ereignisse durch Warnmeldungen und visuelle Rückmeldungen. Jede dieser Aufgaben wird mithilfe spezifischer MQL5-Funktionen und -Mechanismen umgesetzt, die zusammen eine reaktionsschnelle Überwachungsumgebung schaffen.

Trendlinien im Chart erkennen

Der erste Schritt bei der Umsetzung besteht darin, die im Chart eingezeichneten Trendlinien zu identifizieren. In MetaTrader 5 werden grafische Elemente wie Trendlinien als Chart-Objekte dargestellt, auf die programmgesteuert zugegriffen werden kann und die verwaltet werden können.

Um diese Objekte zu erkennen, nutzt der Expert Advisor das von MQL5 bereitgestellte Chart-Ereignissystem, insbesondere die Funktion OnChartEvent(). Diese Funktion wird immer dann ausgelöst, wenn ein Chart-Ereignis eintritt, darunter das Erstellen, Ändern oder Löschen von grafischen Objekten. Wenn ein Trader eine Trendlinie im Chart einzeichnet, generiert die Plattform ein Ereignis, das mit OnChartEvent() erfasst werden kann. Die Funktion erhält Parameter, die den Ereignistyp und das betroffene Objekt beschreiben. Anhand dieser Informationen kann das Programm feststellen, ob das Ereignis der Erstellung einer Trendlinie entspricht.

//+------------------------------------------------------------------+
//| Handle chart events and detect newly created trendlines          |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
   //--- Detect object creation event
   if(id==CHARTEVENT_OBJECT_CREATE)
     {
      string object_name=sparam;

      //--- Check if the object is a trendline
      if(ObjectGetInteger(0,object_name,OBJPROP_TYPE)==OBJ_TREND)
        {
         Print("Trendline detected: ",object_name);

         //--- Further processing can be performed here
        }
     }
  }
//+------------------------------------------------------------------+

Die Identifizierung einer Trendlinie erfolgt in der Regel dadurch, dass der Objekttyp mithilfe der Funktion ObjectGetInteger() abgerufen und geprüft wird, ob das Objekt zur Kategorie OBJ_TREND gehört. Nach der Bestätigung ruft das Programm den Namen des Objekts ab und greift anschließend auf dessen Eigenschaften zu. Durch diesen Mechanismus erkennt der Expert Advisor die vom Trader direkt eingeführten Analysestrukturen.

Eigenschaften einer Trendlinie abrufen

Nachdem eine Trendlinie erkannt wurde, besteht der nächste Schritt darin, ihre Strukturparameter zu ermitteln. Der Expert Advisor ermittelt die beiden Ankerpunkte, die die Trendlinie im Chart definieren. Jeder Ankerpunkt enthält eine Zeitkoordinate und eine Kurskoordinate. Diese Werte werden mithilfe der Funktionen ObjectGetInteger() und ObjectGetDouble() ermittelt.

Die Zeitkoordinaten werden über Eigenschaften wie OBJPROP_TIME1 und OBJPROP_TIME2 abgerufen, während die Kurskoordinaten über OBJPROP_PRICE1 und OBJPROP_PRICE2 ermittelt werden. Durch die Erfassung dieser vier Werte erhält das System die vollständige geometrische Definition der Trendlinie. Diese Parameter werden anschließend intern gespeichert, damit die Trendlinie in zukünftigen Überwachungszyklen ausgewertet werden kann.

//+------------------------------------------------------------------+
//| Retrieve anchor points from a trendline object                   |
//+------------------------------------------------------------------+
bool GetTrendlinePoints(string name,
                        datetime &t1,double &p1,
                        datetime &t2,double &p2)
  {
   //--- Verify that the object exists
   if(ObjectFind(0,name)<0)
      return(false);

   //--- Retrieve first anchor point
   t1=(datetime)ObjectGetInteger(0,name,OBJPROP_TIME1);
   p1=ObjectGetDouble(0,name,OBJPROP_PRICE1);

   //--- Retrieve second anchor point
   t2=(datetime)ObjectGetInteger(0,name,OBJPROP_TIME2);
   p2=ObjectGetDouble(0,name,OBJPROP_PRICE2);

   return(true);
  }
//+------------------------------------------------------------------+

Durch diesen Schritt wird die grafische Trendlinie effektiv in numerische Daten umgewandelt, die vom Programm analysiert werden können.

Synchronisierung der Trendlinie mit dem Überwachungssystem

Nachdem eine Trendlinie erkannt und ihre Eigenschaften abgerufen wurden, folgt als nächster Schritt die Synchronisation. Die Synchronisation legt fest, ob ein bestimmtes Trendlinienobjekt vom System überwacht werden soll.

Trader zeichnen bei der Analyse eines Charts häufig mehrere Trendlinien ein. Einige dieser Linien dienen möglicherweise nur als vorübergehende visuelle Orientierungshilfen, während andere bedeutende Unterstützungs- oder Widerstandsniveaus darstellen, die einer kontinuierlichen Beobachtung bedürfen. Aus diesem Grund verfolgt das Überwachungssystem nicht automatisch jede Trendlinie, die im Chart erscheint. Stattdessen wird ein Synchronisationsschritt eingeführt. In diesem Schritt wählt der Trader das jeweilige Trendlinienobjekt aus, das überwacht werden soll. Anschließend ruft das Programm den Objektnamen und die Eigenschaften der Ankerpunkte mithilfe von ObjectGetInteger() und ObjectGetDouble() ab.

//+------------------------------------------------------------------+
//| Structure representing a monitored trendline                     |
//+------------------------------------------------------------------+
struct TrendlineInfo
  {
   string   name;
   datetime t1;
   double   p1;
   datetime t2;
   double   p2;
   int      state;
  };

//--- Dynamic list of monitored trendlines
TrendlineInfo MonitoredLines[];

//+------------------------------------------------------------------+
//| Synchronize a trendline with the monitoring system               |
//+------------------------------------------------------------------+
void SynchronizeTrendline(string name)
  {
   TrendlineInfo line;

   //--- Retrieve anchor points
   if(!GetTrendlinePoints(name,line.t1,line.p1,line.t2,line.p2))
      return;

   line.name=name;
   line.state=0;

   int size=ArraySize(MonitoredLines);
   ArrayResize(MonitoredLines,size+1);

   MonitoredLines[size]=line;

   Print("Trendline synchronized: ",name);
  }
//+------------------------------------------------------------------+

Sobald die Trendlinie synchronisiert ist, werden ihre Identifikationsdaten in der internen Überwachungsstruktur gespeichert. Das System protokolliert:

• Den Namen des Trendlinienobjekts
• Den ersten Ankerpunkt (OBJPROP_TIME1, OBJPROP_PRICE1)
• Den zweiten Ankerpunkt (OBJPROP_TIME2, OBJPROP_PRICE2)
• Den aktuellen Überwachungsstatus

Ab diesem Zeitpunkt wird die synchronisierte Trendlinie Teil der analytischen Ebenen, die vom Expert Advisor kontinuierlich ausgewertet werden. Diese Annäherung stellt sicher, dass die Überwachung unter Kontrolle bleibt und sich ausschließlich auf die Trendlinien konzentriert, die der Trader für wichtig erachtet.

Führen einer strukturierten Liste der überwachten Trendlinien

Sobald eine Trendlinie synchronisiert wurde, müssen ihre Daten in strukturierter Form gespeichert werden, damit sie während jedes Überwachungszyklus effizient ausgewertet werden können. Ohne eine solche Struktur wäre es für das Programm schwierig, mehrere Trendlinien gleichzeitig zu verwalten. Der Expert Advisor führt daher eine interne Liste, die alle synchronisierten Trendlinien enthält, die derzeit überwacht werden. Diese Liste kann mithilfe von Arrays oder benutzerdefinierten Strukturen implementiert werden, in denen die mit jedem Trendlinienobjekt verbundenen Eigenschaften gespeichert werden.

//+------------------------------------------------------------------+
//| Main monitoring cycle executed on every market tick              |
//+------------------------------------------------------------------+
void OnTick()
  {
   int total=ArraySize(MonitoredLines);

   //--- Evaluate each synchronized trendline
   for(int i=0;i<total;i++)
     {
      EvaluateTrendline(MonitoredLines[i]);
     }
  }
//+------------------------------------------------------------------+

Wenn eine Trendlinie synchronisiert wird, ruft das Programm deren Identifikationsdaten mithilfe von Funktionen wie ObjectName() und ObjectFind() ab. Mit diesen Funktionen kann das Programm das Vorhandensein des Objekts im Chart bestätigen und dessen eindeutigen Namen ermitteln. Der Objektname wird zur primären Kennung, die vom Überwachungssystem verwendet wird. Die strukturellen Eigenschaften der Trendlinie werden anschließend mithilfe von ObjectGetInteger() und ObjectGetDouble() abgerufen. Diese Funktionen ermöglichen den Zugriff auf die Koordinaten der Ankerpunkte, die die Linie definieren:

• OBJPROP_TIME1 – Zeitpunkt des ersten Ankerpunkts
• OBJPROP_PRICE1 – Kurs des ersten Ankerpunkts
• OBJPROP_TIME2 – Zeitangabe des zweiten Ankerpunkts
• OBJPROP_PRICE2 – Kurs des zweiten Ankerpunkts

Diese Werte werden zusammen mit dem Namen des Trendlinienobjekts in der Überwachungsstruktur gespeichert. Es können auch zusätzliche Felder gespeichert werden, darunter berechnete Parameter wie die Steigung der Trendlinie oder der zuletzt erkannte Interaktionszustand. Sobald die Informationen gespeichert wurden, kann das Überwachungssystem bei jeder Ausführung der Funktion OnTick() die Liste durchlaufen. In jedem Zyklus ruft das Programm die gespeicherten Parameter für jede Trendlinie ab und berechnet deren aktuellen Kurswert auf der Grundlage der neuesten Zeitkoordinate neu. Diese strukturierte Liste ermöglicht es dem Expert Advisor, das Kursverhalten im Verhältnis zu jeder synchronisierten Trendlinie auf einheitliche und übersichtliche Weise zu bewerten. Selbst wenn mehrere Linien im Chart vorhanden sind, kann das System diese nacheinander verarbeiten, ohne dabei ihre individuellen Eigenschaften aus den Augen zu verlieren.

Ein weiterer Vorteil dieser Struktur besteht darin, dass sie das Lebenszyklusmanagement vereinfacht. Wird eine überwachte Trendlinie aus dem Chart gelöscht, kann das Programm dieses Ereignis über OnChartEvent() erkennen und den entsprechenden Eintrag aus der internen Liste entfernen. Dadurch wird sichergestellt, dass das Überwachungssystem stets den aktuellen Zustand des Charts widerspiegelt.

Mathematische Berechnung des Trendlinienwerts

Eine Trendlinie ist eine gerade Linie, die zwei Punkte im Chart verbindet. Jeder Punkt enthält eine Zeitkoordinate und eine Kurskoordinate. Um Wechselwirkungen zwischen dem Kurs und der Linie zu bewerten, muss das Programm den erwarteten Kurs der Trendlinie zum aktuellen Zeitpunkt ermitteln.

//+------------------------------------------------------------------+
//| Calculate the dynamic price of a trendline at current time       |
//+------------------------------------------------------------------+
double CalculateTrendlinePrice(datetime t1,double p1,
                               datetime t2,double p2,
                               datetime current_time)
  {
   double slope=(p2-p1)/(double)(t2-t1);

   double price=p1+slope*(current_time-t1);

   return(price);
  }
//+------------------------------------------------------------------+

Die beiden Ankerpunkte der Trendlinie seien wie folgt definiert:

• Punkt 1: (T1, P1)
• Punkt 2: (T2, P2)

Dabei steht T für die Zeitkoordinate und P für die Kurskoordinate. Die Steigung der Trendlinie wird anhand der Differenz zwischen den beiden Ankerpunkten berechnet:

• Steigung = (P2 - P1)/(T2 - T1)

Sobald die Steigung bekannt ist, lässt sich der Kurs der Trendlinie zu einem beliebigen Zeitpunkt T mithilfe der linearen Gleichung einer Geraden berechnen:

Im Programm kann der aktuelle Zeitwert mithilfe der Funktion TimeCurrent() oder durch Bezugnahme auf die Zeit der letzten Bar abgerufen werden. Setzt man diesen Wert in die Gleichung ein, erhält man das genaue Kursniveau der Trendlinie zum aktuellen Zeitpunkt. Dieser berechnete Wert gibt die dynamische Position der Trendlinie an. Im Laufe der Zeit und mit dem Erscheinen neuer Kerzen passt sich der berechnete Kurs der Linie automatisch an, wodurch sichergestellt wird, dass Kursbewegungen stets anhand der korrekten Position der Linie ausgewertet werden.

Bewertung von Kursinteraktionen mit Trendlinien

Sobald der aktuelle Wert der Trendlinie berechnet wurde, vergleicht das Programm diesen Wert mit dem über SymbolInfoDouble() abgerufenen Echtzeit-Marktkurs. Anhand dieses Vergleichs kann das System ermitteln, wie sich der Marktkurs im Verhältnis zur überwachten Trendlinie verhält. Durch die Auswertung der Entfernung und der Richtung der Kursbewegung im Verhältnis zur Linie kann das Programm verschiedene Arten von Interaktionen klassifizieren.

//+------------------------------------------------------------------+
//| Evaluate market interaction with a monitored trendline           |
//+------------------------------------------------------------------+
void EvaluateTrendline(TrendlineInfo &line)
  {
   datetime current_time=TimeCurrent();

   double trend_price=
      CalculateTrendlinePrice(line.t1,line.p1,
                              line.t2,line.p2,
                              current_time);

   double market_price=SymbolInfoDouble(_Symbol,SYMBOL_BID);

   double tolerance=10*_Point;

   double distance=MathAbs(market_price-trend_price);

   //--- Detect touch condition
   if(distance<=tolerance)
     {
      Print("Touch detected on ",line.name);
     }

   //--- Detect breakout above
   else if(market_price>trend_price+tolerance)
     {
      Print("Breakout above trendline: ",line.name);
     }

   //--- Detect breakout below
   else if(market_price<trend_price-tolerance)
     {
      Print("Breakout below trendline: ",line.name);
     }
  }
//+------------------------------------------------------------------+

Es können verschiedene Interaktionsbedingungen ausgewertet werden:

• Annäherung – wenn sich der Marktkurs innerhalb einer vordefinierten Entfernung zur Trendlinie bewegt. Diese Situation deutet darauf hin, dass sich der Kurs einem potenziell wichtigen Niveau nähert.
• Touch – wenn der Kurs den berechneten Wert der Linie erreicht. Dieses Ereignis deutet darauf hin, dass die Trendlinie vom Markt auf die Probe gestellt wird.
• Ausbruch – wenn der Kurs die Linie überschreitet und sich darüber hinaus weiterbewegt. Ein solches Verhalten deutet oft darauf hin, dass der Markt die bisher beachtete Trendstruktur durchbricht.
• Abprall – wenn sich der Kurs der Linie nähert, dann aber die Richtung wechselt, ohne sie zu überschreiten. Dieses Verhalten könnte darauf hindeuten, dass die Trendlinie als dynamisches Unterstützungs- oder Widerstandsniveau fungiert.

Um diese Zustände zuverlässig zu erkennen, wertet das System die Differenz zwischen dem aktuellen Marktkurs und dem berechneten Trendlinienwert aus. In der Regel wird eine Toleranzschwelle angewendet, um geringfügige Kursschwankungen und Spread-Schwankungen zu berücksichtigen. Im Rahmen dieses Vergleichsprozesses wertet das Überwachungssystem kontinuierlich die Beziehung zwischen dem Markt und den synchronisierten Trendlinien aus.

Erstellen von Warnmeldungen und Benachrichtigungen

Sobald ein Interaktionsereignis erkannt wird, informiert das System den Trader durch Warnmeldungen und Benachrichtigungen. Zu diesem Zweck können mehrere integrierte MQL5-Funktionen verwendet werden. Die Funktion Alert() sorgt für eine sofortige Benachrichtigung innerhalb der Plattform, während die Funktion Print() Informationen im Terminalprotokoll aufzeichnet. Falls mobile Benachrichtigungen erforderlich sind, kann auch die Funktion SendNotification() verwendet werden.

//+------------------------------------------------------------------+
//| Send notifications when trendline interaction occurs             |
//+------------------------------------------------------------------+
void NotifyInteraction(string message)
  {
   //--- Platform alert
   Alert(message);

   //--- Terminal log entry
   Print(message);

   //--- Mobile push notification
   SendNotification(message);
  }
//+------------------------------------------------------------------+

Diese Benachrichtigungen informieren den Trader, sobald sich der Kurs einer überwachten Trendlinie nähert oder diese berührt. Auf diese Weise lassen sich wichtige Ereignisse auch dann erkennen, wenn der Trader den Chart nicht ständig im Blick hat.

Visuelle Rückmeldung über ein Chart-Panel

Neben Warnmeldungen liefert das System über ein Überwachungsfenster direkt im Chart visuelles Feedback. Dieses Panel kann mithilfe von Chartbeschriftungen erstellt werden, die mit der Funktion ObjectCreate() generiert wurden. Jedes Etikett zeigt Informationen zu einer synchronisierten Trendlinie an, darunter deren Namen und die zuletzt erkannte Interaktion.

//+------------------------------------------------------------------+
//| Create a simple monitoring panel on the chart                    |
//+------------------------------------------------------------------+
void CreatePanel()
  {
   string name="TrendMonitorPanel";

   //--- Create label if it does not exist
   if(ObjectFind(0,name)<0)
     {
      ObjectCreate(0,name,OBJ_LABEL,0,0,0);

      ObjectSetInteger(0,name,OBJPROP_CORNER,CORNER_LEFT_UPPER);
      ObjectSetInteger(0,name,OBJPROP_XDISTANCE,10);
      ObjectSetInteger(0,name,OBJPROP_YDISTANCE,20);
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,10);
     }

   //--- Update label text
   ObjectSetString(0,name,OBJPROP_TEXT,
                   "Trendline Monitoring Active");
  }
//+------------------------------------------------------------------+

Durch die dynamische Aktualisierung dieser Beschriftungen bietet das Panel einen Echtzeit-Überblick über die überwachten Trendlinien und deren Interaktionsstatus. Der Trader kann schnell einschätzen, wie sich der Kurs im Verhältnis zu den einzelnen Linien verhält, ohne diese manuell einzeln überprüfen zu müssen.

Diese visuelle Benutzeroberfläche ergänzt das Warnsystem und verbessert die Benutzerfreundlichkeit des Überwachungstools.

Verwaltung des Lebenszyklus von Trendlinien

Im Zuge der Weiterentwicklung der Handelsanalyse können Trendlinien angepasst oder aus dem Chart entfernt werden. Das Überwachungssystem muss daher stets mit dem aktuellen Stand des Charts synchronisiert bleiben. Dies wird durch die Erkennung von Ereignissen zum Löschen von Objekten über OnChartEvent() umgesetzt. Wenn eine überwachte Trendlinie aus dem Chart entfernt wird, wird der entsprechende Datensatz ebenfalls aus der internen Überwachungsstruktur entfernt.

//+------------------------------------------------------------------+
//| Remove a trendline from the monitoring list                      |
//+------------------------------------------------------------------+
void RemoveTrendline(string name)
  {
   int total=ArraySize(MonitoredLines);

   for(int i=0;i<total;i++)
     {
      if(MonitoredLines[i].name==name)
        {
         ArrayRemove(MonitoredLines,i);
         Print("Trendline removed: ",name);
         break;
        }
     }
  }
//+------------------------------------------------------------------+

Diese dynamische Verwaltung stellt sicher, dass die Überwachungsliste stets die aktuell im Chart angezeigten Trendlinien widerspiegelt.

Integration manueller Analysen in die automatisierte Überwachung

Das Endergebnis ist ein hybrides Analysesystem, das die manuelle Chartanalyse mit automatisierter Beobachtung kombiniert. Nach der Synchronisierung wertet der Expert Advisor kontinuierlich das Zusammenspiel der Kurse mit den ausgewählten Trendlinien aus.

Durch die Kombination von manueller Analyse mit automatisierter Überwachung verringert das System die Notwendigkeit einer ständigen Beobachtung der Charts und stellt gleichzeitig sicher, dass wichtige Wechselwirkungen zwischen Kurs und Trendlinien in Echtzeit erkannt werden.

Verwendung des Expert Advisors

Nach der Kompilierung und dem Einbinden in ein Chart stehen im Expert Advisor drei Schaltflächen zur Verfügung:

• Zeichnen – Klicken Sie hier, um den Zeichenmodus zu aktivieren. Die Schaltfläche wird hervorgehoben, was darauf hinweist, dass der EA bereit ist, eine neue Trendlinie zu erkennen.
• Synchronisieren – Nachdem eine Linie gezeichnet wurde, wird diese Schaltfläche aktiv. Klicken Sie darauf, um die neu gezeichnete Linie mit dem Überwachungssystem zu synchronisieren.
• Alle löschen – Entfernt alle synchronisierten Trendlinien aus der Überwachung und stellt ihr ursprüngliches Erscheinungsbild wieder her.

Nach der Synchronisierung verlängert sich die Linie automatisch nach rechts, ändert ihre Farbe und wird dicker. Das Überwachungsfenster zeigt alle synchronisierten Linien / Trendlinien zusammen mit ihrem aktuellen Interaktionsstatus an. Das Fenster lässt sich an eine beliebige Position im Chart ziehen, indem man auf den Hintergrund klickt und die Maustaste gedrückt hält.

Tests

Um das Verhalten des Überwachungssystems zu überprüfen, wurden mehrere Tests mit verschiedenen Währungspaaren und Zeiträumen durchgeführt. Der Übersichtlichkeit halber konzentriert sich dieser Abschnitt auf ein repräsentatives Beispiel mit dem EURUSD-Paar im M30-Zeitrahmen, das im folgenden GIF dargestellt ist.

Im Rahmen der Tests wurden mehrere Trendlinien gleichzeitig synchronisiert, um zu überprüfen, ob das Überwachungssystem mehrere Referenzniveaus ohne Leistungseinbußen verfolgen kann. Der Expert Advisor wurde zudem über verschiedene Zeitrahmen hinweg getestet, um sicherzustellen, dass die Berechnung des Trendlinienwerts / Trendlinienkurses unabhängig von der Skalierung des Charts präzise bleibt. 

Während sich der Markt weiterbewegte, überwachte das Programm kontinuierlich das Zusammenspiel der Kurse mit der synchronisierten Trendlinie. Als sich der Kurs der Linie näherte und diese schließlich berührte, erkannte das System die Interaktion und löste einen Alarm aus. Dieses Verhalten lässt sich in der GIF-Datei beobachten, in der die Warnmeldung in dem Moment ausgelöst wird, in dem der Kurs die überwachte Trendlinie erreicht.

Der Test bestätigt, dass die Überwachungslogik die geometrische Position der Trendlinie korrekt interpretiert und Kursbewegungen in Echtzeit auswertet. Der Synchronisationsmechanismus, die visuelle Rückmeldung und das Warnsystem arbeiten wie erwartet zusammen, sodass manuell eingezeichnete Analysestrukturen automatisch verfolgt werden können, ohne dass eine ständige manuelle Beobachtung des Charts erforderlich ist.

Insgesamt zeigen die Ergebnisse, dass das System in einer Live-Chart-Umgebung zuverlässig funktioniert und Wechselwirkungen zwischen dem Kurs und den synchronisierten Trendlinien erfolgreich erkennt und meldet.

Schlussfolgerung

Die implementierte Annäherung verwandelt die manuelle Trendlinienanalyse in einen reproduzierbaren hybriden Arbeitsablauf: Sie behalten die volle Kontrolle darüber, welche Ankerpunkte und Linien die Marktstruktur darstellen, während der EA die kontinuierliche Beobachtung und die Ereignismeldung übernimmt. Praktisch gesehen verfügen Sie nach der Umsetzung der Anweisungen in diesem Artikel über eine übersichtliche, einsatzbereite Vorlage für MT5, die Folgendes bietet:

• Erkennung neu erstellter OBJ_TREND-Objekte über OnChartEvent,
• Einen expliziten Synchronisationsschritt, um nur die vom Trader ausgewählten Linien zu erfassen,
• Speicherung von Ankerpunkten und Verwaltung des Lebenszyklus (Erstellen/Ändern/Löschen),
• Berechnung des dynamischen Kurses der Linie zum aktuellen Zeitpunkt,
• Klassifizierung von Interaktionen (Annäherung, Berührung, Ausbruch, Abprall) mit einem Toleranzschwellenwert,
• Benachrichtigungen über Alert/Print/SendNotification und ein Live-Panel im Chart zur Statusanzeige.

Einschränkungen und Anwendungsbereich sind klar definiert: Das System überwacht nur synchronisierte Linien (nicht jede Grafik auf dem Chart), nutzt eine konfigurierbare Toleranz, um Fehlsignale zu reduzieren, und wertet Interaktionen anhand der gewählten Marktkursreferenz (z. B. BID) aus. Das Ergebnis ist ein praktisches, testbares Expert-Advisor-Muster, das das menschliche Urteilsvermögen beim Zeichnen von Trendlinien bewahrt und gleichzeitig das Situationsbewusstsein zuverlässig verbessert sowie verpasste Chancen reduziert.