| //+------------------------------------------------------------------+
|
| //| SwingPoints_H4.mq5 |
|
| //| Swing High / Low Detection with Labels |
|
| //| Structural classification: HH / HL / LH / LL |
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //| Detects swing highs and swing lows using configurable left/ |
|
| //| right bar strength, plots them as arrows, and labels each one |
|
| //| with its structural classification. |
|
| //| |
|
| //| FEATURES |
|
| //| -------- |
|
| //| - Configurable left/right strength for pivot detection |
|
| //| - Minimum price move filter to ignore trivial pivots |
|
| //| - HH / HL / LH / LL labels for reading market structure |
|
| //| - Object lifecycle management: old labels are cleaned up |
|
| //| - Buffer-based output, readable via CopyBuffer() from EAs |
|
| //| - Public accessors: GetLastSwingHigh(), GetLastSwingLow() |
|
| //| |
|
| //| INPUTS |
|
| //| ------ |
|
| //| InpLeftBars - bars required to the left (default 3) |
|
| //| InpRightBars - bars required to the right (default 2) |
|
| //| InpMinMovePoints - minimum move in points (default 10) |
|
| //| InpShowLabels - show HH/HL/LH/LL labels (default true) |
|
| //| InpMaxBars - bars to calculate (default 500) |
|
| //| |
|
| //| NOTE |
|
| //| ---- |
|
| //| This is a reference implementation published as part of the |
|
| //| mql5-projects library. It makes no performance claims and is |
|
| //| not a standalone trading system. |
|
| //| |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2026, C.J. Weekes"
|
| #property copyright "Copyright 2026, Alfonso Golden Trader
|
| #property version "1.00"
|
| #property description "Swing high/low detection with HH/HL/LH/LL labels."
|
| #property description "Configurable strength, minimum move filter, object cleanup."
|
| #property description "Buffer output, EA-accessible. Reference implementation."
|
|
|
|
|
| //--- Plot Swing Highs
|
| #property indicator_label1 "SwingHigh"
|
| #property indicator_type1 DRAW_ARROW
|
| #property indicator_color1 clrRed
|
| #property indicator_width1 2
|
| #property indicator_style1 STYLE_SOLID
|
|
|
| //--- Plot Swing Lows
|
| #property indicator_label2 "SwingLow"
|
| #property indicator_type2 DRAW_ARROW
|
| #property indicator_color2 clrBlue
|
| #property indicator_width2 2
|
| #property indicator_style2 STYLE_SOLID
|
|
|
| //--- Input Parameters
|
| input int InpLeftBars = 3; // Left Strength (bars before)
|
| input int InpRightBars = 2; // Right Strength (bars after)
|
| input double InpMinMovePoints = 10; // Min price move in points
|
| input bool InpShowLabels = true; // Show HH/HL/LH/LL labels
|
| input int InpMaxBars = 500; // Bars to calculate
|
|
|
| //--- Indicator buffers
|
| double SwingHighBuffer[];
|
| double SwingLowBuffer[];
|
| double HighPriceBuffer[];
|
| double LowPriceBuffer[];
|
|
|
| //--- Global variables
|
| datetime lastAlertTime = 0;
|
| int swingHighIndex, swingLowIndex;
|
|
|
| //+------------------------------------------------------------------+
|
| //| Custom indicator initialization function |
|
| //+------------------------------------------------------------------+
|
| int OnInit()
|
| {
|
| // Set index mapping
|
| SetIndexBuffer(0, SwingHighBuffer, INDICATOR_DATA);
|
| SetIndexBuffer(1, SwingLowBuffer, INDICATOR_DATA);
|
| SetIndexBuffer(2, HighPriceBuffer, INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(3, LowPriceBuffer, INDICATOR_CALCULATIONS);
|
|
|
| // Set empty value
|
| PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0);
|
| PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, 0);
|
|
|
| // Set arrow codes (MQL5 uses Wingdings character codes)
|
| PlotIndexSetInteger(0, PLOT_ARROW, 217); // Down arrow
|
| PlotIndexSetInteger(1, PLOT_ARROW, 218); // Up arrow
|
|
|
| // Set arrow shifts
|
| PlotIndexSetInteger(0, PLOT_ARROW_SHIFT, 5);
|
| PlotIndexSetInteger(1, PLOT_ARROW_SHIFT, -5);
|
|
|
| IndicatorSetString(INDICATOR_SHORTNAME, "SwingPoints_H4 (" + IntegerToString(InpLeftBars) + "," +
|
| IntegerToString(InpRightBars) + ")");
|
|
|
| return(INIT_SUCCEEDED);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Custom indicator iteration function |
|
| //+------------------------------------------------------------------+
|
| int OnCalculate(const int rates_total,
|
| const int prev_calculated,
|
| const datetime &time[],
|
| const double &open[],
|
| const double &high[],
|
| const double &low[],
|
| const double &close[],
|
| const long &tick_volume[],
|
| const long &volume[],
|
| const int &spread[])
|
| {
|
| // Ensure arrays are properly sized
|
| if(rates_total <= InpLeftBars + InpRightBars)
|
| return(0);
|
|
|
| // Limit calculation range for performance
|
| int start = prev_calculated - InpRightBars - 1;
|
| if(start < InpRightBars + 1)
|
| start = InpRightBars + 1;
|
|
|
| // Limit to MaxBars for speed
|
| int end = rates_total - 1;
|
| if(end - start > InpMaxBars && prev_calculated == 0)
|
| start = end - InpMaxBars;
|
| if(start < InpRightBars + 1)
|
| start = InpRightBars + 1;
|
|
|
| // Clear buffers at start
|
| if(prev_calculated == 0)
|
| {
|
| ArrayInitialize(SwingHighBuffer, 0);
|
| ArrayInitialize(SwingLowBuffer, 0);
|
| ArrayInitialize(HighPriceBuffer, 0);
|
| ArrayInitialize(LowPriceBuffer, 0);
|
| }
|
|
|
| // Detect swing points
|
| for(int i = start; i <= end - InpRightBars && !IsStopped(); i++)
|
| {
|
| // Skip if no price movement
|
| if(high[i] == low[i]) continue;
|
|
|
| // Check for Swing High
|
| if(IsSwingHigh(high, i, rates_total))
|
| {
|
| SwingHighBuffer[i] = high[i];
|
| HighPriceBuffer[i] = high[i];
|
|
|
| // Draw HH/HL label if enabled
|
| if(InpShowLabels)
|
| DrawSwingLabel(time, high, low, i, true);
|
| }
|
| else
|
| SwingHighBuffer[i] = 0;
|
|
|
| // Check for Swing Low
|
| if(IsSwingLow(low, i, rates_total))
|
| {
|
| SwingLowBuffer[i] = low[i];
|
| LowPriceBuffer[i] = low[i];
|
|
|
| // Draw LH/LL label if enabled
|
| if(InpShowLabels)
|
| DrawSwingLabel(time, high, low, i, false);
|
| }
|
| else
|
| SwingLowBuffer[i] = 0;
|
| }
|
|
|
| // Clean up old trend labels if needed
|
| if(InpShowLabels && prev_calculated > 0)
|
| CleanupOldLabels(time, rates_total);
|
|
|
| return(rates_total);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check if bar at index is a swing high |
|
| //+------------------------------------------------------------------+
|
| bool IsSwingHigh(const double &high[], int index, int rates_total)
|
| {
|
| // Need enough bars on both sides
|
| if(index < InpLeftBars || index + InpRightBars >= rates_total)
|
| return false;
|
|
|
| double candidateHigh = high[index];
|
| double minMove = InpMinMovePoints * _Point;
|
|
|
| // Check left side - all must be lower
|
| for(int l = 1; l <= InpLeftBars; l++)
|
| {
|
| if(high[index - l] >= candidateHigh - minMove)
|
| return false;
|
| }
|
|
|
| // Check right side - all must be lower
|
| for(int r = 1; r <= InpRightBars; r++)
|
| {
|
| if(high[index + r] >= candidateHigh - minMove)
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check if bar at index is a swing low |
|
| //+------------------------------------------------------------------+
|
| bool IsSwingLow(const double &low[], int index, int rates_total)
|
| {
|
| // Need enough bars on both sides
|
| if(index < InpLeftBars || index + InpRightBars >= rates_total)
|
| return false;
|
|
|
| double candidateLow = low[index];
|
| double minMove = InpMinMovePoints * _Point;
|
|
|
| // Check left side - all must be higher
|
| for(int l = 1; l <= InpLeftBars; l++)
|
| {
|
| if(low[index - l] <= candidateLow + minMove)
|
| return false;
|
| }
|
|
|
| // Check right side - all must be higher
|
| for(int r = 1; r <= InpRightBars; r++)
|
| {
|
| if(low[index + r] <= candidateLow + minMove)
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw HH/HL/LH/LL labels |
|
| //+------------------------------------------------------------------+
|
| void DrawSwingLabel(const datetime &time[], const double &high[], const double &low[], int index, bool isHigh)
|
| {
|
| string labelName = "SwingLabel_" + IntegerToString(index) + "_" + (isHigh ? "H" : "L");
|
|
|
| // Delete existing label if it exists
|
| ObjectDelete(0, labelName);
|
|
|
| // Determine if this is HH/HL or LH/LL by comparing to previous swing
|
| bool isHigher = false;
|
| bool isLower = false;
|
|
|
| // Find previous swing of same type
|
| int prevIndex = FindPreviousSwing(index - 1, isHigh);
|
|
|
| if(prevIndex >= 0)
|
| {
|
| if(isHigh)
|
| {
|
| if(high[index] > high[prevIndex])
|
| isHigher = true; // HH
|
| else
|
| isLower = true; // LH
|
| }
|
| else
|
| {
|
| if(low[index] < low[prevIndex])
|
| isLower = true; // LL
|
| else
|
| isHigher = true; // HL
|
| }
|
| }
|
|
|
| // Create label
|
| string labelText = "";
|
| color labelColor = clrGray;
|
| double labelPrice;
|
|
|
| if(isHigh)
|
| {
|
| labelPrice = high[index] + (20 * _Point);
|
| if(isHigher) { labelText = "HH"; labelColor = clrLimeGreen; }
|
| else if(isLower) { labelText = "LH"; labelColor = clrOrange; }
|
| else labelText = "H";
|
| }
|
| else
|
| {
|
| labelPrice = low[index] - (20 * _Point);
|
| if(isLower) { labelText = "LL"; labelColor = clrRed; }
|
| else if(isHigher) { labelText = "HL"; labelColor = clrGreen; }
|
| else labelText = "L";
|
| }
|
|
|
| if(StringLen(labelText) > 0)
|
| {
|
| ObjectCreate(0, labelName, OBJ_TEXT, 0, time[index], labelPrice);
|
| ObjectSetString(0, labelName, OBJPROP_TEXT, labelText);
|
| ObjectSetInteger(0, labelName, OBJPROP_COLOR, labelColor);
|
| ObjectSetInteger(0, labelName, OBJPROP_FONTSIZE, 8);
|
| ObjectSetInteger(0, labelName, OBJPROP_BACK, true);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find previous swing point |
|
| //+------------------------------------------------------------------+
|
| int FindPreviousSwing(int startIndex, bool isHigh)
|
| {
|
| if(isHigh)
|
| {
|
| for(int i = startIndex; i >= 0; i--)
|
| {
|
| if(i < ArraySize(SwingHighBuffer) && SwingHighBuffer[i] > 0)
|
| return i;
|
| }
|
| }
|
| else
|
| {
|
| for(int i = startIndex; i >= 0; i--)
|
| {
|
| if(i < ArraySize(SwingLowBuffer) && SwingLowBuffer[i] > 0)
|
| return i;
|
| }
|
| }
|
| return -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Clean up old labels |
|
| //+------------------------------------------------------------------+
|
| void CleanupOldLabels(const datetime &time[], int total)
|
| {
|
| // Keep only last 100 labels for performance
|
| string prefix = "SwingLabel_";
|
| int keepCount = 100;
|
| int found = 0;
|
|
|
| for(int i = total - 1; i >= 0 && found < keepCount; i--)
|
| {
|
| string nameH = prefix + IntegerToString(i) + "_H";
|
| string nameL = prefix + IntegerToString(i) + "_L";
|
|
|
| if(ObjectFind(0, nameH) >= 0)
|
| found++;
|
| if(ObjectFind(0, nameL) >= 0)
|
| found++;
|
| }
|
|
|
| // Delete older ones
|
| for(int i = 0; i < total - keepCount * 2; i++)
|
| {
|
| string nameH = prefix + IntegerToString(i) + "_H";
|
| string nameL = prefix + IntegerToString(i) + "_L";
|
|
|
| ObjectDelete(0, nameH);
|
| ObjectDelete(0, nameL);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get latest swing high (for EA use) |
|
| //+------------------------------------------------------------------+
|
| double GetLastSwingHigh(int shift = 1)
|
| {
|
| int total = ArraySize(SwingHighBuffer);
|
| for(int i = total - shift; i >= 0; i--)
|
| {
|
| if(i < total && SwingHighBuffer[i] > 0)
|
| return SwingHighBuffer[i];
|
| }
|
| return 0;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get latest swing low (for EA use) |
|
| //+------------------------------------------------------------------+
|
| double GetLastSwingLow(int shift = 1)
|
| {
|
| int total = ArraySize(SwingLowBuffer);
|
| for(int i = total - shift; i >= 0; i--)
|
| {
|
| if(i < total && SwingLowBuffer[i] > 0)
|
| return SwingLowBuffer[i];
|
| }
|
| return 0;
|
| }
|
| //+------------------------------------------------------------------+ |
