Автоматическое построение сессионного профиля объема на MQL5: Визуализация POC и зоны стоимости без сторонних инструментов
Введение
В MetaTrader 5 нет встроенного индикатора профиля объема. Это создает практическую проблему для трейдеров и разработчиков количественных инструментов, которым нужен анализ распределения объема по ценовым уровням в рамках сессии — выявление уровней, на которых рынок проявлял наибольшую торговую активность, выраженную через накопленный тиковый объем на каждом ценовом уровне.
Эту проблему можно полностью решить с помощью средств стандартной библиотеки MQL5. Функция CopyTicksRange() предоставляет торговые данные на уровне тиков, ограниченные явно заданными временными интервалами. Для визуализации используются стандартные функции рисования графических объектов. Ни DLL, ни сторонние библиотеки, ни внешние зависимости не нужны.
В этой статье рассматриваются проектирование и реализация индикатора сессионного профиля объема на MQL5. Он собирает тиковые данные за заданную пользователем сессию, агрегирует их по ценовым интервалам, рассчитывает POC и зону стоимости, охватывающую 70% объема, и отображает результаты с помощью штатных графических объектов.
Почему именно профили объема и почему именно сейчас
На графике баров каждый временной интервал представлен четырьмя ценами. Он показывает цену открытия, уровни, которых достигала цена, и цену закрытия. Но график ничего не говорит о том, на каких ценовых уровнях торговля шла дольше всего. Две сессии могут иметь одинаковые значения OHLC, но совершенно разные распределения объема: в ходе одной цена часами держится в узком диапазоне перед прорывом, а в ходе другой равномерно проходит весь диапазон. График OHLC не позволяет их различить, а профиль объема — позволяет.
Профиль объема представляет рыночную активность в виде гистограммы, повернутой на девяносто градусов. По вертикальной оси отложена цена. На горизонтальной оси отображается накопленный тиковый объем. Каждая строка гистограммы соответствует ценовому интервалу — дискретному диапазону цен, — а ее ширина отражает объем, накопленный в этом интервале в течение сессии. Распределение показывает, на каких уровнях рынок принимал цену (уровни с высоким объемом), а на каких — отвергал (уровни с низким объемом).
На основе этого распределения рассчитываются три величины, которые используются в качестве опорных уровней в следующей сессии:
- Точка контроля (POC) — ценовой уровень с наибольшим накопленным объемом. С концептуальной точки зрения это цена, при которой в ходе торговой сессии на рынке было достигнуто наибольшее согласие между покупателями и продавцами.
- Верхняя граница зоны стоимости (VAH) — верхняя граница непрерывного ценового диапазона с центром на уровне POC, содержащего 70% общего объема за сессию.
- Нижняя граница зоны стоимости (VAL) — нижняя граница того же диапазона.
Тиковый объем по инструментам CFD
Прежде чем рассматривать реализацию, необходимо понять одно принципиальное различие. Биржевой объем отражает фактическое количество контрактов, по которым совершены сделки. Эти данные поступают из централизованной клиринговой системы. Тиковый объем — это число событий изменения цены за период измерения, причем каждый отдельный тик учитывается как единица независимо от объема стоящей за ним сделки.
На рынках валют и CFD центральной биржи не существует. Брокеры публикуют свои собственные потоки данных. Данные о фактическом биржевом объеме недоступны розничным участникам рынка. Тиковый объем служит косвенным показателем активности: там, где цена часто меняется, активность предполагается высокой.
У большинства розничных брокеров, работающих с CFD, поля структуры MqlTick заполняются следующим образом:
| Поле | Заполнение | Примечания |
|---|---|---|
| bid | Всегда | Основное поле цены для внебиржевых инструментов |
| ask | Всегда | Дополнительное поле цены |
| last | Ноль | Отсутствует цена последней сделки на централизованной бирже |
| volume | Ноль | Нет данных о количестве лотов в биржевых сделках |
| volume_real | Ноль | Нет данных о фактическом объеме |
Это означает, что любая реализация, отбирающая тики по условию volume > 0 или volume_real > 0, будет отбрасывать все тики у этих брокеров. Правильный критерий отбора тиковых данных CFD — наличие ненулевой цены bid или ask. Вес по объему, присваиваемый каждому тику, по умолчанию равен 1, поэтому гистограмма представляет собой карту плотности тиков, а не распределение фактического объема по ценовым уровням. Это стандартная интерпретация для внебиржевых инструментов, позволяющая получать аналитически полезные профили.

Сквозной конвейер обработки индикатора "Сессионный профиль объема" — от определения границ сессии и сбора тиков через группировку по ценовым интервалам, определение POC, расширение зоны стоимости и отрисовку до итогового отображения на графике. Каждый этап соответствует отдельному модулю в реализации.
Математические основы
Формирование ценовых интервалов
Исходные тики представляют собой наблюдения за ценой на непрерывной шкале. Профиль требует дискретного представления. Каждой цене тика сопоставляется индекс ценового интервала по формуле:
Индекс ценового интервала = floor((Pᵢ - session_low) / BinSize)
Здесь Pᵢ — цена тика, session_low — минимальная цена, по которой совершались сделки в течение сессии, а BinSize — заданный пользователем размер ценового интервала в единицах цены. Предварительное вычитание session_low сдвигает начало ценового диапазона к нулю, поэтому минимальная цена, по которой совершались сделки, всегда соответствует ценовому интервалу с индексом 0. Округление результата деления вниз дает целочисленный индекс интервала. Все цены в пределах одного ценового интервала сопоставляются с одним и тем же индексом.
Общее количество ценовых интервалов:
bin_count = ceil((session_high - session_low) / BinSize) + 1
Добавление единицы гарантирует, что максимальная цена сессии будет отнесена к отдельному ценовому интервалу, а не окажется на границе последнего интервала.
Точка контроля
POC = argmax_bin { BinVolume(bin) }
Индекс ценового интервала с максимальным накопленным объемом. Цена POC соответствует нижней границе этого интервала.
Зона стоимости — правило 70%
Алгоритм расчета зоны стоимости выполняет жадное расширение от POC в обе стороны, на каждом шаге присоединяя ценовой интервал с той стороны, где он добавляет больший объем:
- Рассчитать целевой объем: va_threshold = total_volume × 0.70
- Задать накопителю начальное значение, равное объему ценового интервала POC
- Сравнить объем в следующем ценовом интервале выше с объемом в следующем ценовом интервале ниже
- Присоединить интервал с большим объемом, сдвинув соответствующий указатель границы
- Повторять, пока не выполнится условие va_volume ≥ va_threshold или обе границы не достигнут краев гистограммы
VAH — это нижняя граница самого верхнего ценового интервала, включенного в зону стоимости. VAL — это нижняя граница самого нижнего ценового интервала, включенного в зону стоимости.
Основные переменные
| Обозначение | Значение |
|---|---|
| Pᵢ | Цена i-го тика |
| Vᵢ | Вес по объему i-го тика |
| BinSize | Размер ценового интервала в абсолютных единицах цены |
| POC | Цена точки контроля |
| VAH | Цена верхней границы зоны стоимости |
| VAL | Цена нижней границы зоны стоимости |
Вычислительная сложность
| Компонент | Сложность |
|---|---|
| Сбор тиков | O(N) |
| Накопление объемов в гистограмме | O(N) |
| Поиск POC | O(M) |
| Расширение зоны стоимости | O(M) |
| Рендеринг | O(M) |
N — количество тиков, собранных в течение сессии. M — количество ценовых интервалов.
На практике M ≪ N, поскольку многие тики попадают в один и тот же ценовой интервал.
Архитектура программы
Код реализован в семи исходных файлах. Каждый модуль выполняет одну четко определенную функцию.
| # | Имя | Тип | Описание |
|---|---|---|---|
| 1 | SessionManager.mqh | Заголовочный файл класса | Расчет границ сессии и обнаружение смены сессии |
| 2 | TickCollector.mqh | Заголовочный файл класса | Получение тиков с помощью CopyTicksRange и фильтрация с учетом особенностей CFD |
| 3 | PriceHistogram.mqh | Заголовочный файл класса | Накопление объема по дискретным ценовым интервалам |
| 4 | VolumeProfileCalculator.mqh | Заголовочный файл класса | Расчет POC и зоны стоимости |
| 5 | ProfileRenderer.mqh | Заголовочный файл класса | Создание графических объектов, масштабирование в режиме фиксированной ширины и очистка |
| 6 | ProfileStatistics.mqh | Заголовочный файл класса | Вывод диагностических данных на вкладку "Эксперты" |
| 7 | SessionVolumeProfile.mq5 | Индикатор | Основные обработчики событий и координация компонентов |
Модуль 1 — CSessionManager
CSessionManager преобразует выбранный пользователем тип сессии в конкретные границы типа datetime, привязанные к текущей календарной дате. Он определяет момент начала новой сессии и передает эти границы сборщику тиков и модулю отрисовки.
Объявление класса
//+------------------------------------------------------------------+ //| SessionManager.mqh | //| Session Volume Profile Engine | //+------------------------------------------------------------------+ #ifndef SESSION_MANAGER_MQH #define SESSION_MANAGER_MQH //--- Session type enumeration enum ENUM_SESSION_TYPE { SESSION_LONDON = 0, // London 08:00 - 17:00 UTC SESSION_NEW_YORK = 1, // New York 13:00 - 22:00 UTC SESSION_CUSTOM = 2 // User-defined hours }; //+------------------------------------------------------------------+ //| Session Manager Class | //+------------------------------------------------------------------+ class CSessionManager { private: ENUM_SESSION_TYPE m_session_type; int m_start_hour; int m_start_minute; int m_end_hour; int m_end_minute; datetime m_session_start; datetime m_session_end; datetime m_last_session_date; public: CSessionManager(void); ~CSessionManager(void); void Configure(ENUM_SESSION_TYPE type, int start_hour, int start_minute, int end_hour, int end_minute); bool Update(datetime current_time); bool IsNewSession(void) const; datetime GetSessionStart(void) const; datetime GetSessionEnd(void) const; private: void ResolveSessionHours(void); };
В объявлении класса вводится перечисление ENUM_SESSION_TYPE с именованными вариантами для выбора пользователем: лондонская сессия, нью-йоркская сессия или полностью настраиваемое временное окно. Семь закрытых полей хранят тип сессии, заданные часы ее границ, вычисленные границы типа datetime для текущей сессии и m_last_session_date — маркер последней обработанной даты сессии, который обновляется раз в календарный день и служит для обнаружения смены сессии. Открытый интерфейс предоставляет метод Configure() для однократной настройки, метод Update() для проверки на каждом баре и два метода доступа, которые последующие модули вызывают для получения границ текущей сессии.
Конструктор и деструктор
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CSessionManager::CSessionManager(void) : m_session_type(SESSION_LONDON), m_start_hour(8), m_start_minute(0), m_end_hour(17), m_end_minute(0), m_session_start(0), m_session_end(0), m_last_session_date(0) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CSessionManager::~CSessionManager(void) { }
Конструктор CSessionManager с помощью списка инициализации членов задает всем полям значения по умолчанию для лондонской сессии. Полю m_last_session_date намеренно присваивается нулевое значение: ноль предшествует любой допустимой временной метке торговых данных, поэтому уже первый вызов метода Update() обязательно обнаружит несовпадение и сформирует сигнал о начале новой сессии. Тело деструктора пустое, поскольку класс не выделяет памяти в куче и не владеет никакими внешними ресурсами.
Configure
//+------------------------------------------------------------------+ //| Configure session parameters | //+------------------------------------------------------------------+ void CSessionManager::Configure(ENUM_SESSION_TYPE type, int start_hour, int start_minute, int end_hour, int end_minute) { m_session_type = type; m_start_hour = start_hour; m_start_minute = start_minute; m_end_hour = end_hour; m_end_minute = end_minute; ResolveSessionHours(); }
Метод Configure() сохраняет все пять параметров, переданных вызывающей стороной, и сразу же вызывает функцию ResolveSessionHours(). Вызов функции ResolveSessionHours() необходим, поскольку для двух встроенных типов сессий часы, переданные вызывающей стороной, игнорируются: применяются стандартные границы сессий по UTC. Для SESSION_CUSTOM функция ResolveSessionHours() оставляет сохраненные значения без изменений.
ResolveSessionHours
//+------------------------------------------------------------------+ //| Resolve hard-coded session hours for built-in types | //+------------------------------------------------------------------+ void CSessionManager::ResolveSessionHours(void) { if(m_session_type == SESSION_LONDON) { m_start_hour = 8; m_start_minute = 0; m_end_hour = 17; m_end_minute = 0; } else if(m_session_type == SESSION_NEW_YORK) { m_start_hour = 13; m_start_minute = 0; m_end_hour = 22; m_end_minute = 0; } //--- SESSION_CUSTOM retains caller-supplied values }
Функция ResolveSessionHours() устанавливает стандартные границы по UTC для двух встроенных типов сессий. Лондонская сессия проходит с 08:00 до 17:00 по UTC, а нью-йоркская — с 13:00 до 22:00 по UTC. Ветвь SESSION_CUSTOM намеренно отсутствует — если ни одно из условий не выполняется, метод завершается без изменения каких-либо полей, сохраняя значения часов, переданные вызывающей стороной через Configure().
Update
//+------------------------------------------------------------------+ //| Update session boundaries and detect rollover | //+------------------------------------------------------------------+ bool CSessionManager::Update(datetime current_time) { //--- Extract the calendar date component from current_time MqlDateTime dt; TimeToStruct(current_time, dt); //--- Build session start and end for today dt.hour = m_start_hour; dt.min = m_start_minute; dt.sec = 0; datetime today_start = StructToTime(dt); dt.hour = m_end_hour; dt.min = m_end_minute; dt.sec = 0; datetime today_end = StructToTime(dt); //--- Detect new session by comparing today's date to the last recorded date bool is_new = (today_start != m_last_session_date); if(is_new) { m_session_start = today_start; m_session_end = today_end; m_last_session_date = today_start; } return(is_new); }
Метод Update() вызывается из функции OnCalculate() один раз для каждого бара. Метод преобразует current_time в структуру MqlDateTime с помощью TimeToStruct(), затем подставляет в эту структуру время начала сессии и восстанавливает значение типа datetime с помощью StructToTime(). В результате получается today_start — метка времени начала сессии для календарной даты текущего бара. Ключевое сравнение today_start != m_last_session_date позволяет определить, наступила ли новая календарная дата с момента последнего срабатывания. На каждом баре одного и того же торгового дня значение today_start одинаково, поэтому сравнение возвращает false, и метод немедленно завершается с пренебрежимо малыми затратами ресурсов. На первом баре нового дня значение today_start изменяется, а is_new принимает значение true, в результате чего обновляются оба поля границ сессии и маркер. Затем метод возвращает значение true, чтобы сообщить основному конвейеру обработки о необходимости перестроения профиля.
GetSessionStart и GetSessionEnd
//+------------------------------------------------------------------+ //| Return session start timestamp | //+------------------------------------------------------------------+ datetime CSessionManager::GetSessionStart(void) const { return(m_session_start); } //+------------------------------------------------------------------+ //| Return session end timestamp | //+------------------------------------------------------------------+ datetime CSessionManager::GetSessionEnd(void) const { return(m_session_end); } #endif // SESSION_MANAGER_MQH
GetSessionStart() и GetSessionEnd() — простые методы доступа с квалификатором const, которые предоставляют CTickCollector и CProfileRenderer границы активной сессии. Эти значения имеют смысл только после того, как хотя бы один вызов метода Update() вернул значение true.
Модуль 2 — CTickCollector
CTickCollector служит оберткой для CopyTicksRange() и применяет фильтр, учитывающий особенности CFD: он принимает любой тик с ненулевой ценой bid или ask независимо от значений полей объема.
Объявление класса
//+------------------------------------------------------------------+ //| TickCollector.mqh | //| Session Volume Profile Engine | //+------------------------------------------------------------------+ #ifndef TICK_COLLECTOR_MQH #define TICK_COLLECTOR_MQH //+------------------------------------------------------------------+ //| Tick Collector Class | //+------------------------------------------------------------------+ class CTickCollector { private: MqlTick m_ticks[]; int m_count; int m_total_raw; public: CTickCollector(void); ~CTickCollector(void); bool Collect(const string symbol, datetime session_start, datetime session_end); int GetCount(void) const; double GetPrice(int index) const; long GetVolume(int index) const; };
Класс содержит три закрытых члена: массив исходных тиков m_ticks[], заполняемый функцией CopyTicksRange(), количество тиков, прошедших фильтр по цене (m_count), и общее количество тиков, полученных до фильтрации (m_total_raw). Разделение этих двух показателей важно для диагностики — когда m_total_raw имеет положительное значение, а m_count равно нулю, проблема заключается в логике фильтра, а не в самом вызове функции извлечения данных. Открытый интерфейс предоставляет метод Collect() для сбора данных и два метода доступа по индексу, которые CPriceHistogram вызывает при построении гистограммы.
Конструктор и деструктор
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CTickCollector::CTickCollector(void) : m_count(0), m_total_raw(0) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CTickCollector::~CTickCollector(void) { ArrayFree(m_ticks); }
Конструктор CTickCollector инициализирует оба счетчика нулями. Деструктор вызывает функцию ArrayFree(), чтобы освободить память кучи, занятую массивом m_ticks[]. Функцию ArrayFree() можно безопасно вызывать для массива, размер которого никогда не изменялся, поэтому предварительная проверка условия не требуется.
Collect
//+------------------------------------------------------------------+ //| Collect and filter session ticks using CopyTicksRange | //+------------------------------------------------------------------+ bool CTickCollector::Collect(const string symbol, datetime session_start, datetime session_end) { m_count = 0; m_total_raw = 0; ArrayFree(m_ticks); //--- Convert datetime boundaries to millisecond timestamps ulong from_ms = (ulong)session_start * 1000; ulong to_ms = (ulong)session_end * 1000; //--- Request all ticks within the session range int total = CopyTicksRange(symbol, m_ticks, COPY_TICKS_ALL, from_ms, to_ms); if(total <= 0) { PrintFormat("CopyTicksRange returned %d for %s [%s - %s]", total, symbol, TimeToString(session_start), TimeToString(session_end)); return(false); } m_total_raw = total; //--- Diagnostic: inspect first tick to understand broker volume fields if(total > 0) { PrintFormat("First tick — bid=%.5f ask=%.5f last=%.5f volume=%d volume_real=%.2f flags=%d", m_ticks[0].bid, m_ticks[0].ask, m_ticks[0].last, m_ticks[0].volume, m_ticks[0].volume_real, m_ticks[0].flags); } //--- Count valid ticks: any tick with a non-zero bid OR ask price //--- This handles CFD brokers that report zero in volume and volume_real for(int i = 0; i < total; i++) { bool has_price = (m_ticks[i].bid > 0.0 || m_ticks[i].ask > 0.0); bool in_window = (m_ticks[i].time >= session_start && m_ticks[i].time <= session_end); if(has_price && in_window) m_count++; } if(m_count <= 0) { PrintFormat("No valid price ticks found — raw=%d symbol=%s", total, symbol); return(false); } PrintFormat("CopyTicksRange: raw=%d valid=%d symbol=%s", m_total_raw, m_count, symbol); return(true); }
Метод Collect() сначала сбрасывает оба счетчика и освобождает ранее выделенный массив тиков, обеспечивая чистое исходное состояние перед каждым повторным построением профиля сессии. Границы временного диапазона типа datetime умножаются на 1000 для преобразования из секунд в миллисекунды — единицу измерения, которую CopyTicksRange() использует для параметров временных меток. В этом заключается ключевое отличие CopyTicksRange() от CopyTicks(): первая функция принимает явно заданную временную метку окончания, что позволяет точно ограничить выборку временным окном сессии. Вторая функция принимает количество тиков, которое не гарантирует соответствия границе сессии.
Блок диагностики первого тика выводит на вкладку "Эксперты" все шесть связанных с объемом полей первого полученного тика. Эта единственная строка вывода позволяет разработчику сразу определить, какие поля заполняет брокер, и не гадать, следует ли фильтровать тики по полю volume, по полю volume_real или только по ценовым полям.
Цикл фильтрации применяет правило, учитывающее особенности CFD: тик считается допустимым, если его цена bid или ask ненулевая и он попадает во временное окно сессии. Дополнительная проверка временных меток позволяет учесть крайние случаи, когда возвращаемые тики незначительно выходят за пределы запрошенного диапазона из-за внутреннего округления.
GetPrice
//+------------------------------------------------------------------+ //| Return the most meaningful price for a specific tick | //+------------------------------------------------------------------+ double CTickCollector::GetPrice(int index) const { if(index < 0 || index >= ArraySize(m_ticks)) return(0.0); //--- Priority: last traded price → mid price (bid+ask)/2 → bid alone if(m_ticks[index].last > 0.0) return(m_ticks[index].last); if(m_ticks[index].bid > 0.0 && m_ticks[index].ask > 0.0) return((m_ticks[index].bid + m_ticks[index].ask) * 0.5); return(m_ticks[index].bid); }
Метод GetPrice() использует трехуровневую стратегию выбора цены. Предпочтение отдается полю last, поскольку для биржевых инструментов оно содержит фактическую цену совершенной сделки. Если значение поля last равно нулю — как у всех CFD-брокеров, — используется средняя цена (bid + ask) * 0.5. Средняя цена точнее, чем одна лишь цена bid, поскольку она отражает справедливую стоимость между двумя котируемыми ценами, не отдавая предпочтения ни одной из сторон котировки. Если доступна только цена bid, она возвращается как последний резервный вариант. Проверка границ в начале метода предотвращает выход за пределы массива при некорректных вызовах со стороны модуля построения гистограммы.
GetVolume
//+------------------------------------------------------------------+ //| Return the best available volume weight for a specific tick | //+------------------------------------------------------------------+ long CTickCollector::GetVolume(int index) const { if(index < 0 || index >= ArraySize(m_ticks)) return(0); //--- Priority: integer volume → volume_real cast → count the tick as 1 if(m_ticks[index].volume > 0) return(m_ticks[index].volume); if(m_ticks[index].volume_real > 0.0) return((long)MathRound(m_ticks[index].volume_real)); //--- Broker reports no volume at all: treat each tick as unit weight return(1); } #endif // TICK_COLLECTOR_MQH
Метод GetVolume() использует ту же трехуровневую схему, что и GetPrice(). Для биржевых инструментов целочисленное поле volume содержит количество лотов, и его значение возвращается напрямую. Для инструментов, по которым передается дробный фактический объем, значение volume_real округляется до целого типа long. У CFD-брокеров, для которых оба поля равны нулю, метод возвращает 1. Этот последний резервный вариант превращает профиль в карту плотности тиков, где каждый тик добавляет одну единицу объема в свой ценовой интервал. Хотя такой подход не эквивалентен использованию фактического биржевого объема, он позволяет получать аналитически значимые профили для внебиржевых инструментов, по которым нет более качественных данных.
Модуль 3 — CPriceHistogram
Класс CPriceHistogram преобразует исходный массив тиков в вектор накопленных объемов по ценовым интервалам. Это основная структура данных, на основе которой рассчитываются точка контроля (POC) и зона стоимости.
Объявление класса
//+------------------------------------------------------------------+ //| PriceHistogram.mqh | //| Session Volume Profile Engine | //+------------------------------------------------------------------+ #ifndef PRICE_HISTOGRAM_MQH #define PRICE_HISTOGRAM_MQH #include "TickCollector.mqh" //+------------------------------------------------------------------+ //| Price Histogram Class | //+------------------------------------------------------------------+ class CPriceHistogram { private: double m_bin_volumes[]; double m_session_low; double m_session_high; double m_bin_size; int m_bin_count; double m_total_volume; string m_symbol; public: CPriceHistogram(void); ~CPriceHistogram(void); bool Build(const string symbol, double bin_size_points, const CTickCollector &collector); int GetBinCount(void) const; double GetBinVolume(int bin) const; double GetBinPrice(int bin) const; double GetSessionLow(void) const; double GetSessionHigh(void) const; double GetTotalVolume(void) const; void Reset(void); private: int PriceToBin(double price) const; };
Класс хранит массив объемов по ценовым интервалам m_bin_volumes[], ценовой диапазон сессии, заданный полями m_session_low и m_session_high, определенный размер ценового интервала в абсолютных единицах цены (m_bin_size), рассчитанное количество ценовых интервалов (m_bin_count) и суммарный накопленный объем по всем ценовым интервалам. Закрытый метод PriceToBin() инкапсулирует формулу дискретизации с округлением вниз, сосредоточивая вычисление индекса интервала в одном месте. Общедоступные методы доступа служат интерфейсом, через который классы CVolumeProfileCalculator и CProfileRenderer используют готовое распределение.
Конструктор, деструктор и сброс
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CPriceHistogram::CPriceHistogram(void) : m_session_low(0.0), m_session_high(0.0), m_bin_size(0.0), m_bin_count(0), m_total_volume(0.0) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CPriceHistogram::~CPriceHistogram(void) { ArrayFree(m_bin_volumes); } //+------------------------------------------------------------------+ //| Reset histogram state | //+------------------------------------------------------------------+ void CPriceHistogram::Reset(void) { ArrayFree(m_bin_volumes); m_session_low = 0.0; m_session_high = 0.0; m_bin_size = 0.0; m_bin_count = 0; m_total_volume = 0.0; }
Конструктор CPriceHistogram инициализирует все скалярные поля нулями. Деструктор освобождает массив объемов по ценовым интервалам. Метод Reset() явно вызывается из основного файла индикатора в начале каждого перестроения профиля сессии: он выполняет ту же очистку, что и деструктор, и обнуляет все скалярные поля, подготавливая объект к новому вызову Build() без уничтожения и повторного создания экземпляра. Это позволяет избежать дополнительных затрат на создание объектов при каждой смене сессии.
Build
//+------------------------------------------------------------------+ //| Build histogram from collected ticks | //+------------------------------------------------------------------+ bool CPriceHistogram::Build(const string symbol, double bin_size_points, const CTickCollector &collector) { int tick_count = collector.GetCount(); if(tick_count <= 0) return(false); //--- Resolve bin size in price units double point = SymbolInfoDouble(symbol, SYMBOL_POINT); m_bin_size = bin_size_points * point; m_symbol = symbol; //--- First pass: find session high and low m_session_low = collector.GetPrice(0); m_session_high = collector.GetPrice(0); for(int i = 1; i < tick_count; i++) { double p = collector.GetPrice(i); if(p < m_session_low) m_session_low = p; if(p > m_session_high) m_session_high = p; } //--- Calculate number of price bins m_bin_count = (int)MathCeil((m_session_high - m_session_low) / m_bin_size) + 1; if(m_bin_count <= 0 || m_bin_count > 10000) return(false); //--- Allocate and zero the bin volume array ArrayResize(m_bin_volumes, m_bin_count); ArrayInitialize(m_bin_volumes, 0.0); //--- Second pass: accumulate volume into bins m_total_volume = 0.0; for(int i = 0; i < tick_count; i++) { double price = collector.GetPrice(i); long vol = collector.GetVolume(i); int bin = PriceToBin(price); if(bin >= 0 && bin < m_bin_count) { m_bin_volumes[bin] += (double)vol; m_total_volume += (double)vol; } } return(true); }
Функция Build() выполняется в два последовательных прохода по данным тиков. В ходе первого прохода определяется диапазон цен, по которым велась торговля в течение сессии: для этого среди всех цен тиков находятся минимальное и максимальное значения. Перед этим проходом по данным заданный пользователем размер ценового интервала в пунктах умножается на SYMBOL_POINT, чтобы преобразовать его в абсолютную разницу цен. Эта нормализация необходима для работы с разными инструментами: размер пункта для EURUSD составляет 0,00001, а для XAUUSD — 0,01. Без нормализации одно и то же входное значение давало бы совершенно разную детализацию группировки по ценовым интервалам на разных инструментах.
Количество ценовых интервалов рассчитывается на основе наблюдаемого диапазона цен. При этом предусмотрены проверки на неположительное количество интервалов и на превышение предела в 10 000 интервалов, которое указывало бы на чрезмерно малый размер ценового интервала относительно диапазона цен сессии. Эта защита предотвращает как исчерпание памяти, так и появление бессмысленных профилей.
Во втором проходе средняя цена каждого тика преобразуется в индекс ценового интервала с помощью PriceToBin(), а вес по объему этого тика добавляется к накопленному объему соответствующего интервала. Проверка индекса ценового интервала bin на допустимый диапазон внутри цикла служит последним уровнем защиты на тот редкий случай, когда из-за вычислений с плавающей запятой в PriceToBin() получается индекс на границе массива или за ее пределами.
PriceToBin
//+------------------------------------------------------------------+ //| Map price to bin index | //+------------------------------------------------------------------+ int CPriceHistogram::PriceToBin(double price) const { return((int)MathFloor((price - m_session_low) / m_bin_size)); }
Метод PriceToBin() непосредственно реализует формулу дискретизации с округлением вниз. Вычитание m_session_low сдвигает диапазон цен к нулю, так что самая низкая цена торгов всегда соответствует индексу 0. Деление на m_bin_size дает дробное значение позиции в массиве ценовых интервалов. Функция MathFloor() выполняет округление вниз до целочисленного индекса ценового интервала, благодаря чему все цены в полуоткрытом интервале [lower_edge, lower_edge + bin_size) получают один и тот же индекс.
Методы доступа
//+------------------------------------------------------------------+ //| Return accumulated volume for a specific bin | //+------------------------------------------------------------------+ double CPriceHistogram::GetBinVolume(int bin) const { if(bin < 0 || bin >= m_bin_count) return(0.0); return(m_bin_volumes[bin]); } //+------------------------------------------------------------------+ //| Return the reference price (lower edge) of a specific bin | //+------------------------------------------------------------------+ double CPriceHistogram::GetBinPrice(int bin) const { return(m_session_low + bin * m_bin_size); } //+------------------------------------------------------------------+ //| Accessor methods | //+------------------------------------------------------------------+ int CPriceHistogram::GetBinCount(void) const { return(m_bin_count); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ double CPriceHistogram::GetSessionLow(void) const { return(m_session_low); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ double CPriceHistogram::GetSessionHigh(void) const { return(m_session_high); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ double CPriceHistogram::GetTotalVolume(void) const { return(m_total_volume); } #endif // PRICE_HISTOGRAM_MQH
Метод GetBinVolume() проверяет границы массива и возвращает ноль для индексов вне допустимого диапазона, предотвращая обращение за пределы массива. Это важно, поскольку алгоритм расширения зоны стоимости в CVolumeProfileCalculator вызывает этот метод для граничных индексов в рамках проверки условия завершения. Функция GetBinPrice() восстанавливает нижнюю границу ценового интервала по минимальной цене сессии и индексу ценового интервала, выполняя преобразование, обратное формуле PriceToBin(). Полученная цена служит ценовой координатой при отрисовке каждой полосы гистограммы на графике.
Модуль 4 — CVolumeProfileCalculator
CVolumeProfileCalculator работает исключительно с готовой гистограммой. Он определяет точку контроля (POC) и расширяет зону стоимости от нее в обе стороны, находя ее границы с помощью стандартного алгоритма жадного расширения до достижения 70% объема.
Объявление класса
//+------------------------------------------------------------------+ //| VolumeProfileCalculator.mqh | //| Session Volume Profile Engine | //+------------------------------------------------------------------+ #ifndef VOLUME_PROFILE_CALCULATOR_MQH #define VOLUME_PROFILE_CALCULATOR_MQH #include "PriceHistogram.mqh" //+------------------------------------------------------------------+ //| Volume Profile Calculator Class | //+------------------------------------------------------------------+ class CVolumeProfileCalculator { private: int m_poc_bin; double m_poc_price; double m_vah_price; double m_val_price; public: CVolumeProfileCalculator(void); ~CVolumeProfileCalculator(void); bool Calculate(const CPriceHistogram &histogram, double value_area_percent); double GetPOC(void) const; double GetVAH(void) const; double GetVAL(void) const; };
Класс хранит четыре закрытых скалярных поля: индекс ценового интервала POC, соответствующую ему цену, а также цены VAH и VAL. Единственный вычислительный метод Calculate() принимает гистограмму по константной ссылке и целевую долю объема зоны стоимости в процентах. Обычно эта доля равна 70.0, но задается параметром, чтобы можно было экспериментировать. Вся предметная логика сосредоточена в Calculate() — три метода доступа лишь возвращают сохраненные им результаты.
Конструктор и деструктор
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CVolumeProfileCalculator::CVolumeProfileCalculator(void) : m_poc_bin(0), m_poc_price(0.0), m_vah_price(0.0), m_val_price(0.0) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CVolumeProfileCalculator::~CVolumeProfileCalculator(void) { }
Конструктор CVolumeProfileCalculator инициализирует все четыре поля результатов нулями. Деструктор пуст, поскольку класс не выделяет память в куче: все данные считываются из гистограммы, переданной в Calculate() по ссылке, а результаты хранятся по значению в четырех скалярных полях.
Calculate
//+------------------------------------------------------------------+ //| Calculate POC and Value Area | //+------------------------------------------------------------------+ bool CVolumeProfileCalculator::Calculate(const CPriceHistogram &histogram, double value_area_percent) { int bin_count = histogram.GetBinCount(); double total_volume = histogram.GetTotalVolume(); if(bin_count <= 0 || total_volume <= 0.0) return(false); //--- Locate the Point of Control m_poc_bin = 0; double max_volume = histogram.GetBinVolume(0); for(int i = 1; i < bin_count; i++) { double v = histogram.GetBinVolume(i); if(v > max_volume) { max_volume = v; m_poc_bin = i; } } m_poc_price = histogram.GetBinPrice(m_poc_bin); //--- Compute the volume threshold for the Value Area double va_threshold = total_volume * (value_area_percent / 100.0); double va_volume = histogram.GetBinVolume(m_poc_bin); int upper_bin = m_poc_bin; int lower_bin = m_poc_bin; //--- Expand the Value Area outward from the POC while(va_volume < va_threshold) { double vol_above = (upper_bin + 1 < bin_count) ? histogram.GetBinVolume(upper_bin + 1) : -1.0; double vol_below = (lower_bin - 1 >= 0) ? histogram.GetBinVolume(lower_bin - 1) : -1.0; if(vol_above < 0.0 && vol_below < 0.0) break; //--- Add the side with greater volume if(vol_above >= vol_below) { upper_bin++; va_volume += vol_above; } else { lower_bin--; va_volume += vol_below; } } m_vah_price = histogram.GetBinPrice(upper_bin); m_val_price = histogram.GetBinPrice(lower_bin); return(true); }
Метод Calculate() работает в два логических этапа. На первом этапе выполняется линейный проход по всем M ценовым интервалам для определения интервала с максимальным объемом. В начале прохода кандидатом выбирается ценовой интервал с индексом 0. При обнаружении интервала с большим объемом кандидат обновляется. После прохода GetBinPrice() преобразует индекс ценового интервала с максимальным объемом в ценовую координату, которая сохраняется в m_poc_price.
На втором этапе реализуется алгоритм жадного расширения зоны стоимости. Целевой объем рассчитывается по формуле: total_volume × (value_area_percent / 100.0). Накопитель va_volume инициализируется объемом ценового интервала POC, а оба указателя границ, upper_bin и lower_bin, изначально указывают на этот интервал. На каждой итерации определяется объем в ценовом интервале непосредственно выше текущей верхней границы и в интервале непосредственно ниже текущей нижней границы. Когда граница достигает края гистограммы, для объема с этой стороны задается сигнальное значение -1.0, которое при сравнении всегда уступает фактическому объему с другой стороны. Когда дальнейшее расширение невозможно с обеих сторон, оператор break завершает цикл. По правилу жадного расширения к зоне всегда добавляется соседний ценовой интервал с большим объемом. Благодаря этому зона стоимости остается максимально компактной вокруг точки контроля (POC), что соответствует общепринятому правилу такого расчета.
Методы доступа
//+------------------------------------------------------------------+ //| Accessor: Point of Control price | //+------------------------------------------------------------------+ double CVolumeProfileCalculator::GetPOC(void) const { return(m_poc_price); } //+------------------------------------------------------------------+ //| Accessor: Value Area High price | //+------------------------------------------------------------------+ double CVolumeProfileCalculator::GetVAH(void) const { return(m_vah_price); } //+------------------------------------------------------------------+ //| Accessor: Value Area Low price | //+------------------------------------------------------------------+ double CVolumeProfileCalculator::GetVAL(void) const { return(m_val_price); } #endif // VOLUME_PROFILE_CALCULATOR_MQH
Методы GetPOC(), GetVAH() и GetVAL() предоставляют три рассчитанных ценовых уровня классу CProfileRenderer для размещения графических объектов, а также классу CProfileStatistics для вывода диагностической информации. Эти значения корректны только после того, как метод Calculate() вернет true.
Модуль 5 — CProfileRenderer
CProfileRenderer преобразует гистограмму и ключевые ценовые уровни в видимые графические объекты. Он поддерживает два режима отрисовки: режим фиксированной ширины, в котором полоса гистограммы на уровне POC всегда занимает заданное пользователем число баров графика, и пропорциональный режим, в котором ширина полос гистограммы масштабируется в соответствии с фактической продолжительностью сессии. Режим фиксированной ширины используется по умолчанию, поскольку обеспечивает читаемость профилей на любом таймфрейме.
Объявление класса
//+------------------------------------------------------------------+ //| ProfileRenderer.mqh | //| Session Volume Profile Engine | //+------------------------------------------------------------------+ #ifndef PROFILE_RENDERER_MQH #define PROFILE_RENDERER_MQH #include "PriceHistogram.mqh" //+------------------------------------------------------------------+ //| Profile Renderer Class | //+------------------------------------------------------------------+ class CProfileRenderer { private: string m_prefix; color m_bar_color; color m_poc_color; color m_vah_color; color m_val_color; int m_bar_width; int m_fixed_bar_count; bool m_use_fixed_width; public: CProfileRenderer(void); ~CProfileRenderer(void); void Configure(string prefix, color bar_color, color poc_color, color vah_color, color val_color, int bar_width, int fixed_bar_count, bool use_fixed_width); void RemoveSessionObjects(void); void Render(const CPriceHistogram &histogram, double poc_price, double vah_price, double val_price, datetime session_start, datetime session_end); private: void DrawBar(int bin, double bin_price, double volume, double max_volume, datetime session_end, long bar_span_seconds); void DrawHLine(string name, double price, datetime session_start, datetime session_end, color line_color, int line_style); long ResolveBarSpan(datetime session_start, datetime session_end); };
Класс содержит восемь закрытых полей, задающих визуальные параметры и режим отрисовки. m_prefix — это строка, добавляемая в начало имени каждого графического объекта, создаваемого этим модулем отрисовки. Она обеспечивает однозначное определение объектов для удаления, позволяя методу RemoveSessionObjects() находить все объекты этого модуля без ведения отдельного реестра. Два поля режима — m_fixed_bar_count и m_use_fixed_width — управляют работой ResolveBarSpan(), ключевого метода, обеспечивающего независимость профиля от таймфрейма. Три закрытых метода отвечают за три отдельные операции отрисовки: вычисление ширины полос гистограммы, отрисовку отдельных полос гистограммы и отрисовку линий ключевых уровней.
Конструктор и деструктор
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CProfileRenderer::CProfileRenderer(void) : m_prefix("SVP_"), m_bar_color(clrSteelBlue), m_poc_color(clrYellow), m_vah_color(clrLimeGreen), m_val_color(clrRed), m_bar_width(2), m_fixed_bar_count(20), m_use_fixed_width(true) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CProfileRenderer::~CProfileRenderer(void) { }
Конструктор CProfileRenderer задает разумные значения по умолчанию для всех визуальных параметров и включает режим фиксированной ширины, благодаря чему индикатор сразу выводит читаемую гистограмму на любом таймфрейме, не требуя от пользователя предварительной настройки параметров. Деструктор пуст, поскольку графические объекты принадлежат терминалу MetaTrader и управляются им, а не этим классом: очистка выполняется явно через RemoveSessionObjects(), а не при уничтожении экземпляра класса.
Configure
//+------------------------------------------------------------------+ //| Configure renderer parameters | //+------------------------------------------------------------------+ void CProfileRenderer::Configure(string prefix, color bar_color, color poc_color, color vah_color, color val_color, int bar_width, int fixed_bar_count, bool use_fixed_width) { m_prefix = prefix; m_bar_color = bar_color; m_poc_color = poc_color; m_vah_color = vah_color; m_val_color = val_color; m_bar_width = bar_width; m_fixed_bar_count = fixed_bar_count; m_use_fixed_width = use_fixed_width; }
Метод Configure() переносит все заданные пользователем входные параметры из основного файла индикатора в закрытые поля модуля отрисовки за один вызов из OnInit(). Отделение настройки от создания позволяет перенастраивать тот же экземпляр модуля отрисовки без повторного создания и устраняет зависимость конструктора от системы входных параметров индикатора.
RemoveSessionObjects
//+------------------------------------------------------------------+ //| Remove all chart objects belonging to this session | //+------------------------------------------------------------------+ void CProfileRenderer::RemoveSessionObjects(void) { long chart_id = ChartID(); int total = ObjectsTotal(chart_id, 0, -1); //--- Iterate in reverse to safely delete during traversal for(int i = total - 1; i >= 0; i--) { string name = ObjectName(chart_id, i, 0, -1); if(StringFind(name, m_prefix) == 0) ObjectDelete(chart_id, name); } }
Метод RemoveSessionObjects() перебирает все графические объекты в порядке убывания индексов и удаляет те, чьи имена начинаются со строки m_prefix. Обход в обратном порядке обязателен: ObjectDelete() немедленно уменьшает значение, возвращаемое ObjectsTotal(), поэтому при прямом обходе после первого удаления пропускался бы каждый второй объект. Обход в обратном порядке позволяет избежать этого, поскольку обработка всегда идет с текущего конца списка. Соглашение об использовании префикса гарантирует, что удаляются только объекты этого экземпляра индикатора, а объекты, созданные другими индикаторами или размещенные вручную, остаются нетронутыми.
ResolveBarSpan
//+------------------------------------------------------------------+ //| Resolve the time span in seconds for the maximum histogram bar | //+------------------------------------------------------------------+ long CProfileRenderer::ResolveBarSpan(datetime session_start, datetime session_end) { if(m_use_fixed_width) { //--- Fixed mode: POC bar spans exactly m_fixed_bar_count chart bars long period_seconds = (long)PeriodSeconds(); return(period_seconds * m_fixed_bar_count); } //--- Proportional mode: POC bar spans the full session duration return((long)(session_end - session_start)); }
ResolveBarSpan() — это метод, обеспечивающий адаптацию профиля к таймфрейму. В режиме фиксированной ширины функция PeriodSeconds() возвращает период текущего графика в секундах — 60 для M1, 3600 для H1, 14400 для H4. Умножение на m_fixed_bar_count дает временной интервал, который всегда соответствует именно такому числу видимых баров на текущем графике независимо от активного таймфрейма. При просмотре лондонской сессии на графике H1 с параметром m_fixed_bar_count = 15 получается полоса гистограммы POC шириной 15 часов — она хорошо различима. При просмотре той же сессии на графике H4 с параметром m_fixed_bar_count = 6 получается полоса POC шириной 24 часа. Она также хорошо различима и визуально соразмерна расстоянию между свечами на графике H4. В пропорциональном режиме возвращается полная продолжительность сессии, в результате чего полоса POC занимает всё окно сессии. Этот режим наиболее полезен на таймфрейме, ближайшем по длительности к сессии.
Render
//+------------------------------------------------------------------+ //| Render full volume profile | //+------------------------------------------------------------------+ void CProfileRenderer::Render(const CPriceHistogram &histogram, double poc_price, double vah_price, double val_price, datetime session_start, datetime session_end) { int bin_count = histogram.GetBinCount(); double max_volume = 0.0; //--- Find maximum bin volume for bar scaling for(int i = 0; i < bin_count; i++) { double v = histogram.GetBinVolume(i); if(v > max_volume) max_volume = v; } if(max_volume <= 0.0) return; //--- Resolve the time span for the longest bar long bar_span_seconds = ResolveBarSpan(session_start, session_end); //--- Draw histogram bars for(int i = 0; i < bin_count; i++) { double bin_price = histogram.GetBinPrice(i); double bin_volume = histogram.GetBinVolume(i); if(bin_volume > 0.0) DrawBar(i, bin_price, bin_volume, max_volume, session_end, bar_span_seconds); } //--- Draw POC line DrawHLine(m_prefix + "POC", poc_price, session_start, session_end, m_poc_color, STYLE_SOLID); //--- Draw VAH line DrawHLine(m_prefix + "VAH", vah_price, session_start, session_end, m_vah_color, STYLE_DASH); //--- Draw VAL line DrawHLine(m_prefix + "VAL", val_price, session_start, session_end, m_val_color, STYLE_DASH); ChartRedraw(); }
Render() — это публичная точка входа, которая последовательно выполняет все операции отрисовки. Сначала гистограмма сканируется в последний раз для определения максимального объема ценового интервала — это значение необходимо для нормализации ширины всех полос гистограммы относительно полосы POC. Затем один раз вызывается функция ResolveBarSpan(), чтобы определить временной интервал полосы гистограммы POC, который передается при каждом вызове функции DrawBar(). Ценовые интервалы с нулевым объемом полностью пропускаются, чтобы избежать создания объектов нулевой ширины. После размещения полос гистограммы функция DrawHLine() вызывается три раза для уровней POC, VAH и VAL. Завершающий вызов ChartRedraw() отображает все отложенные изменения объектов за одну операцию перерисовки вместо обновления экрана после создания каждого отдельного объекта.
DrawBar
//+------------------------------------------------------------------+ //| Draw a single histogram bar anchored to session end | //+------------------------------------------------------------------+ void CProfileRenderer::DrawBar(int bin, double bin_price, double volume, double max_volume, datetime session_end, long bar_span_seconds) { //--- Scale bar length proportionally to the maximum bin volume double ratio = volume / max_volume; long secs = (long)MathRound((double)bar_span_seconds * ratio); datetime bar_start = session_end - (datetime)secs; datetime bar_end = session_end; string name = m_prefix + "BAR_" + IntegerToString(bin); if(ObjectFind(ChartID(), name) < 0) ObjectCreate(ChartID(), name, OBJ_TREND, 0, bar_start, bin_price, bar_end, bin_price); else { //--- Update anchor times if object already exists ObjectSetInteger(ChartID(), name, OBJPROP_TIME, 0, bar_start); ObjectSetInteger(ChartID(), name, OBJPROP_TIME, 1, bar_end); ObjectSetDouble(ChartID(), name, OBJPROP_PRICE, 0, bin_price); ObjectSetDouble(ChartID(), name, OBJPROP_PRICE, 1, bin_price); } ObjectSetInteger(ChartID(), name, OBJPROP_COLOR, m_bar_color); ObjectSetInteger(ChartID(), name, OBJPROP_WIDTH, m_bar_width); ObjectSetInteger(ChartID(), name, OBJPROP_STYLE, STYLE_SOLID); ObjectSetInteger(ChartID(), name, OBJPROP_RAY, false); ObjectSetInteger(ChartID(), name, OBJPROP_SELECTABLE, false); }
Функция DrawBar() отображает один ценовой интервал в виде горизонтальной линии OBJ_TREND. Нормирующее отношение volume / max_volume переводит объем каждого ценового интервала в диапазон [0, 1], а умножение на bar_span_seconds преобразует это отношение в длину по оси времени. Правая точка привязки каждой полосы гистограммы зафиксирована на session_end, поэтому все полосы гистограммы выровнены правым краем по границе сессии, а их левые точки привязки смещены влево пропорционально объему. Если задать обеим точкам привязки одну и ту же цену bin_price, линия тренда станет горизонтальной. В ветке else обновляются координаты точек привязки уже существующего объекта вместо его повторного создания, что эффективнее при обновлении профиля в течение сессии. Значение OBJPROP_RAY = false не позволяет линии продолжаться за пределы точек привязки в соседние сессии.
DrawHLine
//+------------------------------------------------------------------+ //| Draw a horizontal key level line extending rightward | //+------------------------------------------------------------------+ void CProfileRenderer::DrawHLine(string name, double price, datetime session_start, datetime session_end, color line_color, int line_style) { if(ObjectFind(ChartID(), name) < 0) ObjectCreate(ChartID(), name, OBJ_TREND, 0, session_start, price, session_end, price); ObjectSetInteger(ChartID(), name, OBJPROP_COLOR, line_color); ObjectSetInteger(ChartID(), name, OBJPROP_WIDTH, 2); ObjectSetInteger(ChartID(), name, OBJPROP_STYLE, line_style); ObjectSetInteger(ChartID(), name, OBJPROP_RAY_RIGHT, true); ObjectSetInteger(ChartID(), name, OBJPROP_RAY_LEFT, false); ObjectSetInteger(ChartID(), name, OBJPROP_SELECTABLE, false); } #endif // PROFILE_RENDERER_MQH
Функция DrawHLine() создает горизонтальную линию тренда на указанном ценовом уровне на всю сессию — от session_start до session_end. Основное свойство, отличающее линии ключевых уровней от полос гистограммы, — OBJPROP_RAY_RIGHT = true. Оно продлевает линию неограниченно вправо за session_end. Благодаря этому уровни POC, VAH и VAL остаются видимыми независимо от того, насколько далеко график прокручен вперед по времени, что крайне важно для удобства работы, поскольку на эти уровни ориентируются в следующей сессии. Значение OBJPROP_RAY_LEFT = false не позволяет линии продолжаться влево в предыдущие сессии, обеспечивая четкое визуальное разделение профилей последовательных сессий.
Модуль 6 — CProfileStatistics
После каждого успешного построения профиля CProfileStatistics выводит на вкладку "Эксперты" в MetaTrader структурированный диагностический отчет с полной сводкой о выполнении конвейера обработки.
Объявление класса, конструктор, деструктор и метод Print
//+------------------------------------------------------------------+ //| ProfileStatistics.mqh | //| Session Volume Profile Engine | //+------------------------------------------------------------------+ #ifndef PROFILE_STATISTICS_MQH #define PROFILE_STATISTICS_MQH //+------------------------------------------------------------------+ //| Profile Statistics Class | //+------------------------------------------------------------------+ class CProfileStatistics { public: CProfileStatistics(void); ~CProfileStatistics(void); void Print(int tick_count, int bin_count, double poc_price, double vah_price, double val_price, int object_count); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CProfileStatistics::CProfileStatistics(void) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CProfileStatistics::~CProfileStatistics(void) { } //+------------------------------------------------------------------+ //| Print session diagnostic report | //+------------------------------------------------------------------+ void CProfileStatistics::Print(int tick_count, int bin_count, double poc_price, double vah_price, double val_price, int object_count) { PrintFormat("Session Build Started"); PrintFormat("Ticks Collected = %d", tick_count); PrintFormat("Price Bins = %d", bin_count); PrintFormat("POC = %.5f", poc_price); PrintFormat("VAH = %.5f", vah_price); PrintFormat("VAL = %.5f", val_price); PrintFormat("Objects Rendered = %d", object_count); } #endif // PROFILE_STATISTICS_MQH //+------------------------------------------------------------------+
У класса CProfileStatistics нет закрытых полей, и он не выделяет память в куче, поэтому его конструктор и деструктор пусты. Единственное назначение этого класса — вынести вызовы PrintFormat() из основного файла индикатора, чтобы можно было перенаправлять, отключать или расширять диагностический вывод, не затрагивая другие модули.
Метод Print() выводит на вкладку "Эксперты" семь строк, охватывающих все этапы конвейера обработки. Количество тиков подтверждает, что CTickCollector успешно получил данные. Количество ценовых интервалов подтверждает, что CPriceHistogram построил невырожденное распределение. Три ценовых уровня подтверждают, что CVolumeProfileCalculator дал правдоподобные результаты. Количество объектов служит итоговой арифметической проверкой: для профиля с B ценовыми интервалами ожидаемое количество объектов составляет B + 3 (по одному объекту на ценовой интервал плюс POC, VAH и VAL). Несоответствие между количеством ценовых интервалов и количеством объектов указывает на то, что некоторые объекты не удалось создать. Обычно это означает, что достигнут лимит количества объектов на графике.
Ожидаемый вывод на вкладке "Эксперты" после успешного построения профиля:
Session Build Started Ticks Collected = 3611 Price Bins = 87 POC = 1733.88500 VAH = 1735.38500 VAL = 1731.98500 Objects Rendered = 91
Модуль 7 — SessionVolumeProfile.mq5
В главном файле индикатора объявляются все входные параметры, создаются шесть объектов модулей в виде глобальных переменных и координируется работа всего конвейера обработки с помощью трех обработчиков событий.
Объявления и входные параметры
//+------------------------------------------------------------------+ //| SessionVolumeProfile.mq5 | //+------------------------------------------------------------------+ #property indicator_chart_window #property indicator_buffers 0 #property indicator_plots 0 #include <Session_Volume_Profile_Builder\SessionManager.mqh> #include <Session_Volume_Profile_Builder\TickCollector.mqh> #include <Session_Volume_Profile_Builder\PriceHistogram.mqh> #include <Session_Volume_Profile_Builder\VolumeProfileCalculator.mqh> #include <Session_Volume_Profile_Builder\ProfileRenderer.mqh> #include <Session_Volume_Profile_Builder\ProfileStatistics.mqh> //--- Inputs input ENUM_SESSION_TYPE InpSessionType = SESSION_LONDON; // Session type input int InpStartHour = 8; // Custom start hour input int InpStartMinute = 0; // Custom start minute input int InpEndHour = 17; // Custom end hour input int InpEndMinute = 0; // Custom end minute input int InpBinSizePoints = 10; // Bin size (points) input double InpValueAreaPercent = 70.0; // Value Area percentage input color InpBarColor = clrSteelBlue; // Histogram bar color input color InpPOCColor = clrYellow; // POC line color input color InpVAHColor = clrLimeGreen; // VAH line color input color InpVALColor = clrRed; // VAL line color input int InpBarWidth = 2; // Bar line width input string InpPrefix = "SVP_"; // Object name prefix input bool InpFixedWidth = true; // Use fixed bar width mode input int InpFixedBarCount = 20; // POC bar width (chart bars) //--- Global instances CSessionManager g_session_mgr; CTickCollector g_tick_collector; CPriceHistogram g_histogram; CVolumeProfileCalculator g_calculator; CProfileRenderer g_renderer; CProfileStatistics g_statistics;
Директивы indicator buffers 0 и indicator plots 0 указывают, что индикатор не использует буферы данных и не выполняет отрисовку на их основе. Все визуальные элементы отрисовываются с помощью графических объектов. В цепочке #include перечислены шесть заголовочных файлов в строгом порядке зависимости: PriceHistogram.mqh зависит от TickCollector.mqh, VolumeProfileCalculator.mqh зависит от PriceHistogram.mqh, а ProfileRenderer.mqh также зависит от PriceHistogram.mqh. Пятнадцать входных параметров позволяют пользователю настраивать все предусмотренные аспекты работы системы в диалоговом окне свойств индикатора. Шесть глобальных экземпляров модулей объявлены в области видимости файла, поэтому они существуют на протяжении всего времени работы индикатора.
OnInit
//+------------------------------------------------------------------+ //| Indicator Initialization | //+------------------------------------------------------------------+ int OnInit(void) { g_session_mgr.Configure(InpSessionType, InpStartHour, InpStartMinute, InpEndHour, InpEndMinute); g_renderer.Configure(InpPrefix, InpBarColor, InpPOCColor, InpVAHColor, InpVALColor, InpBarWidth, InpFixedBarCount, InpFixedWidth); return(INIT_SUCCEEDED); }
Функция OnInit() настраивает только два модуля, которые используют параметры, заданные пользователем. Модулю g_session_mgr требуются тип сессии и время ее начала и окончания. Модулю g_renderer требуются все настройки внешнего вида и режима отрисовки. Четыре оставшихся экземпляра модулей — g_tick_collector, g_histogram, g_calculator и g_statistics — не требуют настройки, поскольку они полностью управляются данными, которые получают во время выполнения через параметры своих методов.
OnDeinit
//+------------------------------------------------------------------+ //| Indicator Deinitialization | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { g_renderer.RemoveSessionObjects(); }
Функция OnDeinit() полностью делегирует очистку методу g_renderer.RemoveSessionObjects(). Без этого вызова все полосы гистограммы и линии ключевых уровней оставались бы на графике на неопределенный срок после удаления индикатора, превращаясь в объекты, которыми больше не управляет никакой выполняющийся код. Параметр reason принимается, но не используется — очистка выполняется безусловно, независимо от того, был ли индикатор удален пользователем, заменен после повторной компиляции или удален при перезапуске терминала.
OnCalculate
//+------------------------------------------------------------------+ //| Indicator Calculation | //+------------------------------------------------------------------+ 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 < 1) return(0); //--- Suppress tick-driven recalculation; only process on new bar if(prev_calculated == rates_total) return(rates_total); datetime current_time = time[rates_total - 1]; bool is_new = g_session_mgr.Update(current_time); if(!is_new) return(rates_total); //--- Remove previous session objects g_renderer.RemoveSessionObjects(); //--- Collect ticks for the new session datetime session_start = g_session_mgr.GetSessionStart(); datetime session_end = g_session_mgr.GetSessionEnd(); bool collected = g_tick_collector.Collect(_Symbol, session_start, session_end); if(!collected) return(rates_total); //--- Build the price histogram g_histogram.Reset(); bool built = g_histogram.Build(_Symbol, InpBinSizePoints, g_tick_collector); if(!built) return(rates_total); //--- Calculate POC and Value Area bool calculated = g_calculator.Calculate(g_histogram, InpValueAreaPercent); if(!calculated) return(rates_total); //--- Render the profile g_renderer.Render(g_histogram, g_calculator.GetPOC(), g_calculator.GetVAH(), g_calculator.GetVAL(), session_start, session_end); //--- Print diagnostics int object_count = ObjectsTotal(ChartID(), 0, -1); g_statistics.Print(g_tick_collector.GetCount(), g_histogram.GetBinCount(), g_calculator.GetPOC(), g_calculator.GetVAH(), g_calculator.GetVAL(), object_count); return(rates_total); }
Функция OnCalculate() управляет последовательностью этапов конвейера обработки. Она не реализует собственной логики предметной области — каждое решение делегируется соответствующему модулю, а сама функция отвечает лишь за правильную последовательность этих вызовов и передачу сигналов о сбоях на более высокий уровень.
Первая защитная проверка if(prev_calculated == rates_total) предотвращает пересчет при поступлении тиков. На графике M1 функция OnCalculate() вызывается при поступлении каждого ценового тика — потенциально много раз в минуту. Когда prev_calculated равно rates_total, с момента последнего вызова не сформировался ни один новый бар, и функция немедленно завершает работу со сложностью O(1). Таким образом, проверка начала новой сессии выполняется не при поступлении каждого тика, а при появлении нового бара. Это гарантирует, что процесс перестроения профиля запускается не чаще одного раза на новый бар.
Вторая защитная проверка if(!is_new) обрабатывает типичный случай, когда сформировался новый бар, но граница сессии не изменилась. Подавляющее большинство событий, связанных с барами, обрабатывается по этому пути с практически нулевыми затратами ресурсов.
При обнаружении новой сессии этапы конвейера обработки выполняются строго в порядке, определяемом их зависимостями. Старые графические объекты удаляются до создания новых, что предотвращает визуальное наложение объектов последовательных сессий. На каждом этапе проверяется возвращаемое значение, и в случае сбоя конвейер обработки прерывается — если CTickCollector::Collect() возвращает false из-за недоступности истории тиков, ни модуль построения гистограммы, ни модуль отрисовки не вызываются. Затем диагностические данные, выводимые функцией CProfileStatistics::Print(), позволяют определить, на каком этапе произошел сбой и по какой причине.
Сводка объектов отрисовки
| Шаблон имени объекта | Тип | Назначение |
|---|---|---|
| SVP_BAR_N | OBJ_TREND (горизонтальный) | По одной полосе гистограммы на каждый непустой ценовой интервал |
| SVP_POC | OBJ_TREND (луч вправо) | Уровень точки контроля |
| SVP_VAH | OBJ_TREND (луч вправо) | Уровень верхней границы зоны стоимости |
| SVP_VAL | OBJ_TREND (луч вправо) | Уровень нижней границы зоны стоимости |

Сессионный профиль объема на графике ETHUSD H1: полосы гистограммы (синие), точка контроля (желтая линия), верхняя граница зоны стоимости (зеленая пунктирная линия) и нижняя граница зоны стоимости (красная пунктирная линия).
Рекомендуемое фиксированное число баров в зависимости от таймфрейма
Параметр InpFixedBarCount определяет ширину полосы POC, выраженную в барах графика. Ширина полос всех остальных ценовых интервалов масштабируется пропорционально в пределах этого максимума. Следующие значения позволяют получить наглядные профили на наиболее распространенных таймфреймах:
| Таймфрейм | Рекомендуемое значение InpFixedBarCount | Временной охват полосы гистограммы POC |
|---|---|---|
| M1 | 30 | 30 минут |
| M5 | 20 | 100 минут |
| H1 | 15 | 15 часов |
| H4 | 6 | 24 часа (при таймфрейме H4 и InpFixedBarCount = 6: 6 × 4 ч = 24 ч) |
| D1 | 5 | 5 дней |
Установка InpFixedWidth = false в диалоговом окне входных параметров возвращает индикатор в пропорциональный режим, в котором ширина полосы гистограммы POC соответствует полной длительности сессии. Этот режим обеспечивает наиболее точное с геометрической точки зрения отображение временной структуры сессии, однако на таймфреймах, значительно превышающих длительность самой сессии, изображение становится визуально сжатым.
Ограничения
- Тиковый объем как приближенный показатель: индикатор измеряет плотность тиков, а не фактический объем совершенных сделок. В условиях низкой ликвидности (в часы перед сессией, в праздничные дни, а также незадолго до запланированных публикаций новостей и после них) корреляция между количеством тиков и фактическим потоком ордеров ослабевает. Профили, построенные в эти периоды, имеют меньшую аналитическую значимость.
- Доступность истории тиков: функция CopyTicksRange() считывает данные из локального кэша базы тиков терминала. В только что установленном терминале или на демо-счете, для которого ранее не загружалась история тиков по нужному инструменту за указанный период, функция возвращает ноль тиков. Прокрутка вкладки "Тики" в окне "Обзор рынка" для соответствующего символа заставляет терминал загрузить и сохранить в кэше необходимую историю.
- Поля объема CFD: у розничных брокеров CFD значения "volume" и "volume_real" обычно равны нулю для всех тиков. Индикатор присваивает каждому тику вес в одну единицу объема, формируя профиль плотности тиков. Это единственный подход, доступный для таких инструментов. Он дает полезные для анализа результаты, но не эквивалентен профилю фактического объема по ценовым уровням, построенному на основе биржевых данных.
- Ценовые разрывы между сессиями: на инструментах с ночными ценовыми разрывами первый бар новой сессии может находиться по цене далеко от последнего бара предыдущей сессии. Индикатор не выполняет интерполяцию в пределах ценовых разрывов. Каждый сессионный профиль объема строится исключительно по тикам, попадающим в заданное временное окно сессии.
- Количество графических объектов при использовании нескольких экземпляров индикатора: для каждого непустого ценового интервала требуется один графический объект. Для одновременного запуска нескольких экземпляров индикатора на одном графике необходимо, чтобы каждый экземпляр использовал собственное значение InpPrefix. В противном случае вызовы функции RemoveSessionObjects() из одного экземпляра приведут к удалению объектов, созданных другим экземпляром.
- Интерпретация без прогнозирования: профили объема показывают, на каких ценовых уровнях происходила торговая активность в течение завершенной сессии. POC, VAH и VAL — это ретроспективные ориентировочные уровни. Они не позволяют предсказать, в каком направлении будет двигаться цена на следующей сессии.
Заключение
MetaTrader 5 предоставляет все базовые средства, необходимые для построения с нуля полноценного сессионного профиля объема. Функция CopyTicksRange() ограничивает извлечение тиков явно заданным временным окном и корректно обрабатывает данные CFD при фильтрации по наличию цены, а не по полям объема. Построение гистограммы за два прохода преобразует поток тиков в дискретное распределение объема по ценовым интервалам. Жадное расширение от точки контроля до охвата 70% объема определяет стандартные границы зоны стоимости. Режим фиксированной ширины, привязанный к PeriodSeconds(), обеспечивает геометрическую согласованность профиля на всех таймфреймах без изменения кода — для каждого графика требуется настроить лишь параметр InpFixedBarCount.
Архитектура, состоящая из семи модулей, позволяет четко разделить области ответственности. CSessionManager отвечает за управление временем. CTickCollector отвечает за сбор данных. CPriceHistogram обеспечивает дискретизацию. CVolumeProfileCalculator отвечает за расчет статистических показателей. CProfileRenderer отвечает за визуализацию. CProfileStatistics отвечает за наблюдаемость. Программа SessionVolumeProfile.mq5 задает последовательность их работы. Ни один модуль не имеет представления о внутреннем состоянии других модулей, и каждый из них можно изучать, тестировать и модифицировать в изоляции от остальных.
Программы, использованные в статье:
| # | Имя | Тип | Описание |
|---|---|---|---|
| 1 | SessionManager.mqh | Включаемый файл | Определяет границы сессии, преобразуя выбранный пользователем тип сессии в конкретные временные метки начала и окончания, привязанные к текущей календарной дате, и генерирует сигнал смены сессии при начале каждого нового торгового дня. |
| 2 | TickCollector.mqh | Включаемый файл | Извлекает все необработанные тики в пределах временного окна активной сессии с помощью CopyTicksRange() и применяет фильтр с учетом особенностей CFD, который принимает любой тик с ненулевой ценой bid или ask и присваивает ему вес по объему, равный единице, если брокер передает нули во всех полях объема. |
| 3 | PriceHistogram.mqh | Включаемый файл | Преобразует необработанный поток тиков в дискретное распределение объема по цене за два последовательных прохода: сопоставляет среднюю цену каждого тика с целочисленным индексом ценового интервала по формуле дискретизации с округлением вниз, а затем добавляет вес по объему этого тика в накопитель соответствующего ценового интервала. |
| 4 | VolumeProfileCalculator.mqh | Включаемый файл | Вычисляет точку контроля (POC), просматривая все ценовые интервалы в поисках максимального накопленного объема, а затем определяет верхнюю границу зоны стоимости (VAH) и нижнюю границу зоны стоимости (VAL) путем жадного расширения от POC по стандартному правилу 70%. |
| 5 | ProfileRenderer.mqh | Включаемый файл | Преобразует готовую гистограмму и три ключевых ценовых уровня в штатные графические объекты, отображая каждый ценовой интервал в виде выровненной по правому краю горизонтальной линии тренда, ширина которой пропорциональна объему интервала. При этом ширина полосы гистограммы POC задается фиксированным числом баров графика, что обеспечивает читаемость профиля на любом таймфрейме. |
| 6 | ProfileStatistics.mqh | Включаемый файл | После каждого успешного построения профиля сессии выводит на вкладку "Эксперты" MetaTrader структурированный диагностический отчет с количеством тиков, количеством ценовых интервалов, значениями POC, VAH, VAL и общим количеством отображенных объектов, что позволяет проверить каждый этап конвейера обработки без отладчика. |
| 7 | SessionVolumeProfile.mq5 | Пользовательский индикатор | Выступает в качестве основного координирующего компонента: создает экземпляры всех шести модулей, настраивает их в OnInit() на основе заданных пользователем входных параметров и последовательно выполняет весь конвейер обработки в OnCalculate() при каждом обнаружении новой границы сессии на текущем баре. |
| 8 | Session_Volume_Profile.zip | Архив в формате ZIP | ZIP-архив, содержащий все приложенные файлы и их пути относительно корневой папки терминала. |
Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/23169
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.