Indicator
Indicator
Indicator
Indicator
Dynamic Trend Overlay (Original Recreation)DTO-Recreation combines an adaptive EMA/ATR trend trail with multi-timeframe confirmation, StochRSI-validated re-entries, and configurable stop-loss/take-profit handling in a single strategy framework. It's built for traders who want a trend-following core that filters out counter-trend noise using higher-timeframe agreement, rather than trading every flip on the chart's own timeframe in isolation.
FEATURES
Adaptive Trend Trail — Supertrend-style flip mechanism built on an EMA basis (rather than hl2) with ATR bands. Five sensitivity presets — Reactive, Filtered, Balale EMA length, ATR length, and ATR multipliertogether, from fast scalping flips to slow macro confirmation.
Multi-Timeframe Confirmation — The same trail runs independently on the chart timeframe (CTF), a higher timeframe (HTF), and an optional higher-higher timeframe (HHTF)F agreement, cutting low-quality trades takenagainst the larger trend.
Dynamic Zones & Equilibrium Band — Each timeframe's ATR bands plot as a filled zone (blue bullish / red bearish). An equilibrium band marks the midpoint between CTersion reference.
Trend Flip & Re-Entry Signals — Confirmed CTF rigger entries. Pullback re-entries arevalidated by a StochRSI cross out of oversold/overbought, gated by a per-direction cooldown, and blocked if price already
tagged the HTF zone since the last flip (possi pullback).
Risk Management — Stop-loss: fixed % or structprofit: fixed % or ATR trailing. A secondsame-direction (pyramided) entry is only allowed if the existing position is already profitable — no averaging into
losers.
BEST FOR
- Trend traders who want higher-timeframe agreement enforced before entry
- Traders who want at-a-glance visual confirmament
- Anyone using pullback re-entries who wants them filtered by momentum and cooldown-protected
NOTES
Original, independently written, open-source sed). Built to explore the same general category of multi-timeframe trend-overlay tools on PulseWire — not copied or reverse-engineered from any closed-source script. All inputs are user-configurable. Backtest resimeframe/setting-dependent, and not a forecastor investment advice. Strategy
Indicator
Indicator
Ultimate Deep Fibonacci & Institutional Chart Matrix ProUltimate Deep Fibonacci and Institutional Chart Matrix Pro
Overview
The Ultimate Deep Fibonacci and Institutional Chart Matrix Pro is a comprehensive visual framework designed for Pine Script v6. It combines Smart Money Concepts, dynamic support and resistance zones, session liquidity levels, and structural Fibonacci pricing into a unified chart layout.
This tool maps market structure transitions, identifies key institutional high and low swing levels, tracks Asian session ranges, and visualizes overall price flow through a custom smooth wave with integrated volume price background fill.
Core Features
Natural Price Wave and Shadow Fill
Maps underlying market momentum using a smoothed wave calculation.
Dynamically fills the space between the current close price and the wave line to visualize expanding or contracting momentum.
Color coded green for bullish conditions and red for bearish conditions.
Deep Institutional Fibonacci Matrix
Plots critical institutional Fibonacci levels based on recent market swings:
0.50 Equilibrium (EQ): The midpoint balance level.
0.618 Golden Zone: A primary level for premium or discount interest.
0.786 Deep Discount: A deep structural reversal or continuation level.
Dynamic Support and Resistance Zones
Automatically draws extended resistance and support boxes using dynamic pivot points and Average True Range buffering.
Labels automatically project forward on the chart without obscuring live price action.
Major ITH and ITL Badges
Identifies significant Intermediate Term Highs (ITH, colored Red) and Intermediate Term Lows (ITL, colored Green).
Configurable lookback parameters filter out minor noise, focusing solely on major swing structural points.
Smart Money Concepts Structure
Detects and plots structural breaks:
BOS (Break of Structure): Signals trend continuation.
CHoCH (Change of Character): Signals potential market trend shifts.
Asian Session Liquidity Tracking
Tracks the high and low levels established during the Asian trading session.
Plots dotted projection lines until price breaks or sweeps these liquidity levels.
Dynamic Projection Arrow and Low Resistance Liquidity
Projects short term expected direction using Average True Range volatility metrics.
Highlights major liquidity pools based on key high and low boundaries.
On Screen Live Dashboard
Displays real time market stats in the top right corner, including Market Flow, Golden Zone values, Asian Session status, Volatility, and Market Structure Alignment.
Settings Breakdown
Price Wave and Shadow Settings
Show Natural Price Wave and Fill Shadow: Enables or disables the wave line and its background fill.
Wave Sensitivity: Adjusts the lookback period for the wave calculation (Default: 20).
Shadow Transparency (0-100): Controls the background fill opacity.
Deep Fibonacci Matrix
Show Deep Institutional Fib: Enables or disables structural Fibonacci lines.
Fib Swing Lookback: Determines the number of bars evaluated for top and bottom Fibonacci anchors (Default: 40).
Dynamic Support and Resistance Box Zones
Show Dynamic Box S/R Zones: Toggles support and resistance box zones.
S/R Sensitivity: Controls the pivot detection length for drawing zones (Default: 20).
Major ITH and ITL Settings
Show Major ITH and ITL Badges: Toggles ITH and ITL visual markers.
Major ITH and ITL Lookback: Controls swing sensitivity to filter minor noise (Default: 20).
Projection and Liquidity Settings
Show Direction Projection Arrow: Toggles the forward projection arrow.
Arrow Forward Bars: Controls how far ahead the arrow projects (Default: 12).
Show Low Resistance Liquidity: Toggles liquidity baseline highlights.
Asian Liquidity and SMC Settings
Show Active Asian High / Low: Toggles Asian range tracking lines.
Show BOS and CHoCH Structure: Enables market structure labels.
Structure Sensitivity: Controls pivot lookback for structural breaks.
How to Use
Context Identification: Look at the Market Flow and Price Wave Fill Shadow to determine the directional bias (Bullish = Green, Bearish = Red).
Key Zone Mapping: Identify price interaction with the Support Zone or Resistance Zone. Monitor how price behaves near the 0.618 Golden Zone or 0.786 Deep Discount lines.
Structure Confirmation: Confirm structural updates via BOS or CHoCH markers. Look for ITH (Red) or ITL (Green) labels to mark key swing pivots.
Session Liquidity: Monitor the ASIA H and ASIA L dotted lines for potential liquidity sweeps during peak trading hours.
Things to Avoid
Avoid Over-Leveraging at Single Levels: Never rely on a single line or zone in isolation; always seek confluence across structural breaks and dynamic zones.
Avoid High Sensitivity on Low Timeframes: Setting swing sensitivities too low on lower timeframes can lead to excessive noise. Adjust lookback values according to your target timeframe.
Avoid Trading directly into major Resistance or Support: Exercise caution when opening new directional positions directly inside established Resistance or Support boxes.
Disclaimer
Trading financial markets involves significant risk and can result in the loss of your capital. This indicator is designed strictly for educational and analytical purposes to assist with visual market structure identification. It is not financial advice, investment recommendation, or a signal service. Always manage your risk responsibly, conduct your own independent research, and follow your own personalized trading plan. Indicator
Agent Doji Session Zones US100Overview
AVE Agent US100 Doji Session Zones is an intraday charting tool developed specifically for the US100 index.
The indicator detects small-body candles during a defined New York trading window and converts each qualifying candle into a temporary price zone. When a valid candle appears between 9:30 AM and 11:00 AM GMT-4, the script draws a box from the candle’s high to its low and extends the zone until 12:30 PM.
A dashed midpoint is also displayed at 50% of the candle’s total range.
Detection logic
A candle qualifies when both conditions are met:
The candle body is no greater than 0.5 US100 index points
The combined length of the upper and lower wicks is no greater than 30 US100 index points
The candle body is calculated using the absolute difference between the open and close.
The total wick size is calculated by adding the upper wick and lower wick together. The two wicks do not need to be equal. One wick may be larger than the other, provided their combined size stays within the allowed limit.
Session filter
New zones are created only during the following period:
Detection start: 9:30 AM GMT-4
Detection end: 11:00 AM GMT-4
Zone extension: 12:30 PM GMT-4
Candles outside the detection period do not create new zones.
Zone construction
For every qualifying candle, the indicator draws:
A box covering the complete candle range
An upper boundary at the candle high
A lower boundary at the candle low
A dashed midpoint at 50% of the range
A horizontal extension until 12:30 PM GMT-4
The zone is intended to represent a short-term area of balance or indecision that formed during the selected US100 session.
Session visualization
The script also provides visual session guidance:
The chart background is darkened outside the 9:30 AM to 12:30 PM session
A blue background marker highlights 11:00 AM
A red background marker highlights 12:30 PM
These markers separate the candle-detection period from the later observation period.
How to use it
The indicator is designed as a discretionary analysis tool rather than a complete trading system.
Traders may use the zones to observe:
Reactions at the zone high or low
Rejections from the zone boundaries
Breakouts above or below the zone
Retests after a breakout
Price interaction with the midpoint
Acceptance or rejection of the original candle range
The tool does not automatically determine market direction and does not provide direct buy or sell signals.
Entries, stop-losses, profit targets, confirmations and risk-management rules must be defined separately by the trader.
Originality and purpose
The script combines several related functions into one US100-specific workflow:
Fixed-point small-body candle detection
Combined upper- and lower-wick measurement
New York session filtering
Automatic projection of the full candle range
Midpoint visualization
Session timing markers
The purpose is not simply to identify standard Doji candles. The script converts qualifying US100 candles into time-limited intraday zones that can be monitored for later price interaction during the same session.
These components are designed to work together as one structured chart-analysis process.
Intended market and timeframe
This version is designed specifically for the US100 index.
Because it uses fixed index-point thresholds, it may not behave correctly on other instruments such as forex pairs, gold, cryptocurrencies or US500.
It is mainly intended for lower intraday timeframes such as:
1-minute
3-minute
5-minute
The exact number of detected zones may vary depending on the broker’s US100 price feed.
Customizable settings
Users can adjust:
Zone border color
Zone background color
Zone midpoint color
The body threshold, combined wick threshold and session times are fixed in the current version.
Limitations
The indicator does not predict future market direction.
It does not generate automatic entries or exits.
It does not include stop-loss or take-profit calculations.
Fixed point values may behave differently across brokers.
A candle that looks visually small may still fail the filter because its exact body or wick size is too large.
Session timing is based on GMT-4 and may not automatically adapt to daylight-saving changes.
Multiple qualifying candles may produce overlapping zones.
Historical reactions do not guarantee future results.
Disclaimer
This indicator is provided for educational and analytical purposes only. It is not financial advice and does not guarantee profitable results. Traders should test the indicator independently and use appropriate risk management before applying it to live trading. Indicator
Indicator
Indicator
Indicator
Indicator
Indicator
J.TRADER XAU FLOW PILOT EMA 12/26 REV D | Manual Trade AssistantVersion 2 Update
- Changed the primary trend calculation from EMA 9/21 to EMA 12/26.
- A buy indication is generated when EMA 12 crosses above EMA 26.
- A sell indication is generated when EMA 12 crosses below EMA 26.
- Signals can be confirmed after the candle closes to reduce intrabar changes.
- Updated chart labels, dashboard information, multi-timeframe status, and checklist values to use EMA 12/26.
- Updated alert messages with Thai-language signal details.
- Added webhook-compatible alert formatting for external notification services.
- Alert information now includes the symbol, timeframe, current price, momentum condition, news-session status, and current EMA direction.
- The momentum, RSI guard, pressure, reversal guard, confidence score, and news-session filter remain supporting information and do not replace the EMA crossover condition.
- The script does not place, manage, or close orders automatically.
This indicator is intended as a technical analysis tool. Its indications should be evaluated together with market structure, price action, and appropriate risk management. Historical indications do not guarantee future results.
อัปเดตเวอร์ชัน 2
- เปลี่ยนการคำนวณแนวโน้มหลักจาก EMA 9/21 เป็น EMA 12/26
- แสดงสัญญาณซื้อเมื่อ EMA 12 ตัดขึ้นเหนือ EMA 26
- แสดงสัญญาณขายเมื่อ EMA 12 ตัดลงต่ำกว่า EMA 26
- สามารถยืนยันสัญญาณหลังแท่งเทียนปิด เพื่อลดการเปลี่ยนแปลงของสัญญาณระหว่างแท่ง
- ปรับป้ายบนกราฟ แดชบอร์ด สถานะหลายกรอบเวลา และรายการตรวจสอบให้ใช้ EMA 12/26
- ปรับข้อความแจ้งเตือนให้แสดงรายละเอียดเป็นภาษาไทย
- เพิ่มรูปแบบข้อความที่รองรับการส่งผ่าน Webhook ไปยังบริการแจ้งเตือนภายนอก
- ข้อความแจ้งเตือนประกอบด้วยชื่อสินทรัพย์ กรอบเวลา ราคาปัจจุบัน สถานะโมเมนตัม ช่วงเวลาเฝ้าระวังข่าว และทิศทาง EMA
- Momentum, RSI Guard, Pressure, Reversal Guard, Confidence Score และตัวกรองช่วงข่าวเป็นข้อมูลประกอบ โดยไม่เปลี่ยนเงื่อนไขหลักของการตัดกัน EMA
- อินดิเคเตอร์ไม่เปิด ปิด หรือจัดการคำสั่งซื้อขายโดยอัตโนมัติ
อินดิเคเตอร์นี้เป็นเครื่องมือประกอบการวิเคราะห์ทางเทคนิค ผู้ใช้งานควรประเมินร่วมกับโครงสร้างตลาด พฤติกรรมราคา และการบริหารความเสี่ยง ผลที่เกิดขึ้นในอดีตไม่รับประกันผลลัพธ์ในอนาคต Indicator
ZeyneptenBiriCrSinyalZeyneptenBiriCrSinyal combines EMA trend filtering, Fair Value Gaps (FVG), Order Blocks (OB), Breaker Blocks (BB), and BOS/CHoCH structure into a multi-factor scoring system to generate LONG/SHORT signals.
How it works:
Trend direction is determined using EMA 50/200
FVG, Order Block, and Breaker Block zones are auto-detected and plotted
BOS/CHoCH labels mark structure shifts
RSI and volume act as confirmation filters
All factors combine into a score; when the score passes your threshold and Risk/Reward falls within your set range, a signal fires with Entry, Stop, Target, and RR shown on the chart
Features:
Toggle each component (EMA, FVG, OB, BB, BOS/CHoCH) independently
Live score panel showing LONG/SHORT scores, RSI, and ATR
Optional repaint protection (calculates only on confirmed bars)
Built-in alerts for new LONG/SHORT signals
For educational purposes only — not financial advice. Backtest before live use. Indicator
Indicator
Indicator
Combined Breaker Blocks with Imbalance Filter//@version=6
indicator("Combined Breaker Blocks with Imbalance Filter", shorttitle = "Combined Breakers + Imbalance", overlay = true, behind_chart = false, max_boxes_count = 500, max_lines_count = 500, max_labels_count = 500, max_bars_back = 5000)
import PulseWire/ta/12
// ============================================================================
// BỘ LỌC IMBALANCE (FVG)
// ============================================================================
grp_imb = "Bộ Lọc Imbalance (FVG)"
useImbalanceFilter = input.bool(true, title = "Chỉ giữ OB có Imbalance (FVG)", group = grp_imb, tooltip = "Lọc bỏ những vùng OB/Breaker không có khoảng trống giá Imbalance xung quanh.")
// Hàm kiểm tra Imbalance
f_has_imbalance_bull() =>
// Bullish Imbalance (FVG Tăng): Giá cao nhất cây 2 thanh trước thấp hơn giá thấp nhất cây hiện tại
(high < low) or (high < low ) or (high < low)
f_has_imbalance_bear() =>
// Bearish Imbalance (FVG Giảm): Giá thấp nhất cây 2 thanh trước cao hơn giá cao nhất cây hiện tại
(low > high) or (low > high ) or (low > high)
// ============================================================================
// SECTION 1: ALGOALPHA BREAKER BLOCKS
// ============================================================================
// --- Inputs (AlgoAlpha) ---
preventOverlap = input.bool(true, title = "Prevent Overlap", group = "AlgoAlpha - Calculation", tooltip = "When enabled, new orderblocks will not be created if their price range overlaps any existing active orderblock.")
zLen = input.int(100, title = "Z-Score Window (bars)", minval = 1, group = "AlgoAlpha - Calculation", tooltip = "Lookback window used to normalize the impulse distance into a z-score.")
maxAge = input.int(500, title = "Max Box Age (bars)", minval = 1, group = "AlgoAlpha - Calculation", tooltip = "Maximum lifetime (in bars) of an orderblock that has not been mitigated.")
bullCol = input.color(#00ffbb, title = "Bullish Colour", group = "AlgoAlpha - Appearance", tooltip = "Color used for bullish breaker zones and bullish signals.")
bearCol = input.color(#ff1100, title = "Bearish Colour", group = "AlgoAlpha - Appearance", tooltip = "Color used for bearish breaker zones and bearish signals.")
// --- Calculations (AlgoAlpha) ---
var updist = 0.0
var downdist = 0.0
updist := close > open ? nz(updist ) + (close - open) : 0.0
downdist := close < open ? nz(downdist ) + (open - close) : 0.0
upMean = ta.sma(updist, zLen)
upStdev = ta.stdev(updist, zLen)
dnMean = ta.sma(downdist, zLen)
dnStdev = ta.stdev(downdist, zLen)
zUp = (updist - upMean) / (upStdev == 0.0 ? na : upStdev)
zDn = (downdist - dnMean) / (dnStdev == 0.0 ? na : dnStdev)
// Bổ sung lọc Imbalance cho tín hiệu AlgoAlpha
bullish = ta.crossover(zUp, 4) and nz(zUp ) != 0 and (not useImbalanceFilter or f_has_imbalance_bull())
bearish = ta.crossunder(-zDn, -4) and nz((-zDn) ) != 0 and (not useImbalanceFilter or f_has_imbalance_bear())
var box bullBoxes = array.new()
var box bearBoxes = array.new()
var int bullStarts = array.new_int()
var int bearStarts = array.new_int()
var line bullMidLines = array.new()
var line bearMidLines = array.new()
var box breakerBullBoxes = array.new()
var box breakerBearBoxes = array.new()
var int breakerBullStarts = array.new_int()
var int breakerBearStarts = array.new_int()
var line breakerBullMidLines = array.new()
var line breakerBearMidLines = array.new()
breakerBullPlot = float(na)
breakerBearPlot = float(na)
rejectBullPlot = float(na)
rejectBearPlot = float(na)
f_can_create(float tNew, float bNew) =>
bool ok = true
if bullBoxes.size() > 0
for j = 0 to array.size(bullBoxes) - 1
exB = array.get(bullBoxes, j)
float exTop = box.get_top(exB)
float exBot = box.get_bottom(exB)
if (tNew > exBot) and (bNew < exTop)
ok := false
break
if ok and bearBoxes.size() > 0
for j = 0 to array.size(bearBoxes) - 1
exS = array.get(bearBoxes, j)
float exTop2 = box.get_top(exS)
float exBot2 = box.get_bottom(exS)
if (tNew > exBot2) and (bNew < exTop2)
ok := false
break
if ok and breakerBullBoxes.size() > 0
for j = 0 to array.size(breakerBullBoxes) - 1
exB = array.get(breakerBullBoxes, j)
float exTop = box.get_top(exB)
float exBot = box.get_bottom(exB)
if (tNew > exBot) and (bNew < exTop)
ok := false
break
if ok and breakerBearBoxes.size() > 0
for j = 0 to array.size(breakerBearBoxes) - 1
exS = array.get(breakerBearBoxes, j)
float exTop2 = box.get_top(exS)
float exBot2 = box.get_bottom(exS)
if (tNew > exBot2) and (bNew < exTop2)
ok := false
break
ok
f_can_create_breaker(float tNew, float bNew) =>
f_can_create(tNew, bNew)
lastDownIdx = ta.valuewhen(close < open, bar_index, 0)
lastDownHigh = ta.valuewhen(close < open, high, 0)
lastDownLow = ta.valuewhen(close < open, low, 0)
breakerBullPlot := na
breakerBearPlot := na
rejectBullPlot := na
rejectBearPlot := na
if bullish and not na(lastDownIdx) and not na(lastDownHigh) and not na(lastDownLow)
if not preventOverlap or f_can_create(lastDownHigh, lastDownLow)
float midYB = (lastDownHigh + lastDownLow) / 2.0
bx = box.new(lastDownIdx, lastDownHigh, lastDownIdx + 1, lastDownLow, border_color = color.new(color.gray, 40), bgcolor = color.new(color.gray, 85))
ln = line.new(x1 = lastDownIdx, y1 = midYB, x2 = lastDownIdx + 1, y2 = midYB, xloc = xloc.bar_index, extend = extend.none, color = color.new(color.gray, 40), style = line.style_dashed, width = 1)
array.unshift(bullBoxes, bx)
array.unshift(bullStarts, lastDownIdx)
array.unshift(bullMidLines, ln)
lastUpIdx = ta.valuewhen(close > open, bar_index, 0)
lastUpHigh = ta.valuewhen(close > open, high, 0)
lastUpLow = ta.valuewhen(close > open, low, 0)
if bearish and not na(lastUpIdx) and not na(lastUpHigh) and not na(lastUpLow)
if not preventOverlap or f_can_create(lastUpHigh, lastUpLow)
float midYS = (lastUpHigh + lastUpLow) / 2.0
bx2 = box.new(lastUpIdx, lastUpHigh, lastUpIdx + 1, lastUpLow, border_color = color.new(color.gray, 40), bgcolor = color.new(color.gray, 85))
ln2 = line.new(x1 = lastUpIdx, y1 = midYS, x2 = lastUpIdx + 1, y2 = midYS, xloc = xloc.bar_index, extend = extend.none, color = color.new(color.gray, 40), style = line.style_dashed, width = 1)
array.unshift(bearBoxes, bx2)
array.unshift(bearStarts, lastUpIdx)
array.unshift(bearMidLines, ln2)
if bullBoxes.size() > 0
for i = array.size(bullBoxes) - 1 to 0
if array.size(bullBoxes) <= i or array.size(bullStarts) <= i
continue
b = array.get(bullBoxes, i)
box.set_right(b, bar_index)
if array.size(bullMidLines) > i
ln = array.get(bullMidLines, i)
float topB = box.get_top(b)
float botB = box.get_bottom(b)
float midY = (topB + botB) / 2.0
int leftX = box.get_left(b)
line.set_x1(ln, leftX)
line.set_x2(ln, bar_index)
line.set_y1(ln, midY)
line.set_y2(ln, midY)
float topB = box.get_top(b)
float botB = box.get_bottom(b)
bool mitigatedB = close < botB and close < botB
int startB = array.get(bullStarts, i)
bool expiredB = (bar_index - startB) >= maxAge
if mitigatedB or expiredB
bool makeBreaker = mitigatedB
array.remove(bullBoxes, i)
array.remove(bullStarts, i)
if array.size(bullMidLines) > i
array.remove(bullMidLines, i)
if makeBreaker and (not preventOverlap or f_can_create_breaker(topB, botB))
float midYB = (topB + botB) / 2.0
int leftX = bar_index
bxBr = box.new(leftX, topB, leftX + 1, botB, border_color = color.new(bearCol, 40), bgcolor = color.new(bearCol, 85))
lnBr = line.new(x1 = leftX, y1 = midYB, x2 = leftX + 1, y2 = midYB, xloc = xloc.bar_index, extend = extend.none, color = color.new(bearCol, 40), style = line.style_dashed, width = 1)
array.unshift(breakerBearBoxes, bxBr)
array.unshift(breakerBearStarts, leftX)
array.unshift(breakerBearMidLines, lnBr)
breakerBearPlot := topB
if bearBoxes.size() > 0
for i = array.size(bearBoxes) - 1 to 0
if array.size(bearBoxes) <= i or array.size(bearStarts) <= i
continue
b = array.get(bearBoxes, i)
box.set_right(b, bar_index)
if array.size(bearMidLines) > i
ln = array.get(bearMidLines, i)
float topS = box.get_top(b)
float botS = box.get_bottom(b)
float midY = (topS + botS) / 2.0
int leftX = box.get_left(b)
line.set_x1(ln, leftX)
line.set_x2(ln, bar_index)
line.set_y1(ln, midY)
line.set_y2(ln, midY)
float topS = box.get_top(b)
float botS = box.get_bottom(b)
bool mitigatedS = close > topS and close > topS
int startS = array.get(bearStarts, i)
bool expiredS = (bar_index - startS) >= maxAge
if mitigatedS or expiredS
bool makeBreaker = mitigatedS
array.remove(bearBoxes, i)
array.remove(bearStarts, i)
if array.size(bearMidLines) > i
array.remove(bearMidLines, i)
if makeBreaker and (not preventOverlap or f_can_create_breaker(topS, botS))
float midYS = (topS + botS) / 2.0
int leftX = bar_index
bxBr = box.new(leftX, topS, leftX + 1, botS, border_color = color.new(bullCol, 40), bgcolor = color.new(bullCol, 85))
lnBr = line.new(x1 = leftX, y1 = midYS, x2 = leftX + 1, y2 = midYS, xloc = xloc.bar_index, extend = extend.none, color = color.new(bullCol, 40), style = line.style_dashed, width = 1)
array.unshift(breakerBullBoxes, bxBr)
array.unshift(breakerBullStarts, leftX)
array.unshift(breakerBullMidLines, lnBr)
breakerBullPlot := botS
if breakerBullBoxes.size() > 0
for i = array.size(breakerBullBoxes) - 1 to 0
if array.size(breakerBullBoxes) <= i or array.size(breakerBullStarts) <= i
continue
b = array.get(breakerBullBoxes, i)
box.set_right(b, bar_index)
if array.size(breakerBullMidLines) > i
ln = array.get(breakerBullMidLines, i)
float topB = box.get_top(b)
float botB = box.get_bottom(b)
float midY = (topB + botB) / 2.0
int leftX = box.get_left(b)
line.set_x1(ln, leftX)
line.set_x2(ln, bar_index)
line.set_y1(ln, midY)
line.set_y2(ln, midY)
float topB = box.get_top(b)
float botB = box.get_bottom(b)
bool mitigatedB = close < botB and close < botB
int startB = array.get(breakerBullStarts, i)
bool expiredB = (bar_index - startB) >= maxAge
if not mitigatedB and not expiredB and high > botB and low < topB and close > topB
float pad = math.max(math.abs(topB - botB) * 0.1, syminfo.mintick * 2)
rejectBullPlot := botB - pad
if mitigatedB or expiredB
array.remove(breakerBullBoxes, i)
array.remove(breakerBullStarts, i)
if array.size(breakerBullMidLines) > i
array.remove(breakerBullMidLines, i)
if breakerBearBoxes.size() > 0
for i = array.size(breakerBearBoxes) - 1 to 0
if array.size(breakerBearBoxes) <= i or array.size(breakerBearStarts) <= i
continue
b = array.get(breakerBearBoxes, i)
box.set_right(b, bar_index)
if array.size(breakerBearMidLines) > i
ln = array.get(breakerBearMidLines, i)
float topS = box.get_top(b)
float botS = box.get_bottom(b)
float midY = (topS + botS) / 2.0
int leftX = box.get_left(b)
line.set_x1(ln, leftX)
line.set_x2(ln, bar_index)
line.set_y1(ln, midY)
line.set_y2(ln, midY)
float topS = box.get_top(b)
float botS = box.get_bottom(b)
bool mitigatedS = close > topS and close > topS
int startS = array.get(breakerBearStarts, i)
bool expiredS = (bar_index - startS) >= maxAge
if not mitigatedS and not expiredS and high > botS and low < topS and close < botS
float pad = math.max(math.abs(topS - botS) * 0.1, syminfo.mintick * 2)
rejectBearPlot := topS + pad
if mitigatedS or expiredS
array.remove(breakerBearBoxes, i)
array.remove(breakerBearStarts, i)
if array.size(breakerBearMidLines) > i
array.remove(breakerBearMidLines, i)
// --- Plots (AlgoAlpha) ---
breakerBullFormed = not na(breakerBullPlot)
breakerBearFormed = not na(breakerBearPlot)
rejectBull = not na(rejectBullPlot)
rejectBear = not na(rejectBearPlot)
plotshape(breakerBullPlot, "Bullish Breaker ", shape.labelup, location.absolute, bullCol, size = size.tiny, text = "▲", textcolor = chart.fg_color)
plotshape(breakerBearPlot, "Bearish Breaker ", shape.labeldown, location.absolute, bearCol, size = size.tiny, text = "▼", textcolor = chart.fg_color)
plotchar(rejectBullPlot, title = "Bullish Rejection ", char = "▲", location = location.absolute, color = bullCol, size = size.tiny)
plotchar(rejectBearPlot, title = "Bearish Rejection ", char = "▼", location = location.absolute, color = bearCol, size = size.tiny)
// ============================================================================
// SECTION 2: VOLUMIZED BREAKER BLOCKS
// ============================================================================
const bool DEBUG = false
const int maxBoxesCount = 500
const float overlapThresholdPercentage = 0
const int maxDistanceToLastBar = 1750
const int maxOrderBlocks = 60
var bool initRun = true
// --- Inputs (Flux Charts) ---
showInvalidated = input.bool(true, "Show Historic Zones", group = "Flux Charts - Configuration", display = display.none)
OBsEnabled = true
breakBlockVolumetricInfo = input.bool(false, "Volumetric Info", group = "Flux Charts - Configuration", inline="EV", display = display.none)
obEndMethod = input.string("Close", "Order Block Invalidation", options = , group = "Flux Charts - Configuration", display = display.none)
bbEndMethod = input.string("Close", "Breaker Block Invalidation", options = , group = "Flux Charts - Configuration", display = display.none)
combineOBs = DEBUG ? input.bool(true, "Combine Zones", group = "Flux Charts - Configuration", display = display.none) : true
maxATRMult = DEBUG ? input.float(3.5,"Max Atr Multiplier", group = "Flux Charts - Configuration") : 3.5
swingLength = input.int(10, 'Swing Length', minval = 3, tooltip="Swing length is used when finding breaker block formations.", group = "Flux Charts - Configuration", display = display.none)
zoneCount = input.string("Low", 'Zone Count', options = , tooltip = "Number of Breaker Block Zones to be rendered.", group = "Flux Charts - Configuration", display = display.none)
bullishBreakerBlockColor = input(color.new(#2962ff, 75), "Bullish Breaker", inline = 'breakerColor', group = 'Flux Charts - Configuration', display = display.none)
bearishBreakerBlockColor = input(color.new(#ffeb3b, 75), "Bearish Breaker", inline = 'breakerColor', group = 'Flux Charts - Configuration', display = display.none)
bullishBreakerBlocks = zoneCount == "Low" ? 3 : zoneCount == "Medium" ? 5 : 10
bearishBreakerBlocks = zoneCount == "Low" ? 3 : zoneCount == "Medium" ? 5 : 10
bullishOrderBlocks = zoneCount == "Low" ? 15 : zoneCount == "Medium" ? 30 : 60
bearishOrderBlocks = zoneCount == "Low" ? 15 : zoneCount == "Medium" ? 30 : 60
BBsEnabled = true
timeframe1Enabled = true
timeframe1 = ""
breakersFull = DEBUG ? input.bool(true, "Breakers Full", group = "Flux Charts - Style", display = display.none) : true
textColor = input.color(#ffffff80, "Text Color", group = "Flux Charts - Style")
combinedText = DEBUG ? input.bool(false, "Combined Text", group = "Flux Charts - Style", inline = "CombinedColor") : false
atr = ta.atr(10)
// --- Types (Flux Charts) ---
type orderBlockInfo
float top
float bottom
float obVolume
string obType
int startTime
float bbVolume
float obLowVolume
float obHighVolume
bool breaker
int breakTime
string timeframeStr
bool disabled = false
string combinedTimeframesStr = na
bool combined = false
type orderBlock
orderBlockInfo info
bool isRendered = false
box orderBox = na
box breakerBox = na
line orderBoxLineTop = na
line orderBoxLineBottom = na
line breakerBoxLineTop = na
line breakerBoxLineBottom = na
box orderBoxText = na
box orderBoxPositive = na
box orderBoxNegative = na
line orderSeperator = na
line orderTextSeperator = na
createOrderBlock(orderBlockInfo orderBlockInfoF) =>
orderBlock newOrderBlock = orderBlock.new(orderBlockInfoF)
newOrderBlock
safeDeleteOrderBlock(orderBlock orderBlockF) =>
orderBlockF.isRendered := false
box.delete(orderBlockF.orderBox)
box.delete(orderBlockF.breakerBox)
box.delete(orderBlockF.orderBoxText)
box.delete(orderBlockF.orderBoxPositive)
box.delete(orderBlockF.orderBoxNegative)
line.delete(orderBlockF.orderBoxLineTop)
line.delete(orderBlockF.orderBoxLineBottom)
line.delete(orderBlockF.breakerBoxLineTop)
line.delete(orderBlockF.breakerBoxLineBottom)
line.delete(orderBlockF.orderSeperator)
line.delete(orderBlockF.orderTextSeperator)
type timeframeInfo
int index = na
string timeframeStr = na
bool isEnabled = false
orderBlockInfo bullishOrderBlocksList = na
orderBlockInfo bearishOrderBlocksList = na
newTimeframeInfo(index, timeframeStr, isEnabled) =>
newTFInfo = timeframeInfo.new()
newTFInfo.index := index
newTFInfo.isEnabled := isEnabled
newTFInfo.timeframeStr := timeframeStr
newTFInfo
type obSwing
int x = na
float y = na
float swingVolume = na
bool crossed = false
var timeframeInfo timeframeInfos = array.from(newTimeframeInfo(1, timeframe1, timeframe1Enabled))
var bullishOrderBlocksList = array.new(0)
var bearishOrderBlocksList = array.new(0)
var allOrderBlocksList = array.new(0)
// --- Helper Functions (Flux Charts) ---
renderOrderBlock(orderBlock ob) =>
orderBlockInfo info = ob.info
ob.isRendered := true
breakerBlockColor = ob.info.obType == "Bull" ? bearishBreakerBlockColor : bullishBreakerBlockColor
if info.breaker and BBsEnabled
startTime = (OBsEnabled and not breakersFull) ? info.breakTime : info.startTime
ob.breakerBox := box.new(startTime, info.top, time + 1, info.bottom, na, bgcolor = breakerBlockColor, extend = extend.none, xloc = xloc.bar_time, text_color = textColor, text_size = size.normal)
BBText = (na(ob.info.combinedTimeframesStr) ? (ob.info.timeframeStr == "" ? timeframe.period : ob.info.timeframeStr) : ob.info.combinedTimeframesStr) + " BB"
box.set_text(ob.breakerBox, (breakBlockVolumetricInfo ? str.tostring(ob.info.bbVolume, format.volume) + " " : "") + (combinedText and ob.info.combined ? " " : "") + BBText)
ob.breakerBoxLineTop := line.new(startTime, info.top, time + 1, info.top, xloc.bar_time, extend.none, color.new(breakerBlockColor, 0), line.style_dashed)
ob.breakerBoxLineBottom := line.new(startTime, info.bottom, time + 1, info.bottom, xloc.bar_time, extend.none, color.new(breakerBlockColor, 0), line.style_dashed)
findOBSwings(len) =>
var swingType = 0
var obSwing top = obSwing.new(na, na)
var obSwing bottom = obSwing.new(na, na)
upper = ta.highest(len)
lower = ta.lowest(len)
swingType := high > upper ? 0 : low < lower ? 1 : swingType
if swingType == 0 and swingType != 0
top := obSwing.new(bar_index , high , volume )
if swingType == 1 and swingType != 1
bottom := obSwing.new(bar_index , low , volume )
findOrderBlocks() =>
if bar_index > last_bar_index - maxDistanceToLastBar
= findOBSwings(swingLength)
useBody = false
max = useBody ? math.max(close, open) : high
min = useBody ? math.min(close, open) : low
// Bullish Order Block (có bổ sung kiểm tra Imbalance)
if bullishOrderBlocksList.size() > 0
for i = bullishOrderBlocksList.size() - 1 to 0
currentOB = bullishOrderBlocksList.get(i)
if not currentOB.breaker
if ((obEndMethod == "Wick" ? low : close) < currentOB.bottom)
currentOB.breaker := true
currentOB.breakTime := time
currentOB.bbVolume := volume
else
if (bbEndMethod == "Wick" ? high : close) > currentOB.top
bullishOrderBlocksList.remove(i)
if close > top.y and not top.crossed and (not useImbalanceFilter or f_has_imbalance_bull())
top.crossed := true
boxBtm = max
boxTop = min
boxLoc = time
for i = 1 to (bar_index - top.x) - 1
boxBtm := math.min(min , boxBtm)
boxTop := boxBtm == min ? max : boxTop
boxLoc := boxBtm == min ? time : boxLoc
newOrderBlockInfo = orderBlockInfo.new(boxTop, boxBtm, volume + volume + volume , "Bull", boxLoc)
newOrderBlockInfo.obLowVolume := volume
newOrderBlockInfo.obHighVolume := volume + volume
obSize = math.abs(newOrderBlockInfo.top - newOrderBlockInfo.bottom)
if obSize <= atr * maxATRMult
bullishOrderBlocksList.unshift(newOrderBlockInfo)
if bullishOrderBlocksList.size() > maxOrderBlocks
bullishOrderBlocksList.pop()
// Bearish Order Block (có bổ sung kiểm tra Imbalance)
if bearishOrderBlocksList.size() > 0
for i = bearishOrderBlocksList.size() - 1 to 0
currentOB = bearishOrderBlocksList.get(i)
if not currentOB.breaker
if (obEndMethod == "Wick" ? high : close) > currentOB.top
currentOB.breaker := true
currentOB.breakTime := time
currentOB.bbVolume := volume
else
if (bbEndMethod == "Wick" ? low : close) < currentOB.bottom
bearishOrderBlocksList.remove(i)
if close < btm.y and not btm.crossed and (not useImbalanceFilter or f_has_imbalance_bear())
btm.crossed := true
boxBtm = min
boxTop = max
boxLoc = time
for i = 1 to (bar_index - btm.x) - 1
boxTop := math.max(max , boxTop)
boxBtm := boxTop == max ? min : boxBtm
boxLoc := boxTop == max ? time : boxLoc
newOrderBlockInfo = orderBlockInfo.new(boxTop, boxBtm, volume + volume + volume , "Bear", boxLoc)
newOrderBlockInfo.obLowVolume := volume + volume
newOrderBlockInfo.obHighVolume := volume
obSize = math.abs(newOrderBlockInfo.top - newOrderBlockInfo.bottom)
if obSize <= atr * maxATRMult
bearishOrderBlocksList.unshift(newOrderBlockInfo)
if bearishOrderBlocksList.size() > maxOrderBlocks
bearishOrderBlocksList.pop()
true
areaOfOB(orderBlockInfo OBInfoF) =>
float XA1 = OBInfoF.startTime
float XA2 = na(OBInfoF.breakTime) ? time + 1 : OBInfoF.breakTime
float YA1 = OBInfoF.top
float YA2 = OBInfoF.bottom
float edge1 = math.sqrt((XA2 - XA1) * (XA2 - XA1) + (YA2 - YA2) * (YA2 - YA2))
float edge2 = math.sqrt((XA2 - XA2) * (XA2 - XA2) + (YA2 - YA1) * (YA2 - YA1))
edge1 * edge2
doOBsTouch(orderBlockInfo OBInfo1, orderBlockInfo OBInfo2) =>
float XA1 = OBInfo1.startTime
float XA2 = na(OBInfo1.breakTime) ? time + 1 : OBInfo1.breakTime
float YA1 = OBInfo1.top
float YA2 = OBInfo1.bottom
float XB1 = OBInfo2.startTime
float XB2 = na(OBInfo2.breakTime) ? time + 1 : OBInfo2.breakTime
float YB1 = OBInfo2.top
float YB2 = OBInfo2.bottom
float intersectionArea = math.max(0, math.min(XA2, XB2) - math.max(XA1, XB1)) * math.max(0, math.min(YA1, YB1) - math.max(YA2, YB2))
float unionArea = areaOfOB(OBInfo1) + areaOfOB(OBInfo2) - intersectionArea
float overlapPercentage = (intersectionArea / unionArea) * 100.0
overlapPercentage > overlapThresholdPercentage
isOBValid(orderBlockInfo OBInfo) =>
not OBInfo.disabled
combineOBsFunc() =>
if allOrderBlocksList.size() > 0
lastCombinations = 999
while lastCombinations > 0
lastCombinations := 0
for i = 0 to allOrderBlocksList.size() - 1
curOB1 = allOrderBlocksList.get(i)
for j = 0 to allOrderBlocksList.size() - 1
curOB2 = allOrderBlocksList.get(j)
if i == j or not isOBValid(curOB1.info) or not isOBValid(curOB2.info) or curOB1.info.obType != curOB2.info.obType
continue
if doOBsTouch(curOB1.info, curOB2.info)
curOB1.info.disabled := true
curOB2.info.disabled := true
orderBlock newOB = createOrderBlock(orderBlockInfo.new(math.max(curOB1.info.top, curOB2.info.top), math.min(curOB1.info.bottom, curOB2.info.bottom), curOB1.info.obVolume + curOB2.info.obVolume, curOB1.info.obType))
newOB.info.startTime := math.min(curOB1.info.startTime, curOB2.info.startTime)
newOB.info.breakTime := math.max(nz(curOB1.info.breakTime), nz(curOB2.info.breakTime))
newOB.info.breakTime := newOB.info.breakTime == 0 ? na : newOB.info.breakTime
newOB.info.timeframeStr := curOB1.info.timeframeStr
newOB.info.obVolume := curOB1.info.obVolume + curOB2.info.obVolume
newOB.info.obLowVolume := curOB1.info.obLowVolume + curOB2.info.obLowVolume
newOB.info.obHighVolume := curOB1.info.obHighVolume + curOB2.info.obHighVolume
newOB.info.bbVolume := nz(curOB1.info.bbVolume, 0) + nz(curOB2.info.bbVolume, 0)
newOB.info.breaker := curOB1.info.breaker or curOB2.info.breaker
newOB.info.combined := true
allOrderBlocksList.unshift(newOB)
lastCombinations += 1
reqSeq(timeframeStr) =>
request.security(syminfo.tickerid, timeframeStr, )
getTFData(timeframeInfo timeframeInfoF, timeframeStr) =>
if timeframeInfoF.isEnabled
reqSeq(timeframeStr)
else
handleTimeframeInfo(timeframeInfo timeframeInfoF, bullishOrderBlocksListF, bearishOrderBlocksListF) =>
if timeframeInfoF.isEnabled
timeframeInfoF.bullishOrderBlocksList := bullishOrderBlocksListF
timeframeInfoF.bearishOrderBlocksList := bearishOrderBlocksListF
arrHasOB(orderBlock arr, orderBlock obF) =>
hasOB = false
if arr.size() > 0
for i = 0 to arr.size() - 1
orderBlock ob1 = arr.get(i)
if isOBValid(ob1.info) and isOBValid(obF.info) and (ob1.info.breaker == obF.info.breaker) and doOBsTouch(ob1.info, obF.info)
hasOB := true
break
hasOB
bool newBullishBBTick = false
bool newBearishBBTick = false
handleOrderBlocksFinal() =>
newBullishOBAlert = false
newBearishOBAlert = false
newBullishBBAlert = false
newBearishBBAlert = false
alertTimeOB = ""
alertTimeBB = ""
orderBlock orderBlocksToAdd = array.new(0)
for i = 0 to timeframeInfos.size() - 1
curTimeframe = timeframeInfos.get(i)
if not curTimeframe.isEnabled
continue
if not na(curTimeframe.bullishOrderBlocksList)
if curTimeframe.bullishOrderBlocksList.size() > 0
for j = 0 to math.min(curTimeframe.bullishOrderBlocksList.size() - 1, bullishOrderBlocks - 1)
orderBlockInfoF = curTimeframe.bullishOrderBlocksList.get(j)
orderBlockInfoF.timeframeStr := curTimeframe.timeframeStr
orderBlocksToAdd.unshift(createOrderBlock(orderBlockInfo.copy(orderBlockInfoF)))
if not na(curTimeframe.bearishOrderBlocksList)
if curTimeframe.bearishOrderBlocksList.size() > 0
for j = 0 to math.min(curTimeframe.bearishOrderBlocksList.size() - 1, bearishOrderBlocks - 1)
orderBlockInfoF = curTimeframe.bearishOrderBlocksList.get(j)
orderBlockInfoF.timeframeStr := curTimeframe.timeframeStr
orderBlocksToAdd.unshift(createOrderBlock(orderBlockInfo.copy(orderBlockInfoF)))
if orderBlocksToAdd.size() > 0
for i = 0 to orderBlocksToAdd.size() - 1
obToTest = orderBlocksToAdd.get(i)
if obToTest.info.breaker == false
if not arrHasOB(allOrderBlocksList, obToTest)
alertTimeOB := obToTest.info.timeframeStr
if obToTest.info.obType == "Bull"
newBullishOBAlert := true
else
newBearishOBAlert := true
else
if not arrHasOB(allOrderBlocksList, obToTest)
alertTimeBB := obToTest.info.timeframeStr
if obToTest.info.obType == "Bull"
newBearishBBAlert := true
else
newBullishBBAlert := true
if allOrderBlocksList.size() > 0
for i = 0 to allOrderBlocksList.size() - 1
safeDeleteOrderBlock(allOrderBlocksList.get(i))
allOrderBlocksList.clear()
if orderBlocksToAdd.size() > 0
for i = 0 to orderBlocksToAdd.size() - 1
allOrderBlocksList.unshift(orderBlocksToAdd.get(i))
if combineOBs
combineOBsFunc()
if allOrderBlocksList.size() > 0
for i = 0 to allOrderBlocksList.size() - 1
curOB = allOrderBlocksList.get(i)
if isOBValid(curOB.info)
renderOrderBlock(curOB)
findOrderBlocks()
= getTFData(timeframeInfos.get(0), timeframe1)
if barstate.isconfirmed and (bar_index > last_bar_index - maxDistanceToLastBar)
handleTimeframeInfo(timeframeInfos.get(0), bullishOrderBlocksListTimeframe1, bearishOrderBlocksListTimeframe1)
= handleOrderBlocksFinal()
if newBullishBBAlert
newBullishBBTick := true
if newBearishBBAlert
newBearishBBTick := true
// --- Alerts (Flux Charts) ---
alertcondition((newBullishBBTick or newBearishBBTick) and not initRun, "Breaker Block Formation ", "A new Breaker Block has formed.")
alertcondition(newBullishBBTick and not initRun, "Bullish Breaker Block Formation ", "A new Bullish Breaker Block has formed.")
alertcondition(newBearishBBTick and not initRun, "Bearish Breaker Block Formation ", "A new Bearish Breaker Block has formed.")
if barstate.isconfirmed
initRun := false Indicator
BK AK-Bl00DHoundBK AK-Bl00DHound - Footprint CVD Spark
A session-based footprint CVD, opening-relative price, slope-transition, participation, and confluence framework for intraday market analysis.
Acknowledgment
All glory and gratitude to G-d.
The AK in BK AK-Bl00DHound honors my mentor, A.K.—the man whose guidance shaped my discipline, patience, market judgment, and respect for clean execution. I dedicate every indicator I build to his honor.
Original Source and Attribution
BK AK-Bl00DHound is a modified and substantially expanded derivative of Intraday Spark Chart , created by PulseWire author AstrideUnicorn.
Full credit is given to AstrideUnicorn for the originating Spark Chart concept and source foundation. This publication does not claim authorship of AstrideUnicorn’s original work.
The BK implementation expands that foundation through independently developed modules including:
Native footprint CVD
ETH, RTH, full-session, and custom-session architecture
Raw, Delta Ratio, and Normalized display modes
Display-independent raw signal coordinates
Scaled opening-relative price comparison
Extreme slope-transition detection
Synchronized price and CVD pivot analysis
Peak and valley evidence scoring
Buy/sell participation tracking
High-delta, limited-price-response analysis
Per-bar Point of Control migration
CVD velocity bands
Eight intraday sub-session windows
Session-intensity measurements
Peak and valley background highlighting
Per-bar delta histogram
Session markers and CVD labels
Compact and detailed dashboards
Composite directional-alignment scoring
Alerts and contextual tooltips
The source header identifies AstrideUnicorn’s original work and the separate modifications and expansions developed for BK AK-Bl00DHound.
What BK AK-Bl00DHound Is
BK AK-Bl00DHound is a separate-pane intraday framework designed to compare:
Cumulative footprint delta
Price movement from the session open
CVD direction
Opening-relative price direction
Buy and sell participation
Delta acceleration
Price-versus-CVD disagreement
Session extremes
Confirmed pivot structure
High-delta, limited-price-response conditions
Per-bar POC migration
Time-of-day participation
Composite directional alignment
The framework follows one connected analytical sequence:
Footprint participation → session CVD → opening-relative price → slope relationship → structural evidence → composite context
Its purpose is not to predict every high, low, continuation, or reversal.
Its purpose is to show when price, CVD, participation, slope, structure, velocity, and session context are aligned—and when they are disagreeing.
Footprint Data
BK AK-Bl00DHound uses PulseWire’s native footprint data to obtain:
Buy volume
Sell volume
Net delta
Total volume
Per-bar Point of Control
Footprint Value Area information used by the request
The CVD line is constructed by accumulating native footprint delta during the active session.
When footprint data is unavailable, the indicator displays a warning. It does not replace the unavailable footprint information with candle-direction volume.
Footprint availability depends on the chart symbol and the user’s PulseWire data access.
The optional symbol input is display-only. All calculations remain connected to the chart’s actual symbol.
Session Architecture
BK AK-Bl00DHound supports five session configurations:
Auto
ETH + RTH
RTH Only
Full Session
Custom
Auto
Auto mode uses:
ETH + RTH on chart timeframes of 15 minutes or less
Full Session on chart timeframes above 15 minutes
ETH + RTH
This mode measures the broader futures session while resetting the framework at the ETH and RTH transitions.
It allows overnight and regular-session participation to be analyzed separately.
RTH Only
RTH Only measures the configured regular session.
The default RTH window is:
09:30–16:00 America/New_York
Full Session
Full Session uses the configured:
18:00–17:00
session structure and resets at the evening opening.
Custom
Custom mode uses the session and timezone selected by the user.
The session definition should match the instrument being analyzed. An incorrect session or timezone will change every session-based calculation.
Session CVD
Session CVD is the cumulative sum of native footprint delta during the active session.
Positive CVD means accumulated buy volume exceeds accumulated sell volume under PulseWire’s footprint classification.
Negative CVD means accumulated sell volume exceeds accumulated buy volume.
CVD reports classified buying and selling participation.
It does not identify individual traders, institutions, funds, market makers, or participant intent.
Display Modes
BK AK-Bl00DHound includes three display modes:
Raw
Delta Ratio
Normalized
Raw
Raw mode displays accumulated footprint delta in native volume units.
The size of the reading depends on:
Instrument
Liquidity
Timeframe
Session length
Trading activity
Raw values should not be directly compared across unrelated instruments.
Delta Ratio
Delta Ratio divides session CVD by accumulated session volume.
This expresses directional participation relative to total analyzed volume.
Normalized
Normalized mode compares session CVD with an adaptive range derived from completed sessions.
This produces the wider and clearer default pane appearance.
Raw Signal Lock
The display mode changes only the visible presentation.
Peak, valley, and extreme slope-transition logic continues to use dedicated raw CVD and raw Spark coordinates.
Changing between Raw, Delta Ratio, and Normalized therefore changes:
Visible scale
Displayed CVD
Displayed Spark
Histogram height
Label formatting
It does not change the underlying raw signal thresholds or raw signal history.
Opening-Relative Price Spark
The Spark line measures price movement from the active session opening.
That price displacement is scaled into the CVD pane so price and directional participation can be compared visually.
The Spark line does not convert price into volume.
It creates a shared visual reference for questions such as:
Is price rising while CVD rises?
Is price rising while CVD falls?
Is price falling while CVD falls?
Is price falling while CVD rises?
The displayed Spark follows the selected Data Mode.
The signal Spark remains tied to the raw source geometry.
Dynamic Line Coloring
The visible CVD and Spark lines can be colored by:
Their position relative to zero
Their current slope direction
With slope coloring enabled:
Rising line segments use bullish colors
Falling line segments use bearish colors
With slope coloring disabled:
Values above zero use bullish colors
Values below zero use bearish colors
The CVD area fill can either:
Match the visible CVD line
Follow the legacy above-zero and below-zero behavior
An independent fill can also be displayed between the CVD and Spark lines.
Flow Relationship
The Flow state compares the current slope direction of raw CVD and raw Spark.
Confirm Up
Spark rising and CVD rising.
Price and directional participation are aligned upward.
Peak Warning
Spark rising while CVD is flat or falling.
Price is advancing while directional participation is not advancing with it.
Valley Warning
Spark falling while CVD is flat or rising.
Price is declining while directional participation is not declining with it.
Confirm Down
Spark falling and CVD falling.
Price and directional participation are aligned downward.
Flat
No qualified directional relationship is active.
These states describe current alignment or disagreement. They do not guarantee continuation or reversal.
Extreme Slope Transition
The Extreme Slope Reversal module can monitor:
CVD Only
Spark Only
Either
Both
The engine uses an armed-state process.
High-side event
The selected line reaches or exceeds its configured high level.
The line must still be rising.
The high-side condition becomes armed.
The signal fires on the first confirmed bar that changes to a falling slope.
Low-side event
The selected line reaches or falls below its configured low level.
The line must still be falling.
The low-side condition becomes armed.
The signal fires on the first confirmed bar that changes to a rising slope.
The reversal bar does not need to remain beyond the original threshold.
This allows the transition to print on the first confirmed opposite-slope close after the extreme was armed.
The Minimum Session Bars setting prevents slope events from firing before enough session history has accumulated.
Peak and Valley Pattern Engine
The pattern engine combines several evidence families.
Potential peak evidence includes:
Bearish price-versus-CVD divergence
Hidden bearish divergence
Peak-style flow disagreement
High-side slope transition
Price near the upper session range while CVD is comparatively weak
Elevated session intensity
High-delta, limited-price-response evidence
Potential valley evidence uses the corresponding bullish conditions.
Synchronized Pivot Comparison
Price pivots are confirmed using the selected Pivot Lookback.
When a price pivot confirms, BK AK-Bl00DHound stores the raw CVD value from that exact price-pivot bar.
This avoids comparing:
A price pivot from one bar
With an unrelated CVD pivot from another bar
Separate CVD pivots are maintained for the optional pivot dots.
Balanced Mode
Balanced mode requires:
The evidence score to meet the configured threshold
At least one qualifying evidence family
A confirmed raw slope transition in the relevant direction
Strict Mode
Strict mode requires every Balanced condition and also requires price and CVD to occupy opposing session extremes.
A confirmed Peak or Valley means the configured evidence requirements aligned.
It does not establish that the final market high or low has occurred.
Peak and Valley Markers
A downward arrow identifies a qualified Peak condition.
An upward arrow identifies a qualified Valley condition.
The optional background mode can shade:
The exact confirmed Peak or Valley arrow bar
The underlying Extreme Slope Reversal bar
No bars
The default Peak / Valley Arrows mode links the vertical background tint directly to the confirmed arrow event.
The arrow and background are two visual representations of the same completed rule set.
Pattern Evidence Score
The pattern engine assigns points to active evidence families.
Potential contributors include:
Pivot disagreement
Flow disagreement
Slope transition
Session-range position
Session intensity
High-delta, limited-price-response evidence
Session-mode context
The result is an internal evidence score.
It is not:
A probability
A win rate
A confidence interval
A position-size recommendation
A guarantee of reversal
The score represents how many weighted conditions are currently aligned.
High-Delta, Limited-Price-Response Analysis
The script identifies a candidate event when:
Absolute footprint delta exceeds 1.3 times its 20-bar average
Candle-body movement is below 0.6 times its 20-bar average
A bullish candidate requires:
Negative delta
Price holding or closing above the open
A bearish candidate requires:
Positive delta
Price holding or closing below the open
The script accumulates and decays an internal session score.
The displayed states include:
None
Mild
Strong
Elevated
This is an effort-versus-result measurement.
It does not prove:
A hidden order
A resting bid or offer
Institutional activity
Accumulation
Distribution
A defended level
Point-of-Control Migration
For every available footprint bar, BK AK-Bl00DHound reads the footprint POC.
It then counts how frequently the per-bar POC moves:
Up
Down
The resulting migration ratio is compared with price movement from the session opening.
Acceptance Context
Price and POC migration are moving in the same general direction.
Rejection Context
Price and POC migration are moving in opposing directions.
Neutral Context
Neither relationship exceeds the internal threshold.
This is a comparison of consecutive per-bar POCs.
It is not a developing session-volume-profile POC and does not guarantee breakout acceptance or rejection.
Delta Velocity
Delta Velocity measures the rate of change in raw session CVD.
The module calculates:
CVD change over the selected period
Average CVD change
Standard deviation of CVD change
Upper statistical band
Lower statistical band
A reading above the upper band indicates unusually strong positive CVD acceleration relative to the recent sample.
A reading below the lower band indicates unusually strong negative CVD acceleration.
A band breach identifies a statistical outlier.
It does not require the move to reverse.
Session Intensity
Session Intensity compares the magnitude of current session CVD with an adaptive completed-session CVD range.
The states include:
Quiet
Normal
Active
Hot
Extreme
These classifications describe relative CVD magnitude.
They do not establish direction, participant identity, or a future market outcome.
Time-of-Day Windows
BK AK-Bl00DHound divides the default New York session structure into eight windows:
Asia: 18:00–02:00
London: 02:00–08:00
Premarket: 08:00–09:30
Opening Drive: 09:30–10:30
Morning: 10:30–12:00
Lunch: 12:00–14:00
Afternoon: 14:00–15:30
Market-on-Close window: 15:30–16:00
For each window, the engine tracks:
Cumulative delta
Total footprint volume
Historical absolute CVD activity
Current relative intensity
Direction of completed windows
The sub-session strip summarizes whether completed windows produced positive or negative CVD.
These windows provide context. They do not predict the following session or the next trading day.
Per-Bar Delta Histogram
The histogram displays the current footprint delta for each bar.
Its visible height can be multiplied using the Bar Delta Scale setting.
Positive bars use the selected positive color.
Negative bars use the selected negative color.
Changing the histogram scale affects only visual height.
It does not alter:
CVD
Peak and Valley logic
Slope-transition logic
Composite scoring
Session Markers
The script can display vertical lines at:
RTH opening
ETH opening
Optional RTH and ETH letters can be displayed above those lines.
The line height, transparency, width, and colors are configurable.
These are pane references only.
Session Labels and CVD Extremes
Session labels display current or completed session CVD in the selected display units.
The script can also mark:
Highest displayed session CVD
Lowest displayed session CVD
These marks identify observed CVD extremes within the active session.
They do not represent fixed limits on future buying or selling activity.
Composite Directional Alignment
The dashboard combines several internal modules into a directional score from -100 to +100.
Potential contributors include:
Flow relationship
Extreme slope transition
Peak or Valley evidence
High-delta, limited-price-response context
Delta velocity
POC migration
The score can be classified as:
Strong Bullish Alignment
Bullish Lean
Neutral
Bearish Lean
Strong Bearish Alignment
The composite score is an internal weighted summary.
A score of +70 does not mean a 70% probability that price will rise.
A score of -70 does not mean a 70% probability that price will fall.
Dashboards
Zenith Meter
The Zenith Meter provides a compact summary of:
Composite alignment
Direction meter
Flow state
Slope state
Pattern state
High-delta response state
POC state
Velocity state
Session delta
Delta Ratio
Buy/sell percentage
Session intensity
Current time window
Current ETH or RTH segment
Detailed Dashboard
The Detailed dashboard expands the framework into rows for:
Session delta
Buy/sell participation
Delta Ratio
Flow
Slope
Intensity
Pattern
High-delta response
POC migration
Velocity
Time of day
Completed-window strip
Session CVD high and low
Previous-session CVD
Current session mode
The dashboards organize the underlying measurements. They do not place trades or replace direct chart analysis.
Alerts
Alerts are available for:
Qualified Peak condition
Qualified Valley condition
Bullish extreme slope transition
Bearish extreme slope transition
CVD velocity-band breach
Elevated high-delta, limited-price-response condition
An alert means a configured rule set became active.
It does not guarantee a particular market response.
How to Use BK AK-Bl00DHound
1. Use an Intraday Chart
BK AK-Bl00DHound is designed for chart timeframes of four hours or lower.
A warning appears on timeframes above four hours.
The framework is most useful on liquid instruments where native footprint data is available.
2. Confirm Footprint Availability
Before interpreting the CVD line, confirm that the No footprint data warning is absent.
Without footprint data:
Bar delta is unavailable
Session CVD cannot develop normally
Buy/sell percentages are unavailable
POC migration is unavailable
High-delta response analysis is unavailable
3. Select the Correct Session
Choose the session mode that matches the analysis.
Use:
ETH + RTH to compare overnight and regular-session participation
RTH Only for cash-session analysis
Full Session for one continuous futures session
Custom for another market schedule
Auto for the timeframe-sensitive defaults
Verify the selected timezone.
4. Begin With Normalized Mode
Normalized is the default display and provides the wider, clearer pane presentation.
Because signal logic remains locked to raw coordinates, changing the display mode does not alter the underlying raw signal logic.
Use:
Raw for native accumulated delta values
Delta Ratio for delta relative to session volume
Normalized for clearer visual comparison
5. Read CVD and Spark Together
The primary relationship is between:
Session CVD
Opening-relative price Spark
Watch for four main conditions:
Both Rising
Price and directional participation are aligned upward.
Both Falling
Price and directional participation are aligned downward.
Spark Rising While CVD Weakens
Price is advancing without equal improvement in directional participation.
Spark Falling While CVD Improves
Price is declining without equal deterioration in directional participation.
Agreement provides continuation context.
Disagreement provides transition or exhaustion context requiring confirmation.
6. Check the Flow State
Use the Flow state as the first summary:
Confirm Up
Peak Warning
Valley Warning
Confirm Down
Flat
Do not act from the Flow label alone.
Review the actual CVD and Spark lines and confirm the condition with price structure.
7. Review the Slope State
A slope event requires:
A raw extreme to become armed
A confirmed opposite-slope close
The configured minimum session-bar count
Use:
CVD Only when participation should control the trigger
Spark Only when opening-relative price should control it
Both for maximum selectivity
Either for greater signal frequency
8. Evaluate Peak and Valley Evidence
When an arrow appears, inspect the contributing evidence:
Pivot disagreement
Flow disagreement
Slope transition
Price location
CVD location
Session intensity
High-delta response
Use Balanced mode for broader qualification.
Use Strict mode when opposing price and CVD session extremes should also be required.
9. Review the Background Highlight
With Peak / Valley Arrows selected, the background shades the exact confirmed arrow bar.
With Extreme Reversal selected, it shades the underlying slope-transition event.
Use the background as a visual locator—not as a separate signal.
10. Check POC Migration
Determine whether per-bar POC migration is:
Moving with price
Moving against price
Mixed
POC movement with price adds acceptance context.
POC movement against price adds disagreement context.
It does not independently determine whether a trend will continue or fail.
11. Review Delta Velocity
A velocity-band breach indicates unusually rapid CVD change.
Determine whether the breach:
Continues
Decelerates
Conflicts with price
Occurs near a Peak or Valley condition
The breach alone is not a reversal signal.
12. Review Time-of-Day Context
Compare the current window with completed windows.
Examples:
Does Opening Drive confirm or reverse Premarket CVD?
Does Morning continue the Opening Drive?
Does Lunch reduce directional participation?
Does Afternoon rebuild or reverse the earlier session flow?
Does the Market-on-Close window agree with the broader RTH direction?
Use these comparisons to understand participation shifts.
13. Use the Dashboard as a Summary
Start with the Zenith Meter.
Switch to the Detailed Dashboard when the underlying components need to be inspected.
A strong composite reading should always be traced back to the modules producing it.
14. Confirm With Price Structure
Before acting on any condition, define:
Entry confirmation
Invalidation
Position size
Maximum account risk
Exit method
BK AK-Bl00DHound is a decision-support framework, not an order-management system.
Recommended Starting Configuration
Session Mode: Auto
Timezone: America/New_York for U.S. futures
Data Mode: Normalized
Extreme Slope Reversal: On
Trigger Source: Either
CVD Slope Length: 1
Spark Slope Length: 1
CVD High/Low Levels: +65 / -65
Spark High/Low Levels: +65 / -65
Minimum Session Bars: 10
Background Trigger: Peak / Valley Arrows
Pattern Detection: On
Pivot Lookback: 5
Evidence Threshold: 45
Signal Mode: Balanced
Time-of-Day Tracking: On
Delta Velocity: On
Velocity Period: 14
Band Multiplier: 2.0
Price Overlay: On
CVD/Price Gap Fill: On
Per-Bar Delta Histogram: On
Dashboard Mode: Zenith Meter
What Is Original
Opening-relative Spark charts, CVD, pivots, statistical bands, Point of Control, and session analysis are established concepts.
The source foundation is credited to AstrideUnicorn.
The separate BK contribution is the specific architecture connecting:
Native footprint CVD
Multi-session reset governance
Independent display and raw signal coordinates
Adaptive normalized-session ranges
Scaled opening-relative price
Persistent slope-direction states
Armed extreme-transition logic
Same-bar confirmed reversal events
Synchronized price-pivot and CVD sampling
Balanced and Strict evidence qualification
High-delta, limited-price-response scoring
Per-bar POC migration
Eight time-of-day participation windows
CVD velocity bands
Session-intensity normalization
Arrow-linked background shading
Session CVD labels and extrema
Composite directional-alignment scoring
Compact and detailed dashboards
Unified alerts and contextual tooltips
The value of BK AK-Bl00DHound is not one individual calculation.
It is the governed interaction between footprint participation, session CVD, opening-relative price, slope transitions, structural evidence, and time-of-day context.
Realtime Behavior and Limitations
Native footprint values can change while the active bar is forming.
Session CVD changes intrabar.
Peak and Valley signals require confirmed slope-transition bars.
Price pivots require the selected right-side confirmation period.
Pivot-related information appears after the pivot has formed.
Normalization changes visible coordinates but not raw signal coordinates.
Adaptive display ranges depend on completed-session history.
Early-session measurements use smaller samples.
POC migration compares consecutive per-bar POCs.
High-delta response is a heuristic.
Velocity-band breaches are statistical outliers, not guaranteed exhaustion.
Time-of-day classifications do not predict subsequent windows.
Composite scores are model outputs, not probabilities.
The script does not include commissions, slippage, position sizing, or execution.
It is an indicator, not a PulseWire strategy backtest.
Every condition can fail.
Suitable Markets and Timeframes
BK AK-Bl00DHound is designed for intraday charts up to four hours.
It is most applicable to liquid markets where native footprint information is available, including supported:
Futures
Equities
Cryptocurrency markets
Other high-volume instruments
Appropriate settings can differ across instruments, sessions, and timeframes.
Risk Disclosure
BK AK-Bl00DHound is provided for analytical and educational purposes.
It does not provide financial advice, guarantee performance, identify institutional activity, or predict future market direction with certainty.
Users remain responsible for their own:
Market analysis
Entry decisions
Exit decisions
Position sizing
Invalidation
Order execution
Account risk
Track the flow. Compare it with price. Confirm the transition. Respect the invalidation. Indicator
Bear Logic Systems: Sector Heatmap V1Bear Logic Systems: Sector Heatmap V1
===========
This Pine Script v5 code is a custom PulseWire indicator titled "Bear Logic Systems: Sector Heatmap V1". It renders a dynamic dashboard/table directly on your chart that tracks tech sector health, market volatility, and key metrics for the currently viewed stock.
Key Features & Functionality
Market & Sector Breadth Tracking:
Fetches data for 23 top tech stocks to calculate percentage-based market breadth for three major sector ETFs: XLK (Tech), IGV (Software), and SOXX (Semiconductors).
Tracks the VIX Index and its daily percentage change to monitor overall market volatility/fear.
VWAP & Open Tracking:
Displays whether XLK, IGV, SOXX, and the active ticker are trading above or below their Volume Weighted Average Price (VWAP), including slope direction arrows (↗, ↘) and percentage distances.
Shows performance relative to the daily opening price.
Gap Analysis & All-Time High (ATH) Status:
Calculates daily gap status (Gap UP, Gap DOWN, or Flat) along with dollar and percentage changes.
Measures drawdown distance (%) from the All-Time High (ATH) for each sector and the active ticker.
Pre-Market High (PMH):
Detects and displays the exact Pre-Market High price for the active symbol during extended session trading.
Customizable Dashboard Layout:
Options to adjust table position on the screen (e.g., Bottom Left, Top Right).
Toggles to show/hide specific rows (Headers, Breadth %, VWAP & Open, Gap Status, ATH Drop, Pre-Market High).
Adjustable background transparency and dynamic text coloring based on bullish/bearish conditions. Indicator
Bear Logic Systems: Sector Heatmap V1This Pine Script v6 code is a custom PulseWire indicator titled "Bear Logic Systems: Sector Heatmap V1". It renders a dynamic dashboard/table directly on your chart that tracks tech sector health, market volatility, and key metrics for the currently viewed stock.
Key Features & Functionality
Market & Sector Breadth Tracking:
Fetches data for 23 top tech stocks to calculate percentage-based market breadth for three major sector ETFs: XLK (Tech), IGV (Software), and SOXX (Semiconductors).
Tracks the VIX Index and its daily percentage change to monitor overall market volatility/fear.
VWAP & Open Tracking:
Displays whether XLK, IGV, SOXX, and the active ticker are trading above or below their Volume Weighted Average Price (VWAP), including slope direction arrows (↗, ↘) and percentage distances.
Shows performance relative to the daily opening price.
Gap Analysis & All-Time High (ATH) Status:
Calculates daily gap status (Gap UP, Gap DOWN, or Flat) along with dollar and percentage changes.
Measures drawdown distance (%) from the All-Time High (ATH) for each sector and the active ticker.
Pre-Market High (PMH):
Detects and displays the exact Pre-Market High price for the active symbol during extended session trading.
Customizable Dashboard Layout:
Options to adjust table position on the screen (e.g., Bottom Left, Top Right).
Toggles to show/hide specific rows (Headers, Breadth %, VWAP & Open, Gap Status, ATH Drop, Pre-Market High).
Adjustable background transparency and dynamic text coloring based on bullish/bearish conditions. Indicator
Smart Money Liquidity Matrix & Session Finder==============================================================================================
SMART MONEY LIQUIDITY MATRIX & SESSION FINDER
==============================================================================================
OVERVIEW
The Smart Money Liquidity Matrix & Session Finder is a lightweight, high-precision technical mapping indicator designed to help traders analyze market structure, session ranges, and key supply/demand areas in real time.
By combining smooth higher-timeframe trend directional bias, automated swing structure breaks, and session liquidity windows, this tool provides a clean, clutter-free environment for contextual chart analysis.
KEY TECHNICAL FEATURES
1. ASIAN SESSION RANGE & TIMING ENGINE
• Automatically tracks and marks the Asian Range boundaries (default: 20:00–00:00 NY time).
• Defines a clear trading session execution window (default: 00:00–03:00 NY time) to analyze session breakouts and liquidity sweeps.
2. DYNAMIC SMOOTHED TREND DIRECTION
• Utilizes a double-smoothed moving average filter to plot a clean, adaptive trend line.
• Eliminates false color flips during minor pullbacks, staying Green during bullish momentum and Red during bearish trends.
3. STRUCTURE BREAK MAPPING (BOS & CHoCH)
• Automatically identifies major market structure pivots and plots clean horizontal level lines.
• Features centered text labels for Break of Structure (BOS) and Change of Character (CHoCH) to maintain clean horizontal visualization.
4. BREAKER BLOCK STYLE ZONES
• Maps key dynamic Support and Resistance areas directly around pivot wicks and bodies.
• Features clean, right-aligned inside box text labels identifying major Reversal and Support/Resistance boundaries.
INDICATOR SETTINGS & INPUTS EXPLAINED
1. SESSION & TIMEZONE SETTINGS
• NY Timezone: Configures the base exchange time standard for accurate session calculation.
• Range Window: Defines the exact session hours used to calculate initial liquidity range high/low.
• Trade Window: Sets the active session hours where breakout evaluation is active.
2. SIGNAL & ENTRY CONFIGURATION
• Show Buy / Sell Signals: Toggle display for session breakout and FVG confirmation labels.
• Only 1 Trade Per Day: Limits signal generation to a single daily execution setup to prevent over-analysis.
• Signal Padding: Adjusts the vertical offset (in ticks) for signal labels relative to candle highs/lows.
3. MAJOR SMOOTH TREND LINE
• Smooth Trend Length: Adjusts the baseline length of the trend-following moving average (Higher values smooth out short-term market noise).
4. PROFESSIONAL STRUCTURE (BOS / CHoCH)
• Major Swing Sensitivity: Controls pivot lookback period for detecting major structural breaks (Higher values focus only on higher-timeframe swings).
5. BREAKER BLOCK ZONES
• Zone Sensitivity: Controls the lookback depth for active Support and Resistance breaker zones.
HOW TO USE IN YOUR ANALYSIS
• Trend Bias: Use the smooth dynamic trend line to align your trades with the primary market direction
( Green = Bullish Bias, Red = Bearish Bias).
• Session Liquidity: Observe price behavior relative to the Asian Session High/Low levels during the active trade window.
• Breaker Zones: Dynamic Resistance boxes indicate potential supply/reversal areas, while Support boxes highlight potential demand/bounce levels.
• Structure Confirmation: Use BOS and CHoCH signals to confirm structural trend continuations or shifts.
DISCLAIMER
This technical indicator is provided strictly for educational and chart analysis purposes. It does not constitute financial or investment advice. Past performance is not indicative of future results. Always manage risk responsibly.
==============================================================================================
Indicator
