Создание системы прогнозного моделирования на основе пересечения EMA (Окончание): Интерактивные синтетические свечи
Содержание
Введение
В первой статье мы создали основные компоненты движка прогнозного моделирования для MetaTrader 5. Мы начали с простого детектора пересечения EMA. Затем мы добавили механизм задания точки привязки, цикл построения проекции на основе наклона EMA, правило аннулирования с порогом в пипсах и систему отрисовки с помощью графических объектов. В результате был создан автономный индикатор, способный строить проекцию из фиксированного числа синтетических свечей OHLC после подтвержденного пересечения EMA. Эти свечи отображались с видимыми телами и тенями, имели четкие подписи на графике и автоматически удалялись при аннулировании сигнала или появлении нового. Эта первоначальная версия заложила основу системы, включая обнаружение сигналов, управление состояниями, обработку объектов и повторяемый процесс формирования свечей. Она также показала, что визуализацию будущих движений цены можно интегрировать в традиционный индикатор EMA, сделав ее практически полезной.
В данной статье эта основа развивается в трех ключевых областях. Во-первых, движок построения проекций теперь определяет размеры тел и теней свечей на основе средних характеристик недавних рыночных свечей для текущего торгового инструмента и таймфрейма. Наклон EMA по-прежнему служит фактором импульса, однако размеры свечей теперь отражают фактическую волатильность торгового инструмента. В результате проекции естественным образом адаптируются к различным рынкам — от волатильного XAUUSD на M15 до более стабильного EURUSD на H1. Во-вторых, визуальное представление улучшено благодаря настраиваемым промежуткам между свечами, синусоидальной огибающей размеров тел, пропорциональному расчету размеров теней и контролируемому добавлению контртрендовых свечей. Эти дополнения позволяют создавать более реалистичные ценовые последовательности, сохраняя при этом общую направленность.
Наконец, свечи проекции теперь стали интерактивными. При закрытии каждой новой рыночной свечи удаляется самая старая свеча проекции. Таким образом, проекция располагается на один бар впереди текущего рыночного бара и сдвигается по мере поступления новых данных. В совокупности эти усовершенствования превращают исходную статическую проекцию в динамическую, самообновляющуюся модель будущего движения цены, которая изменяется вместе с графиком в режиме реального времени.
Обзор системы
Индикатор построен на основе трех независимых модулей, каждый из которых выполняет одну конкретную функцию. Первый — сигнальный модуль, который отслеживает пересечение быстрой и медленной EMA по последним двум закрытым барам. Когда быстрая линия пересекает медленную снизу вверх, фиксируется бычье состояние; когда она пересекает ее сверху вниз — медвежье. Каждое новое пересечение сбрасывает движок и обновляет средние характеристики свечей на основе выборки последних закрытых баров текущего торгового инструмента на текущем таймфрейме. Эти показатели (средний размер тела свечи, средняя длина верхней тени и средняя длина нижней тени) становятся калибровочной основой для всего, что отрисовывается далее.

Прежде чем отрисовать хотя бы одну синтетическую свечу, движок анализирует сам график — измеряет фактические размеры реальных свечей и их теней, чтобы проекция говорила на том же визуальном языке, что и график торгового инструмента, на котором она строится.
Как работает механизм калибровки:
- Шаг 1: Сформировать выборку из последних 50 закрытых баров → Рассчитать средние размеры тел свечей и длины теней.
- Шаг 2: Быстрая EMA пересекает медленную EMA снизу вверх → Сигнал зафиксирован, точка привязки установлена.
- Шаг 3: Рассчитанные средние значения становятся основой для построения каждой будущей свечи.
- Шаг 4: Панель в режиме реального времени отображает состояние сигнала и значения калибровки.
Второй модуль — механизм прогнозирования, который использует эту калибровочную основу для построения последовательности синтетических свечей с данными OHLC. Размеры тел свечей изменяются по синусоидальной огибающей, наложенной на экспоненциальное затухание, поэтому вдоль проекции свечи пульсируют по размеру и постепенно уменьшаются к ее концу. Через каждые N баров добавляется контртрендовая свеча уменьшенного размера, чтобы имитировать реалистичные откаты в рамках преобладающего направления движения. Длины теней рассчитываются на основе измеренных отношений длины тени к размеру тела, поэтому тени свечей в проекции естественным образом воспроизводят характер теней, свойственный данному торговому инструменту.
Третий модуль — модуль отрисовки. Он отрисовывает каждую синтетическую свечу с помощью графических объектов: закрашенного прямоугольника для тела и двух трендовых линий для теней. Свечи размещаются в будущих временных интервалах с настраиваемыми промежутками между ними. По мере закрытия каждой новой реальной свечи первая свеча проекции удаляется, благодаря чему моделирование постоянно опережает график на один бар без какого-либо ручного вмешательства.

Проекция — это не статичный прогноз, наложенный на график, а живая последовательность свечей, которая продвигается во времени вместе с рынком. Размеры и форма свечей определяются историей самого торгового инструмента.
Как строится проекция будущих свечей:
- Шаг 1: Размеры тел свечей изменяются по синусоидальному закону и постепенно уменьшаются к концу последовательности.
- Шаг 2: Через каждые несколько баров контртрендовая свеча имитирует реалистичный откат.
- Шаг 3: Длина каждой тени рассчитывается на основе откалиброванного отношения длины тени к размеру тела.
- Шаг 4: По мере закрытия каждой реальной свечи исчезает самая старая свеча проекции — моделирование всегда опережает график на один бар.
Начало работы
//+------------------------------------------------------------------+ //| Forward Simulation_V2.mq5 | //| Copyright 2025, MetaQuotes Ltd. | //| https://www.mql5.com/en/users/johnhlomohang/ | //+------------------------------------------------------------------+ #property copyright "Copyright 2025, MetaQuotes Ltd." #property link "https://www.mql5.com/en/users/johnhlomohang/" #property version "2.00" #property indicator_chart_window #property indicator_buffers 2 #property indicator_label1 "Fast EMA" #property indicator_type1 DRAW_LINE #property indicator_color1 clrDodgerBlue #property indicator_style1 STYLE_SOLID #property indicator_width1 2 #property indicator_label2 "Slow EMA" #property indicator_type2 DRAW_LINE #property indicator_color2 clrOrangeRed #property indicator_style2 STYLE_SOLID #property indicator_width2 2 //+------------------------------------------------------------------+ //| INDICATOR BUFFERS | //+------------------------------------------------------------------+ double FastEMABuffer[]; double SlowEMABuffer[]; //+------------------------------------------------------------------+ //| INPUT PARAMETERS | //+------------------------------------------------------------------+ input int FastEMA_Period = 9; // Fast EMA period input int SlowEMA_Period = 21; // Slow EMA period input int FutureBars = 30; // Number of future candles to project input double SpreadMultiplier = 2.0; // Wick size multiplier input bool AutoAnchor = true; // Auto-move anchor to latest cross bar input string AnchorLineName = "FSE_Anchor"; // Anchor vertical line name input color BullishColor = clrDodgerBlue; // Bullish body color input color BearishColor = clrCrimson; // Bearish body color input color WickColor = clrDimGray; // Wick color input bool ShowZoneLabel = true; // Show projection label input bool ShowSeparatorLine = true; // Show dashed separator at anchor input int InvalidationPips = 10; // Pip distance to trigger invalidation input double CandleGapFraction = 0.08; // Gap between candles as fraction of bar width (0.04–0.20) input int CounterCandleFreq = 4; // Insert 1 counter-trend candle every N candles (min 3) input int AvgLookback = 50; // Bars used to measure average candle size
Для начала мы определяем индикатор, отображаемый в окне графика, с двумя выходными индикаторными буферами для отображения быстрой и медленной экспоненциальных скользящих средних (EMA). Затем мы настраиваем внешний вид обеих линий EMA, включая их цвета, толщину и стиль, чтобы их можно было легко различить на графике. Далее мы объявляем индикаторные буферы, в которых будут храниться вычисленные значения EMA. Раздел входных параметров обеспечивает полный контроль над поведением движка прогнозного моделирования. Здесь мы задаем периоды EMA, количество будущих свечей в проекции, масштабирование теней, управление точкой привязки, цвета свечей, расстояние аннулирования, интервал между свечами, частоту контртрендовых свечей и период ретроспективного анализа, используемый для расчета средних характеристик свечей.
//+------------------------------------------------------------------+ //| STRUCTS | //+------------------------------------------------------------------+ struct PredictedCandle { double open; double high; double low; double close; bool bullish; }; //+------------------------------------------------------------------+ //| GLOBALS | //+------------------------------------------------------------------+ int g_FastHandle = INVALID_HANDLE; int g_SlowHandle = INVALID_HANDLE; int g_LastSignal = 0; // +1 bull, -1 bear, 0 none bool g_SignalActive = false; double g_SignalPrice = 0.0; datetime g_SignalBarTime = 0; datetime g_DrawnAnchor = 0; // anchor time of the last successful draw //--- Measured average candle metrics (refreshed on each new signal) double g_AvgBody = 0.0; // average |close - open| over AvgLookback bars double g_AvgUpperWick = 0.0; // average (high - max(open,close)) double g_AvgLowerWick = 0.0; // average (min(open,close) - low) double g_AvgRange = 0.0; // average (high - low) – full candle height //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- Bind and configure the two visible EMA plot buffers SetIndexBuffer(0, FastEMABuffer, INDICATOR_DATA); SetIndexBuffer(1, SlowEMABuffer, INDICATOR_DATA); ArraySetAsSeries(FastEMABuffer, false); ArraySetAsSeries(SlowEMABuffer, false); PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, FastEMA_Period); PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, SlowEMA_Period); //--- Internal calculation handles g_FastHandle = iMA(_Symbol, _Period, FastEMA_Period, 0, MODE_EMA, PRICE_CLOSE); g_SlowHandle = iMA(_Symbol, _Period, SlowEMA_Period, 0, MODE_EMA, PRICE_CLOSE); if(g_FastHandle == INVALID_HANDLE || g_SlowHandle == INVALID_HANDLE) { Print("ForwardSimEngine [ERROR]: iMA handle creation failed. " "Symbol=", _Symbol, " TF=", EnumToString(_Period)); return INIT_FAILED; } Print("ForwardSimEngine [INIT]: OK FastEMA=", FastEMA_Period, " SlowEMA=", SlowEMA_Period, " FutureBars=", FutureBars, " InvalidationPips=", InvalidationPips, " AvgLookback=", AvgLookback); //--- Pre-compute average candle metrics from history CalcAvgCandleMetrics(); EventSetTimer(3); return INIT_SUCCEEDED; } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { EventKillTimer(); CleanAllObjects(); Print("ForwardSimEngine [DEINIT]: objects cleaned, reason=", reason); }
Основой движка служит структура PredictedCandle, которая выступает в качестве контейнера для каждой синтетической свечи, генерируемой системой построения проекций. Каждый экземпляр хранит цены открытия, максимума, минимума и закрытия свечи, а также признак бычьей свечи, указывающий ее направленность.
Далее мы объявляем набор глобальных переменных, которые хранят состояние индикатора. К ним относятся дескрипторы для расчета быстрой и медленной EMA, переменные, отслеживающие последний сигнал пересечения EMA, а также информация об активной проекции, такая как цена сигнала, время появления сигнала и положение точки привязки. Кроме того, мы резервируем память для рассчитанных статистических характеристик свечей, включая средний размер тела свечи, длины теней и полный диапазон свечи. Эти значения позволяют калибровать будущие проекции с учетом реального поведения рынка, а не полагаться исключительно на оценки, полученные на основе индикаторов.
Функция OnInit() подготавливает индикатор к работе. Здесь мы привязываем буферы EMA к графику, настраиваем параметры их отображения и создаем внутренние дескрипторы для расчета EMA с помощью функции iMA(). Прежде чем продолжить выполнение, мы проверяем, что оба дескриптора успешно созданы. После завершения инициализации мы рассчитываем средние показатели свечей на основе последних исторических данных и запускаем таймер, который будет обеспечивать выполнение периодических задач по обслуживанию. При удалении индикатора функция OnDeinit() выполняет действия, обратные инициализации. Она останавливает таймер, удаляет все графические объекты, созданные движком, и записывает сообщение о завершении работы в журнал.
//+-----------------------------------------------------------------------+ //| ON CALCULATE | //+-----------------------------------------------------------------------+ int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[]) { if(rates_total < SlowEMA_Period + 5) { Print("ForwardSimEngine [WARN]: Not enough bars: ", rates_total); return 0; } //--- How many bars to (re)calculate int limit = (prev_calculated > 1) ? rates_total - prev_calculated + 1 : rates_total; //--- Start index in the buffer (oldest bar that needs updating) int startBar = rates_total - limit; //--- Local arrays for engine logic double tmpFast[], tmpSlow[]; ArraySetAsSeries(tmpFast, false); ArraySetAsSeries(tmpSlow, false); ArrayResize(tmpFast, rates_total); ArrayResize(tmpSlow, rates_total); //--- Copy ALL bars into local arrays (needed by RunEngine for crossover) int copiedFast = CopyBuffer(g_FastHandle, 0, 0, rates_total, tmpFast); int copiedSlow = CopyBuffer(g_SlowHandle, 0, 0, rates_total, tmpSlow); if(copiedFast <= 0 || copiedSlow <= 0) { Print("ForwardSimEngine [WARN]: CopyBuffer returned <=0. fast=", copiedFast, " slow=", copiedSlow); return prev_calculated; } /* Write into plot buffers ONLY within the confirmed copied range and only within what MT5 has allocated (ArraySize guard).*/ int bufSzFast = ArraySize(FastEMABuffer); int bufSzSlow = ArraySize(SlowEMABuffer); int safeFast = MathMin(copiedFast, bufSzFast); int safeSlow = MathMin(copiedSlow, bufSzSlow); for(int i = startBar; i < safeFast; i++) FastEMABuffer[i] = tmpFast[i]; for(int i = startBar; i < safeSlow; i++) SlowEMABuffer[i] = tmpSlow[i]; // ── Run the simulation engine ───────────────────────────────── RunEngine(rates_total, time, close, tmpFast, tmpSlow); return rates_total; } //+------------------------------------------------------------------+ //| ON TIMER | //+------------------------------------------------------------------+ void OnTimer() { // If user moved the anchor manually, force a redraw on next tick if(!AutoAnchor) { datetime curAnchor = GetAnchorTime(); if(curAnchor != g_DrawnAnchor && curAnchor != 0) { g_DrawnAnchor = 0; ChartRedraw(); } } }
Функция OnCalculate() представляет собой основной цикл выполнения. Она запускается при появлении новых рыночных данных. Для начала мы проверяем, достаточно ли исторических баров для расчета медленной EMA. Если данных недостаточно, функция записывает предупреждение в журнал и досрочно завершает работу. Затем мы вычисляем, сколько баров требуют пересчета, исходя из значения prev_calculated. Это позволяет избежать обработки всей истории данных при каждом тике. Затем создаются временные массивы для хранения значений быстрой и медленной EMA, которые копируются из внутренних дескрипторов EMA с помощью функции CopyBuffer(). Убедившись, что данные успешно скопированы, мы переносим значения в индикаторные буферы, используемые для отображения, и выполняем проверки, предотвращающие запись за пределы выделенного размера буфера.
После обновления данных EMA мы передаем актуальную рыночную информацию и массивы EMA в функцию RunEngine(), где выполняются алгоритмы обнаружения пересечений EMA, генерации проекций и отрисовки. Затем функция OnCalculate() возвращает общее количество обработанных баров, что позволяет MetaTrader 5 правильно отслеживать последующие обновления. Функция OnTimer() обеспечивает дополнительную поддержку ручного управления точкой привязки. Когда автоматическая привязка отключена, система постоянно отслеживает положение заданной пользователем точки привязки. Если точка привязки перемещается в новое место, функция принудительно запускает перерисовку, сбрасывая сохраненное состояние последней отрисованной точки привязки и запрашивая обновление графика. Это обеспечивает соответствие положения свечей проекции выбранной пользователем точке привязки без необходимости перезагрузки индикатора.
//+------------------------------------------------------------------+ //| CALC AVERAGE CANDLE METRICS | //+------------------------------------------------------------------+ void CalcAvgCandleMetrics() { int lookback = (AvgLookback < 10) ? 10 : AvgLookback; // minimum 10 bars double hiBuf[], loBuf[], opBuf[], clBuf[]; ArraySetAsSeries(hiBuf, true); ArraySetAsSeries(loBuf, true); ArraySetAsSeries(opBuf, true); ArraySetAsSeries(clBuf, true); //--- Copy starting at shift 1 (skip the live bar), going back lookback bars int copiedH = CopyHigh(_Symbol, _Period, 1, lookback, hiBuf); int copiedL = CopyLow(_Symbol, _Period, 1, lookback, loBuf); int copiedO = CopyOpen(_Symbol, _Period, 1, lookback, opBuf); int copiedC = CopyClose(_Symbol, _Period, 1, lookback, clBuf); int n = MathMin(MathMin(copiedH, copiedL), MathMin(copiedO, copiedC)); if(n <= 0) { Print("ForwardSimEngine [AVG]: CopyPrice failed, keeping previous averages."); return; } double sumBody = 0, sumUWick = 0, sumLWick = 0, sumRange = 0; for(int i = 0; i < n; i++) { double bodyTop = MathMax(opBuf[i], clBuf[i]); double bodyBot = MathMin(opBuf[i], clBuf[i]); sumBody += bodyTop - bodyBot; sumUWick += hiBuf[i] - bodyTop; sumLWick += bodyBot - loBuf[i]; sumRange += hiBuf[i] - loBuf[i]; } double pip = _Point * 10.0; // 1 pip floor g_AvgBody = MathMax(sumBody / n, pip); g_AvgUpperWick = MathMax(sumUWick / n, pip * 0.5); g_AvgLowerWick = MathMax(sumLWick / n, pip * 0.5); g_AvgRange = MathMax(sumRange / n, pip * 2.0); Print("ForwardSimEngine [AVG]: lookback=", n, " AvgBody=", DoubleToString(g_AvgBody / _Point, 1), " pts", " AvgUpperWick=", DoubleToString(g_AvgUpperWick / _Point, 1), " pts", " AvgLowerWick=", DoubleToString(g_AvgLowerWick / _Point, 1), " pts", " AvgRange=", DoubleToString(g_AvgRange / _Point, 1), " pts"); } //+------------------------------------------------------------------+ //| CORE ENGINE | //| All arrays: index 0 = oldest, rates_total-1 = live forming bar | //| rates_total-2 = last fully closed bar (bar index 1) | //| rates_total-3 = bar before that (bar index 2) | //+------------------------------------------------------------------+ void RunEngine(const int rates_total, const datetime &time[], const double &close[], const double &fastBuf[], const double &slowBuf[]) { int barLive = rates_total - 1; // live/forming bar int barClosed = rates_total - 2; // last fully closed bar int barPrev = rates_total - 3; // bar before that if(barPrev < SlowEMA_Period) return; //--- 1. Crossover detection //--- We look at the two most recently CLOSED bars (barPrev and barClosed). //--- Cross occurs when the fast EMA crossed over the slow EMA between them. double fCur = fastBuf[barClosed]; double fPrev = fastBuf[barPrev]; double sCur = slowBuf[barClosed]; double sPrev = slowBuf[barPrev]; int newSignal = 0; if(fPrev <= sPrev && fCur > sCur) newSignal = 1; // bullish if(fPrev >= sPrev && fCur < sCur) newSignal = -1; // bearish //--- Heartbeat log (first 3 ticks + every new signal) static int s_ticks = 0; s_ticks++; if(s_ticks <= 3 || newSignal != 0) { Print("ForwardSimEngine [TICK #", s_ticks, "]", " fCur=", DoubleToString(fCur, _Digits), " sCur=", DoubleToString(sCur, _Digits), " gap=", DoubleToString(fCur - sCur, _Digits), " newSig=", newSignal, " active=", g_SignalActive, " lastSig=",g_LastSignal); } //--- 2. Latch new signal if(newSignal != 0) { g_LastSignal = newSignal; g_SignalActive = true; g_SignalPrice = close[barClosed]; g_SignalBarTime = time[barClosed]; g_DrawnAnchor = 0; // force full redraw /* Refresh measured candle averages at the moment of the signal so the projection uses the most recent volatility context. */ CalcAvgCandleMetrics(); Print("ForwardSimEngine [SIGNAL]: ", (newSignal == 1 ? ">>> BULLISH CROSS <<<" : ">>> BEARISH CROSS <<<"), " bar=", TimeToString(g_SignalBarTime), " px=", DoubleToString(g_SignalPrice, _Digits)); } //--- 3. Invalidation check if(g_SignalActive) { double livePx = close[barLive]; //--- 1 pip = 10 * _Point for a 5-digit broker (covers 3-digit too) double pipSize = _Point * 10.0; double thresh = InvalidationPips * pipSize; bool inv = false; if(g_LastSignal == 1 && livePx < g_SignalPrice - thresh) inv = true; if(g_LastSignal == -1 && livePx > g_SignalPrice + thresh) inv = true; if(inv) { Print("ForwardSimEngine [INVALIDATED]", " signalPx=", DoubleToString(g_SignalPrice, _Digits), " livePx=", DoubleToString(livePx, _Digits), " thresh=", DoubleToString(thresh, _Digits)); g_SignalActive = false; g_LastSignal = 0; g_DrawnAnchor = 0; CleanAllObjects(); DrawInvalidationLabel(g_SignalBarTime, g_SignalPrice); ChartRedraw(); return; } } //--- 4. Only draw/redraw when there is an active signal if(!g_SignalActive || g_LastSignal == 0) return; datetime anchorTime = (AutoAnchor) ? g_SignalBarTime : GetAnchorTime(); if(anchorTime == 0) anchorTime = g_SignalBarTime; //--- Skip if already drawn at this anchor if(anchorTime == g_DrawnAnchor) return; g_DrawnAnchor = anchorTime; //--- 5. Build synthetic candles double emaSlope = fCur - fPrev; PredictedCandle pred[]; ArrayResize(pred, FutureBars); GeneratePrediction(close[barClosed], emaSlope, pred); //--- 6. Render CleanAllObjects(); DrawAllCandles(anchorTime, pred); if(ShowSeparatorLine) DrawSeparator(anchorTime); if(ShowZoneLabel) DrawZoneLabel(anchorTime, close[barClosed]); UpdateAnchorLine(anchorTime); ChartRedraw(); Print("ForwardSimEngine [DRAWN]", " signal=", g_LastSignal, " anchor=", TimeToString(anchorTime), " bars=", FutureBars, " slope=", DoubleToString(emaSlope, _Digits)); }
Функция CalcAvgCandleMetrics() оценивает недавнее поведение рынка и преобразует результаты в статистические показатели, которые движок построения проекций может использовать повторно. Мы устанавливаем минимальный период ретроспективного анализа в десять баров, чтобы расчеты основывались на выборке достаточного объема. Затем функция получает цены открытия, максимума, минимума и закрытия недавно закрывшихся свечей, намеренно пропуская текущий формирующийся бар. На основе этих данных мы рассчитываем средний размер тела свечи, среднюю длину верхней тени, среднюю длину нижней тени и средний полный диапазон свечи. Эти показатели сохраняются в глобальных переменных и отражают текущий профиль волатильности активного торгового инструмента на выбранном таймфрейме. Чтобы избежать нереалистичных значений, перед сохранением средних значений и их записью в журнал к ним применяются нижние пороги, выраженные в пипсах.
Функция RunEngine() выполняет роль центрального контроллера движка прогнозного моделирования. Сначала мы определяем последние закрытые бары и сравниваем значения быстрой и медленной EMA, чтобы выявить бычьи или медвежьи пересечения EMA. При обнаружении нового пересечения EMA обновляется состояние сигнала, фиксируются цена и временная метка сигнала, а также пересчитываются средние характеристики свечей, чтобы будущие проекции отражали последние рыночные условия.
Затем функция проверяет условия аннулирования активного сигнала, определяя, прошла ли цена против направления сигнала расстояние, превышающее заданный порог в пипсах. В случае аннулирования все объекты проекции удаляются, и на экране появляется визуальное уведомление. Пока действующий сигнал остается активным, функция определяет нужную точку привязки, генерирует последовательность синтетических свечей на основе текущего наклона EMA и рассчитанных статистических характеристик свечей, а затем отображает проекцию на графике.
//+------------------------------------------------------------------+ //| PREDICTION ENGINE | //+------------------------------------------------------------------+ void GeneratePrediction(double startPrice, double emaSlope, PredictedCandle &out[]) { MathSrand((int)(TimeLocal() % 32767)); int n = ArraySize(out); int sig = g_LastSignal; // +1 bull, -1 bear double pip = _Point * 10.0; //--- Baseline body size from measured history //--- Guard: if CalcAvgCandleMetrics hasn't run yet use a pip floor double avgBody = (g_AvgBody > pip) ? g_AvgBody : pip * 3.0; double avgUWick = (g_AvgUpperWick > 0) ? g_AvgUpperWick : avgBody * 0.5; double avgLWick = (g_AvgLowerWick > 0) ? g_AvgLowerWick : avgBody * 0.5; //--- EMA-slope momentum scale: 0.5× (weak) … 1.5× (strong) //--- Normalise slope against avgBody so it is always unit-consistent double slopeAbs = MathAbs(emaSlope); double slopeRatio = slopeAbs / avgBody; // 0 = flat, 1 = slope equals avg body //--- Clamp to a ±0.5 band around 1.0 double momentumScale = 0.5 + MathMin(slopeRatio, 1.0); // 0.5 … 1.5 //--- baseStep = what one average trend-direction candle body should be double baseStep = avgBody * momentumScale; //--- Counter-candle frequency guard int ccFreq = (CounterCandleFreq < 3) ? 3 : CounterCandleFreq; double prevClose = startPrice; for(int i = 0; i < n; i++) { //--- Sine envelope: body pulses between 40% and 130% of baseStep double phase = (double)i / (double)n * 2.0 * M_PI; double sinSq = MathSin(phase) * MathSin(phase); // 0 … 1 double envelope = 0.40 + 0.90 * sinSq; // 0.40 … 1.30 //--- Exponential decay: projection flattens toward the tail double decay = MathPow(0.93, i); //--- Body for this candle double bodySize = baseStep * envelope * decay; //--- ±8% random jitter double jitter = 1.0 + ((double)(MathRand() % 160) - 80.0) * 0.001; bodySize *= jitter; //--- Hard floor: at least 0.5 × avgBody so candles are always visible if(bodySize < avgBody * 0.5) bodySize = avgBody * 0.5; //--- Counter-trend injection every ccFreq bars bool isCounter = (i > 0 && (i % ccFreq == 0)); double retracePct = 0.25 + (MathRand() % 21) * 0.01; // 0.25–0.45 double step; if(isCounter) step = -(double)sig * bodySize * retracePct; else step = (double)sig * bodySize; //--- OHLC out[i].open = prevClose; out[i].close = prevClose + step; out[i].bullish = (out[i].close >= out[i].open); double bodyTop = MathMax(out[i].open, out[i].close); double bodyBot = MathMin(out[i].open, out[i].close); double bHeight = bodyTop - bodyBot; if(bHeight < _Point) bHeight = _Point; //--- Wicks anchored to measured avg wick ratios //--- Base ratio = avgWick / avgBody, then add ±25% random spread double uRatioBase = avgUWick / avgBody; double lRatioBase = avgLWick / avgBody; double uJitter = 1.0 + ((double)(MathRand() % 50) - 25.0) * 0.01; // ±25% double lJitter = 1.0 + ((double)(MathRand() % 50) - 25.0) * 0.01; double upWick = bHeight * uRatioBase * uJitter; double dnWick = bHeight * lRatioBase * lJitter; //--- Trend bias: the shadow in the signal direction is slightly longer if(out[i].bullish) upWick *= 1.20; else dnWick *= 1.20; //--- Minimum wick: 20% of body height if(upWick < bHeight * 0.20) upWick = bHeight * 0.20; if(dnWick < bHeight * 0.20) dnWick = bHeight * 0.20; out[i].high = bodyTop + upWick; out[i].low = bodyBot - dnWick; prevClose = out[i].close; } } //+------------------------------------------------------------------+ //| DRAW ALL CANDLES – project one bar-width ahead of anchor | //+------------------------------------------------------------------+ void DrawAllCandles(datetime startTime, PredictedCandle &candles[]) { int barSec = PeriodSeconds(); int total = ArraySize(candles); //--- Gap in seconds on each side of the body (max 45% each side) double gapFrac = CandleGapFraction; if(gapFrac < 0.01) gapFrac = 0.01; if(gapFrac > 0.45) gapFrac = 0.45; int gapSec = (int)(barSec * gapFrac); for(int i = 0; i < total; i++) { //--- Slot boundaries (full bar width) datetime slotStart = startTime + (datetime)((i + 1) * barSec); datetime slotEnd = slotStart + (datetime)barSec; //--- Body boundaries (inset by gap on each side) datetime bodyStart = slotStart + (datetime)gapSec; datetime bodyEnd = slotEnd - (datetime)gapSec; datetime bodyMid = slotStart + (datetime)(barSec / 2); // wick centre DrawSingleCandle(i, bodyStart, bodyEnd, bodyMid, candles[i]); } }
Функция GeneratePrediction() отвечает за создание последовательности синтетических свечей, формирующих проекцию на будущее. Затем мы задаем базовые размеры свечей по средним размерам тел и длинам теней, рассчитанным на основе недавней рыночной истории. Эти средние значения задают реалистичные размеры свечей, отражающие поведение активного торгового инструмента на выбранном таймфрейме. После этого наклон EMA преобразуется в коэффициент масштабирования импульса, благодаря чему более сильные сигналы пересечения EMA дают более крупные свечи проекции, а более слабые — более мелкие.
По мере развития проекции синусоидальная огибающая обеспечивает естественное изменение размеров свечей, а коэффициент экспоненциального затухания постепенно ослабляет импульс к концу последовательности. Также применяются небольшие случайные корректировки, чтобы проекция не выглядела слишком механической. Движок периодически вставляет контртрендовые свечи, которые частично компенсируют основное движение, создавая более реалистичные откаты в рамках прогнозируемого тренда.
После определения размера тела и направления каждой синтетической свечи функция формирует полную структуру OHLC. Цены открытия и закрытия формируются на основе предыдущей свечи проекции, а длины теней рассчитываются с использованием коэффициентов, полученных из измеренных средних длин верхних и нижних теней. В длины теней вносится случайная вариация, а с учетом направления преобладающего тренда соответствующая ему тень немного удлиняется. Также задается минимальная длина теней, чтобы каждая свеча оставалась хорошо различимой.
Затем готовые данные свечей передаются в функцию DrawAllCandles(), которая преобразует свечи проекции в графические объекты. Эта функция выделяет полный временной интервал для каждой будущей свечи, задает настраиваемые отступы с обеих сторон тела свечи и размещает тень по центру интервала. Благодаря разделению генерации и отрисовки свечей архитектура остается модульной, а логика построения проекции может развиваться независимо от слоя визуализации.
//+------------------------------------------------------------------+ //| DRAW ONE CANDLE | //+------------------------------------------------------------------+ void DrawSingleCandle(int idx, datetime t1, datetime t2, datetime tMid, const PredictedCandle &c) { string pfx = "FutureCandle_" + IntegerToString(idx); color bodyCol = c.bullish ? BullishColor : BearishColor; //--- Doji guard double bOpen = c.open; double bClose = c.close; if(MathAbs(bOpen - bClose) < _Point) bClose = bOpen + (c.bullish ? _Point * 2 : -_Point * 2); //--- Filled body string nm = pfx + "_body"; ObjectDelete(0, nm); if(ObjectCreate(0, nm, OBJ_RECTANGLE, 0, t1, bOpen, t2, bClose)) { ObjectSetInteger(0, nm, OBJPROP_COLOR, bodyCol); ObjectSetInteger(0, nm, OBJPROP_FILL, true); ObjectSetInteger(0, nm, OBJPROP_BACK, false); ObjectSetInteger(0, nm, OBJPROP_WIDTH, 1); ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, nm, OBJPROP_HIDDEN, false); } //--- Body outline nm = pfx + "_bord"; ObjectDelete(0, nm); if(ObjectCreate(0, nm, OBJ_RECTANGLE, 0, t1, bOpen, t2, bClose)) { ObjectSetInteger(0, nm, OBJPROP_COLOR, bodyCol); ObjectSetInteger(0, nm, OBJPROP_FILL, false); ObjectSetInteger(0, nm, OBJPROP_BACK, false); ObjectSetInteger(0, nm, OBJPROP_WIDTH, 1); ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, nm, OBJPROP_HIDDEN, false); } //--- Upper wick (centred on full slot, not the inset body) nm = pfx + "_wU"; ObjectDelete(0, nm); double wTop = MathMax(bOpen, bClose); if(ObjectCreate(0, nm, OBJ_TREND, 0, tMid, wTop, tMid, c.high)) { ObjectSetInteger(0, nm, OBJPROP_COLOR, WickColor); ObjectSetInteger(0, nm, OBJPROP_WIDTH, 1); ObjectSetInteger(0, nm, OBJPROP_RAY_RIGHT, false); ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, nm, OBJPROP_HIDDEN, false); } //--- Lower wick nm = pfx + "_wD"; ObjectDelete(0, nm); double wBot = MathMin(bOpen, bClose); if(ObjectCreate(0, nm, OBJ_TREND, 0, tMid, wBot, tMid, c.low)) { ObjectSetInteger(0, nm, OBJPROP_COLOR, WickColor); ObjectSetInteger(0, nm, OBJPROP_WIDTH, 1); ObjectSetInteger(0, nm, OBJPROP_RAY_RIGHT, false); ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, nm, OBJPROP_HIDDEN, false); } } //+------------------------------------------------------------------+ //| SEPARATOR | //+------------------------------------------------------------------+ void DrawSeparator(datetime t) { string nm = "FSE_Sep"; ObjectDelete(0, nm); if(ObjectCreate(0, nm, OBJ_VLINE, 0, t, 0)) { ObjectSetInteger(0, nm, OBJPROP_COLOR, clrSilver); ObjectSetInteger(0, nm, OBJPROP_STYLE, STYLE_DASH); ObjectSetInteger(0, nm, OBJPROP_WIDTH, 1); ObjectSetInteger(0, nm, OBJPROP_BACK, true); ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, nm, OBJPROP_HIDDEN, false); } } //+------------------------------------------------------------------+ //| ZONE LABEL | //+------------------------------------------------------------------+ void DrawZoneLabel(datetime t, double price) { string nm = "FSE_Label"; string txt = (g_LastSignal == 1) ? "[ BULLISH PROJECTION ]" : "[ BEARISH PROJECTION ]"; color col = (g_LastSignal == 1) ? BullishColor : BearishColor; ObjectDelete(0, nm); if(ObjectCreate(0, nm, OBJ_TEXT, 0, t + (datetime)PeriodSeconds(), price)) { ObjectSetString(0, nm, OBJPROP_TEXT, txt); ObjectSetInteger(0, nm, OBJPROP_COLOR, col); ObjectSetInteger(0, nm, OBJPROP_FONTSIZE, 10); ObjectSetString(0, nm, OBJPROP_FONT, "Courier New"); ObjectSetInteger(0, nm, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER); ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, nm, OBJPROP_HIDDEN, false); } }
Функция DrawSingleCandle() отвечает за преобразование прогнозируемой свечи в видимые графические объекты. Для начала мы создаем уникальный префикс для названия свечи и выбираем соответствующий цвет тела в зависимости от того, является ли свеча бычьей или медвежьей. Затем принимаются меры для отображения свечей с очень маленьким телом, в том числе доджи. Тело свечи отрисовывается с помощью двух прямоугольных объектов: прямоугольника с заливкой для самого тела и прямоугольника без заливки, образующего контур. Перед созданием каждого объекта существующий объект с тем же именем, если он есть, удаляется во избежание дублирования. Дополнительно настраиваются свойства, управляющие внешним видом, видимостью и взаимодействием с пользователем, чтобы свечи проекции служили визуальными элементами, а не редактируемыми графическими объектами.
Остальные функции добавляют вспомогательные графические элементы, которые повышают наглядность зоны проекции. Функция DrawSingleCandle() завершает отрисовку свечи, проводя линии верхней и нижней теней по центру выделенного для свечи временного интервала. Функция DrawSeparator() размещает вертикальную штриховую линию в точке привязки, создавая четкую визуальную границу между историческими рыночными данными и свечами проекции. Затем функция DrawZoneLabel() добавляет поясняющую текстовую метку, указывающую, является ли проекция бычьей или медвежьей. Метка располагается вблизи начала области проекции и окрашивается в цвет, соответствующий активному сигналу.
//+------------------------------------------------------------------+ //| INVALIDATION LABEL | //+------------------------------------------------------------------+ void DrawInvalidationLabel(datetime t, double price) { string nm = "FSE_Invalid"; ObjectDelete(0, nm); if(ObjectCreate(0, nm, OBJ_TEXT, 0, t + (datetime)PeriodSeconds(), price)) { ObjectSetString(0, nm, OBJPROP_TEXT, "[ INVALIDATED - AWAITING NEXT CROSS ]"); ObjectSetInteger(0, nm, OBJPROP_COLOR, clrOrange); ObjectSetInteger(0, nm, OBJPROP_FONTSIZE, 9); ObjectSetString(0, nm, OBJPROP_FONT, "Courier New"); ObjectSetInteger(0, nm, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER); ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, nm, OBJPROP_HIDDEN, false); } } //+------------------------------------------------------------------+ //| ANCHOR LINE HELPERS | //+------------------------------------------------------------------+ void PlaceAnchorLine(datetime t) { ObjectDelete(0, AnchorLineName); if(ObjectCreate(0, AnchorLineName, OBJ_VLINE, 0, t, 0)) { ObjectSetInteger(0, AnchorLineName, OBJPROP_COLOR, clrGold); ObjectSetInteger(0, AnchorLineName, OBJPROP_STYLE, STYLE_DASHDOTDOT); ObjectSetInteger(0, AnchorLineName, OBJPROP_WIDTH, 2); ObjectSetInteger(0, AnchorLineName, OBJPROP_SELECTABLE, true); ObjectSetInteger(0, AnchorLineName, OBJPROP_HIDDEN, false); } } //+------------------------------------------------------------------+ //| Update Anchor Line | //+------------------------------------------------------------------+ void UpdateAnchorLine(datetime t) { if(ObjectFind(0, AnchorLineName) < 0) PlaceAnchorLine(t); else ObjectSetInteger(0, AnchorLineName, OBJPROP_TIME, t); } //+------------------------------------------------------------------+ //| Get Anchor Time | //+------------------------------------------------------------------+ datetime GetAnchorTime() { if(ObjectFind(0, AnchorLineName) >= 0) return (datetime)ObjectGetInteger(0, AnchorLineName, OBJPROP_TIME); return 0; } //+------------------------------------------------------------------+ //| CLEANUP | //+------------------------------------------------------------------+ void CleanAllObjects() { ObjectsDeleteAll(0, "FutureCandle_"); ObjectsDeleteAll(0, "FSE_"); } //+------------------------------------------------------------------+
Функция DrawnIvalidationLabel() визуально оповещает об аннулировании активной проекции. Когда выполняются условия аннулирования, мы сначала удаляем существующую метку аннулирования, чтобы избежать дублирования. Затем рядом с местом появления аннулированного сигнала создается текстовый объект с сообщением о том, что проекция отменена и движок ожидает следующего пересечения EMA. Для метки задаются оранжевый цвет, определенный шрифт и способ привязки текста. Это сразу подтверждает трейдерам, что предыдущий прогноз больше не считается действительным.
Функции управления точкой привязки позволяют нам задавать, где на графике начинается проекция. Функция PlaceAnchorLine() создает перемещаемую вертикальную линию, которая задает точку привязки проекции, а функция UpdateAnchorLine() создает линию привязки, если она отсутствует, или при необходимости перемещает ее в новое положение. Функция GetAnchorTime() получает текущую временную метку точки привязки, позволяя другим компонентам движка правильно размещать свечи проекции по времени. Наконец, функция CleanAllObjects() выполняет очистку, удаляя все графические объекты, созданные движком прогнозного моделирования. Это гарантирует удаление устаревших свечей, меток и маркеров перед построением новой проекции, поддерживая чистоту графика и предотвращая накопление объектов с течением времени.
Демонстрация моделирования 
Заключение
В этой статье представлен значительно усовершенствованный движок прогнозного моделирования, завершающий рассмотрение данной темы. В исходной версии была заложена базовая архитектура, включающая обнаружение пересечений EMA на закрытых барах, проекции с фиксацией относительно точки привязки, генерацию свечей на основе наклона EMA, аннулирование по порогу в пипсах, а также полноценную систему отрисовки и очистки. Эти основы остаются неизменными. В этой версии усовершенствованы все компоненты, а также добавлены новые уровни реалистичности и интерактивности.
Самым важным нововведением является калибровочный слой. Вместо того чтобы полагаться исключительно на наклон EMA, движок теперь рассчитывает средний размер тела и средние длины верхней и нижней теней последних закрытых свечей с помощью функций CopyOpen, CopyHigh, CopyLow и CopyClose. Благодаря этому каждая проекция отражает фактическую волатильность текущего торгового инструмента на выбранном таймфрейме. Проекция для "XAUUSD M15" теперь напоминает реальное движение цены на графике XAUUSD с таймфреймом M15, а не обобщенную приблизительную оценку. Наклон EMA по-прежнему используется как фактор импульса: более сильные сигналы позволяют формировать более крупные синтетические свечи, сохраняя при этом соответствие реальным рыночным условиям.
Кроме того, было внедрено несколько визуальных улучшений. Настраиваемое расстояние между свечами повышает наглядность графика, а огибающая на основе квадрата синуса обеспечивает естественное изменение размеров тел свечей по всей проекции. Длины теней масштабируются на основе измеренных средних рыночных значений, что позволяет формировать более реалистичные свечи. Контролируемое добавление контртрендовых свечей создает периодические откаты в проецируемой последовательности. Эти откаты помогают проекции воспроизводить реальное поведение рынка и позволяют избежать нереалистичной картины непрерывного однонаправленного движения.
Новый уровень интерактивности напрямую связывает моделирование с реальной рыночной активностью. При закрытии каждой новой свечи движок удаляет самую старую свечу проекции. Благодаря этому проекция всегда начинается на один бар впереди текущего рыночного бара. Моделирование сохраняет актуальность по мере изменения цены, а устаревшие графические объекты не накапливаются. В сочетании с существующими механизмами задания точки привязки, аннулирования и очистки это позволяет получить проекцию будущего движения цены, которая остается синхронизированной с графиком в реальном времени.
Архитектура по-прежнему остается модульной и легко расширяемой. Такие компоненты, как CalcAvgCandleMetrics, GeneratePrediction, DrawAllCandles и конечный автомат управления состояниями сигнала, работают независимо друг от друга. Разработчики могут заменить механизм запуска по пересечению EMA моделью на основе рыночной структуры, внедрить систему учета волатильности на основе ATR или добавить визуальные эффекты, зависящие от степени уверенности в прогнозе, не изменяя слои отрисовки и аннулирования. Таким образом, программная основа, разработанная в этих двух статьях, представляет собой нечто большее, чем просто готовый индикатор. Она служит понятной и расширяемой основой для создания продвинутых инструментов построения проекций и визуализации сценариев в MetaTrader 5.
Сопровождение этой статьи осуществляется на платформе AlgoForge.
Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/22927
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.