IMBALANCE projections rectangulaires

Bonjour @JC_Bywan

Cette capture te sera peut-être utile: XAUUSD en 5m Bougie de 13h00.

Cordialement.

Retracement-Capture-decran-2026-11-06-135959.png

Espérons que nous trouverons une solution cette fois-ci. Voici une autre suggestion :

//----------------------------------------------
// VIRGIN IMBALANCES v6
//----------------------------------------------
DEFPARAM DrawOnLastBarOnly = true
DEFPARAM CalculateOnLastBars = 20000

// ================================================================
// SETTINGS
// ================================================================
// projection window in bars: 720 = 30 days in H1 (8640 = 30 days in 5 min)
maxBars = 720

// ================================================================
// INITIALISATION
// ================================================================
ONCE nTop = 0
ONCE nBot = 0
ONCE tFirst = 0
ONCE bFirst = 0

// ================================================================
// ORIGINAL DETECTION - unchanged
// ================================================================
TopImb = 0
TopImbalance = low[2] <= open[1] AND high[0] >= close[1]
TopImbalancesize = low[2] - high[0]
IF TopImbalance AND TopImbalancesize > 0 THEN
   LowerWick = (min(open,close) - low) <= (range * 0.05)
   Body = abs(Close - Open)
   TopImb = (TopImbalancesize > Body) AND LowerWick AND (low[2] <= (min(open,close) + 2*PipSize))
ENDIF

BottomInbalance = high[2] >= open[1] AND low[0] <= close[1]
BottomInbalancesize = low[0] - high[2]

// ================================================================
// STORE THE NEW ZONES
// Top imbalance: the gap is ABOVE price, between high[0] and low[2]
// Bottom imbalance: the gap is BELOW price, between high[2] and low[0]
// ================================================================
IF TopImbalance AND TopImbalancesize > 0 THEN
   $tH[nTop] = low[2]      // upper edge, fixed
   $tL0[nTop] = high[0]    // original lower edge
   $tL[nTop] = high[0]     // lower edge of the unfilled part: moves UP
   $tB[nTop] = barindex
   nTop = nTop + 1
ENDIF

IF BottomInbalance AND BottomInbalancesize > 0 THEN
   $bL[nBot] = high[2]     // lower edge, fixed
   $bH0[nBot] = low[0]     // original upper edge
   $bH[nBot] = low[0]      // upper edge of the unfilled part: moves DOWN
   $bB[nBot] = barindex
   nBot = nBot + 1
ENDIF

// ================================================================
// RETRACEMENT - each candle eats the part of the zone it touches
// The zone is only cut, never enlarged: a candle that comes back less
// deep than an earlier one changes nothing. And the high (low) of the
// candle in progress can only rise (fall), so recalculating it on every
// tick always leaves the same edge as the close of the candle.
// ================================================================
barLimit = barindex - maxBars

// Top zones: the high of the candle pushes the lower edge up
IF nTop > tFirst THEN
   newFirst = tFirst
   FOR k = tFirst TO nTop - 1 DO
      IF $tB[k] < barLimit THEN
         // older than the window: no longer followed nor drawn
         newFirst = k + 1
      ELSIF barindex > $tB[k] THEN
         IF high > $tL[k] THEN
            IF $tL[k] = $tL0[k] THEN
               // first candle that comes back into the zone
               $tT[k] = barindex
            ENDIF
            $tL[k] = min(high, $tH[k])
         ENDIF
      ENDIF
   NEXT
   tFirst = newFirst
ENDIF

// Bottom zones: the low of the candle pushes the upper edge down
IF nBot > bFirst THEN
   newFirst = bFirst
   FOR k = bFirst TO nBot - 1 DO
      IF $bB[k] < barLimit THEN
         newFirst = k + 1
      ELSIF barindex > $bB[k] THEN
         IF low < $bH[k] THEN
            IF $bH[k] = $bH0[k] THEN
               $bT[k] = barindex
            ENDIF
            $bH[k] = max(low, $bL[k])
         ENDIF
      ENDIF
   NEXT
   bFirst = newFirst
ENDIF

// ================================================================
// DRAWING - everything is redrawn from the arrays on the last bar,
// so the rectangles of the previous bars do not pile up.
// A partially filled zone is rebuilt step by step from the candles:
// a new rectangle starts at each candle that goes deeper into it.
// ================================================================
IF islastbarupdate THEN
   
   // Top imbalances
   IF nTop > tFirst THEN
      FOR k = tFirst TO nTop - 1 DO
         // original imbalance on its 3 candles (yellow)
         DrawRectangle($tB[k] - 2, $tH[k], $tB[k], $tL0[k]) coloured(255,255,0,120) BorderColor(255,255,0,0)
         // unfilled part projected up to the current candle
         IF $tL[k] < $tH[k] THEN
            xStart = $tB[k]
            edge = $tL0[k]
            IF $tL[k] > $tL0[k] THEN
               FOR j = $tT[k] TO barindex DO
                  hj = high[barindex - j]
                  IF hj > edge THEN
                     DrawRectangle(xStart, $tH[k], j, edge) coloured(255,200,0,20) BorderColor(255,200,0,160)
                     xStart = j
                     edge = hj
                  ENDIF
               NEXT
            ENDIF
            DrawRectangle(xStart, $tH[k], barindex, edge) coloured(255,200,0,20) BorderColor(255,200,0,160)
         ENDIF
      NEXT
   ENDIF
   
   // Bottom imbalances
   IF nBot > bFirst THEN
      FOR k = bFirst TO nBot - 1 DO
         DrawRectangle($bB[k] - 2, $bH0[k], $bB[k], $bL[k]) coloured(255,255,0,120) BorderColor(255,255,0,0)
         IF $bH[k] > $bL[k] THEN
            xStart = $bB[k]
            edge = $bH0[k]
            IF $bH[k] < $bH0[k] THEN
               FOR j = $bT[k] TO barindex DO
                  lj = low[barindex - j]
                  IF lj < edge THEN
                     DrawRectangle(xStart, edge, j, $bL[k]) coloured(255,200,0,20) BorderColor(255,200,0,160)
                     xStart = j
                     edge = lj
                  ENDIF
               NEXT
            ENDIF
            DrawRectangle(xStart, edge, barindex, $bL[k]) coloured(255,200,0,20) BorderColor(255,200,0,160)
         ENDIF
      NEXT
   ENDIF
   
ENDIF

RETURN

image-1793981044258.png