English
preview
Разработка индикатора внутренней и внешней структуры рынка

Разработка индикатора внутренней и внешней структуры рынка

MetaTrader 5 — Индикаторы |
21 0
ALGOYIN LTD
Israel Pelumi Abioye

Введение

На ценовых графиках в MetaTrader 5 отображаются свечи и базовые индикаторы, однако они не показывают явно элементы структуры рынка, такие как подтверждённые свинговые максимумы и свинговые минимумы, формирование внешнего тренда и первый значимый внутренний сдвиг (пробой структуры или смена характера) в рамках этого тренда. В результате выявление структуры вручную занимает много времени, субъективно и трудно воспроизводится, а нечётко заданные правила в коде могут приводить к дублированию сигналов и несогласованному определению структуры.

В этой статье представлена реализация на MQL5, специально разработанная для этой задачи и основанная на чётких правилах: она автоматизирует выявление и визуализацию внешней и внутренней структуры рынка и преобразует первый подтверждённый внутренний сдвиг в торговый сетап с полностью заданными параметрами. Индикатор выявляет свинги S1→S4 с помощью явно заданных функций IsSwingHigh() и IsSwingLow(), уточняет истинные экстремумы между этими опорными точками, проверяет внешнюю бычью или медвежью последовательность, а затем ищет внутри подтверждённого диапазона первую последовательность IH→IL→CHoCH. В результате получается индикатор с воспроизводимыми результатами и возможностью отладки, который отображает линии структуры и метки, создаёт маркер входа, устанавливает стоп-лосс на уровне внутреннего минимума и рассчитывает уровень тейк-профита на расстоянии 1,5 величины риска от входа.


Обзор проекта и план реализации

Перед началом реализации необходимо разобраться в устройстве и принципах работы индикатора внутренней и внешней структуры рынка. Полное понимание цели проекта облегчает определение функций каждого компонента и оптимизацию процесса разработки.

Что мы создаем

В этой статье мы разработаем индикатор внутренней и внешней структуры рынка для MetaTrader 5. Этот индикатор автоматически выявляет важные структурные точки в движении цены и отображает их на графике. Индикатор анализирует исторические ценовые данные, чтобы определять свинговые максимумы и свинговые минимумы, которые служат основой для выявления как внутренней, так и внешней структуры рынка. Максимум свечи считается свинговым максимумом, если он превышает максимумы заданного числа свечей с каждой стороны от неё. Это свидетельствует о том, что цена достигла локального максимума на рынке. Аналогично, минимум свечи считается свинговым минимумом, если он ниже минимумов заданного числа свечей с каждой стороны от неё, что подтверждает локальный минимум рынка. Такой подход гарантирует, что фиксируются только значимые точки разворота, а не произвольные ценовые свинги.

Для определения внешней структуры мы используем больший диапазон поиска свингов. Это означает, что мы сравниваем каждую потенциальную точку свинга с большим количеством свечей до и после неё. Использование большего количества баров позволяет отфильтровать незначительные ценовые движения и сосредоточиться только на крупных рыночных свингах, определяющих общий тренд. Затем эти крупные свинги используются для определения внешнего максимума и внешнего минимума, которые отражают доминирующую структуру рынка. В отличие от внешней структуры, для внутренней структуры используется меньший диапазон поиска свингов. При выявлении внутренних свингов используется меньше свечей, что позволяет с большей чувствительностью улавливать более мелкие ценовые движения. Это позволяет индикатору раньше выявлять пробой структуры и смену характера в рамках тренда. Внешняя структура отражает общее направление движения рынка. Внутренняя структура отражает краткосрочные изменения динамики в рамках данного тренда.

Для бычьей внешней структуры индикатор отображает свинговый минимум, свинговый максимум, более высокий минимум и более высокий максимум. Внешний максимум (EXH) соответствует более высокому максимуму, а внешний минимум (EXL) — более высокому минимуму.

Рисунок 1. Бычья внешняя структура

Индикатор отслеживает первый внутренний структурный сдвиг в рамках данного тренда после формирования внешней структуры. Когда цена пробивает внутренний максимум (INH) вверх после формирования внутреннего минимума (INL), это указывает на возможное изменение краткосрочной динамики в рамках более масштабного бычьего тренда. Это первый бычий пробой структуры или смена характера в рамках бычьей внешней структуры.

Рисунок 2. Бычья внутренняя структура

Для медвежьей внешней структуры индикатор отображает свинговый максимум, свинговый минимум, более низкий максимум и более низкий минимум. Более низкий минимум становится внешним минимумом (EXL), а более низкий максимум — внешним максимумом (EXH). Данный индикатор отслеживает первое внутреннее структурное изменение в рамках данного тренда после того, как внешняя структура уже сформировалась. В условиях медвежьей внешней структуры индикатор ищет первый медвежий пробой структуры или смену характера, когда цена пробивает внутренний минимум (INL) вниз после формирования внутреннего максимума (INH), что сигнализирует о потенциальном изменении краткосрочного импульса в рамках более широкого медвежьего тренда и возможном продолжении медвежьей структуры.

Рисунок 3. Медвежья внешняя и внутренняя структура


В конечном итоге трендовые линии, метки и сигнальные маркеры используются для визуализации всех выявленных структур на графике, что позволяет легко понять структуру рынка как при разработке алгоритмических стратегий, так и при ручном анализе.

Примечание: чтобы избежать повторений, мы рассмотрим процесс выявления только на примере бычьего сценария, поскольку медвежья структура строится по очень схожей логике, но с обратными условиями. Те же принципы, которые используются для определения свинговых максимумов, свинговых минимумов и структурных изменений, можно применять и при анализе медвежьей структуры рынка, инвертировав условия.

План реализации

Индикатор будет реализован по следующей схеме:

  1. Построение, уточнение и валидация внешней структуры (EXH/EXL)
  2. Выявление первой внутренней структуры с проверкой действительности внешней структуры
  3. Визуализация и формирование торговых сетапов с управлением графическими объектами

Примечание: проект, рассматриваемый в данной статье, целиком основан на практической работе и призван обучить читателей языку MQL5 на реальных прикладных задачах. Это не является гарантированным способом получения прибыли при реальной торговле.


Реализация на языке MQL5

В этом разделе мы перейдем от теории к практической реализации, воплотив рассмотренные ранее концепции в коде MQL5. Мы шаг за шагом реализуем каждый компонент индикатора, включая выявление свингов, определение внешней структуры, анализ внутренней структуры и формирование торговых сетапов.

Построение, уточнение и валидация внешней структуры (EXH/EXL)

Как указано в плане реализации, первым шагом является определение свинговых максимумов и свинговых минимумов, которые послужат основой для построения внешней структуры рынка. Прежде чем приступить к этому анализу, необходимо убедиться в наличии достаточного количества исторических баров. Для выявления свингов необходимы свечи как до, так и после потенциальной точки свинга.

Пример:

#property indicator_chart_window
#property indicator_buffers 0
#property indicator_plots   0
#define OBJ_PREFIX      "EISM_"  // Prefix for all chart objects

int look_back     = 1000;              // number of candles to scan for pattern detection
int EX_SwingLookback = 15;             // swing validation range (left and right candles)
datetime lastTradeBarTime = 0;        // ensures logic runs once per new bar

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t rates_total,
                const int32_t 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 int32_t &spread[])
  {
//---
//--- Skip processing if not enough bars are available
   if(rates_total < look_back + EX_SwingLookback)
      return 0;

//--- Get the time of the current (latest) candle
   datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);

//--- Only execute logic once per new candle to avoid redundant processing
   if(currentBarTime != lastTradeBarTime)
     {

      lastTradeBarTime = currentBarTime; // update last processed bar time to prevent re-running on same candle
     }

//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Пояснение

Все визуальные элементы, включая трендовые линии, подписи и маркеры сделок, будут создаваться непосредственно на свечном графике, поскольку директива #property indicator_chart_window задаёт отображение индикатора в основном окне ценового графика. Поскольку индикатор не использует традиционные методы построения графиков на основе буферов, значения параметров indicator_buffers и indicator_plots установлены равными 0. Вместо этого его отображение полностью основано на графических объектах. Чтобы каждый созданный индикатором объект можно было легко распознать, им можно было управлять и при необходимости удалить, задаётся специальный префикс объектов — EISM_.

Основные управляющие переменные определяют, каким образом индикатор анализирует рыночные данные. Параметр look_back задаёт количество свечей, проверяемых для выявления паттернов, тем самым ограничивая анализ индикатора определённым участком истории цен. Значение EX_SwingLookback установлено равным 15, поскольку этот параметр используется для выявления внешней структуры, при котором учитываются только значимые свинговые максимумы и свинговые минимумы. Значение 15 обеспечивает проверку каждой потенциальной точки свинга по 15 свечам слева и справа, что позволяет отфильтровать незначительные колебания и учитывать при определении внешней структуры только значимые рыночные движения. Переменная lastTradeBarTime используется в качестве временного ориентира, чтобы гарантировать, что основная логика выполняется только один раз для каждой вновь сформировавшейся свечи.

Прежде чем начать обработку внутри функции OnCalculate, индикатор сначала проверяет, достаточно ли имеется исторических баров для анализа. Это важно, поскольку для выявления свингов необходимо сравнивать свечи, расположенные до и после каждой потенциальной точки свинга. Если общее количество баров меньше look_back + EX_SwingLookback , функция немедленно завершается (return 0). Это позволяет избежать некорректных вычислений и ошибок, связанных с выходом за пределы допустимого диапазона.

Индикатор использует функцию iTime для получения времени формирования последней свечи. Чтобы определить, сформировалась ли новая свеча, это значение сравнивается с ранее сохранённым значением lastTradeBarTime. Если время текущей свечи отличается от сохранённого значения, значит, появился новый бар и можно выполнять логику обработки. После подтверждения переменной lastTradeBarTime присваивается время текущей свечи, что обеспечивает выполнение всех вычислений один раз на бар и исключает повторное выполнение логики на той же свече.

После подтверждения выполнения этих условий программа приступает к выявлению внешних свинговых максимумов и свинговых минимумов, которые служат основой для определения внешней структуры рынка.

Примечание: По мере продвижения мы будем выделять конкретные разделы кода, относящиеся к каждому этапу реализации, чтобы каждая часть была понятна сама по себе, без смешивания с ранее рассмотренными разделами.

Пример:

#property indicator_chart_window
#property indicator_buffers 0
#property indicator_plots   0
#define OBJ_PREFIX      "EISM_"  // Prefix for all chart objects

int look_back     = 1000;        // number of candles to scan for pattern detection
int EX_SwingLookback = 15;       // swing validation range (left and right candles)
datetime lastTradeBarTime = 0;   // ensures logic runs once per new bar
int window_start;                // starting index of scan window

//--- External structure points (swing high/low anchors)
double s1_l;                     // swing 1 low price
datetime s1_l_t;                 // swing 1 low time
double s2_h;                     // swing 2 high price
datetime s2_h_t;                 // swing 2 high time
double s3_l;                     // swing 3 low price
datetime s3_l_t;                 // swing 3 low time
double s4_h;                     // swing 4 high price
datetime s4_h_t;                 // swing 4 high time

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t rates_total,
                const int32_t 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 int32_t &spread[])
  {
//---
//--- Skip processing if not enough bars are available
   if(rates_total < look_back + EX_SwingLookback)
      return 0;

//--- Get the time of the current (latest) candle
   datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);

//--- Define the start of the scanning window accounting for swing lookback
   window_start = rates_total - look_back + EX_SwingLookback;

//--- Only execute logic once per new candle to avoid redundant processing
   if(currentBarTime != lastTradeBarTime)
     {
      //--- Scan for swing 1 low (S1) - the start of the external structure
      for(int i = window_start; i < rates_total - EX_SwingLookback - 2; i++)
        {
         if(IsSwingLow(low, i, EX_SwingLookback))
           {
            s1_l   = low[i];   // record S1 low price
            s1_l_t = time[i];  // record S1 low time

            //--- Scan forward for swing 2 high (S2) above S1 low
            for(int j = i; j < rates_total - EX_SwingLookback - 2; j++)
              {
               if(IsSwingHigh(high, j, EX_SwingLookback) && high[j] > s1_l)
                 {
                  s2_h   = high[j];  // record S2 high price
                  s2_h_t = time[j];  // record S2 high time

                  //--- Scan forward for swing 3 low (S3) below S2 high
                  for(int k = j; k < rates_total - EX_SwingLookback - 2; k++)
                    {
                     if(IsSwingLow(low, k, EX_SwingLookback) && low[k] < s2_h)
                       {
                        s3_l   = low[k];   // record S3 low price
                        s3_l_t = time[k];  // record S3 low time

                        //--- Scan forward for swing 4 high (S4) above S2 high - confirms external bullish structure
                        for(int l = k; l < rates_total - EX_SwingLookback - 2; l++)
                          {
                           if(IsSwingHigh(high, l, EX_SwingLookback) && high[l] > s2_h)
                             {
                              s4_h   = high[l];  // record S4 high price
                              s4_h_t = time[l];  // record S4 high time

                              break;
                             }
                          }
                        break;
                       }
                    }
                  break;
                 }
              }
           }
        }

      lastTradeBarTime = currentBarTime; // update last processed bar time to prevent re-running on same candle
     }

//--- return value of prev_calculated for next call
   return(rates_total);
  }

//+------------------------------------------------------------------+
//| Returns true if the bar at index is a swing low                  |
//| Checks that it is lower than all bars within the lookback range  |
//+------------------------------------------------------------------+
bool IsSwingLow(const double &low_price[], int index, int lookback)
  {
   for(int i = 1; i <= lookback; i++)
     {
      //--- Fail if any left or right neighbour is lower than the candidate bar
      if(low_price[index] > low_price[index - i] || low_price[index] > low_price[index + i])
         return false;
     }
   return true; // all neighbours are higher - confirmed swing low
  }

//+------------------------------------------------------------------+
//| Returns true if the bar at index is a swing high                 |
//| Checks that it is higher than all bars within the lookback range |
//+------------------------------------------------------------------+
bool IsSwingHigh(const double &high_price[], int index, int lookback)
  {
   for(int i = 1; i <= lookback; i++)
     {
      //--- Fail if any left or right neighbour is higher than the candidate bar
      if(high_price[index] < high_price[index - i] || high_price[index] < high_price[index + i])
         return false;
     }
   return true; // all neighbours are lower - confirmed swing high
  }
//+------------------------------------------------------------------+

Пояснение

Функция IsSwingLow отвечает за определение того, является ли минимум свечи корректным свинговым минимумом. Для этого она сравнивает минимум проверяемой свечи с минимумами заданного числа свечей с каждой стороны от неё. Это число определяется параметром lookback. Проверяемая свеча отклоняется, и её минимум не считается свинговым минимумом, если минимум хотя бы одной соседней свечи ниже минимума проверяемой свечи. Минимум свечи подтверждается как корректный свинговый минимум только в том случае, если он ниже минимумов всех соседних свечей в заданном диапазоне. Функция IsSwingHigh работает аналогично, но с обратным условием: она определяет, превышает ли максимум свечи максимумы всех соседних свечей в диапазоне, заданном параметром lookback. Проверяемая свеча отклоняется, если максимум хотя бы одной соседней свечи выше её максимума. В противном случае её максимум подтверждается как корректный свинговый максимум.

После определения логики обнаружения свингов программа задаёт начало окна сканирования с помощью выражения window_start = rates_total - look_back + EX_SwingLookback. Это гарантирует, что индикатор анализирует только последний участок исторических данных, оставляя с каждой стороны от каждой потенциальной точки свинга достаточно свечей для корректной проверки. Учёт EX_SwingLookback гарантирует, что при обнаружении свингов не будут проверяться свечи, расположенные слишком близко к границам набора данных, где полное сравнение невозможно.

После определения окна сканирования программа приступает к построению внешней структуры рынка. Сначала программа ищет начальный свинговый минимум (S1), который может стать отправной точкой бычьей структуры. Чтобы подтвердить, что цена действительно совершила восходящее движение, программа ищет среди последующих свечей свинговый максимум (S2), сформировавшийся выше S1. После этого алгоритм ищет свинговый минимум (S3) ниже S2, а затем свинговый максимум (S4) выше S2. Бычий рыночный паттерн формируется на основе этой последовательности уровней S1, S2, S3 и S4. Прежде чем программа перейдёт к более глубокому анализу, каждый этап проверяется с помощью функций обнаружения свингов и заданных условий, чтобы регистрировались только значимые структурные формации.

Следующий шаг — убедиться, что выявленные точки свингов образуют корректную и надёжную структуру рынка.

Пример:

//--- Refined price extremes between external swing points
int s3_s4_lbars;           // bar count between s3 low and s4 high
int s3_lowest_index;       // index of lowest low between s3 and s4
double s3_lowest;          // lowest low price between s3 and s4
datetime s3_lowest_t;      // time of lowest low between s3 and s4

int s2_s3_hbars;           // bar count between s2 high and s3 lowest
int s2_higest_index;       // index of highest high between s2 and s3 lowest
double s2_highest;         // highest high price between s2 and s3 lowest
datetime s2_highest_t;     // time of highest high between s2 and s3 lowest

int s1_s2_lbars;           // bar count between s1 low and s2 highest
int s1_lowest_index;       // index of lowest low between s1 and s2 highest
double s1_lowest;          // lowest low price between s1 and s2 highest
datetime s1_lowest_t;      // time of lowest low between s1 and s2 highest

//--- Object name strings for external structure lines and labels
string line_s1_2;          // trendline from swing 1 low to swing 2 high
string line_s2_3;          // trendline from swing 2 high to swing 3 low
string line_s3_4;          // trendline from swing 3 low to swing 4 high
string EXLow;              // text label for external low
string EXHigh;             // text label for external high

//+------------------------------------------------------------------+
//| Create or update a trendline                                     |
//| Returns true if a new object was created                         |
//+------------------------------------------------------------------+
bool DrawTrend(const string name,
               datetime x1t, double x1,
               datetime x2t, double x2,
               color fillCol)
  {
   bool created = false;

//--- Create object only if it does not exist
   if(ObjectFind(0, name) < 0)
     {
      ObjectCreate(0, name, OBJ_TREND, 0, x1t, x1, x2t, x2);
      //--- Set object properties
      ObjectSetInteger(0, name, OBJPROP_COLOR, fillCol);

      created = true;
     }

   return created;
  }

//+------------------------------------------------------------------+
//| Create text objects on the chart                                 |
//+------------------------------------------------------------------+
bool DrawTxt(const string name,
             datetime xt, double x,
             string message, color fillCol)
  {
   bool created = false;

//--- Create object only if it does not exist
   if(ObjectFind(0, name) < 0)
     {
      ObjectCreate(0, name, OBJ_TEXT, 0, xt, x);
      ObjectSetString(0, name, OBJPROP_TEXT, message);
      ObjectSetInteger(0, name, OBJPROP_COLOR, fillCol);

      created = true;
     }

   return created;
  }
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| OnDeinit - runs when indicator is removed from chart             |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Remove all objects created by this indicator
   ObjectsDeleteAll(0, OBJ_PREFIX);
  }

Пример:

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t rates_total,
                const int32_t 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 int32_t &spread[])
  {
//---
//--- Skip processing if not enough bars are available
   if(rates_total < look_back + EX_SwingLookback)
      return 0;

//--- Get the time of the current (latest) candle
   datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);

//--- Define the start of the scanning window accounting for swing lookback
   window_start = rates_total - look_back + EX_SwingLookback;

   bool need_redraw = false; // tracks whether any new object was drawn this pass

//--- Only execute logic once per new candle to avoid redundant processing
   if(currentBarTime != lastTradeBarTime)
     {
      //--- Scan for swing 1 low (S1) - the start of the external structure
      for(int i = window_start; i < rates_total - EX_SwingLookback - 2; i++)
        {
         if(IsSwingLow(low, i, EX_SwingLookback))
           {
            s1_l   = low[i];   // record S1 low price
            s1_l_t = time[i];  // record S1 low time

            //--- Scan forward for swing 2 high (S2) above S1 low
            for(int j = i; j < rates_total - EX_SwingLookback - 2; j++)
              {
               if(IsSwingHigh(high, j, EX_SwingLookback) && high[j] > s1_l)
                 {
                  s2_h   = high[j];  // record S2 high price
                  s2_h_t = time[j];  // record S2 high time

                  //--- Scan forward for swing 3 low (S3) below S2 high
                  for(int k = j; k < rates_total - EX_SwingLookback - 2; k++)
                    {
                     if(IsSwingLow(low, k, EX_SwingLookback) && low[k] < s2_h)
                       {
                        s3_l   = low[k];   // record S3 low price
                        s3_l_t = time[k];  // record S3 low time

                        //--- Scan forward for swing 4 high (S4) above S2 high - confirms external bullish structure
                        for(int l = k; l < rates_total - EX_SwingLookback - 2; l++)
                          {
                           if(IsSwingHigh(high, l, EX_SwingLookback) && high[l] > s2_h)
                             {
                              s4_h   = high[l];  // record S4 high price
                              s4_h_t = time[l];  // record S4 high time

                              //--- Find the true lowest low between S3 and S4 to refine external low
                              s3_s4_lbars     = Bars(_Symbol, PERIOD_CURRENT, s3_l_t, s4_h_t);
                              s3_lowest_index = ArrayMinimum(low, k, s3_s4_lbars);
                              s3_lowest       = low[s3_lowest_index];
                              s3_lowest_t     = time[s3_lowest_index];

                              //--- Find the true highest high between S2 and the refined S3 low
                              s2_s3_hbars     = Bars(_Symbol, PERIOD_CURRENT, s2_h_t, s3_lowest_t);
                              s2_higest_index = ArrayMaximum(high, j, s2_s3_hbars);
                              s2_highest      = high[s2_higest_index];
                              s2_highest_t    = time[s2_higest_index];

                              //--- Find the true lowest low between S1 and the refined S2 high
                              s1_s2_lbars     = Bars(_Symbol, PERIOD_CURRENT, s1_l_t, s2_highest_t);
                              s1_lowest_index = ArrayMinimum(low, i, s1_s2_lbars);
                              s1_lowest       = low[s1_lowest_index];
                              s1_lowest_t     = time[s1_lowest_index];

                              //--- Validate the external structure: higher low, lower high inside, and new high above S2
                              if(s1_lowest < s2_highest && s3_lowest < s2_highest && s3_lowest > s1_lowest && s4_h > s2_highest)
                                {
                                 //--- Build unique object names for external structure using swing point times
                                 line_s1_2 = OBJ_PREFIX + "Line S12" + TimeToString(time[i]) + TimeToString(time[j]);
                                 line_s2_3 = OBJ_PREFIX + "Line S23" + TimeToString(time[j]) + TimeToString(time[k]);
                                 line_s3_4 = OBJ_PREFIX + "Line S34" + TimeToString(time[k]) + TimeToString(time[l]);
                                 EXLow     = OBJ_PREFIX + "External Low"  + TimeToString(time[k]) + TimeToString(time[l]);
                                 EXHigh    = OBJ_PREFIX + "External High" + TimeToString(time[k]) + TimeToString(time[l]);

                                 if(DrawTrend(line_s1_2, s1_lowest_t, s1_lowest, s2_highest_t, s2_highest, clrBlue)
                                    && DrawTrend(line_s2_3, s2_highest_t, s2_highest, s3_lowest_t, s3_lowest, clrGreen)
                                    && DrawTrend(line_s3_4, s3_lowest_t, s3_lowest, s4_h_t, s4_h, clrRed)
                                    && DrawTxt(EXLow,  s3_lowest_t, s3_lowest, "EXL", clrRed)
                                    && DrawTxt(EXHigh, s4_h_t,      s4_h,      "EXH", clrGreen))
                                   {
                                    need_redraw = true; // mark chart for redraw
                                   }
                                }

                              break;
                             }
                          }
                        break;
                       }
                    }
                  break;
                 }
              }
           }
        }

      lastTradeBarTime = currentBarTime; // update last processed bar time to prevent re-running on same candle
     }

//--- Redraw the chart only if at least one new object was created
   if(need_redraw)
      ChartRedraw(0);

//--- return value of prev_calculated for next call
   return(rates_total);
  }

Рисунок 4. Подтверждённая внешняя структура

Пояснение

На этом этапе мы уточняем точки свингов, обнаруженные при первоначальном сканировании, чтобы повысить качество выявленной внешней структуры. Чтобы выявить фактические рыночные экстремумы, индикатор повторно анализирует движение цены между первоначальными свинговыми максимумами и свинговыми минимумами, а не использует их в исходном виде. Первый шаг — проанализировать ценовой диапазон между S3 и S4 и найти самый низкий минимум в этом диапазоне. Этот уточненный минимум становится внешним минимумом, чтобы структура отражала самый глубокий откат на данном этапе тренда.

Затем индикатор определяет диапазон между S2 и уточненным минимумом S3 и ищет в нем самый высокий максимум. На этом этапе внешний максимум уточняется так, чтобы отразить наибольшее восходящее движение перед последующим изменением структуры. Наконец, процедура повторяется между S1 и уточненным максимумом S2, чтобы найти самый низкий минимум в начале структуры и точно определить начальную точку внешнего движения.

Функция DrawTrend управляет созданием трендовых линий. Сначала функция проверяет, существует ли уже графический объект с указанным именем. Если такой объект не найден, применяются необходимые графические параметры и создается новая трендовая линия, соединяющая две ценовые точки. Эта функция предотвращает ненужное дублирование графических объектов и сигнализирует индикатору о необходимости обновления графика, поскольку возвращает результат успешного выполнения только в том случае, если действительно создается новый объект.

Индикатор использует функцию DrawTxt для отображения меток, таких как структурные маркеры и аннотации. Сначала функция проверяет, существует ли уже указанный текстовый объект на графике. Если объекта нет, в указанной позиции создается новый текстовый объект, которому затем задаются нужный текст и цвет. Как и функция построения трендовых линий, она сообщает об успешном выполнении только при добавлении нового объекта, позволяя легко отслеживать обновления графика и избегать ненужного создания объектов.

Программа проверяет внешнюю структуру с помощью фиксированного набора условий. Она проверяет, что цена формирует закономерную последовательность движений, а самая низкая точка структуры находится ниже внутренних максимумов. Также программа проверяет, что S1 ниже S2, S3 находится ниже S2, но выше S1, а S4 пробивает уровень S2 вверх. Это позволяет еще до визуализации убедиться, что на рынке сформировалась корректная бычья внешняя структура.

После проверки внешней структуры индикатор использует временные метки выявленных точек свинга, чтобы присвоить каждому графическому объекту уникальное имя. Это позволяет управлять каждой трендовой линией и меткой по отдельности и предотвращает замену ранее заданных структур вновь создаваемыми объектами. Затем, соединяя трендовыми линиями S1 с S2, S2 с S3 и S3 с S4, индикатор формирует внешнюю структуру. Текстовые метки используются для обозначения внешнего минимума (EXL) и внешнего максимума (EXH). Если все объекты успешно созданы, устанавливается флаг перерисовки, благодаря чему готовая структура сразу отображается на графике.

Флаг need_redraw определяет, когда необходимо обновить график. Когда флаг need_redraw принимает значение true, вызов ChartRedraw(0) заставляет MetaTrader 5 немедленно обновить график, чтобы на нём отобразились вновь созданные элементы, такие как трендовые линии, подписи или торговые отметки. Благодаря тому, что перерисовка графика выполняется только при возникновении реальных визуальных изменений, этот метод сокращает количество ненужных циклов обновления и повышает скорость работы. Кроме того, удаляя только объекты, созданные данным индикатором, функция ObjectsDeleteAll(0, OBJ_PREFIX) гарантирует надлежащую очистку. Эта функция отбирает объекты по указанному префиксу, чтобы не затрагивать элементы графика, добавленные вручную или другими средствами, и не оставлять лишних объектов после удаления индикатора.

Выявление первой внутренней структуры с проверкой действительности внешней структуры

Это второй этап плана реализации, на котором мы анализируем внутренние свинги в рамках подтверждённой внешней структуры, чтобы выявить первые сигналы пробоя структуры или смены характера.

Пример:

//--- Internal structure swing points
double i_high;       // internal high price
datetime i_high_t;   // internal high time
double i_low;        // internal low price
datetime i_low_t;    // internal low time
int in_bars;         // bar count from s4 high to current scan bar

//--- External structure bar range and search flag
int ex_bars;         // total bar count of the external structure range

//--- Object name strings for internal structure and trade objects
string in_line_s1_2; // trendline from internal high to internal low
string in_line_s1_c; // trendline from internal high to CHoCH cross candle

Пример:

//--- Validate the external structure: higher low, lower high inside, and new high above S2
if(s1_lowest < s2_highest && s3_lowest < s2_highest && s3_lowest > s1_lowest && s4_h > s2_highest)
  {
//--- Build unique object names for external structure using swing point times
   line_s1_2 = OBJ_PREFIX + "Line S12" + TimeToString(time[i]) + TimeToString(time[j]);
   line_s2_3 = OBJ_PREFIX + "Line S23" + TimeToString(time[j]) + TimeToString(time[k]);
   line_s3_4 = OBJ_PREFIX + "Line S34" + TimeToString(time[k]) + TimeToString(time[l]);
   EXLow     = OBJ_PREFIX + "External Low"  + TimeToString(time[k]) + TimeToString(time[l]);
   EXHigh    = OBJ_PREFIX + "External High" + TimeToString(time[k]) + TimeToString(time[l]);


   if(DrawTrend(line_s1_2, s1_lowest_t, s1_lowest, s2_highest_t, s2_highest, clrBlue)
      && DrawTrend(line_s2_3, s2_highest_t, s2_highest, s3_lowest_t, s3_lowest, clrGreen)
      && DrawTrend(line_s3_4, s3_lowest_t, s3_lowest, s4_h_t, s4_h, clrRed)
      && DrawTxt(EXLow,  s3_lowest_t, s3_lowest, "EXL", clrRed)
      && DrawTxt(EXHigh, s4_h_t,      s4_h,      "EXH", clrGreen))
     {
      need_redraw = true; // mark chart for redraw
     }

//--- Calculate total bar range of the confirmed external structure
   ex_bars = Bars(_Symbol, PERIOD_CURRENT, s1_lowest_t, s4_h_t);

//--- Scan for internal highs after the external structure completes
   for(int m = l + EX_SwingLookback; m < rates_total - 3 - 2; m++)
     {
      //--- Only search if no valid internal setup has been found yet for this structure
      if(IsSwingHigh(high, m, 3))
        {
         i_high   = high[m]; // record internal high price
         i_high_t = time[m]; // record internal high time

         //--- Scan forward for the first internal low after this internal high
         for(int n = m; n < rates_total - 3 - 2; n++)
           {
            if(IsSwingLow(low, n, 3))
              {
               i_low   = low[n];   // record internal low price
               i_low_t = time[n];  // record internal low time

               //--- Scan forward for a CHoCH candle that crosses above the internal high
               for(int o = n; o <= rates_total - 1; o++)
                 {
                  in_bars = Bars(_Symbol, PERIOD_CURRENT, s4_h_t, time[o]); // bars from S4 to current candle

                  //--- CHoCH condition: candle opens below and closes above the internal high within the structure range
                  if(in_bars <= ex_bars && open[o] < i_high && close[o] > i_high)
                    {
                     //--- Internal low must be below the internal high for a valid IH-IL-CHoCH sequence
                     if(i_low < i_high)
                       {
                        //--- Build unique object names for this internal setup
                        in_line_s1_2 = OBJ_PREFIX + "In Line S12"       + TimeToString(time[m]) + TimeToString(time[n]);
                        in_line_s1_c = OBJ_PREFIX + "In Line Cross S12" + TimeToString(time[m]) + TimeToString(time[o]);

                        //--- Draw internal structure lines, entry arrow, SL, and TP objects
                        if(DrawTrend(in_line_s1_2, i_high_t,  i_high,  i_low_t,  i_low,   clrBlue)
                           && DrawTrend(in_line_s1_c, i_high_t,  i_high,  time[o], i_high,  clrBlue)
                          )
                          {
                           need_redraw = true; // mark chart for redraw
                          }
                       }
                     break;
                    }
                 }

               break;
              }
           }
        }
     }
  }

Результат:

Рисунок 5. Несколько внутренних структур

Пояснение

На этом этапе индикатор начинает выявлять внутреннюю структуру рынка в рамках уже подтверждённой внешней структуры. Сначала индикатор рассчитывает полный диапазон баров внешней структуры по разнице во времени между внешним минимумом (область S1/S3) и внешним максимумом (S4), что помогает ограничить весь анализ внутренней структуры допустимыми структурными границами. Этот диапазон сохраняется в переменной ex_bars и впоследствии используется для того, чтобы алгоритм не обнаруживал внутренние сдвиги, выходящие за пределы зафиксированного внешнего движения.

Далее индикатор сканирует график вперёд от конца внешней структуры, чтобы выявить внутренние максимумы, используя меньший диапазон поиска свингов. Эти внутренние максимумы представляют собой временные пики в рамках более широкого тренда и служат отправной точкой для анализа внутренней структуры. Как только обнаруживается внутренний максимум, алгоритм фиксирует его цену и время, а затем продолжает сканирование вперед, чтобы найти первый внутренний минимум, следующий за ним. Этот внутренний минимум соответствует коррекционному откату в рамках структуры.

После определения внутреннего максимума и внутреннего минимума индикатор ищет событие смены характера (CHoCH). Это происходит, когда свеча пробивает внутренний максимум, открываясь ниже него и закрываясь выше, что подтверждает бычий сдвиг внутренней структуры. Однако такой пробой считается действительным только в том случае, если он происходит в пределах ранее рассчитанного диапазона внешней структуры: это обеспечивает структурную значимость сигнала и его соответствие контексту основного тренда.

После подтверждения действительного события CHoCH индикатор создает уникальные имена объектов для внутренней формации и рисует на графике соответствующие линии внутренней структуры. Первая линия соединяет внутренний максимум и внутренний минимум, а вторая — внутренний максимум и свечу пробоя. После успешного создания этих объектов устанавливается флаг для обновления графика, чтобы новая внутренняя структура сразу стала видна.

Одна из проблем текущей реализации заключается в том, что она обнаруживает несколько событий смены характера (CHoCH) или пробоя структуры в пределах одной и той же внешней структуры, вместо того чтобы учитывать только первый действительный сдвиг внутренней структуры. В идеале после подтверждения внешней структуры индикатор должен выявлять только первое событие CHoCH или пробоя структуры, а затем прекращать дальнейший поиск внутренней структуры в пределах этой внешней структуры. Однако при текущей логике цикл продолжает проверять последующие внутренние формации, что приводит к появлению нескольких сигналов в рамках одной фазы внешней структуры рынка.

Теперь нужно изменить программу в соответствии с задуманной логикой, чтобы после подтверждения внешней структуры обнаруживалось только первое действительное событие смены характера (CHoCH) или пробоя структуры. Это изменение улучшит работу индикатора: оно предотвратит появление нескольких внутренних сигналов в рамках одной внешней структуры и обеспечит только один четкий сдвиг внутренней структуры для анализа в каждой фазе внешней структуры. Кроме того, нужно убедиться, что после подтверждения внешней структуры ни внешний максимум, ни внешний минимум не были пробиты.

Пример:

//--- External structure bar range and search flag
int ex_bars;   // total bar count of the external structure range
bool found;    // flag — true once a valid internal setup is found for this structure

Пример:

//--- Validate the external structure: higher low, lower high inside, and new high above S2
if(s1_lowest < s2_highest && s3_lowest < s2_highest && s3_lowest > s1_lowest && s4_h > s2_highest)
  {

//--- Build unique object names for external structure using swing point times
   line_s1_2 = OBJ_PREFIX + "Line S12" + TimeToString(time[i]) + TimeToString(time[j]);
   line_s2_3 = OBJ_PREFIX + "Line S23" + TimeToString(time[j]) + TimeToString(time[k]);
   line_s3_4 = OBJ_PREFIX + "Line S34" + TimeToString(time[k]) + TimeToString(time[l]);
   EXLow     = OBJ_PREFIX + "External Low"  + TimeToString(time[k]) + TimeToString(time[l]);
   EXHigh    = OBJ_PREFIX + "External High" + TimeToString(time[k]) + TimeToString(time[l]);

   if(DrawTrend(line_s1_2, s1_lowest_t, s1_lowest, s2_highest_t, s2_highest, clrBlue)
      && DrawTrend(line_s2_3, s2_highest_t, s2_highest, s3_lowest_t, s3_lowest, clrGreen)
      && DrawTrend(line_s3_4, s3_lowest_t, s3_lowest, s4_h_t, s4_h, clrRed)
      && DrawTxt(EXLow,  s3_lowest_t, s3_lowest, "EXL", clrRed)
      && DrawTxt(EXHigh, s4_h_t,      s4_h,      "EXH", clrGreen))
     {
      need_redraw = true; // mark chart for redraw
     }

//--- Calculate total bar range of the confirmed external structure
   ex_bars = Bars(_Symbol, PERIOD_CURRENT, s1_lowest_t, s4_h_t);
   found   = false; // reset search flag for this structure

//--- Scan for internal highs after the external structure completes
   for(int m = l + EX_SwingLookback; m < rates_total - 3 - 2; m++)
     {
      //--- Only search if no valid internal setup has been found yet for this structure
      if(found == false && IsSwingHigh(high, m, 3))
        {
         i_high   = high[m]; // record internal high price
         i_high_t = time[m]; // record internal high time

         //--- Scan forward for the first internal low after this internal high
         for(int n = m; n < rates_total - 3 - 2; n++)
           {
            if(IsSwingLow(low, n, 3))
              {
               i_low   = low[n];   // record internal low price
               i_low_t = time[n];  // record internal low time

               //--- Scan forward for a CHoCH candle that crosses above the internal high
               for(int o = n; o <= rates_total - 1; o++)
                 {
                  in_bars = Bars(_Symbol, PERIOD_CURRENT, s4_h_t, time[o]); // bars from S4 to current candle

                  //--- CHoCH condition: candle opens below and closes above the internal high within the structure range
                  if(in_bars <= ex_bars && open[o] < i_high && close[o] > i_high)
                    {
                     //--- Internal low must be below the internal high for a valid IH-IL-CHoCH sequence
                     if(i_low < i_high)
                       {
                        //--- Check whether a previous internal structure already exists between m and o
                        bool is_prev_in = false;

                        //--- Scan for any earlier internal high between the current IH and CHoCH candle
                        for(int x = m + 1; x <= o - 2; x++)
                          {
                           if(IsSwingHigh(high, x, 3))
                             {
                              //--- Scan for an internal low after that earlier high
                              for(int y = x; y <= o - 2; y++)
                                {
                                 if(IsSwingLow(low, y, 3))
                                   {
                                    //--- Check if a CHoCH already occurred for that earlier internal high
                                    for(int z = y; z < o; z++)
                                      {
                                       if(open[z] < high[x] && close[z] > high[x])
                                         {
                                          is_prev_in = true; // a prior internal sequence already fired

                                          break; // stop scanning - prior internal found
                                         }
                                      }
                                    break; // use only the first internal low after x
                                   }
                                }
                             }
                          }

                        //--- Find the lowest low from S3 to the CHoCH candle for external low validation
                        exll_bars = Bars(_Symbol, PERIOD_CURRENT, s3_lowest_t, time[o]);
                        exll      = low[ArrayMinimum(low, s3_lowest_index, exll_bars)];

                        //--- Find the highest high from S4 to the CHoCH candle for external high validation
                        exhh_bars = Bars(_Symbol, PERIOD_CURRENT, s4_h_t, time[o]);
                        exhh      = high[ArrayMaximum(high, l, exhh_bars)];

                        //--- Build unique object names for this internal setup
                        in_line_s1_2 = OBJ_PREFIX + "In Line S12"       + TimeToString(time[m]) + TimeToString(time[n]);
                        in_line_s1_c = OBJ_PREFIX + "In Line Cross S12" + TimeToString(time[m]) + TimeToString(time[o]);

                        //--- Draw objects only if no prior internal exists and external structure is still intact
                        if(is_prev_in == false && exll == s3_lowest && exhh == s4_h)
                          {
                           //--- Draw internal structure lines, entry arrow, SL, and TP objects
                           if(DrawTrend(in_line_s1_2, i_high_t,  i_high,  i_low_t,  i_low,   clrBlue)
                              && DrawTrend(in_line_s1_c, i_high_t,  i_high,  time[o], i_high,  clrBlue)
                             )
                             {
                              need_redraw = true; // mark chart for redraw
                             }
                          }
                       }

                     found = true; // mark this structure as processed - stop scanning m for new internal highs
                     break;
                    }
                 }

               break;
              }
           }
        }
     }
  }

Результат:

Рисунок 6. Первая внутренняя структура


Пояснение

Программа предотвращает появление нескольких внутренних сигналов в пределах одной и той же внешней структуры. Чтобы обозначить, что предыдущая внутренняя структура еще не найдена, программа сначала инициализирует булевый флаг is_prev_in значением false. Затем программа анализирует движение цены между текущим кандидатом на внутренний максимум (m) и свечой CHoCH (o), чтобы проверить, не существует ли уже более ранней внутренней формации. Для этого сначала выполняется поиск любого более раннего внутреннего максимума в пределах данного диапазона, а затем — поиск первого внутреннего минимума, следующего за этим максимумом.

Найдя эту последовательность из внутреннего максимума и внутреннего минимума, программа проверяет, не произошло ли уже событие CHoCH: есть ли на этом отрезке свеча, которая открывается ниже внутреннего максимума и закрывается выше него. Выполнение этого условия означает, что в рамках внутренней структуры уже произошел действительный пробой, поэтому флагу is_prev_in присваивается значение true, а цикл немедленно прерывается во избежание дальнейших ненужных проверок. Это гарантирует, что учитывается только первая допустимая внутренняя структура, и предотвращает появление дубликатов внутренних сигналов в пределах одной и той же внешней структуры.

Следующий этап алгоритма направлен на проверку того, остается ли внешняя структура ненарушенной на момент обнаружения внутреннего CHoCH. Для этого пересчитываются нижняя и верхняя ценовые границы внешней структуры вплоть до свечи CHoCH. Сначала код находит наименьший минимум на участке от уточненной области внешнего минимума (начиная с S3) до свечи CHoCH. Это значение, сохраненное в переменной exll, позволяет убедиться, что после формирования внешней структуры не появился более низкий минимум. Далее код находит наибольший максимум на участке от внешнего максимума (S4) до свечи CHoCH и сохраняет его в переменной exhh, чтобы убедиться, что во время внутреннего движения цена не пробила исходный внешний максимум вверх. Вместе эти вычисления служат проверкой целостности в реальном времени и позволяют убедиться, что внешняя структура остается действительной, прежде чем принять какой-либо внутренний сигнал.

После завершения обеих проверок окончательное условие определяет, следует ли отобразить внутреннюю структуру на графике. Индикатор продолжает обработку только в том случае, если предыдущая внутренняя структура отсутствует (is_prev_in == false), внешний минимум остается неизменным (exll == s3_lowest), а внешний максимум не нарушен (exhh == s4_h). Выполнение всех этих условий подтверждает, что обнаруженный внутренний CHoCH — первый допустимый сигнал такого типа в рамках внешней структуры, которая остается ненарушенной и не содержит ранее принятых внутренних сигналов. На этом этапе программа рисует линии внутренней структуры, соединяющие внутренний максимум и внутренний минимум, чтобы наглядно отобразить движение рынка. Наконец, флаг found устанавливается в значение true, что прекращает дальнейший поиск дополнительных внутренних формаций в пределах той же внешней структуры и обеспечивает формирование только одного четкого и допустимого внутреннего сигнала для каждого внешнего тренда.

Визуализация и формирование торговых сетапов с управлением графическими объектами

Это последний этап, на котором мы преобразуем подтвержденные внутреннюю и внешнюю структуры рынка в полноценный торговый сетап.

Пример:

//--- Trade objects calculation variables
double tp;           // computed take profit price (1.5R)
string tp_line;      // take profit horizontal line object name
string tp_txt;       // take profit text label object name
string buy_obj;      // buy arrow object at entry candle
string sl_line;      // stop loss horizontal line
string sl_txt;       // stop loss text label

Пример:

//+------------------------------------------------------------------+
//| Create arrow or shape objects on the chart                       |
//+------------------------------------------------------------------+
bool DrawObject(const string name,
                datetime xt, double x,
                ENUM_OBJECT obj_type)
  {
   bool created = false;

//--- Create object only if it does not exist
   if(ObjectFind(0, name) < 0)
     {
      ObjectCreate(0, name, obj_type, 0, xt, x);
      created = true;
     }

   return created;
  }

Пример:

//--- Calculate take profit at 1.5x the risk from entry close
tp      = close[o] + ((close[o] - low[n]) * 1.5);
tp_line = OBJ_PREFIX + "TP Line" + TimeToString(time[n]) + TimeToString(time[o]);
tp_txt  = OBJ_PREFIX + "TP Text" + TimeToString(time[o]);
buy_obj      = OBJ_PREFIX + "Buy Object"         + TimeToString(time[o]);
sl_line      = OBJ_PREFIX + "SL Line"            + TimeToString(time[n]) + TimeToString(time[o]);
sl_txt       = OBJ_PREFIX + "SL Text"            + TimeToString(time[o]);

//--- Draw objects only if no prior internal exists and external structure is still intact
if(is_prev_in == false && exll == s3_lowest && exhh == s4_h)
  {
//--- Draw internal structure lines, entry arrow, SL, and TP objects
   if(DrawTrend(in_line_s1_2, i_high_t,  i_high,  i_low_t,  i_low,   clrBlue)
      && DrawTrend(in_line_s1_c, i_high_t,  i_high,  time[o], i_high,  clrBlue
                   && DrawObject(buy_obj,     time[o],   close[o],          OBJ_ARROW_BUY)
                   && DrawTrend(sl_line,      time[n],   low[n],  time[o], low[n],  clrBlue)
                   && DrawTxt(sl_txt,         time[o],   low[n],  "SL",    clrBlue)
                   && DrawTrend(tp_line,      time[n],   tp,      time[o], tp,      clrBlue)
                   && DrawTxt(tp_txt,         time[o],   tp,      "TP",    clrBlue))
     )
     {
      need_redraw = true; // mark chart for redraw
     }
  }

Результат:

Рисунок 7. Расположение уровней входа, стоп-лосса и тейк-профита

Пояснение

Эта часть кода отвечает за определение уровней управления сделкой после подтверждения допустимой внутренней структуры и сигнала CHoCH. В ходе первого расчёта определяется уровень тейк-профита исходя из фиксированного соотношения риска и потенциальной прибыли 1:1,5. Риск измеряется как расстояние между ценой входа (ценой закрытия свечи CHoCH — close[o]) и уровнем стоп-лосса (внутренним минимумом — low[n]). Затем эту величину риска умножают на 1,5 и прибавляют к цене входа, чтобы рассчитать уровень тейк-профита выше цены входа. Это гарантирует, что каждый торговый сетап основан на едином принципе расчета потенциальной прибыли непосредственно на основе волатильности рынка, а не произвольных значений.

После расчета тейк-профита код присваивает уникальные имена объектам всех элементов сделки, включая линию тейк-профита и её метку, маркер сигнала на покупку, линию стоп-лосса и метку стоп-лосса. Цель этого начального блока кода — предотвратить формирование нескольких внутренних сигналов в пределах одной и той же внешней структуры. Перед отображением каких-либо объектов, связанных с торговлей, индикатор выполняет заключительную проверку, чтобы обеспечить корректность структуры. Проверяя, что ранее внутренняя структура не была обнаружена, индикатор гарантирует, что это первый достоверный внутренний сигнал. Кроме того, сравнивая exll и exhh с их исходными подтвержденными значениями, индикатор проверяет, что границы внешней структуры по-прежнему не нарушены. Если эти требования не выполняются, отрисовка блокируется и торговый сетап не отображается на графике.

По завершении проверки индикатор наносит на график все элементы исполнения сделок. Он размещает стрелку покупки на свече входа, проводит линию стоп-лосса на уровне внутреннего минимума и отмечает её меткой "SL". Кроме того, он проводит линию тейк-профита на рассчитанном целевом уровне и отмечает её меткой "TP". Если все операции отрисовки выполнены успешно, флаг need_redraw устанавливается в true, чтобы график немедленно обновился и отобразил полностью сформированный торговый сетап.

 

Заключение

В результате работы над этой статьей мы создали целостную и структурированную основу для выявления внутренней и внешней структуры рынка на MQL5, предложив практический подход, который можно проверить до полной реализации. Основное внимание уделялось разбиению всего процесса выявления структуры на четкие, логически последовательные этапы, которые обеспечивают точность, согласованность и упрощают отладку на протяжении всей разработки. Система построена на основе следующих ключевых компонентов:

  • выявление свингов для определения достоверных точек разворота рынка;
  • построение и уточнение внешней структуры для определения истинных рыночных экстремумов;
  • выявление внутренней структуры для анализа поведения рынка в рамках более широкого тренда;
  • проверка сигналов смены характера (CHoCH) и пробоя структуры для подтверждения изменений импульса во внутренней структуре;
  • определение уровней входа, стоп-лосса и тейк-профита непосредственно на основе структуры рынка.

Эта система обеспечивает структурированный подход к анализу структуры рынка на MQL5, основанный на четких правилах, и повышает надежность, ясность и согласованность как распознавания паттернов, так и логики исполнения сделок.

Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/22968

Прикрепленные файлы |
Автоматизация классических рыночных методов на MQL5 (Часть 7): Система коробок Николаса Дарваса Автоматизация классических рыночных методов на MQL5 (Часть 7): Система коробок Николаса Дарваса
В данной статье метод коробок Дарваса реализован в виде полнофункционального советника на языке MQL5. Мы программируем обнаружение коробок с подтверждением экстремума в течение трех торговых сессий, снижение объема во время консолидации и пробои, подтвержденные объемом, а также пирамидальное наращивание позиции по принципу пирамидинга с общим перемещаемым стопом на уровне нижней границы последней коробки. Советник использует конечный автомат для параллельного поиска коробок и управления сделками, представляя собой готовую к компиляции систему с настраиваемыми входными параметрами и наглядной диагностикой на графике.
Создание системы прогнозного моделирования на основе пересечения EMA (Окончание): Интерактивные синтетические свечи Создание системы прогнозного моделирования на основе пересечения EMA (Окончание): Интерактивные синтетические свечи
В этой статье мы завершаем разработку движка прогнозного моделирования для MetaTrader 5, калибруя синтетические свечи по недавней рыночной волатильности вместо определения их размеров исключительно по наклону EMA. Движок рассчитывает средний размер тела и среднюю длину верхней и нижней теней по закрытым барам, применяет синусоидальную огибающую с затуханием, задает пропорциональные размеры теней и промежутки между свечами, а также периодически добавляет контртрендовые свечи. В результате получается динамическая проекция, которая непрерывно сдвигается, оставаясь на один бар впереди текущего рыночного бара. Ее код можно повторно использовать для отрисовки откалиброванных проекций относительно точки привязки и автоматической очистки.
Поиск торгового преимущества (Часть 4): Изотоническая регрессия и прогнозирование направления движения цены с помощью PNN в советнике Поиск торгового преимущества (Часть 4): Изотоническая регрессия и прогнозирование направления движения цены с помощью PNN в советнике
Мы рассматриваем методы, с помощью которых изотоническая регрессия преобразует исходные оценки сигналов RSI, стохастического осциллятора и ценовой динамики в упорядоченные вероятности, а отдельная вероятностная нейронная сеть оценивает сходные состояния рынка в прошлом. В этой статье оба подхода реализованы в готовом пользовательском классе торгового сигнала на MQL5, совместимом с Мастером MQL5 и предлагающем до семи режимов входа на выбор. В воспроизводимых тестах сигналы, полученные только с помощью изотонической регрессии, сравниваются с сигналами комбинированной модели изотонической регрессии и PNN, чтобы оценить, даёт ли сеть полезную информацию сверх той, которую предоставляет более простая базовая модель.
Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте
Мы добавляем на холст восемь инструментов для рисования фигур и девять инструментов для создания аннотаций, а также реализуем полнофункциональную систему редактирования меток на месте. В статье подробно рассматриваются геометрия, отрисовка со сглаживанием, общие вспомогательные функции для переноса слов и отрисовки текста с суперсэмплингом, а также конечный автомат редактирования, основанный на положении текстового курсора и отвечающий за ввод текста, навигацию и выделение. В результате получается полный и согласованный набор инструментов для аннотирования с редактируемыми метками, который интегрируется в существующий конвейер взаимодействия.