Entwicklung eines individuellen Indikators für die Marktstimmung

Einführung

Es ist schwierig, die wahre Richtung des Marktes zu erkennen, insbesondere wenn verschiedene Zeitrahmen widersprüchliche Aussagen machen. Auf der 30-Minuten-Chart könnte sich ein starker Aufwärtstrend abzeichnen, während die 4-Stunden-Chart weiterhin Abwärtsdruck signalisiert. Dies führt häufig zu Verwirrung, falsch ausgerichteten Handelsgeschäften oder dem Eingehen von Positionen gegen die vorherrschende Marktrichtung. Ohne eine strukturierte Methode zur Abstimmung von Signalen mit höherem und niedrigerem Zeitrahmen laufen Händler Gefahr, impulsive Entscheidungen auf der Grundlage unvollständiger Informationen zu treffen, was letztlich die Konsistenz und Rentabilität verringert.

Der nutzerdefinierte Indikator Market Sentiment geht auf dieses Problem ein, indem er Signale aus verschiedenen Zeitrahmen in einem einzigen, leicht ablesbaren Feld zusammenfasst. Durch die Analyse von Trends auf höheren Zeitskalen und Strukturen auf niedrigeren Zeitskalen wird der Markt in fünf klare Stimmungen eingeteilt, aufwärts, abwärts, mehr und weniger Risiko oder neutral: „bullish“, „bearish“, „risk-on“, „risk-off“ und „neutral“. Dieser vielschichtige Ansatz hilft den Händlern, das Gesamtbild im Auge zu behalten und gleichzeitig den Einstieg mit kurzfristigen Bestätigungen zu timen. Dadurch wird die Entscheidungsfindung vereinfacht, die Unsicherheit verringert und die Anpassung des Handels an die vorherrschenden Marktbedingungen verbessert.

Entwicklung und Logik

Bullish Sentiment:

Tritt auf, wenn Händler und Anleger allgemein steigende Preise erwarten. Dies ist gekennzeichnet durch einen stärkeren Kaufdruck als durch Verkaufsdruck. Häufige Anzeichen sind höhere Höchst- und Tiefststände im Kursgeschehen, ein hohes Volumen bei Aufwärtsbewegungen und ein positiver Wirtschafts- oder Nachrichtenausblick. In ihrer extremen Form kann die Hausse zu Euphorie führen, wenn der Optimismus übertrieben wird, was häufig gegen Ende einer Hausse der Fall ist.

Bearish Sentiment:

Spiegelt die Erwartung sinkender Preise wider, wobei der Verkaufsdruck größer ist als der Kaufdruck. Erkennbar ist dies in der Regel an niedrigeren Höchst- und Tiefstständen im Kursgeschehen, einem starken Volumen bei Abwärtsbewegungen und negativen wirtschaftlichen Entwicklungen oder Nachrichten. In ihrem Extremfall kann sich die Abwärts-Stimmung als Panik manifestieren und zu aggressiven Verkäufen führen, die häufig an oder in der Nähe von Markttiefs auftreten.

Neutral Sentiment:

Entsteht, wenn die Marktteilnehmer unentschlossen sind oder ein Gleichgewicht zwischen Käufern und Verkäufern wahrnehmen. In diesem Umfeld bewegen sich die Kurse in der Regel innerhalb einer Spanne, ohne einen klaren Auf- oder Abwärtstrend zu bilden. Wichtige Anzeichen sind Konsolidierungsphasen, geringe Volatilität und Händler, die auf eine Bestätigung warten, bevor sie Positionen eingehen.

Risk-on Sentiment:

Beschreibt eine Marktstimmung, in der die Anleger risikofreudiger sind und häufig in Aktien, Rohstoffe und renditestarke Anlagen investieren. Das Kapital fließt in Instrumente mit höherem Renditepotenzial. Typische Anzeichen sind steigende Aktienindizes und eine schwache Nachfrage nach sicheren Anlagen wie Gold oder Staatsanleihen.

Risk-off Sentiment:

Andererseits entsteht sie, wenn Anleger aufgrund von Angst oder Unsicherheit Sicherheit suchen. In diesem Fall wird das Kapital in traditionell sicherere Anlagen wie Gold, den US-Dollar, den Schweizer Franken oder Staatsanleihen umgeschichtet. Sie ist in der Regel durch fallende Aktienindizes und eine steigende Nachfrage nach sicheren Währungen und Vermögenswerten gekennzeichnet.

Beziehung der Zeitrahmen:

Diagramm des Aufbaus:

Die ersten Schritte

//+------------------------------------------------------------------+
//|                                                  Market_Sent.mq5 |
//|                        GIT under Copyright 2025, MetaQuotes Ltd. |
//|                     https://www.mql5.com/en/users/johnhlomohang/ |
//+------------------------------------------------------------------+
#property copyright "GIT under Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/johnhlomohang/"
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 0
#property indicator_plots   0


//+------------------------------------------------------------------+
//| Input parameters                                                 |
//+------------------------------------------------------------------+
input group "Timeframe Settings"
input ENUM_TIMEFRAMES HigherTF = PERIOD_H4;     
input ENUM_TIMEFRAMES LowerTF1 = PERIOD_H1;     
input ENUM_TIMEFRAMES LowerTF2 = PERIOD_M30;    

input group "Indicator Settings"
input int MAPeriod = 200;                       
input int SwingLookback = 5;                    
input double ATRThreshold = 0.002;              

input group "Visual Settings"
// force top-left dark theme
input int PanelCorner = 0;                      
input int PanelX = 10;                          
input int PanelY = 10;                          
input string FontFace = "Arial";                
input int FontSize = 10;                        
input color BullishColor = clrLimeGreen;        
input color BearishColor = clrRed;              
input color RiskOnColor = clrDodgerBlue;        
input color RiskOffColor = clrOrangeRed;        
input color NeutralColor = clrGold;      

Wir beginnen damit, den Rahmen für einen individuellen Indikator für die Marktstimmung in MQL5 einzurichten. Der obere Abschnitt enthält Metadaten wie Copyright, Version und Link sowie Direktiven, die die Eigenschaften des Indikators definieren. Die Angaben indicator_buffers 0 und indicator_plots 0 bedeuten, dass keine Standardpuffer oder -diagramme verwendet werden, da dieser Indikator eher als visuelles Hilfsmittel im Stil eines Panels konzipiert ist, als dass er Linien oder Histogramme aufzeichnet. Diese Anfangseinstellungen legen im Wesentlichen die Umgebung fest, in der die nutzerdefinierte Logik der Stimmungsanalyse ausgeführt wird.

Die Eingabeparameter bieten den Händlern Flexibilität bei der Konfiguration des Indikators. In der Gruppe „Zeitrahmen-Einstellungen“ kann der Nutzer einen höheren Zeitrahmen (standardmäßig H4) und zwei niedrigere Zeitrahmen (H1 und M30) für die Sentimentanalyse auswählen. Unter „Indikatoreinstellungen“ können Händler technische Parameter wie den Zeitraum des gleitenden Durchschnitts, den Rückblicksbereich und den ATR-Schwellenwert anpassen, die zur Interpretation des Kursverhaltens und der Volatilität verwendet werden. Schließlich steuert die Gruppe „Visuelle Einstellungen“, wie das Stimmungspanel im Chart angezeigt wird, einschließlich seiner Position, Schriftart, Größe und der spezifischen Farben, die verwendet werden, um die Bedingungen für „bullish“, „bearish“, „risk-on“, „risk-off“ und „neutral“ darzustellen. Zusammen bilden diese Inputs eine flexible Grundlage für die Erkennung und Visualisierung von Marktstimmungen über mehrere Zeiträume hinweg.

//+------------------------------------------------------------------+
//| Global variables                                                 |
//+------------------------------------------------------------------+
int higherTFHandle, lowerTF1Handle, lowerTF2Handle;
double higherTFMA[], lowerTF1MA[], lowerTF2MA[];
datetime lastUpdateTime = 0;
string indicatorName = "MarketSentiment";

//--- helper: convert timeframe to string
string TFtoString(int tf)
{
   switch(tf)
   {
      case PERIOD_M1:  return "M1";
      case PERIOD_M5:  return "M5";
      case PERIOD_M15: return "M15";
      case PERIOD_M30: return "M30";
      case PERIOD_H1:  return "H1";
      case PERIOD_H4:  return "H4";
      case PERIOD_D1:  return "D1";
      case PERIOD_W1:  return "W1";
      case PERIOD_MN1: return "MN";
      default: return "TF?";
   }
}

In diesem Abschnitt werden die für den Marktstimmungsindikator erforderlichen globalen Variablen und Hilfsfunktionen definiert. Die drei Handle-Variablen (higherTFHandle, lowerTF1Handle und lowerTF2Handle) werden zum Speichern von Verweisen auf Berechnungen des gleitenden Durchschnitts für verschiedene Zeitrahmen verwendet, während die Arrays (higherTFMA[], lowerTF1MA[], lowerTF2MA[]) die entsprechenden Datenwerte enthalten. Eine lastUpdateTime-Variable wird initialisiert, um zu verfolgen, wann der Indikator zuletzt aktualisiert wurde, um effiziente Aktualisierungen zu gewährleisten, und indicatorName bietet eine konsistente Bezeichnung für im Chart gezeichnete Objekte. Außerdem wandelt die Hilfsfunktion TFtoString() numerische Zeitrahmenkonstanten in lesbare Strings um (z. B. PERIOD_H1 -> „H1“), was für die Beschriftung oder Anzeige von Informationen im Indikatorpanel nützlich ist.

//+------------------------------------------------------------------+
//| OnInit                                                           |
//+------------------------------------------------------------------+
int OnInit()
{
    indicatorName = "MarketSentiment_" + IntegerToString(ChartID());
    
    higherTFHandle = iMA(_Symbol, HigherTF, MAPeriod, 0, MODE_EMA, PRICE_CLOSE);
    lowerTF1Handle = iMA(_Symbol, LowerTF1, MAPeriod, 0, MODE_EMA, PRICE_CLOSE);
    lowerTF2Handle = iMA(_Symbol, LowerTF2, MAPeriod, 0, MODE_EMA, PRICE_CLOSE);
    
    ArraySetAsSeries(higherTFMA, true);
    ArraySetAsSeries(lowerTF1MA, true);
    ArraySetAsSeries(lowerTF2MA, true);
    
    CreatePanel();
    return(INIT_SUCCEEDED);
}

Die Funktion OnInit() initialisiert den Marktstimmungsindikator, indem sie eine eindeutige Benennung für Chart-Objekte unter Verwendung der Chart-ID einrichtet und gleitende Durchschnitts-Handles für den oberen und unteren Zeitrahmen mit der angegebenen Periode und EMA-Methode erstellt. Außerdem werden die MA-Arrays so konfiguriert, dass sie zeitreihenorientiert sind, was eine einfachere Indizierung beim Zugriff auf aktuelle Werte gewährleistet. Schließlich wird die Funktion CreatePanel() aufgerufen, um das Stimmungsanzeigefeld auf dem Chart zu zeichnen, und anschließend wird INIT_SUCCEEDED zurückgegeben, um die erfolgreiche Initialisierung zu bestätigen.

//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    ObjectsDeleteAll(0, indicatorName);
    IndicatorRelease(higherTFHandle);
    IndicatorRelease(lowerTF1Handle);
    IndicatorRelease(lowerTF2Handle);
}

Die Funktion OnDeinit() sorgt für eine ordnungsgemäße Bereinigung, wenn der Indikator entfernt wird, indem sie alle Chart-Objekte löscht, die mit seinem eindeutigen Indikatornamen verknüpft sind, und die Handles der gleitenden Durchschnitte des oberen und unteren Zeitrahmens freigibt, wodurch Speicherlecks verhindert werden und die Chart-umgebung sauber bleibt.

//+------------------------------------------------------------------+
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[])
{
    if (TimeCurrent() - lastUpdateTime < 10 && prev_calculated > 0)
        return(rates_total);
    
    lastUpdateTime = TimeCurrent();
    
    CopyBuffer(higherTFHandle, 0, 0, 3, higherTFMA);
    CopyBuffer(lowerTF1Handle, 0, 0, 3, lowerTF1MA);
    CopyBuffer(lowerTF2Handle, 0, 0, 3, lowerTF2MA);
    
    double higherTFPrice = iClose(_Symbol, HigherTF, 0);
    double lowerTF1Price = iClose(_Symbol, LowerTF1, 0);
    double lowerTF2Price = iClose(_Symbol, LowerTF2, 0);
    
    int higherTFBias = GetHigherTFBias(higherTFPrice, higherTFMA[0]);
    
    bool lowerTF1Bullish = IsBullishStructure(LowerTF1, SwingLookback);
    bool lowerTF1Bearish = IsBearishStructure(LowerTF1, SwingLookback);
    bool lowerTF2Bullish = IsBullishStructure(LowerTF2, SwingLookback);
    bool lowerTF2Bearish = IsBearishStructure(LowerTF2, SwingLookback);
    
    bool lowerTF1Breakout = HasBreakout(LowerTF1, SwingLookback, higherTFBias);
    bool lowerTF2Breakout = HasBreakout(LowerTF2, SwingLookback, higherTFBias);
    
    int sentiment = DetermineSentiment(
        higherTFBias, 
        lowerTF1Bullish, lowerTF1Bearish, lowerTF1Breakout,
        lowerTF2Bullish, lowerTF2Bearish, lowerTF2Breakout
    );
    
    UpdatePanel(higherTFBias,
                lowerTF1Bullish, lowerTF1Bearish,
                lowerTF2Bullish, lowerTF2Bearish,
                sentiment);
    
    return(rates_total);
}

Die Funktion OnCalculate() dient als Hauptverarbeitungsschleife des Indikators und wird jedes Mal ausgeführt, wenn neue Kursdaten oder Ticks eintreffen. Es beginnt mit einer Aktualisierungsdrossel, die sicherstellt, dass Berechnungen nur dann durchgeführt werden, wenn seit der letzten Aktualisierung mindestens 10 Sekunden vergangen sind, was die Effizienz erhöht. Die Funktion kopiert dann die Werte des gleitenden Durchschnitts aus den Puffern des oberen und unteren Zeitrahmens und holt die letzten Schlusskurse für jeden Zeitrahmen, die die Grundlage für die Sentimentbewertung bilden.

Nach der Erfassung der Preis- und MA-Daten bestimmt die Funktion die Tendenz auf dem höheren Zeitrahmen und prüft die strukturellen Bedingungen (Auf- oder Abwärtsmuster) auf dem niedrigeren Zeitrahmen. Sie bestätigt auch potenzielle Ausbrüche in Übereinstimmung mit der Ausrichtung auf einen höheren Zeitrahmen. Diese Bedingungen werden in der Funktion DetermineSentiment() kombiniert, um den Markt in „bullish“, „bearish“, „risk-on“, „risk-off“ und „neutral“ zu klassifizieren. Schließlich werden die Ergebnisse über UpdatePanel() visuell auf dem Chart dargestellt, sodass Händler ein Echtzeit-Dashboard der Stimmungen in mehreren Zeitrahmen erhalten.

//+------------------------------------------------------------------+
//| Determine higher timeframe bias                                  |
//+------------------------------------------------------------------+
int GetHigherTFBias(double price, double maValue)
{
    double deviation = MathAbs(price - maValue) / maValue;
    if (price > maValue && deviation > ATRThreshold) return 1;
    else if (price < maValue && deviation > ATRThreshold) return -1;
    else return 0;
}

Diese Funktion bewertet die Trendrichtung im höheren Zeitrahmen, indem sie den aktuellen Kurs mit seinem gleitenden Durchschnittswert vergleicht. Wenn der Kurs über dem MA liegt und die Abweichung den definierten ATR-Schwellenwert übersteigt, gibt er 1 zurück (Aufwärtstrend), während er -1 zurückgibt, wenn der Kurs bei ausreichender Abweichung darunter liegt (Abwärtstrend). Wenn keine der beiden Bedingungen erfüllt ist, wird der Wert 0 zurückgegeben, was einen neutralen oder einen Seitwärtstrend im höheren Zeitrahmen signalisiert.

//+------------------------------------------------------------------+
//| Bullish structure                                                |
//+------------------------------------------------------------------+
bool IsBullishStructure(ENUM_TIMEFRAMES tf, int lookback)
{
    int swingHighIndex = iHighest(_Symbol, tf, MODE_HIGH, lookback * 2, 1);
    int swingLowIndex  = iLowest (_Symbol, tf, MODE_LOW,  lookback * 2, 1);
    int prevHigh = iHighest(_Symbol, tf, MODE_HIGH, lookback, lookback+1);
    int prevLow  = iLowest (_Symbol, tf, MODE_LOW,  lookback, lookback+1);
    if (swingHighIndex==-1 || swingLowIndex==-1 || prevHigh==-1 || prevLow==-1) return false;
    return (iHigh(_Symbol, tf, swingHighIndex) > iHigh(_Symbol, tf, prevHigh) &&
            iLow(_Symbol, tf, swingLowIndex)   > iLow (_Symbol, tf, prevLow));
}
//+------------------------------------------------------------------+
//| Bearish structure                                                |
//+------------------------------------------------------------------+
bool IsBearishStructure(ENUM_TIMEFRAMES tf, int lookback)
{
    int swingHighIndex = iHighest(_Symbol, tf, MODE_HIGH, lookback * 2, 1);
    int swingLowIndex  = iLowest (_Symbol, tf, MODE_LOW,  lookback * 2, 1);
    int prevHigh = iHighest(_Symbol, tf, MODE_HIGH, lookback, lookback+1);
    int prevLow  = iLowest (_Symbol, tf, MODE_LOW,  lookback, lookback+1);
    if (swingHighIndex==-1 || swingLowIndex==-1 || prevHigh==-1 || prevLow==-1) return false;
    return (iHigh(_Symbol, tf, swingHighIndex) < iHigh(_Symbol, tf, prevHigh) &&
            iLow(_Symbol, tf, swingLowIndex)   < iLow (_Symbol, tf, prevLow));
}

Die Funktion IsBullishStructure() identifiziert ein Aufwärtsmuster der Preise in einem bestimmten Zeitrahmen, indem sie die jüngsten Höchst- und Tiefstkurse mit den vorangegangenen Kurspunkten vergleicht. Zunächst werden mit Hilfe der Funktionen iHighest und iLowest die aktuellen und vorherigen Hochs und Tiefs der Umkehrpunkte ermittelt. Ist das aktuelle Hoch höher als das vorherige und das aktuelle Tief höher als das vorherige, gibt die Funktion den Wert „true“ zurück und signalisiert damit eine Aufwärts-Struktur; andernfalls gibt sie den Wert „false“ zurück.

In ähnlicher Weise erkennt die Funktion IsBearishStructure() ein Abwärts-Muster, indem sie die jüngsten Umkehrpunkte mit früheren vergleicht. Wenn das aktuelle Hoch niedriger ist als das vorherige und das aktuelle Tief niedriger ist als das vorherige, wird „true“ zurückgegeben, was auf eine Abwärts-Struktur hinweist. Beide Funktionen beruhen auf der Umkehr-Analyse über einen bestimmten Rückblickszeitraum, wodurch der Indikator eine Methode zur Bewertung kurzfristiger Preistrends im Verhältnis zu ihren früheren Bewegungen bietet.

//+------------------------------------------------------------------+
bool HasBreakout(ENUM_TIMEFRAMES tf, int lookback, int higherTFBias)
{
    int swingHighIndex = iHighest(_Symbol, tf, MODE_HIGH, lookback, 1);
    int swingLowIndex  = iLowest (_Symbol, tf, MODE_LOW,  lookback, 1);
    if (swingHighIndex==-1 || swingLowIndex==-1) return false;
    double swingHigh = iHigh(_Symbol, tf, swingHighIndex);
    double swingLow  = iLow (_Symbol, tf, swingLowIndex);
    double price = iClose(_Symbol, tf, 0);
    if (higherTFBias==1) return (price > swingHigh);
    if (higherTFBias==-1) return (price < swingLow);
    return false;
}

Diese Funktion prüft, ob der aktuelle Kurs die letzten Umkehrpunkte auf einem bestimmten Zeitrahmen über- oder unterschritten hat, wobei der höhere Zeitrahmen berücksichtigt wird. Sie ermittelt den letzten hohen Umkehrpunkt und den letzten tiefen Umkehrpunkt, und wenn keines davon verfügbar ist, gibt sie false zurück. Bei einem steigenden Trend im höherem Zeitrahmen wird der Wert „true“ angezeigt, wenn der aktuelle Kurs einen hohen Umkehrpunkt übersteigt, während er bei einem Abwärtstrend „true“ angezeigt wird, wenn der Kurs unter den tiefen Umkehrpunkt fällt. Wenn der höhere Zeitrahmen neutral ist, wird kein Ausbruch berücksichtigt, und die Funktion gibt false zurück.

//+------------------------------------------------------------------+
int DetermineSentiment(int higherTFBias, 
                      bool tf1Bullish, bool tf1Bearish, bool tf1Breakout,
                      bool tf2Bullish, bool tf2Bearish, bool tf2Breakout)
{
    if (higherTFBias==1 && tf1Bullish && tf2Bullish) return 1;
    if (higherTFBias==-1 && tf1Bearish && tf2Bearish) return -1;
    if (higherTFBias==1 && (tf1Breakout||tf2Breakout)) return 2;
    if (higherTFBias==-1 && (tf1Breakout||tf2Breakout)) return -2;
    return 0;
}

Die Funktion DetermineSentiment() fasst die Marktbedingungen über mehrere Zeitrahmen zusammen, um die allgemeine Marktstimmung zu klassifizieren. Sie liefert 1 für eine Aufwärts-Stimmung, wenn der höhere Zeitrahmen aufwärts tendiert und beide niedrigeren Zeitrahmen Aufwärts-Strukturen aufweisen, -1 für eine Abwärts-Stimmung unter den gegenteiligen Bedingungen, 2 für risk-on, wenn ein steigender, höherer Zeitrahmen Ausbrüche in den niedrigeren Zeitrahmen erlebt, und -2 für risk-off, wenn ein fallender, höherer Zeitrahmen vergleichbare Ausbrüche erlebt. Wenn keine dieser Bedingungen erfüllt ist, wird der Wert 0 zurückgegeben, was auf einen neutralen oder unruhigen Marktzustand hinweist.

//+------------------------------------------------------------------+
//| Panel Creation (dark theme, top-left)                            |
//+------------------------------------------------------------------+
void CreatePanel()
{
   string bg = indicatorName + "_BG";
   ObjectCreate(0, bg, OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, bg, OBJPROP_XDISTANCE, PanelX);
   ObjectSetInteger(0, bg, OBJPROP_YDISTANCE, PanelY);
   ObjectSetInteger(0, bg, OBJPROP_XSIZE, 200);
   ObjectSetInteger(0, bg, OBJPROP_YSIZE, 120);
   ObjectSetInteger(0, bg, OBJPROP_CORNER, 0);
   ObjectSetInteger(0, bg, OBJPROP_BGCOLOR, clrBlack);
   ObjectSetInteger(0, bg, OBJPROP_BORDER_COLOR, clrGray);
   ObjectSetInteger(0, bg, OBJPROP_BACK, true);
   ObjectSetInteger(0, bg, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(0, bg, OBJPROP_HIDDEN, true);

   string title = indicatorName + "_Title";
   ObjectCreate(0, title, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, title, OBJPROP_XDISTANCE, PanelX+10);
   ObjectSetInteger(0, title, OBJPROP_YDISTANCE, PanelY+10);
   ObjectSetInteger(0, title, OBJPROP_CORNER, 0);
   ObjectSetString (0, title, OBJPROP_TEXT, "Market Sentiment");
   ObjectSetInteger(0, title, OBJPROP_COLOR, clrWhite);
   ObjectSetString (0, title, OBJPROP_FONT, FontFace);
   ObjectSetInteger(0, title, OBJPROP_FONTSIZE, FontSize);

   string tfs[3] = { TFtoString(HigherTF), TFtoString(LowerTF1), TFtoString(LowerTF2) };
   for(int i=0;i<3;i++)
   {
      string tfLabel = indicatorName+"_TF"+(string)i;
      ObjectCreate(0, tfLabel, OBJ_LABEL, 0,0,0);
      ObjectSetInteger(0, tfLabel, OBJPROP_XDISTANCE, PanelX+10);
      ObjectSetInteger(0, tfLabel, OBJPROP_YDISTANCE, PanelY+30+i*20);
      ObjectSetInteger(0, tfLabel, OBJPROP_CORNER, 0);
      ObjectSetString (0, tfLabel, OBJPROP_TEXT, tfs[i]+":");
      ObjectSetInteger(0, tfLabel, OBJPROP_COLOR, clrLightGray);
      ObjectSetString (0, tfLabel, OBJPROP_FONT, FontFace);
      ObjectSetInteger(0, tfLabel, OBJPROP_FONTSIZE, FontSize);

      string sentLabel = indicatorName+"_Sentiment"+(string)i;
      ObjectCreate(0, sentLabel, OBJ_LABEL, 0,0,0);
      ObjectSetInteger(0, sentLabel, OBJPROP_XDISTANCE, PanelX+100);
      ObjectSetInteger(0, sentLabel, OBJPROP_YDISTANCE, PanelY+30+i*20);
      ObjectSetInteger(0, sentLabel, OBJPROP_CORNER, 0);
      ObjectSetString (0, sentLabel, OBJPROP_TEXT, "N/A");
      ObjectSetInteger(0, sentLabel, OBJPROP_COLOR, NeutralColor);
      ObjectSetString (0, sentLabel, OBJPROP_FONT, FontFace);
      ObjectSetInteger(0, sentLabel, OBJPROP_FONTSIZE, FontSize);
   }

   string fnl = indicatorName+"_Final";
   ObjectCreate(0, fnl, OBJ_LABEL, 0,0,0);
   ObjectSetInteger(0, fnl, OBJPROP_XDISTANCE, PanelX+10);
   ObjectSetInteger(0, fnl, OBJPROP_YDISTANCE, PanelY+100);
   ObjectSetInteger(0, fnl, OBJPROP_CORNER, 0);
   ObjectSetString (0, fnl, OBJPROP_TEXT, "Final: Neutral");
   ObjectSetInteger(0, fnl, OBJPROP_COLOR, NeutralColor);
   ObjectSetString (0, fnl, OBJPROP_FONT, FontFace);
   ObjectSetInteger(0, fnl, OBJPROP_FONTSIZE, FontSize+2);
}

Die Funktion CreatePanel() initialisiert ein visuell organisiertes Panel in der linken oberen Ecke des Charts, wobei ein dunkles Design verwendet wird, das für schwarz-auf-weiß-Hintergründe geeignet ist. Zunächst wird als Hintergrund ein Rechteck mit schwarzer Füllung und grauem Rand erstellt, das sich hinter anderen Chart-Objekten befindet und nicht wählbar ist. Oben auf dem Panel wird dann eine Beschriftung hinzugefügt, die den Indikator eindeutig als „Market Sentiment“ (Marktstimmung) kennzeichnet, wobei sich der weiße Text vom dunklen Hintergrund abhebt.

Unterhalb des Titels generiert die Funktion Beschriftungen für jeden der drei überwachten Zeitrahmen – einen höheren und einen niedrigeren – und zeigt deren Namen zusammen mit Platzhalter-Stimmungswerten, die mit „N/A“ initialisiert sind, in einer neutralen Farbe an. Eine größere Kennzeichnung am unteren Rand fasst schließlich die endgültige Markteinschätzung zusammen, die zunächst auf „Neutral“ gesetzt wurde. Dieses Setup ermöglicht eine einfache visuelle Verfolgung von Marktverzerrungen über mehrere Zeitrahmen in einem einzigen, kompakten Panel.

//+------------------------------------------------------------------+
//| Panel Update                                                     |
//+------------------------------------------------------------------+
void UpdatePanel(int higherTFBias,
                 bool tf1Bullish, bool tf1Bearish,
                 bool tf2Bullish, bool tf2Bearish,
                 int sentiment)
{
    // Higher TF
    string txt="Neutral"; color col=NeutralColor;
    if(higherTFBias==1){txt="Bullish"; col=BullishColor;}
    else if(higherTFBias==-1){txt="Bearish"; col=BearishColor;}
    ObjectSetString(0, indicatorName+"_Sentiment0", OBJPROP_TEXT, txt);
    ObjectSetInteger(0, indicatorName+"_Sentiment0", OBJPROP_COLOR, col);

    // Lower TF1
    txt="Neutral"; col=NeutralColor;
    if(tf1Bullish){txt="Bullish"; col=BullishColor;}
    else if(tf1Bearish){txt="Bearish"; col=BearishColor;}
    ObjectSetString(0, indicatorName+"_Sentiment1", OBJPROP_TEXT, txt);
    ObjectSetInteger(0, indicatorName+"_Sentiment1", OBJPROP_COLOR, col);

    // Lower TF2
    txt="Neutral"; col=NeutralColor;
    if(tf2Bullish){txt="Bullish"; col=BullishColor;}
    else if(tf2Bearish){txt="Bearish"; col=BearishColor;}
    ObjectSetString(0, indicatorName+"_Sentiment2", OBJPROP_TEXT, txt);
    ObjectSetInteger(0, indicatorName+"_Sentiment2", OBJPROP_COLOR, col);

    // Final
    string finalSent="Neutral"; color finalCol=NeutralColor;
    switch(sentiment){
        case 1: finalSent="Bullish"; finalCol=BullishColor; break;
        case -1: finalSent="Bearish"; finalCol=BearishColor; break;
        case 2: finalSent="Risk-On"; finalCol=RiskOnColor; break;
        case -2: finalSent="Risk-Off"; finalCol=RiskOffColor; break;
    }
    ObjectSetString(0, indicatorName+"_Final", OBJPROP_TEXT, "Final: "+finalSent);
    ObjectSetInteger(0, indicatorName+"_Final", OBJPROP_COLOR, finalCol);
}

Die Funktion UpdatePanel() aktualisiert das Marktstimmungspanel dynamisch auf der Grundlage der neuesten Analysen. Zunächst wird die Tendenz des höheren Zeitrahmens bewertet und die entsprechende Bezeichnung entweder mit „Bullish“, „Bearish“ oder „Neutral“ aktualisiert und entsprechend eingefärbt. Anschließend wird dasselbe für die beiden unteren Zeitrahmen durchgeführt, wobei Auf- und Abwärtsstrukturen geprüft und die Ergebnisse in den jeweiligen Kennzeichnungen mit der richtigen Farbkodierung wiedergegeben werden.

Schließlich ermittelt die Funktion die Gesamtmarktstimmung, indem sie die kombinierten Verzerrungen und Ausbrüche über alle Zeitrahmen hinweg auswertet. Das endgültige Stimmungslabel wird aktualisiert und zeigt „Bullish“, „Bearish“, „Risk-On“, „Risk-Off“ oder „Neutral“ mit einer entsprechenden Farbe an, um eine schnelle, visuell klare Zusammenfassung des aktuellen Marktzustands zu liefern. Dadurch wird sichergestellt, dass Händler die Marktrichtung über mehrere Zeitrahmen hinweg sofort auf einen Blick erkennen können.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass wir einen nutzerdefinierten Marktstimmungsindikator entwickelt haben, der mehrere Zeitrahmen integriert, um eine klare, visuelle Darstellung der Marktbedingungen zu liefern. Der Indikator berechnet gleitende Durchschnitte auf höheren und niedrigeren Zeitrahmen, identifiziert Auf- oder Abwärtsstrukturen anhand von hohen und tiefen Umkehrpunkten, erkennt potenzielle Ausbrüche und ermittelt eine Gesamtstimmung. Ein dunkles Panel oben links zeigt die Stimmung für jeden Zeitrahmen sowie eine kombinierte Gesamtstimmung an, wobei eine Farbkodierung eine schnelle Unterscheidung zwischen den Zuständen bullish, bearish, risk-on, risk-off, and neutral ermöglicht.

Zusammenfassend lässt sich sagen, dass dieser Indikator Händlern hilft, fundiertere Entscheidungen zu treffen, indem er komplexe Marktdaten in einem leicht lesbaren, visuellen Format zusammenfasst. Durch die Bereitstellung der Stimmungsanalysen mehrerer Zeitrahmen in Echtzeit können Händler Markttrends schnell einschätzen, potenzielle Handelsmöglichkeiten erkennen und ihre Strategien auf die vorherrschenden Marktbedingungen abstimmen, was die Unsicherheit verringert und die Entscheidungseffizienz erhöht.