Разработка индикатора внутренней и внешней структуры рынка
Введение
На ценовых графиках в MetaTrader 5 отображаются свечи и базовые индикаторы, однако они не показывают явно элементы структуры рынка, такие как подтверждённые свинговые максимумы и свинговые минимумы, формирование внешнего тренда и первый значимый внутренний сдвиг (пробой структуры или смена характера) в рамках этого тренда. В результате выявление структуры вручную занимает много времени, субъективно и трудно воспроизводится, а нечётко заданные правила в коде могут приводить к дублированию сигналов и несогласованному определению структуры.
В этой статье представлена реализация на MQL5, специально разработанная для этой задачи и основанная на чётких правилах: она автоматизирует выявление и визуализацию внешней и внутренней структуры рынка и преобразует первый подтверждённый внутренний сдвиг в торговый сетап с полностью заданными параметрами. Индикатор выявляет свинги S1→S4 с помощью явно заданных функций IsSwingHigh() и IsSwingLow(), уточняет истинные экстремумы между этими опорными точками, проверяет внешнюю бычью или медвежью последовательность, а затем ищет внутри подтверждённого диапазона первую последовательность IH→IL→CHoCH. В результате получается индикатор с воспроизводимыми результатами и возможностью отладки, который отображает линии структуры и метки, создаёт маркер входа, устанавливает стоп-лосс на уровне внутреннего минимума и рассчитывает уровень тейк-профита на расстоянии 1,5 величины риска от входа.
Обзор проекта и план реализации
Перед началом реализации необходимо разобраться в устройстве и принципах работы индикатора внутренней и внешней структуры рынка. Полное понимание цели проекта облегчает определение функций каждого компонента и оптимизацию процесса разработки.
Что мы создаем
В этой статье мы разработаем индикатор внутренней и внешней структуры рынка для MetaTrader 5. Этот индикатор автоматически выявляет важные структурные точки в движении цены и отображает их на графике. Индикатор анализирует исторические ценовые данные, чтобы определять свинговые максимумы и свинговые минимумы, которые служат основой для выявления как внутренней, так и внешней структуры рынка. Максимум свечи считается свинговым максимумом, если он превышает максимумы заданного числа свечей с каждой стороны от неё. Это свидетельствует о том, что цена достигла локального максимума на рынке. Аналогично, минимум свечи считается свинговым минимумом, если он ниже минимумов заданного числа свечей с каждой стороны от неё, что подтверждает локальный минимум рынка. Такой подход гарантирует, что фиксируются только значимые точки разворота, а не произвольные ценовые свинги.
Для определения внешней структуры мы используем больший диапазон поиска свингов. Это означает, что мы сравниваем каждую потенциальную точку свинга с большим количеством свечей до и после неё. Использование большего количества баров позволяет отфильтровать незначительные ценовые движения и сосредоточиться только на крупных рыночных свингах, определяющих общий тренд. Затем эти крупные свинги используются для определения внешнего максимума и внешнего минимума, которые отражают доминирующую структуру рынка. В отличие от внешней структуры, для внутренней структуры используется меньший диапазон поиска свингов. При выявлении внутренних свингов используется меньше свечей, что позволяет с большей чувствительностью улавливать более мелкие ценовые движения. Это позволяет индикатору раньше выявлять пробой структуры и смену характера в рамках тренда. Внешняя структура отражает общее направление движения рынка. Внутренняя структура отражает краткосрочные изменения динамики в рамках данного тренда.
Для бычьей внешней структуры индикатор отображает свинговый минимум, свинговый максимум, более высокий минимум и более высокий максимум. Внешний максимум (EXH) соответствует более высокому максимуму, а внешний минимум (EXL) — более высокому минимуму.

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

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

В конечном итоге трендовые линии, метки и сигнальные маркеры используются для визуализации всех выявленных структур на графике, что позволяет легко понять структуру рынка как при разработке алгоритмических стратегий, так и при ручном анализе.
Примечание: чтобы избежать повторений, мы рассмотрим процесс выявления только на примере бычьего сценария, поскольку медвежья структура строится по очень схожей логике, но с обратными условиями. Те же принципы, которые используются для определения свинговых максимумов, свинговых минимумов и структурных изменений, можно применять и при анализе медвежьей структуры рынка, инвертировав условия.
План реализации
Индикатор будет реализован по следующей схеме:
- Построение, уточнение и валидация внешней структуры (EXH/EXL)
- Выявление первой внутренней структуры с проверкой действительности внешней структуры
- Визуализация и формирование торговых сетапов с управлением графическими объектами
Примечание: проект, рассматриваемый в данной статье, целиком основан на практической работе и призван обучить читателей языку 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); }

Пояснение
На этом этапе мы уточняем точки свингов, обнаруженные при первоначальном сканировании, чтобы повысить качество выявленной внешней структуры. Чтобы выявить фактические рыночные экстремумы, индикатор повторно анализирует движение цены между первоначальными свинговыми максимумами и свинговыми минимумами, а не использует их в исходном виде. Первый шаг — проанализировать ценовой диапазон между 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; } } } } }
Результат:

Пояснение
На этом этапе индикатор начинает выявлять внутреннюю структуру рынка в рамках уже подтверждённой внешней структуры. Сначала индикатор рассчитывает полный диапазон баров внешней структуры по разнице во времени между внешним минимумом (область 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; } } } } }
Результат:

Пояснение
Программа предотвращает появление нескольких внутренних сигналов в пределах одной и той же внешней структуры. Чтобы обозначить, что предыдущая внутренняя структура еще не найдена, программа сначала инициализирует булевый флаг 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 } }
Результат:

Пояснение
Эта часть кода отвечает за определение уровней управления сделкой после подтверждения допустимой внутренней структуры и сигнала 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
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.