255 lines
11 KiB
MQL5
255 lines
11 KiB
MQL5
|
//+------------------------------------------------------------------+
|
||
|
|
//| ContextPackager.mqh |
|
||
|
|
//| Centaur Quant Architecture — Data Module |
|
||
|
|
//| Historical Context & Swing Mapper (SDP-compatible) |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| PURPOSE |
|
||
|
|
//| Scans recent bars (any timeframe) for significant swing highs |
|
||
|
|
//| and swing lows. Fractal pivots are filtered by a dynamic ATR |
|
||
|
|
//| threshold supplied by CSymbolNormalizer, so noise rejection |
|
||
|
|
//| adapts to each instrument's volatility. Outputs parallel arrays |
|
||
|
|
//| (swing_high, swing_low, swing_time) directly consumable by |
|
||
|
|
//| CSDPEncoder::BuildHistoricalContext(). |
|
||
|
|
//| NOTE: the ATR threshold is sampled on the chart's current period |
|
||
|
|
//| (CSymbolNormalizer); when scanning a different timeframe, tune |
|
||
|
|
//| atr_multiplier to keep the threshold dimensionally consistent. |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
#property strict
|
||
|
|
|
||
|
|
#ifndef CONTEXTPACKAGER_MQH
|
||
|
|
#define CONTEXTPACKAGER_MQH
|
||
|
|
|
||
|
|
#include "../Core/CSymbolNormalizer.mqh"
|
||
|
|
#include "../Network/CSDPEncoder.mqh"
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
class CContextPackager
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
string m_symbol; // instrument whose structure is scanned
|
||
|
|
ENUM_TIMEFRAMES m_scan_period; // timeframe the swing scan runs on
|
||
|
|
string m_tf_name; // SDP wire name of m_scan_period
|
||
|
|
CSymbolNormalizer m_normalizer; // dynamic ATR threshold source
|
||
|
|
CSDPEncoder m_encoder; // SDP serializer
|
||
|
|
|
||
|
|
//--- detected swing bars (parallel arrays, oldest -> newest) ---
|
||
|
|
double m_swing_high[];
|
||
|
|
double m_swing_low[];
|
||
|
|
datetime m_swing_time[];
|
||
|
|
|
||
|
|
string PeriodName(const ENUM_TIMEFRAMES period);
|
||
|
|
void ResetSwings();
|
||
|
|
|
||
|
|
public:
|
||
|
|
CContextPackager(const string symbol, const ENUM_TIMEFRAMES scan_period = PERIOD_CURRENT);
|
||
|
|
~CContextPackager();
|
||
|
|
|
||
|
|
//--- scan recent bars and rebuild the swing arrays ---
|
||
|
|
bool Scan(const int bars_to_scan,
|
||
|
|
const int fractal_radius = 2,
|
||
|
|
const double atr_multiplier = 1.0,
|
||
|
|
const int atr_period = 14);
|
||
|
|
|
||
|
|
//--- serialize detected swings to the SDP historical_context array ---
|
||
|
|
string ContextJSON();
|
||
|
|
|
||
|
|
//--- read access ---
|
||
|
|
int SwingCount() const { return ArraySize(m_swing_time); }
|
||
|
|
bool GetSwing(const int index,
|
||
|
|
double &swing_high, double &swing_low,
|
||
|
|
datetime &swing_time) const;
|
||
|
|
string Symbol() const { return m_symbol; }
|
||
|
|
string Timeframe() const { return m_tf_name; }
|
||
|
|
};
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Constructor — bind symbol and resolve the scan period. |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CContextPackager::CContextPackager(const string symbol, const ENUM_TIMEFRAMES scan_period)
|
||
|
|
: m_symbol(symbol),
|
||
|
|
m_scan_period(scan_period),
|
||
|
|
m_tf_name(""),
|
||
|
|
m_normalizer(symbol),
|
||
|
|
m_encoder()
|
||
|
|
{
|
||
|
|
ENUM_TIMEFRAMES p = m_scan_period;
|
||
|
|
if(p == PERIOD_CURRENT)
|
||
|
|
p = (ENUM_TIMEFRAMES)_Period;
|
||
|
|
m_scan_period = p;
|
||
|
|
m_tf_name = PeriodName(p);
|
||
|
|
if(StringLen(m_symbol) == 0 || !m_normalizer.IsReady())
|
||
|
|
PrintFormat("[CContextPackager] ERROR: invalid symbol '%s' or normalizer not ready.", m_symbol);
|
||
|
|
else
|
||
|
|
PrintFormat("[CContextPackager] INFO: ready on %s %s.", m_symbol, m_tf_name);
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Destructor — nothing to release; present for symmetry. |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CContextPackager::~CContextPackager()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Scan — detect significant swings over the recent window. |
|
||
|
|
//| 1) Dynamic noise threshold = ATR(period) * multiplier (normalizer).|
|
||
|
|
//| 2) Fractal pivot scan: a bar is a pivot when its extreme strictly |
|
||
|
|
//| dominates the +/-fractal_radius window. |
|
||
|
|
//| 3) Significance filter: pivots must ALTERNATE (high/low) and move |
|
||
|
|
//| at least one threshold from the previous accepted swing. |
|
||
|
|
//| Output arrays are chronological (oldest bar first). |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CContextPackager::Scan(const int bars_to_scan,
|
||
|
|
const int fractal_radius,
|
||
|
|
const double atr_multiplier,
|
||
|
|
const int atr_period)
|
||
|
|
{
|
||
|
|
ResetSwings();
|
||
|
|
//--- parameter validation ---
|
||
|
|
if(StringLen(m_symbol) == 0)
|
||
|
|
{
|
||
|
|
PrintFormat("[CContextPackager] ERROR: no symbol configured.");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if(fractal_radius < 1)
|
||
|
|
{
|
||
|
|
PrintFormat("[CContextPackager] ERROR: fractal_radius must be >= 1 (got %d).", fractal_radius);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if(atr_multiplier <= 0.0)
|
||
|
|
{
|
||
|
|
PrintFormat("[CContextPackager] ERROR: atr_multiplier must be > 0 (got %G).", atr_multiplier);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
int bars = bars_to_scan;
|
||
|
|
if(bars > 10000)
|
||
|
|
{
|
||
|
|
PrintFormat("[CContextPackager] WARNING: bars_to_scan %d clamped to 10000.", bars);
|
||
|
|
bars = 10000;
|
||
|
|
}
|
||
|
|
const int min_bars = 2 * fractal_radius + 2;
|
||
|
|
if(bars < min_bars)
|
||
|
|
{
|
||
|
|
PrintFormat("[CContextPackager] ERROR: bars_to_scan %d < minimum %d.", bars, min_bars);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
//--- dynamic noise threshold from the normalizer ---
|
||
|
|
const double threshold = m_normalizer.GetATRBuffer(atr_period, atr_multiplier);
|
||
|
|
if(threshold <= 0.0)
|
||
|
|
{
|
||
|
|
PrintFormat("[CContextPackager] ERROR: ATR threshold unavailable for %s (warm-up?). Scan aborted.",
|
||
|
|
m_symbol);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
//--- copy the scan window; index 0 is the most recent bar ---
|
||
|
|
double high[], low[];
|
||
|
|
datetime time[];
|
||
|
|
const int got_high = CopyHigh(m_symbol, m_scan_period, 0, bars, high);
|
||
|
|
const int got_low = CopyLow(m_symbol, m_scan_period, 0, bars, low);
|
||
|
|
const int got_time = CopyTime(m_symbol, m_scan_period, 0, bars, time);
|
||
|
|
if(got_high < min_bars || got_low < min_bars || got_time < min_bars)
|
||
|
|
{
|
||
|
|
PrintFormat("[CContextPackager] ERROR: insufficient history for %s %s (need %d bars, got %d/%d/%d).",
|
||
|
|
m_symbol, m_tf_name, min_bars, got_high, got_low, got_time);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
const int n = got_time; // all three arrays hold the same window in practice
|
||
|
|
//--- fractal pivot scan, oldest -> newest (chronological output) ---
|
||
|
|
bool have_last = false;
|
||
|
|
bool last_is_high = false;
|
||
|
|
double last_price = 0.0;
|
||
|
|
for(int i = n - 1 - fractal_radius; i >= fractal_radius; i--)
|
||
|
|
{
|
||
|
|
// pivot high: strict max over the surrounding window
|
||
|
|
bool is_high = true;
|
||
|
|
for(int k = i - fractal_radius; k <= i + fractal_radius && is_high; k++)
|
||
|
|
{
|
||
|
|
if(k != i && high[k] >= high[i])
|
||
|
|
is_high = false;
|
||
|
|
}
|
||
|
|
// pivot low: strict min over the surrounding window
|
||
|
|
bool is_low = true;
|
||
|
|
for(int k = i - fractal_radius; k <= i + fractal_radius && is_low; k++)
|
||
|
|
{
|
||
|
|
if(k != i && low[k] <= low[i])
|
||
|
|
is_low = false;
|
||
|
|
}
|
||
|
|
// significance: alternation + at least one threshold of travel
|
||
|
|
bool accept_high = is_high && (!have_last || !last_is_high);
|
||
|
|
if(accept_high && have_last && (high[i] - last_price) < threshold)
|
||
|
|
accept_high = false;
|
||
|
|
bool accept_low = is_low && (!have_last || last_is_high);
|
||
|
|
if(accept_low && have_last && (last_price - low[i]) < threshold)
|
||
|
|
accept_low = false;
|
||
|
|
if(accept_high || accept_low)
|
||
|
|
{
|
||
|
|
const int s = ArraySize(m_swing_time);
|
||
|
|
ArrayResize(m_swing_high, s + 1);
|
||
|
|
ArrayResize(m_swing_low, s + 1);
|
||
|
|
ArrayResize(m_swing_time, s + 1);
|
||
|
|
m_swing_high[s] = high[i];
|
||
|
|
m_swing_low[s] = low[i];
|
||
|
|
m_swing_time[s] = time[i];
|
||
|
|
if(accept_high)
|
||
|
|
{
|
||
|
|
last_is_high = true;
|
||
|
|
last_price = high[i];
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
last_is_high = false;
|
||
|
|
last_price = low[i];
|
||
|
|
}
|
||
|
|
have_last = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
PrintFormat("[CContextPackager] INFO: %s %s scan complete — %d significant swing(s), threshold %.5f.",
|
||
|
|
m_symbol, m_tf_name, ArraySize(m_swing_time), threshold);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| ContextJSON — SDP historical_context JSON array of the detected |
|
||
|
|
//| swings; "" when nothing was detected. |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
string CContextPackager::ContextJSON()
|
||
|
|
{
|
||
|
|
if(ArraySize(m_swing_time) == 0)
|
||
|
|
return "";
|
||
|
|
return m_encoder.BuildHistoricalContext(m_symbol, m_swing_high, m_swing_low, m_swing_time);
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| GetSwing — copy one detected swing bar; false on bad index. |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CContextPackager::GetSwing(const int index,
|
||
|
|
double &swing_high, double &swing_low,
|
||
|
|
datetime &swing_time) const
|
||
|
|
{
|
||
|
|
if(index < 0 || index >= ArraySize(m_swing_time))
|
||
|
|
return false;
|
||
|
|
swing_high = m_swing_high[index];
|
||
|
|
swing_low = m_swing_low[index];
|
||
|
|
swing_time = m_swing_time[index];
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| ResetSwings — clear all detected swing arrays. |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CContextPackager::ResetSwings()
|
||
|
|
{
|
||
|
|
ArrayResize(m_swing_high, 0);
|
||
|
|
ArrayResize(m_swing_low, 0);
|
||
|
|
ArrayResize(m_swing_time, 0);
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| PeriodName — wire name of an ENUM_TIMEFRAMES value. |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
string CContextPackager::PeriodName(const ENUM_TIMEFRAMES period)
|
||
|
|
{
|
||
|
|
ENUM_TIMEFRAMES p = period;
|
||
|
|
if(p == PERIOD_CURRENT)
|
||
|
|
p = (ENUM_TIMEFRAMES)_Period;
|
||
|
|
string name = EnumToString(p); // e.g. "PERIOD_H1"
|
||
|
|
StringReplace(name, "PERIOD_", ""); // "H1"
|
||
|
|
return name;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // CONTEXTPACKAGER_MQH
|