forex-scalping.com

Code: Select all

//@version=5
indicator("DOM Imbalance Bias Filter (Proxy)", overlay=true)

// =========================================================================
// INPUTS
// =========================================================================
grp1 = "Filter Rules"
imbThreshold = input.float(20.0, title="Imbalance Delta % Threshold", group=grp1, tooltip="Minimum volume delta required to confirm bias.")
maxSpread    = input.float(1.5, title="Max Spread (Pips)", group=grp1, tooltip="Disables filter if real-time spread widens.")
sessionZone  = input.session("0800-1700", title="Trading Session", group=grp1, tooltip="Blackout window filter. Set to your active stalking hours.")

grp2 = "Structure Alignment"
structPeriod = input.int(20, title="Structure Baseline (EMA)", group=grp2, tooltip="Ensures imbalance agrees with current M5 flow.")

// =========================================================================
// FILTER 1: BLACKOUT WINDOWS
// =========================================================================
inSession = not na(time(timeframe.period, sessionZone))

// =========================================================================
// FILTER 2: SPREAD / THIN BOOK PROTECTION
// =========================================================================
// syminfo.ask/bid only updates in real-time. Historically, it defaults to na.
realtimeSpread = (syminfo.ask - syminfo.bid) * 10000 // Convert to standard pips for EURUSD
validSpread    = na(realtimeSpread) or (realtimeSpread <= maxSpread)

// =========================================================================
// FILTER 3: IMBALANCE PROXY (TICK VOLUME DELTA)
// =========================================================================
// Estimates aggressive buying vs selling pressure within the candle
range_hl     = high - low == 0 ? 1 : high - low
bullPressure = volume * ((close - low) / range_hl)
bearPressure = volume * ((high - close) / range_hl)
deltaPct     = ((bullPressure - bearPressure) / volume) * 100

// =========================================================================
// FILTER 4: M5 STRUCTURE ALIGNMENT
// =========================================================================
// The ladder must not invent a "yes" against the structural plan.
m5Structure = ta.ema(close, structPeriod)
structBull  = close > m5Structure
structBear  = close < m5Structure

// =========================================================================
// BIAS LOGIC (STALKING PERMISSION)
// =========================================================================
biasBull = inSession and validSpread and structBull and (deltaPct > imbThreshold)
biasBear = inSession and validSpread and structBear and (deltaPct < -imbThreshold)

// =========================================================================
// VISUALS
// =========================================================================
// Highlights the background ONLY when all conditions permit stalking.
bgcolor(biasBull ? color.new(color.green, 90) : biasBear ? color.new(color.red, 90) : na, title="Bias Filter Zone")

// Optional: Plot the structural baseline for visual context
plot(m5Structure, color=color.new(color.gray, 50), title="Structure Baseline")

Code: Select all

//@version=5
indicator("Microstructure & Imbalance Filter [Pro]", overlay=true, max_lines_count=50)

// =========================================================================
// INPUTS & CONFIGURATION
// =========================================================================
grp_struct = "Market Structure (Raw PA)"
mtfRes     = input.timeframe("15", title="HTF Structure Resolution", group=grp_struct)
pivotLeft  = input.int(5, title="Pivot Left Legs", group=grp_struct)
pivotRight = input.int(2, title="Pivot Right Legs", group=grp_struct)

grp_flow   = "Order Flow / Imbalance Proxy"
volSpike   = input.float(1.5, title="Volume Spike Multiplier", tooltip="Requires volume to be X times the SMA to register as institutional footprint", group=grp_flow)
wickAbsorb = input.float(0.4, title="Sweep/Absorption Wick %", tooltip="If price closes within this % of the opposite end on high volume, it signals absorption.", group=grp_flow)

grp_env    = "Execution Environment"
maxSpread  = input.float(1.2, title="Max Allowed Spread (Pips)", group=grp_env)
sessWindow = input.session("0800-1700", title="Active Liquidity Window", group=grp_env)

// =========================================================================
// TYPES & STATE MANAGEMENT (OOP Architecture)
// =========================================================================

// Encapsulates the execution environment state
type ExecutionEnvironment
    bool  isInSession
    float currentSpread
    bool  isTradable

method update(ExecutionEnvironment this) =>
    this.isInSession := not na(time(timeframe.period, sessWindow))
    // Spread calculation (defaults to 0 historically, tracks realtime accurately)
    rtSpread = (syminfo.ask - syminfo.bid) * 10000
    this.currentSpread := na(rtSpread) ? 0.0 : rtSpread
    this.isTradable := this.isInSession and (this.currentSpread <= maxSpread or this.currentSpread == 0.0)

// Encapsulates HTF market structure (BoS / Trend)
type MarketStructure
    int   bias        // 1 = Bullish, -1 = Bearish
    float lastSwingH
    float lastSwingL

method updateStructure(MarketStructure this, float ph, float pl, float c) =>
    if not na(ph)
        this.lastSwingH := ph
    if not na(pl)
        this.lastSwingL := pl
    
    // Break of Structure Logic (Close outside established swings)
    if c > this.lastSwingH
        this.bias := 1
    else if c < this.lastSwingL
        this.bias := -1

// Encapsulates Bar-by-Bar Microstructure (Initiation vs Absorption)
type OrderFlow
    bool isBullImbalance
    bool isBearImbalance

method mapFootprint(OrderFlow this, float h, float l, float c, float v, float avgV) =>
    range_hl = h - l == 0 ? syminfo.mintick : h - l
    isHighVol = v > (avgV * volSpike)
    
    // Close proximity to extremes (0.0 = Low, 1.0 = High)
    closePos = (c - l) / range_hl
    
    // Bull Imbalance: High vol pushing price to close near highs (Initiation) OR 
    // High vol sweeping lows but closing aggressively higher (Absorption)
    this.isBullImbalance := isHighVol and (closePos >= (1.0 - wickAbsorb))
    
    // Bear Imbalance: High vol pushing price near lows OR sweeping highs and rejecting
    this.isBearImbalance := isHighVol and (closePos <= wickAbsorb)

// =========================================================================
// INSTANTIATION & EXECUTION LOOP
// =========================================================================

// 1. Initialize State Objects
var env = ExecutionEnvironment.new(false, 0.0, false)
var ms  = MarketStructure.new(0, high, low)
var of  = OrderFlow.new(false, false)

// 2. Fetch HTF Data (Raw PA only, no smoothing)
[htf_ph, htf_pl, htf_c] = request.security(syminfo.tickerid, mtfRes, [ta.pivothigh(high, pivotLeft, pivotRight), ta.pivotlow(low, pivotLeft, pivotRight), close], lookahead=barmerge.lookahead_on)

// 3. Update States
env.update()
ms.updateStructure(htf_ph, htf_pl, htf_c)

avgVolume = ta.sma(volume, 20)
of.mapFootprint(high, low, close, volume, avgVolume)

// =========================================================================
// FILTER LOGIC (THE GATEKEEPER)
// =========================================================================

// Bias is ONLY granted when HTF structure and LTF order flow align in a valid environment.
// The filter says NO to everything else.
bool permitLong  = env.isTradable and (ms.bias == 1) and of.isBullImbalance
bool permitShort = env.isTradable and (ms.bias == -1) and of.isBearImbalance

// =========================================================================
// VISUALIZATION (Clean & Unobtrusive)
// =========================================================================

// Background color highlights specific bars where all conditions are met for stalking
color longFilterColor  = permitLong  ? color.new(color.teal, 80) : na
color shortFilterColor = permitShort ? color.new(color.maroon, 80) : na

bgcolor(longFilterColor, title="Stalk Long Bias")
bgcolor(shortFilterColor, title="Stalk Short Bias")

// Optional: Plot HTF Structure lines for visual confirmation (uncomment if desired)
// plot(ms.lastSwingH, color=color.new(color.red, 50), style=plot.style_stepline, title="HTF Resistance")
// plot(ms.lastSwingL, color=color.new(color.green, 50), style=plot.style_stepline, title="HTF Support")

Code: Select all

//+------------------------------------------------------------------+
//|                                     MicroBiasFilter_MT5.mq5      |
//+------------------------------------------------------------------+
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   1

#property indicator_type1   DRAW_COLOR_HISTOGRAM
#property indicator_color1  clrNONE, clrTeal, clrMaroon
#property indicator_style1  STYLE_SOLID
#property indicator_width1  3

//--- Inputs
input ENUM_TIMEFRAMES InpHTF           = PERIOD_M15;  // HTF Structure Resolution
input int             InpPivotLookback = 10;          // HTF Pivot Lookback (Legs)
input double          InpVolSpike      = 1.5;         // Volume Spike Multiplier
input double          InpWickAbsorb    = 0.4;         // Sweep/Absorption Wick % (0.0 to 1.0)
input int             InpMaxSpreadPts  = 15;          // Max Spread (Points)
input int             InpSessStartHour = 8;           // Session Start (Hour)
input int             InpSessEndHour   = 17;          // Session End (Hour)

//--- Buffers
double BufferData[];
double BufferColor[];

//+------------------------------------------------------------------+
//| CLASSES (State Encapsulation)                                    |
//+------------------------------------------------------------------+
class CExecutionEnv {
private:
    int m_start, m_end, m_maxSpread;
public:
    void Init(int startH, int endH, int maxSpread) {
        m_start = startH; m_end = endH; m_maxSpread = maxSpread;
    }
    bool IsTradable(datetime time, int spread) {
        MqlDateTime dt;
        TimeToStruct(time, dt);
        bool inSession = (dt.hour >= m_start && dt.hour < m_end);
        return inSession && (spread <= m_maxSpread);
    }
};

class CMarketStructure {
private:
    ENUM_TIMEFRAMES m_htf;
    int m_lookback;
public:
    void Init(ENUM_TIMEFRAMES htf, int lookback) {
        m_htf = htf; m_lookback = lookback;
    }
    int GetBias(datetime ltfTime, double currentClose) {
        int htfShift = iBarShift(_Symbol, m_htf, ltfTime);
        if(htfShift < 0) return 0;
        
        // Find recent HTF extremes to define structure
        double htfHigh[], htfLow[];
        ArraySetAsSeries(htfHigh, true);
        ArraySetAsSeries(htfLow, true);
        
        if(CopyHigh(_Symbol, m_htf, htfShift+1, m_lookback, htfHigh) <= 0) return 0;
        if(CopyLow(_Symbol, m_htf, htfShift+1, m_lookback, htfLow) <= 0) return 0;
        
        int highestIdx = ArrayMaximum(htfHigh, 0, m_lookback);
        int lowestIdx  = ArrayMinimum(htfLow, 0, m_lookback);
        
        double swingH = htfHigh[highestIdx];
        double swingL = htfLow[lowestIdx];
        
        // BoS Bias Definition
        if(currentClose > swingH) return 1;
        if(currentClose < swingL) return -1;
        return 0; // Inside range / Neutral
    }
};

class COrderFlow {
private:
    double m_volMult, m_wickPct;
public:
    void Init(double volMult, double wickPct) {
        m_volMult = volMult; m_wickPct = wickPct;
    }
    int MapFootprint(double h, double l, double c, long v, double avgV) {
        double range = (h - l == 0) ? _Point : (h - l);
        bool isHighVol = v > (avgV * m_volMult);
        double closePos = (c - l) / range;
        
        if(isHighVol && (closePos >= (1.0 - m_wickPct))) return 1;  // Bull Imbalance
        if(isHighVol && (closePos <= m_wickPct)) return -1;         // Bear Imbalance
        return 0;
    }
};

//--- Instances
CExecutionEnv    Env;
CMarketStructure Struct;
COrderFlow       Flow;
int              VolHandle;

//+------------------------------------------------------------------+
//| INIT                                                             |
//+------------------------------------------------------------------+
int OnInit() {
    SetIndexBuffer(0, BufferData, INDICATOR_DATA);
    SetIndexBuffer(1, BufferColor, INDICATOR_COLOR_INDEX);
    IndicatorSetString(INDICATOR_SHORTNAME, "MicroBias MT5");
    
    Env.Init(InpSessStartHour, InpSessEndHour, InpMaxSpreadPts);
    Struct.Init(InpHTF, InpPivotLookback);
    Flow.Init(InpVolSpike, InpWickAbsorb);
    
    VolHandle = iMA(_Symbol, PERIOD_CURRENT, 20, 0, MODE_SMA, PRICE_CLOSE); // Dummy MA for tick volume, requires custom loop in OnCalculate
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 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[]) 
{
    int start = (prev_calculated > 0) ? prev_calculated - 1 : 20;
    
    for(int i = start; i < rates_total; i++) {
        BufferData[i]  = 0.0;
        BufferColor[i] = 0;
        
        // 1. Env Gatekeeper (MT5 stores historical spread!)
        if(!Env.IsTradable(time[i], spread[i])) continue;
        
        // 2. Volume Baseline (SMA of Tick Volume)
        double sumVol = 0;
        for(int v = 0; v < 20; v++) sumVol += (double)tick_volume[i - v];
        double avgVol = sumVol / 20.0;
        
        // 3. Imbalance Footprint
        int flowBias = Flow.MapFootprint(high[i], low[i], close[i], tick_volume[i], avgVol);
        if(flowBias == 0) continue;
        
        // 4. Structure Gatekeeper
        int msBias = Struct.GetBias(time[i], close[i]);
        
        // 5. Alignment Check
        if(msBias == 1 && flowBias == 1) {
            BufferData[i] = 1.0;
            BufferColor[i] = 1; // Teal
        } 
        else if(msBias == -1 && flowBias == -1) {
            BufferData[i] = -1.0;
            BufferColor[i] = 2; // Maroon
        }
    }
    return(rates_total);
}

Code: Select all

//+------------------------------------------------------------------+
//|                                     MicroBiasFilter_MT4.mq4      |
//+------------------------------------------------------------------+
#property strict
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1  clrTeal
#property indicator_color2  clrMaroon
#property indicator_width1  3
#property indicator_width2  3

//--- Inputs
input int    InpHTF           = 15;           // HTF Structure (Minutes)
input int    InpPivotLookback = 10;           // HTF Pivot Lookback (Legs)
input double InpVolSpike      = 1.5;          // Volume Spike Multiplier
input double InpWickAbsorb    = 0.4;          // Sweep/Absorption Wick %
input int    InpMaxSpreadPts  = 15;           // Max Spread (Points - Live Only)
input int    InpSessStartHour = 8;            // Session Start (Hour)
input int    InpSessEndHour   = 17;           // Session End (Hour)

//--- Buffers
double BufferBull[];
double BufferBear[];

//+------------------------------------------------------------------+
//| CLASSES (MQL4 Build 600+ supports OOP)                           |
//+------------------------------------------------------------------+
class CExecutionEnv {
private:
    int m_start, m_end, m_maxSpread;
public:
    void Init(int startH, int endH, int maxSpread) {
        m_start = startH; m_end = endH; m_maxSpread = maxSpread;
    }
    bool IsTradable(datetime time) {
        int h = TimeHour(time);
        bool inSession = (h >= m_start && h < m_end);
        
        // MT4 Cannot backtest spread. Use live spread if it's the current bar.
        int currentSpread = (int)MarketInfo(_Symbol, MODE_SPREAD);
        if(time == Time[0] && currentSpread > m_maxSpread) return false; 
        
        return inSession;
    }
};

class CMarketStructure {
private:
    int m_htf, m_lookback;
public:
    void Init(int htf, int lookback) {
        m_htf = htf; m_lookback = lookback;
    }
    int GetBias(datetime ltfTime, double currentClose) {
        int htfShift = iBarShift(_Symbol, m_htf, ltfTime, false);
        if(htfShift < 0) return 0;
        
        int highestIdx = iHighest(_Symbol, m_htf, MODE_HIGH, m_lookback, htfShift + 1);
        int lowestIdx  = iLowest(_Symbol, m_htf, MODE_LOW, m_lookback, htfShift + 1);
        
        double swingH = iHigh(_Symbol, m_htf, highestIdx);
        double swingL = iLow(_Symbol, m_htf, lowestIdx);
        
        if(currentClose > swingH) return 1;
        if(currentClose < swingL) return -1;
        return 0; 
    }
};

class COrderFlow {
private:
    double m_volMult, m_wickPct;
public:
    void Init(double volMult, double wickPct) {
        m_volMult = volMult; m_wickPct = wickPct;
    }
    int MapFootprint(double h, double l, double c, double v, double avgV) {
        double range = (h - l == 0) ? Point : (h - l);
        bool isHighVol = v > (avgV * m_volMult);
        double closePos = (c - l) / range;
        
        if(isHighVol && (closePos >= (1.0 - m_wickPct))) return 1;
        if(isHighVol && (closePos <= m_wickPct)) return -1;
        return 0;
    }
};

CExecutionEnv    Env;
CMarketStructure Struct;
COrderFlow       Flow;

//+------------------------------------------------------------------+
//| INIT                                                             |
//+------------------------------------------------------------------+
int OnInit() {
    SetIndexBuffer(0, BufferBull);
    SetIndexBuffer(1, BufferBear);
    SetIndexStyle(0, DRAW_HISTOGRAM);
    SetIndexStyle(1, DRAW_HISTOGRAM);
    IndicatorShortName("MicroBias MT4");
    
    Env.Init(InpSessStartHour, InpSessEndHour, InpMaxSpreadPts);
    Struct.Init(InpHTF, InpPivotLookback);
    Flow.Init(InpVolSpike, InpWickAbsorb);
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 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[]) 
{
    int start = (prev_calculated > 0) ? rates_total - prev_calculated : rates_total - 21;
    if(start < 0) start = 0;

    for(int i = start; i >= 0; i--) { // MT4 loops backwards (0 is newest)
        BufferBull[i] = 0;
        BufferBear[i] = 0;
        
        if(!Env.IsTradable(Time[i])) continue;
        
        double sumVol = 0;
        for(int v = 0; v < 20; v++) sumVol += Volume[i + v];
        double avgVol = sumVol / 20.0;
        
        int flowBias = Flow.MapFootprint(High[i], Low[i], Close[i], Volume[i], avgVol);
        if(flowBias == 0) continue;
        
        int msBias = Struct.GetBias(Time[i], Close[i]);
        
        if(msBias == 1 && flowBias == 1) {
            BufferBull[i] = 1.0;
        } 
        else if(msBias == -1 && flowBias == -1) {
            BufferBear[i] = -1.0;
        }
    }
    return(rates_total);
}