CPR_ATR_PIVOTIntroduction
What is so special about this variation of CPR is that it combines three indicators together. It has Central Pivot Range to understand market trend and for taking entry; Average True Range Stop line to identify the stop loss for any trade keeping in view volatility of the instrument; and Standard Pivot Points for profit targets. So overall it combines all essential ingredients for trading in a single indicator.
While CPR and Pivot values will remain fixed, the ATR period and multiple can be changed.
Central Pivot Range: is a useful intraday technical indicator which comprises 3 levels – a Central pivot point (pivot), Top central level (TC), and Bottom central level (BC).
These levels are calculated as follows:
TC = (Pivot – BC) + Pivot
Pivot = (High + Low + Close)/3
BC = (High + Low)/2
The 3 levels are calculated using 3 variables, High, Low, and Close price. When you add CPR levels in a stock’s chart, TC is highest, the pivot is at the center and BC is the lowest level. However, depending on market conditions TC’s value may be lower than BC.
The fundamental idea behind this indicator is that the particular day’s trading range captures everything about the market sentiment, and hence this range can be used to predict the price movement of the following days.
This indicator was first introduced by Mark Fisher in this book “The Logical Trader”. Frank Ochoa added another dimension, central pivot point to this indicator.
Practical Applications:
CPR Breakout:
Any high volume breakout above or below the TC and BC lines respectively indicates a high probability that the movement will continue.
CPR Width
The width of the CPR lines very accurately gives an idea of the expected price movement. If CPR width is narrow, that is the distance between TC and BC lines of CPR is very low, then it indicates a trending market. While if the distance between TC and BC lines is relatively higher it indicates sideways market.
CPR as Support and Resistance
CPR lines can also act as support and resistance. Market may takes support or resistance at the CPR and reverse.
ATR Stop: I am adding another useful indicator known as ATR stop with CPR. Once market takes support and resistance at the CPR, trade can be taken with stoploss under/above (as the case may be) the ATR stop line. It would help in absorbing the intraday volatility in a stock or instrument.
Pivot Points: Pivot points can be taken as target points where partial or full profit (depending upon market conditions and momentum) can be taken.
I hope this indicator would help some traders in taking better trading decisions.
Regards
jjsingh_2020
Cari dalam skrip untuk "high low"
VWAP forex Yesterday Hi/Low update fix This script is an updte fix of an earlier script that stopped functioning when TradingView updated Pine script. This script plots Forex (24 hour session) VWAP, yesterday's high, low, open and close (HLOC),
the day before's HLOC -
Also plots higher timeframe 20 emas
1 minute 5, 15, 60 period 20 ema
5 minute 15, 60 period 20 ema
15 minute 60, 120 , 240 period 20 ema
60 minute 120, 240 period 20 ema
120 minute 240, D period 20 ema
240 minute D period 20 ema
Also signals inside bars (high is less than or equal to the previous bar's high and the low is greater than or equal to the previous low) the : true inside bars have a maroon triangle below the bar as well as a ">" above the bar.
If subsequest bars are inside the last bar before the last true inside bar they also are marked with an ">"
This is probably a slight variation from the way Leaf_West plots the inside bars.
It appears that he marks all bars that are inside the original bar until one a bar has a high or low
outside the original bar. But I would need to see an example on his charts.
The Time Session Glitch and the Fix FX_IDC, COINBASE and BITSTAMP:
The script will correctly default to 1700 hrs to 1700hrs EDT/EST session for FXCM.
Strangely some securities appear to erroneously start their session at 1200 hrs ie. My guess is that they are somehow tied to GMT+0 instead of New York time (GMT+5). See this for yourself by selecting EURUSD using the FXCM exchange (FX:EURUSD) and then EURUSD from the IDC exchange (FX_IDC:EURUSD). The FX-IDC session opening range starts 5 hours before it actually should at 1700 hrs EDT/EST. To correct for this I have implemented an automatic fix (default) and a user selected "5 hour time shift adjust. ment needed on some securities".
There is also a 4 hour time shift button which might be necessary when New York reverts from Eastern Standard Time to Eastern Daylight Time (1 hour difference) in March (and then back again in November). In the default auto adjust mode you will need to select the 1 hour time shift. That is if this glitch still exists at that time.
I have looked at other scripts, other than my own and where the script is available, that need to use information about the opening bar and all have the same time shift issue
COINBASE and BITSTAMP open at 0000 hours GMT. Since I use lines instead of circles or crosses I had to make a small adjustment to plot the lines correctly.
If it needs work let me know.
Jayy
Trade Bằng Mông Xu hướngSure! Here is the English version of your TradingView indicator description:
📈 Key Highs and Lows Zones + Bob Volman Style (H1 Data)
A powerful tool combining price action and EMAs to identify market structure and trend changes with precision.
🧠 Description:
The "Key Highs and Lows Zones + Bob Volman Style" indicator is a smart market structure tool built on the 1-hour (H1) timeframe. It detects confirmed swing highs and lows using breakout logic, while integrating Bob Volman-style EMA bands (15, 21, 35) to visualize trend momentum.
This indicator helps you:
✅ Identify the primary market trend: Uptrend, Downtrend, or Neutral
✅ Mark confirmed swing highs/lows with clean visual labels and range lines
✅ Detect breakout shifts for early trend reversal signals
✅ Optionally display Neutral points with white dot (🔘) labels
✅ Visualize EMA bands to follow market flow with dynamic support/resistance
EMA and Dow Theory Strategies🌐 Strategy Description
📘 Overview
This is a hybrid strategy that combines EMA crossovers, Dow Theory swing logic, and multi-timeframe trend overlays. It is suitable for intraday to short-term trading on any asset class: crypto, forex, stocks, and indices.
The strategy provides precise entry/exit signals, dynamic stop-loss and scale-out, and highly visual trade guidance.
🧠 Key Features
・Dual EMA crossover system (applied to both symbol and external index)
・Dow Theory-based swing high/low detection for trend confirmation
・Visual overlay of higher timeframe swing trend (htfTrend)
・RSI filter to avoid overbought/oversold entries
・Dynamic partial take-profit when trend weakens
・Custom stop-loss (%) control
・Visualized trade PnL labels directly on chart
・Alerts for entry, stop-loss, partial exit
・Gradient background zones for swing zones and trend visualization
・Auto-tracked metrics: APR, drawdown, win rate, equity curve
⚙️ Input Parameters
| Parameter | Description |
| ------------------------- | -------------------------------------------------------- |
| Fast EMA / Slow EMA | Periods for detecting local trend via EMAs |
| Index Fast EMA / Slow EMA | EMAs applied to external reference index |
| StopLoss | Maximum loss threshold in % |
| ScaleOut Threshold | Scale-out percentage when trend changes color |
| RSI Period / Levels | RSI period and overbought/oversold levels |
| Swing Detection Length | Number of bars used to detect swing highs/lows |
| Stats Display Options | Toggle PnL labels and position of statistics table |
🧭 About htfTrend (Higher Timeframe Trend)
The script includes a higher timeframe trend (htfTrend) calculated using Dow Theory (pivot highs/lows).
This trend is only used for visual guidance, not for actual entry conditions.
Why? Strictly filtering trades by higher timeframe often leads to missed opportunities and low frequency.
By keeping htfTrend visual-only, traders can still refer to macro structure but retain trade flexibility.
Use it as a contextual tool, not a constraint.
ストラテジー説明
📘 概要
本ストラテジーは、EMAクロスオーバー、ダウ理論によるスイング判定、**上位足トレンドの視覚表示（htfTrend）**を組み合わせた複合型の短期トレーディング戦略です。
仮想通貨・FX・株式・指数など幅広いアセットに対応し、デイトレード〜スキャルピング用途に適しています。
動的な利確/損切り、視覚的にわかりやすいエントリー/イグジット、統計表示を搭載しています。
🧠 主な機能
・対象銘柄＋外部インデックスのEMAクロスによるトレンド判定
・ダウ理論に基づいたスイング高値・安値検出とトレンド判断
・上位足スイングトレンド（htfTrend）の視覚表示
・RSIフィルターによる過熱・売られすぎの回避
・トレンドの弱まりに応じた部分利確（スケールアウト）
・**損切り閾値（％）**をカスタマイズ可能
・チャート上に損益ラベル表示
・アラート完備（エントリー・決済・部分利確）
・トレンドゾーンを可視化する背景グラデーション
・勝率・ドローダウン・APR・資産増加率などの自動表示
| 設定項目名 | 説明内容 |
| --------------------- | -------------------------- |
| Fast EMA / Slow EMA | 銘柄に対して使用するEMAの期間設定 |
| Index Fast / Slow EMA | 外部インデックスのEMA設定 |
| 損切り（StopLoss） | 損切りラインのしきい値（%で指定） |
| 部分利確しきい値 | トレンド弱化時にスケールアウトする割合（%） |
| RSI期間・水準 | RSI計算期間と、過熱・売られすぎレベル設定 |
| スイング検出期間 | スイング高値・安値の検出に使用するバー数 |
| 統計表示の切り替え | 損益ラベルや統計テーブルの表示／非表示選択 |
🧭 上位足トレンド（htfTrend）について
本スクリプトには、上位足でのスイング高値・安値の更新に基づく**htfTrend（トレンド判定）が含まれています。
これは視覚的な参考情報であり、エントリーやイグジットには直接使用されていません。**
その理由は、上位足を厳密にロジックに組み込むと、トレード機会の損失が増えるためです。
このスクリプトでは、**判断の補助材料として「表示のみに留める」**設計を採用しています。
→ 裁量で「利確を早める」「逆張りを避ける」判断に活用可能です。
ADR TableTrack volatility and session momentum in real-time with customizable precision.
Key Features:
Average Daily Range (ADR): Configurable length (default 5 days), based on previous daily high–low ranges.
Session Anchor Options: Choose anchor at 4 am NY, 6 pm NY, 9:30 am NY, 8:30 am NY, Previous Day Close, or Current Bar.
Session Range & %ADR: Displays the real-time range from the chosen anchor, plus what percentage of ADR has been covered.
High / Low Target Levels: Calculates ADR targets based on anchor: anchor ± ADR.
Optional Target Lines: Draw horizontal lines for high and low targets across the session; customize color and width.
Dynamic Table Display: User-selectable table size and text size (Tiny to Huge) for optimal readability.
Robust Anchor Logic: Uses the first bar at-or-after anchor time each NY day, ensuring stability even on irregular intraday timeframes.
How to Use
Choose your anchor in settings.
View ADR, session range (with %ADR), and target price levels in the top-right pane.Toggle High/Low lines to overlay targets on the chart.
Adjust table and text size to match your workspace.
Why It Matters
Quickly assess where price stands relative to typical volatility.
Easily identify intraday price exhaustion or breakout zones.
Anchor flexibility enables use for both futures and equities, aligning with your trading session.
Clean, professional display—no clutter, no guesswork.
Gabriel's Relative Strength IndexGabriel’s RSI—The Reinvention of Relative Strength
Not your average RSI.
This is a fully reengineered Relative Strength Index that merges the power of advanced signal processing, adaptive smoothing, volume dynamics, and intelligent divergence detection into a single, modular toolkit designed for precision trading across all markets.
Whether you’re scalping crypto, swing trading equities, or dissecting futures contracts—Gabriel’s RSI adapts to your strategy with unrivaled control and clarity.
⚙️ 1. RSI Settings
RSI Length (Jurik): Set to 51 by default to mimic a 21-period standard RSI when Jurik smoothing is applied. Adjust lower (e.g., 22) to mimic a 9-period RSI. 32 would be almost ~14, 13.33 RSI.
RSI Source: The default is hlc3 for smoother RSI. Can be changed to any price-based series (close, open, etc.) for customization.
📡 VIX-Aware: Automatically switches to high/low/close during VIX spikes using a custom Z-score model if toggled. (I backtested it, and it catches bottoms better.) 📡
🎯 2. RSI Smoothing Options
MA Type: Smoothing applies to both RSI and its MA overlay simultaneously. I used to use the 56 EMA RSI, and it works well too.
Options: JMA, T3, Kalman, Laguerre, Super Smoother, ALMA, VWMA, LSMA, etc.
JMA: Best for adaptive recursive smoothing. A power of 2 and a phase of 50 are used.
T3: Smooth and lag-reduced, suitable for trend detection. The alpha is 0.7.
SMA + Bollinger Bands: Adds deviation-based envelopes for volatility spotting. BB StdDev: Only relevant if BBs are used. Controls bandwidth for overbought/oversold zones.
MA Length: Affects how smooth or reactive the RSI signal is.
📉 3. MACD Settings
Fast/Slow Length: Defaults (21/81) optimized for smoother MACD with SMA or T3. For Algo trading, EMA/JMA is best.
Signal Length: Shorter (e.g., 2) gives more reactive crossover signals; it can be increased.
Source: Default is close. Close works best for the settings I input. I also tuned some of the other MA types that worked for it.
MA Types: JMA and EMA reduce noise and increase signal generation. Select SMA for simplicity or T3 for trend-following.
Histogram: Bar colors signal strength and trend of MACD directly on your chart.
🔀 4. Directional Movement Index (DMI)
ADX Smoothing: High values (e.g., 100) offer strong trend confirmation with Hann Window smoothing 12, or 14 for either regular RMA or double smoothed.
DI Length: Affects DI+/- sensitivity. 100 ADX - 12/14 DI or 15 ADX - 35 DI are suggested, the latter for quicker boot time, as 100 bars is quite long.
Smoothing Type: Choose Hann Window for refined smoothing; RMA (SMMA) for simplicity. Double-smoothing is RMA -> Hann window, best of both types.
Volatility Type: ATR includes gaps for a full-range volatility; ADR is useful for gapless strategies, particularly OTC markets and intraday.
Plotted as area fills, 0 to 100 scaled.
Color-coded as Red (ADX), Orange (DI-), Blue (DI+).
📊 5. Volume Z-Score
%R Length: Normalizes volume to percentile range (73 swing, 112 exhaustion).
Z-Score Lengths: Compares short-term and long-term volume trends with Z-scores of volume.
Fast Z-Score < Slow Z-Score = Gives a Volume Squeeze.
Fast MA > Slow MA = Bullish Volume Divergence; volume has been fired. Not via Z-score, but instead via SMA, ALMA, and RMA of volume.
WPR Volume: Weighted %R used to highlight exhaustion/pivot points.
Plot volume bars after a volume squeeze has been fired; if bars aren't plotted, then it's under squeeze. Backtest on ES1! Prove it's good for catching bottoms below 15 minutes as well.
🧠 6. Divergence Engine
Pivot Settings: Pivot Period (12), Divergence minval Lookback (5), and max Lookback Bars (100) control sensitivity. Works well on any asset class; these are the optimal settings for the RSI.
Source Options: RSI, MACD, ADX, DI difference, or Volume %R.
Divergence Types: Regular (Mean Reversal), Hidden (Trend Continuation).
Heikin Ashi Mode: Enables use of HA candles on normal charts for smoother pivots. May distort values if your chart is H.A. so leave it unchecked then.
💥 7. Squeeze Momentum System (SQZMOM PRO)
Squeeze Types:
⚫ Wide (Black) — Regular Compression
🔴 Normal (Red) — Standard squeeze
🟡 Narrow (Yellow) — Golden squeeze
🟣 Very Narrow (Purple) — Extreme compression
🟢 Fired (Green) — Fired Squeeze = Breakout
Plotted on the very bottom of my indicator.
Momentum Bars:
🔷 Cyan = Rising
🔵 Blue = Pullback
🔴 Red = Falling
🟡 Yellow = Corrective
Plotted on the top of my indicator.
Reversal Signals: Dashed lines on momentum–JMA crossovers (DM-style pivot logic) ploted directly on the chart.
📈 8. Rate of Change (RoC)
RoC of Momentum: EMA-smoothed RoC on momentum for leading signals. Double smoothed, once and then another time for smoother signals.
RoC of Momentum → EMA → EMA → JMA Signal.
Signal Line: JMA used to filter noise and generate reversal signals.
Crossovers: Bullish/bearish signals based on RoC vs. signal line are plotted as triangles directly on your chart.
Optimized: Backtested for short-term setups like 1H or faster. Works on Daily timeframes as well for Futures and 24/7 Markets.
🕰️ 9. Multi-Timeframe Squeeze Settings
Each timeframe (Hourly, 4H, Daily, Weekly, Monthly) has:
Reversal Toggle: Enables dashed line DM-style pivots on crossovers.
MA Length: For Jurik MA smoothing on momentum.
BB/KC Thresholds: Define squeeze sensitivity per timeframe. A shorter BB/KC length, 17-14-12, responds better on lower timeframes.
Momentum Length: Tailors oscillator responsiveness; 20 is ideal.
🧮 10. BB Std. Deviation Scaling
Low-Pass Super Smoother : Smooths noise for BBs.
High-Pass Butterworth : Extracts cycles for BB Stdv. blend.
Root Mean Squared : Dynamic BB width adjustment based on market activity. True-range-based.
LP -> HP -> RMS -> Bollinger Band Multiplier (2.0)
Optional Intensify: Increases the squeeze rate * 4. Can be used for some option pricing strategies.
🧵 11. Moving Average Ribbon
4 optional MAs with full customization:
Choose from 13 MA types (incl. Kalman, Laguerre, T3, ALMA)
Color-coded for trend analysis (MA1–MA4 mimicking 9/21/50/200 periods)
Optional crossover alerts
🔔12. Alerts
RSI: Overbought/oversold reversals. Several types. (🦅 / 🕊️)
MACD: Histogram shift through zero line. (🐘 / 🐴)
DMI/ADX: Crossovers and strength conditions. The key level is the level where if DI/ADX is past this threshold, then it's considered to be trending. (🐬 / 🐋 / 🛡️)
Volume: Smart Money alerts on low-volume zones. May concentrate on ICT sessions. (🚨)
Squeeze: Alerts on all 5 squeeze states. (⚫, 🔴, 🟡, 🟣, 🟢)
Momentum: Momentum / JMA crosses and reversals. (🐂 / 🐻)
RoC: Bullish and bearish crosses. (📈 / 📉)
Divergences: Regular, hidden, and combined. (🐂 / 🐻 / 🐾 / 🐼)
MA Ribbon: Cross alert (⚔️)
VIX: VIX Z-Score past 2.0 (🏴☠️)
📊 13. Visual Output Summary
RSI Line + MA + Optional BB
MACD Histogram (Color Adaptive)
DMI/ADX Area Fills
%R Volume Bars (Smart Money)
Squeeze Dots (Circles)
Momentum Bars (Squares)
RoC Arrows (Cross Signals)
Pivot Break Lines (Dashed)
Auto-Divergence Lines & Labels
MA Ribbon Overlay (Optional)
✅ Best Practices ✅
Watch the slope of the RSI for pullbacks on a strong trend. Combine it with squeeze for exit timing.
Combine RSI Divergence with MACD histogram cross and Squeeze firing for precise entry.
Use Volume Z-Score to filter for institutional activity, and enter Long. Watch for reversals as well.
Watch RoC crossovers for fast, leading signals.
Enable Reversal Lines on 1H+ charts for breakout or breakdown pivots.
Use multi-timeframe thresholds for swing confirmation. The TFs I use the most are 2-5-15 minutes for futures and swinging with 1 hour daily and weekly. Those are the TFs I backtested.
An optional MA Ribbon is here as well; it supports 13 MA types.
🌎 Asset-Agnostic
MACD Automatically adjusts for Crypto, Forex, Stocks, Commodities, and Indices.
Custom ALMA, T3, Kalman, and Laguerre filters optimized per asset class and timeframe.
📚 Tech Highlights
Over 15,000 lines of modular, structured Pine Script v6 code.
Integration of Ehlers Cycle Theory and various other filters, one for each indicator.
Designed for visual clarity, multi-dimensional signal stacking, and low lag/high accuracy.
🌀 All 64 outputs are filled, so there might not be any more future updates. It's also a bit slow to load due to that.
Inflection PointInflection Point - The Adaptive Confluence Reversal Engine
This is not just another peak and valley indicator; it is a complete and total reimagining of how market turning points are detected, qualified, and acted upon. Born from the foundational concepts explored in systems like my earlier creation, DAFE - Turning Point, Inflection Point is a ground-up engineering feat designed for the modern trader. It moves beyond static rules and simple pattern recognition into the realm of dynamic, multi-factor confluence analysis and adaptive machine learning.
Where other indicators provide a guess, Inflection Point provides a probability. It meticulously analyzes the market's deepest currents—momentum, exhaustion, and reversal velocity—and fuses them into a single, unified "Confluence Score." This is not a simple combination of indicators; it is an intelligent, weighted system where each component works in concert, creating an analytical engine that is orders of magnitude more sophisticated and reliable than any standard reversal tool.
Furthermore, Inflection Point learns. Through its advanced Adaptive Learning Engine, it constantly monitors its own performance, adjusting its confidence and selectivity in real-time based on its recent success rate. This allows it to adapt its behavior to any security, on any timeframe, with remarkable success.
Theoretical Foundation - Confluence Core
Inflection Point's predictive power does not come from a single, magical formula. It comes from the intelligent synthesis of three critical market phenomena, weighted and scored in real-time to generate a single, high-conviction probability rating.
1. Factor One: Pre-Reversal Momentum State (RSI Analysis)
Instead of reacting to a simple RSI cross, Inflection Point proactively scans for the build-up of momentum that precedes a reversal.
• Formulaic Concept: It measures the highest RSI value over a lookback period for peaks and the lowest RSI for valleys. A signal is only considered valid if significant momentum has been established before the turn, indicating a stretched market condition ripe for reversal.
• Asymmetric Sophistication: The engine uses different, optimized thresholds for bull and bear momentum, recognizing that markets often fall faster than they rise.
2. Factor Two: Volatility Exhaustion (Bollinger Band Analysis)
A true reversal often occurs when price makes a final, exhaustive push into unsustainable territory.
• Formulaic Concept: The engine detects when price has significantly pierced the outer Bollinger Bands. This is not just a touch, but a statistical deviation from the mean that signals volatility exhaustion, where the energy for the current move is likely depleted.
3. Factor Three: Reversal Strength (Rate of Change Analysis)
The character of a reversal matters. A sharp, decisive turn is more significant than a slow, meandering one.
• Formulaic Concept: Using a short-term Rate of Change (ROC), the engine measures the velocity of the reversal itself. A higher ROC score adds significant weight to the final probability, confirming that the new direction has conviction.
4. The Final Calculation: The Adaptive Learning Engine
This is the system's "brain." It maintains a history of its past signals and calculates its real-time win rate. This hitRate is then used to generate an adaptiveMultiplier.
• Self-Correction: In "Quality Control" mode, a high win rate makes the indicator more selective, demanding a higher probability score to issue a signal, thereby protecting streaks. A lower win rate makes it slightly less selective to ensure it continues learning from new market conditions.
• The result is a system that is not static, but a living, breathing tool that adapts its personality to the unique rhythm of any chart.
Why Inflection Point is a Paradigm Shift
Inflection Point is fundamentally different from other reversal indicators for three key reasons:
Confluence Over Isolation: Standard indicators look at one thing (e.g., RSI > 70). Inflection Point simultaneously analyzes momentum, volatility, and velocity, understanding that true reversals are a product of multiple converging factors. It answers not just "if," but "why" a reversal is likely.
Probabilistic Over Binary: Other tools give you a simple "yes" or "no." Inflection Point provides a probability score from 0-100, allowing you to gauge the conviction of every potential signal. This empowers you to differentiate between a weak setup and an A+ opportunity.
Adaptive Over Static: Every other indicator uses the same rules forever. Inflection Point's Adaptive Engine means it is constantly refining its own logic based on what is actually working in the current market, on the specific asset you are trading. It is tailored to the now.
The Inputs Menu - Your Command Center
Every setting is a lever of control, allowing you to tune the engine to your precise trading style and market focus.
🧠 Neural Core Engine
Analysis Depth: This is the primary lookback for the Bollinger Band and other core calculations. A shorter depth makes the indicator faster and more sensitive, ideal for scalping. A longer depth makes it slower and more stable, ideal for swing trading.
Minimum Probability %: This is your master signal filter. It sets the minimum Confluence Score required to plot a signal. Higher values (85-95) will give you only the highest-conviction A+ setups. Lower values (70-80) will show more potential opportunities.
🤖 Adaptive Neural Learning
Enable Adaptive Learning Engine: Toggles the entire learning system. Disabling it will make the indicator's logic static.
Peak/Valley Success Threshold (ATR): This defines what constitutes a "successful" trade for the learning engine. A value of 1.5 means price must move 1.5x the ATR in your favor for the signal to be marked as a win. Adjust this to match your personal take-profit strategy.
Adaptive Mode: This dictates how the engine uses its hitRate. "Quality Control" is recommended for its intelligent filtering. "Aggressive" will always boost signal scores, useful for finding more setups in a known, trending environment.
Asymmetric Balance: Allows you to apply a "boost" to either peak (short) or valley (long) signals. If you find the market you're trading has stronger long reversals, you can increase the "Valley Signal Boost" to catch them more effectively.
🛡️ Elite Filters
Market Noise Filter: An exceptional tool for avoiding choppy markets. It counts the number of directional changes in the last 5 bars. If the market is whipping back and forth too much, it will block the signal. Lower the "Max Direction Changes" to be extremely selective.
Volume Filter: Requires signal confirmation from a significant volume spike. The "Volume Multiplier" dictates how large this spike must be (e.g., 1.2 = 20% above average volume). This is invaluable for filtering out low-conviction moves in stocks and crypto.
The Dashboard - Your Analytical Co-Pilot
The dashboard is not just a set of numbers; it is a holistic overview of the market's health and the engine's current state.
Unified AI Score: This section provides the most critical, at-a-glance information. "Total Score" is the current probability reading, while "Quality" gives you a human-readable interpretation. "Win Rate" shows the real-time performance of the Adaptive Engine.
Order Flow (OFPI): This measures the "weight" of money behind recent price moves by analyzing price change relative to volume. A high positive OFPI suggests strong buying pressure, while a high negative value suggests strong selling pressure. It gives you a peek into the market's underlying flow.
Component Analysis: This allows you to see the individual "Peak" and "Valley" confidence scores before they are filtered, giving you insight into building momentum before a signal forms.
Market Structure: This panel assesses the broader environment. "HTF Trend" tells you the direction of the larger trend (based on EMAs), while "Vol Regime" tells you if the market is in a high, medium, or low volatility state. Use this to align your signals with the broader market context.
Filter & Engine Statistics: Available on the "Large" dashboard, this provides deep insight into how many signals are being blocked by your filters and the current status of the Adaptive Engine's multiplier.
The Visual Interface - A Symphony of Data
Every visual element on the chart is designed for instant interpretation and insight.
Signal Markers: Simple, clean triangles mark the exact bar of a valid signal. A box is drawn around the high/low of the signal bar to highlight the precise point of inflection.
Dynamic Support/Resistance Zones: These are the glowing lines on your chart. They are not static lines; they are dynamic levels that represent the current battlefield between buyers and sellers.
Cyber Cyan (Valley Blue): This is the current Support Zone. This is the price level the market is currently trying to defend.
Neural Pink (Peak Red): This is the current Resistance Zone. This is the price level the market is currently trying to break through.
Grey (Next Level): This line is a projection, based on the current momentum and the size of the S/R range, of where the next major level of conflict will likely be. It acts as a potential price target.
Development & Philosophy
Inflection Point was not assembled; it was engineered. It represents hundreds of hours of research into market dynamics, statistical analysis, and machine learning principles. The goal was to create a tool that moves beyond the limitations of traditional technical analysis, which often fails in modern, algorithm-driven markets. By building a system based on multi-factor confluence and self-adaptive logic, Inflection Point provides a quantifiable, statistical edge that is simply unattainable with simpler tools. This is the result of a relentless pursuit of a better, more intelligent way to trade.
Universal Applicability
The principles of momentum, exhaustion, and velocity are universal to all freely traded markets. Because of its adaptive core and robust filtering options, Inflection Point has proven to be exceptionally effective on any security (stocks, crypto, forex, indices, futures) and on any timeframe (from 1-minute scalping charts to daily swing trading charts).
" Markets are constantly in a state of uncertainty and flux and money is made by discounting the obvious and betting on the unexpected. "
— George Soros
Trade with insight. Trade with anticipation.
— Dskyz, for DAFE Trading Systems
BOR + 08:28BOR + TIME: Precision 1-Minute Opening Range Analysis
METHODOLOGY OVERVIEW
This indicator implements a proprietary time-based trading methodology that combines opening range analysis with precision timing algorithms designed exclusively for 1-minute charts during the New York trading session.
CORE ALGORITHM COMPONENTS
1. Bond Opening Range (BOR) Identification
- Captures the complete price range during 08:00-09:00 NY time
- Establishes the foundational trading range for the session
- Uses high-precision minute-level data to define exact boundaries
2. Critical Time Level Analysis (08:28 Candle)
- Identifies the 08:28-08:29 minute candle as a key reference point
- This specific timing represents a critical juncture before market open
- Captures the exact high/low range of this precise minute
3. Directional Bias Determination (09:00 Analysis)
- At exactly 09:00, compares current price position relative to 08:28 boundaries
- Above 08:28 High: Activates support-seeking mode (bullish bias)
- Below 08:28 Low: Activates resistance-seeking mode (bearish bias)
- Inside 08:28 Range: No directional bias established
4. Dynamic Standard Deviation Projections
- Uses the 08:28 candle range as the mathematical basis for standard deviation calculations
- Support Mode: Projects levels below 08:28 low using range multipliers (-1σ, -2σ, -3σ, -4σ)
- Resistance Mode: Projects levels above 08:28 high using range multipliers (+1σ, +2σ, +3σ, +4σ)
- Levels are active only during 09:00-10:30 trading window
UNIQUE FEATURES
Conditional Logic Engine
- Real-time directional switching based on 09:00 price position
- No static levels - everything adapts to intraday price action
- Eliminates noise by focusing on specific time windows
Precision Timing Requirements
- Requires exact 1-minute timeframe for accurate calculations
- Time-sensitive algorithm that relies on minute-by-minute analysis
- Optimized for high-frequency intraday trading decisions
Mathematical Framework
- Standard deviations calculated using actual candle range data
- Dynamic level spacing based on market volatility (08:28 range)
- Four-tier projection system for multiple target/stop levels
TRADING APPLICATION
Best Used For:
- ES, NQ, YM and other liquid index futures
- Active day trading during NY session (07:00-12:00)
- Scalping and short-term reversal strategies
- Intraday support/resistance identification
Signal Interpretation:
- Red lines represent potential reversal zones
- Direction determined by 09:00 vs 08:28 relationship
- Multiple standard deviation levels provide layered entry/exit points
- Time-restricted plotting ensures relevance during active trading hours
IMPORTANT REQUIREMENTS
- ONLY works on 1-minute charts - precision timing is essential
- Designed for New York trading session (futures markets)
- Most effective during high-volume trading periods
CUSTOMIZATION OPTIONS
- Toggle BOR box visibility and transparency
- Enable/disable 08:28 candle highlighting
- Adjust visual elements (colors, transparency)
- Show/hide range information labels
Clean 20/40/60 High/Low LabelsIPDA Data Ranges
Works on all timeframes
20 period high and low, 40 period high and low, and 60 period high and low
This helps to identify large cycles on the daily and 4H chart
Can also be useful at liquidity injections and opening and closing prices of the market.
Live Breakout Zones (No Repaint)The Live Breakout Zones indicator is a non-repainting, real-time breakout detection tool designed to help traders identify critical price breakouts as they happen — without lag and without repainting past signals.
This indicator scans recent price action to determine the highest high and lowest low over a user-defined lookback period. When price closes above the recent high or below the recent low, it immediately plots a breakout zone on the chart and provides a visual confirmation through labels and optional alerts.
🔍 Key Features:
✅ No Repainting – Signals are locked in as soon as a breakout happens; no future bar confirmation is needed.
⏱️ Minimal Lag – Reacts on breakout of recent range highs/lows without waiting for pivots or candle confirmation.
📦 Breakout Zones – Automatically draws colored rectangles showing the breakout level and zone width for clearer analysis.
🔔 Real-Time Alerts – Alerts for both bullish and bearish breakouts help you stay informed without watching the screen.
⚙️ Customizable – Adjustable lookback length, zone width, and color settings to match your strategy or chart style.
📈 Use Cases:
Identify key breakout moments for entry or retest zones.
Confirm breakout-based strategies in trending or consolidating markets.
Use zones for setting risk-reward areas, SL/TP levels, or re-entry planning.
⚙️ Settings:
Lookback Range (High/Low): Defines how many previous bars are checked for breakout levels.
Zone Width: Number of bars to extend the breakout box forward.
Bullish/Bearish Zone Color: Choose custom colors for breakout visualization.
🧠 Trading Tip:
Combine this tool with volume spikes, tail candles, or support/resistance for more reliable breakout setups.
Normalized Open InterestNormalized Open Interest (nOI) — Indicator Overview
What it does
Normalized Open Interest (nOI) transforms raw futures open-interest data into a 0-to-100 oscillator, so you can see at a glance whether participation is unusually high or low—similar in spirit to an RSI but applied to open interest. The script positions today’s OI inside a rolling high–low range and paints it with contextual colours.
Core logic
Data source – Loads the built-in “_OI” symbol that TradingView provides for the current market.
Rolling range – Looks back a user-defined number of bars (default 500) to find the highest and lowest OI in that window.
Normalization – Calculates
nOI = (OI – lowest) / (highest – lowest) × 100
so 0 equals the minimum of the window and 100 equals the maximum.
Visual cues – Plots the oscillator plus fixed horizontal levels at 70 % and 30 % (or your own numbers). The line turns teal above the upper level, red below the lower, and neutral grey in between.
User inputs
Window Length (bars) – How many candles the indicator scans for the high–low range; larger numbers smooth the curve, smaller numbers make it more reactive.
Upper Threshold (%) – Default 70. Anything above this marks potentially crowded or overheated interest.
Lower Threshold (%) – Default 30. Anything below this marks low or capitulating interest.
Practical uses
Spot extremes – Values above the upper line can warn that the long side is crowded; values below the lower line suggest disinterest or short-side crowding.
Confirm breakouts – A price breakout backed by a sharp rise in nOI signals genuine engagement.
Look for divergences – If price makes a new high but nOI does not, participation might be fading.
Combine with volume or RSI – Layer nOI with other studies to filter false signals.
Tips
On intraday charts for non-crypto symbols the script automatically fetches daily OI data to avoid gaps.
Adjust the thresholds to 80/20 or 60/40 to fit your market and risk preferences.
Alerts, shading, or additional signal logic can be added easily because the oscillator is already normalised.
Metatron Lines (Highs & Lows Geometry)Metatron Lines
Hey TradingView community! 👋
I wanted to share something I've been working on that might help you see market structure from a different angle. This indicator connects pivot highs and lows using geometric patterns, creating what I call "Metatron Lines."
What it does (simply put):
- Finds significant highs and lows on your chart
- Draws lines connecting these points to reveal hidden geometric relationships
- Shows you the underlying structure that price tends to respect
Why I built this:
I noticed that markets often move in patterns that aren't immediately obvious. Sometimes the most important levels aren't the obvious support and resistance lines, but the intersections and angles created by connecting multiple pivot points. This tool helps visualize those relationships.
How it might help you:
- Pattern Recognition : Spot geometric formations that traditional analysis might miss
- Support/Resistance : See where multiple geometric lines converge to create strong levels
- Market Structure : Better understand how price flows and where it might find obstacles
- Confluence Areas : Identify zones where multiple geometric elements align
A few honest thoughts:
This isn't a magic bullet or a guaranteed profit maker (nothing is!). It's simply another lens through which to view price action. Some traders find geometric analysis helpful, others prefer different approaches - and that's perfectly fine.
I've tried to make it customizable so you can adjust it to fit your trading style and timeframe. The default settings work well for most instruments, but feel free to experiment.
Settings you can adjust:
- Pivot detection sensitivity
- Number of connection points
- Line colors and styles
- Which connections to show (highs, lows, or both)
I hope some of you find this useful! I'm always learning from this community, so if you have suggestions for improvements or different ways to use it, I'd love to hear them.
Trade safe and trust your process! 📈
---
This indicator is provided as-is for educational and analysis purposes. Please practice proper risk management and never risk more than you can afford to lose.
Haven Average Daily RangeOverview
This indicator is an enhanced version of the traditional ADR tool that adapts to intraday price movements. Unlike static ADR levels, this indicator dynamically adjusts its range boundaries based on real-time price action while maintaining the original ADR calculation framework.
Key Features
ADR calculation based on multiple periods (5, 10, and 20 days)
ADR levels displayed with automatic style changes upon range reach
Customizable display settings (color, line style)
Price labels for better visualization
The indicator helps traders assess the instrument's volatility, identify potential reversal zones, and plan daily trading targets.
Suitable for all timeframes up to D1 and any trading instrument.
How It Works
Session Start (UTC+0): Calculates ADR based on historical data and sets initial High/Low levels
Dynamic Phase: Monitors price action and adjusts the opposite boundary (ADR Low or High) when new extremes are reached.
When price creates new Day high price above the opening price, the ADR Low level moves upward proportionally.
When price creates new Day low price below the opening price, the ADR High level moves downward proportionally.
Completion Phase: Stops adjustments and highlights breach when price reaches either boundary
Trading Application
Entry and Exit Signals
The ADR boundaries serve as key decision points for trade execution. When price approaches the upper ADR boundary, it often signals a potential selling zone, particularly when confluence exists with other overbought indicators such as RSI divergence or resistance levels. Conversely, price reaching the lower ADR boundary frequently indicates potential buying opportunities, especially when supported by oversold conditions or support confluences.
Trend Continuation Assessment
One of the most valuable applications is gauging the probability of continued directional movement. When the current session's price action has not yet reached either ADR boundary, statistical probability favors trend continuation in the established direction. This information helps traders stay with profitable positions longer rather than exiting prematurely.
Reversal and Consolidation Zones
The visual color change to orange when ADR boundaries are reached provides immediate feedback that the normal daily range has been exhausted. At this point, the probability of trend reversal or sideways consolidation increases significantly. This signal helps traders prepare for potential position adjustments or new counter-trend opportunities.
light_logLight Log - A Defensive Programming Library for Pine Script
Overview
The Light Log library transforms Pine Script development by introducing structured logging and defensive programming patterns typically found in enterprise languages like C#. This library addresses a fundamental challenge in Pine Script: the lack of sophisticated error handling and debugging tools that developers expect when building complex trading systems.
At its core, Light Log provides three transformative capabilities that work together to create more reliable and maintainable code. First, it wraps all native Pine Script types in error-aware containers, allowing values to carry validation state alongside their data. Second, it offers a comprehensive logging system with severity levels and conditional rendering. Third, it includes defensive programming utilities that catch errors early and make code self-documenting.
The Philosophy of Errors as Values
Traditional Pine Script error handling relies on runtime errors that halt execution, making it difficult to build resilient systems that can gracefully handle edge cases. Light Log introduces a paradigm shift by treating errors as first-class values that flow through your program alongside regular data.
When you wrap a value using Light Log's type system, you're not just storing data – you're creating a container that can carry both the value and its validation state. For example, when you call myNumber.INT() , you receive an INT object that contains both the integer value and a Log object that can describe any issues with that value. This approach, inspired by functional programming languages, allows errors to propagate through calculations without causing immediate failures.
Consider how this changes error handling in practice. Instead of a calculation failing catastrophically when it encounters invalid input, it can produce a result object that contains both the computed value (which might be na) and a detailed log explaining what went wrong. Subsequent operations can check has_error() to decide whether to proceed or handle the error condition gracefully.
The Typed Wrapper System
Light Log provides typed wrappers for every native Pine Script type: INT, FLOAT, BOOL, STRING, COLOR, LINE, LABEL, BOX, TABLE, CHART_POINT, POLYLINE, and LINEFILL. These wrappers serve multiple purposes beyond simple value storage.
Each wrapper type contains two fields: the value field v holds the actual data, while the error field e contains a Log object that tracks the value's validation state. This dual nature enables powerful programming patterns. You can perform operations on wrapped values and accumulate error information along the way, creating an audit trail of how values were processed.
The wrapper system includes convenient methods for converting between wrapped and unwrapped values. The extension methods like INT() , FLOAT() , etc., make it easy to wrap existing values, while the from_INT() , from_FLOAT() methods extract the underlying values when needed. The has_error() method provides a consistent interface for checking whether any wrapped value has encountered issues during processing.
The Log Object: Your Debugging Companion
The Log object represents the heart of Light Log's debugging capabilities. Unlike simple string concatenation for error messages, the Log object provides a structured approach to building, modifying, and rendering diagnostic information.
Each Log object carries three essential pieces of information: an error type (info, warning, error, or runtime_error), a message string that can be built incrementally, and an active flag that controls conditional rendering. This structure enables sophisticated logging patterns where you can build up detailed diagnostic information throughout your script's execution and decide later whether and how to display it.
The Log object's methods support fluent chaining, allowing you to build complex messages in a readable way. The write() and write_line() methods append text to the log, while new_line() adds formatting. The clear() method resets the log for reuse, and the rendering methods ( render_now() , render_condition() , and the general render() ) control when and how messages appear.
Defensive Programming Made Easy
Light Log's argument validation functions transform how you write defensive code. Instead of cluttering your functions with verbose validation logic, you can use concise, self-documenting calls that make your intentions clear.
The argument_error() function provides strict validation that halts execution when conditions aren't met – perfect for catching programming errors early. For less critical issues, argument_log_warning() and argument_log_error() record problems without stopping execution, while argument_log_info() provides debug visibility into your function's behavior.
These functions follow a consistent pattern: they take a condition to check, the function name, the argument name, and a descriptive message. This consistency makes error messages predictable and helpful, automatically formatting them to show exactly where problems occurred.
Building Modular, Reusable Code
Light Log encourages a modular approach to Pine Script development by providing tools that make functions more self-contained and reliable. When functions validate their inputs and return wrapped values with error information, they become true black boxes that can be safely composed into larger systems.
The void_return() function addresses Pine Script's requirement that all code paths return a value, even in error handling branches. This utility function provides a clean way to satisfy the compiler while making it clear that a particular code path should never execute.
The static log pattern, initialized with init_static_log() , enables module-wide error tracking. You can create a persistent Log object that accumulates information across multiple function calls, building a comprehensive diagnostic report that helps you understand complex behaviors in your indicators and strategies.
Real-World Applications
In practice, Light Log shines when building sophisticated trading systems. Imagine developing a complex indicator that processes multiple data streams, performs statistical calculations, and generates trading signals. With Light Log, each processing stage can validate its inputs, perform calculations, and pass along both results and diagnostic information.
For example, a moving average calculation might check that the period is positive, that sufficient data exists, and that the input series contains valid values. Instead of failing silently or throwing runtime errors, it can return a FLOAT object that contains either the calculated average or a detailed explanation of why the calculation couldn't be performed.
Strategy developers benefit even more from Light Log's capabilities. Complex entry and exit logic often involves multiple conditions that must all be satisfied. With Light Log, each condition check can contribute to a comprehensive log that explains exactly why a trade was or wasn't taken, making strategy debugging and optimization much more straightforward.
Performance Considerations
While Light Log adds a layer of abstraction over raw Pine Script values, its design minimizes performance impact. The wrapper objects are lightweight, containing only two fields. The logging operations only consume resources when actually rendered, and the conditional rendering system ensures that production code can run with logging disabled for maximum performance.
The library follows Pine Script best practices for performance, using appropriate data structures and avoiding unnecessary operations. The var keyword in init_static_log() ensures that persistent logs don't create new objects on every bar, maintaining efficiency even in real-time calculations.
Getting Started
Adopting Light Log in your Pine Script projects is straightforward. Import the library, wrap your critical values, add validation to your functions, and use Log objects to track important events. Start small by adding logging to a single function, then expand as you see the benefits of better error visibility and code organization.
Remember that Light Log is designed to grow with your needs. You can use as much or as little of its functionality as makes sense for your project. Even simple uses, like adding argument validation to key functions, can significantly improve code reliability and debugging ease.
Transform your Pine Script development experience with Light Log – because professional trading systems deserve professional development tools.
Light Log Technical Deep Dive: Advanced Patterns and Architecture
Understanding Errors as Values
The concept of "errors as values" represents a fundamental shift in how we think about error handling in Pine Script. In traditional Pine Script development, errors are events – they happen at a specific moment in time and immediately interrupt program flow. Light Log transforms errors into data – they become information that flows through your program just like any other value.
This transformation has profound implications. When errors are values, they can be stored, passed between functions, accumulated, transformed, and inspected. They become part of your program's data flow rather than exceptions to it. This approach, popularized by languages like Rust with its Result type and Haskell with its Either monad, brings functional programming's elegance to Pine Script.
Consider a practical example. Traditional Pine Script might calculate a momentum indicator like this:
momentum = close - close
If period is invalid or if there isn't enough historical data, this calculation might produce na or cause subtle bugs. With Light Log's approach:
calculate_momentum(src, period)=>
result = src.FLOAT()
if period <= 0
result.e.write("Invalid period: must be positive", true, ErrorType.error)
result.v := na
else if bar_index < period
result.e.write("Insufficient data: need " + str.tostring(period) + " bars", true, ErrorType.warning)
result.v := na
else
result.v := src - src
result.e.write("Momentum calculated successfully", false, ErrorType.info)
result
Now the function returns not just a value but a complete computational result that includes diagnostic information. Calling code can make intelligent decisions based on both the value and its associated metadata.
The Monad Pattern in Pine Script
While Pine Script lacks the type system features to implement true monads, Light Log brings monadic thinking to Pine Script development. The wrapped types (INT, FLOAT, etc.) act as computational contexts that carry both values and metadata through a series of transformations.
The key insight of monadic programming is that you can chain operations while automatically propagating context. In Light Log, this context is the error state. When you have a FLOAT that contains an error, operations on that FLOAT can check the error state and decide whether to proceed or propagate the error.
This pattern enables what functional programmers call "railway-oriented programming" – your code follows a success track when all is well but can switch to an error track when problems occur. Both tracks lead to the same destination (a result with error information), but they take different paths based on the validity of intermediate values.
Composable Error Handling
Light Log's design encourages composition – building complex functionality from simpler, well-tested components. Each component can validate its inputs, perform its calculation, and return a result with appropriate error information. Higher-level functions can then combine these results intelligently.
Consider building a complex trading signal from multiple indicators:
generate_signal(src, fast_period, slow_period, signal_period) =>
log = init_static_log(ErrorType.info)
// Calculate components with error tracking
fast_ma = calculate_ma(src, fast_period)
slow_ma = calculate_ma(src, slow_period)
// Check for errors in components
if fast_ma.has_error()
log.write_line("Fast MA error: " + fast_ma.e.message, true)
if slow_ma.has_error()
log.write_line("Slow MA error: " + slow_ma.e.message, true)
// Proceed with calculation if no errors
signal = 0.0.FLOAT()
if not (fast_ma.has_error() or slow_ma.has_error())
macd_line = fast_ma.v - slow_ma.v
signal_line = calculate_ma(macd_line, signal_period)
if signal_line.has_error()
log.write_line("Signal line error: " + signal_line.e.message, true)
signal.e := log
else
signal.v := macd_line - signal_line.v
log.write("Signal generated successfully")
else
signal.e := log
signal.v := na
signal
This composable approach makes complex calculations more reliable and easier to debug. Each component is responsible for its own validation and error reporting, and the composite function orchestrates these components while maintaining comprehensive error tracking.
The Static Log Pattern
The init_static_log() function introduces a powerful pattern for maintaining state across function calls. In Pine Script, the var keyword creates variables that persist across bars but are initialized only once. Light Log leverages this to create logging objects that can accumulate information throughout a script's execution.
This pattern is particularly valuable for debugging complex strategies where you need to understand behavior across multiple bars. You can create module-level logs that track important events:
// Module-level diagnostic log
diagnostics = init_static_log(ErrorType.info)
// Track strategy decisions across bars
check_entry_conditions() =>
diagnostics.clear() // Start fresh each bar
diagnostics.write_line("Bar " + str.tostring(bar_index) + " analysis:")
if close > sma(close, 20)
diagnostics.write_line("Price above SMA20", false)
else
diagnostics.write_line("Price below SMA20 - no entry", true, ErrorType.warning)
if volume > sma(volume, 20) * 1.5
diagnostics.write_line("Volume surge detected", false)
else
diagnostics.write_line("Normal volume", false)
// Render diagnostics based on verbosity setting
if debug_mode
diagnostics.render_now()
Advanced Validation Patterns
Light Log's argument validation functions enable sophisticated precondition checking that goes beyond simple null checks. You can implement complex validation logic while keeping your code readable:
validate_price_data(open_val, high_val, low_val, close_val) =>
argument_error(na(open_val) or na(high_val) or na(low_val) or na(close_val),
"validate_price_data", "OHLC values", "contain na values")
argument_error(high_val < low_val,
"validate_price_data", "high/low", "high is less than low")
argument_error(close_val > high_val or close_val < low_val,
"validate_price_data", "close", "is outside high/low range")
argument_log_warning(high_val == low_val,
"validate_price_data", "high/low", "are equal (no range)")
This validation function documents its requirements clearly and fails fast with helpful error messages when assumptions are violated. The mix of errors (which halt execution) and warnings (which allow continuation) provides fine-grained control over how strict your validation should be.
Performance Optimization Strategies
While Light Log adds abstraction, careful design minimizes overhead. Understanding Pine Script's execution model helps you use Light Log efficiently.
Pine Script executes once per bar, so operations that seem expensive in traditional programming might have negligible impact. However, when building real-time systems, every optimization matters. Light Log provides several patterns for efficient use:
Lazy Evaluation: Log messages are only built when they'll be rendered. Use conditional logging to avoid string concatenation in production:
if debug_mode
log.write_line("Calculated value: " + str.tostring(complex_calculation))
Selective Wrapping: Not every value needs error tracking. Wrap values at API boundaries and critical calculation points, but use raw values for simple operations:
// Wrap at boundaries
input_price = close.FLOAT()
validated_period = validate_period(input_period).INT()
// Use raw values internally
sum = 0.0
for i = 0 to validated_period.v - 1
sum += close
Error Propagation: When errors occur early, avoid expensive calculations:
process_data(input) =>
validated = validate_input(input)
if validated.has_error()
validated // Return early with error
else
// Expensive processing only if valid
perform_complex_calculation(validated)
Integration Patterns
Light Log integrates smoothly with existing Pine Script code. You can adopt it incrementally, starting with critical functions and expanding coverage as needed.
Boundary Validation: Add Light Log at the boundaries of your system – where user input enters and where final outputs are produced. This catches most errors while minimizing changes to existing code.
Progressive Enhancement: Start by adding argument validation to existing functions. Then wrap return values. Finally, add comprehensive logging. Each step improves reliability without requiring a complete rewrite.
Testing and Debugging: Use Light Log's conditional rendering to create debug modes for your scripts. Production users see clean output while developers get detailed diagnostics:
// User input for debug mode
debug = input.bool(false, "Enable debug logging")
// Conditional diagnostic output
if debug
diagnostics.render_now()
else
diagnostics.render_condition() // Only shows errors/warnings
Future-Proofing Your Code
Light Log's patterns prepare your code for Pine Script's evolution. As Pine Script adds more sophisticated features, code that uses structured error handling and defensive programming will adapt more easily than code that relies on implicit assumptions.
The type wrapper system, in particular, positions your code to take advantage of potential future features or more sophisticated type inference. By thinking in terms of wrapped values and error propagation today, you're building code that will remain maintainable and extensible tomorrow.
Light Log doesn't just make your Pine Script better today – it prepares it for the trading systems you'll need to build tomorrow.
Library "light_log"
A lightweight logging and defensive programming library for Pine Script.
Designed for modular and extensible scripts, this utility provides structured runtime validation,
conditional logging, and reusable `Log` objects for centralized error propagation.
It also introduces a typed wrapping system for all native Pine values (e.g., `INT`, `FLOAT`, `LABEL`),
allowing values to carry errors alongside data. This enables functional-style flows with built-in
validation tracking, error detection (`has_error()`), and fluent chaining.
Inspired by structured logging patterns found in systems like C#, it reduces boilerplate,
enforces argument safety, and encourages clean, maintainable code architecture.
method INT(self, error_type)
Wraps an `int` value into an `INT` struct with an optional log severity.
Namespace types: series int, simple int, input int, const int
Parameters:
self (int) : The raw `int` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: An `INT` object containing the value and a default Log instance.
method FLOAT(self, error_type)
Wraps a `float` value into a `FLOAT` struct with an optional log severity.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : The raw `float` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `FLOAT` object containing the value and a default Log instance.
method BOOL(self, error_type)
Wraps a `bool` value into a `BOOL` struct with an optional log severity.
Namespace types: series bool, simple bool, input bool, const bool
Parameters:
self (bool) : The raw `bool` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `BOOL` object containing the value and a default Log instance.
method STRING(self, error_type)
Wraps a `string` value into a `STRING` struct with an optional log severity.
Namespace types: series string, simple string, input string, const string
Parameters:
self (string) : The raw `string` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `STRING` object containing the value and a default Log instance.
method COLOR(self, error_type)
Wraps a `color` value into a `COLOR` struct with an optional log severity.
Namespace types: series color, simple color, input color, const color
Parameters:
self (color) : The raw `color` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `COLOR` object containing the value and a default Log instance.
method LINE(self, error_type)
Wraps a `line` object into a `LINE` struct with an optional log severity.
Namespace types: series line
Parameters:
self (line) : The raw `line` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LINE` object containing the value and a default Log instance.
method LABEL(self, error_type)
Wraps a `label` object into a `LABEL` struct with an optional log severity.
Namespace types: series label
Parameters:
self (label) : The raw `label` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LABEL` object containing the value and a default Log instance.
method BOX(self, error_type)
Wraps a `box` object into a `BOX` struct with an optional log severity.
Namespace types: series box
Parameters:
self (box) : The raw `box` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `BOX` object containing the value and a default Log instance.
method TABLE(self, error_type)
Wraps a `table` object into a `TABLE` struct with an optional log severity.
Namespace types: series table
Parameters:
self (table) : The raw `table` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `TABLE` object containing the value and a default Log instance.
method CHART_POINT(self, error_type)
Wraps a `chart.point` value into a `CHART_POINT` struct with an optional log severity.
Namespace types: chart.point
Parameters:
self (chart.point) : The raw `chart.point` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `CHART_POINT` object containing the value and a default Log instance.
method POLYLINE(self, error_type)
Wraps a `polyline` object into a `POLYLINE` struct with an optional log severity.
Namespace types: series polyline, series polyline, series polyline, series polyline
Parameters:
self (polyline) : The raw `polyline` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `POLYLINE` object containing the value and a default Log instance.
method LINEFILL(self, error_type)
Wraps a `linefill` object into a `LINEFILL` struct with an optional log severity.
Namespace types: series linefill
Parameters:
self (linefill) : The raw `linefill` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LINEFILL` object containing the value and a default Log instance.
method from_INT(self)
Extracts the integer value from an INT wrapper.
Namespace types: INT
Parameters:
self (INT) : The wrapped INT instance.
Returns: The underlying `int` value.
method from_FLOAT(self)
Extracts the float value from a FLOAT wrapper.
Namespace types: FLOAT
Parameters:
self (FLOAT) : The wrapped FLOAT instance.
Returns: The underlying `float` value.
method from_BOOL(self)
Extracts the boolean value from a BOOL wrapper.
Namespace types: BOOL
Parameters:
self (BOOL) : The wrapped BOOL instance.
Returns: The underlying `bool` value.
method from_STRING(self)
Extracts the string value from a STRING wrapper.
Namespace types: STRING
Parameters:
self (STRING) : The wrapped STRING instance.
Returns: The underlying `string` value.
method from_COLOR(self)
Extracts the color value from a COLOR wrapper.
Namespace types: COLOR
Parameters:
self (COLOR) : The wrapped COLOR instance.
Returns: The underlying `color` value.
method from_LINE(self)
Extracts the line object from a LINE wrapper.
Namespace types: LINE
Parameters:
self (LINE) : The wrapped LINE instance.
Returns: The underlying `line` object.
method from_LABEL(self)
Extracts the label object from a LABEL wrapper.
Namespace types: LABEL
Parameters:
self (LABEL) : The wrapped LABEL instance.
Returns: The underlying `label` object.
method from_BOX(self)
Extracts the box object from a BOX wrapper.
Namespace types: BOX
Parameters:
self (BOX) : The wrapped BOX instance.
Returns: The underlying `box` object.
method from_TABLE(self)
Extracts the table object from a TABLE wrapper.
Namespace types: TABLE
Parameters:
self (TABLE) : The wrapped TABLE instance.
Returns: The underlying `table` object.
method from_CHART_POINT(self)
Extracts the chart.point from a CHART_POINT wrapper.
Namespace types: CHART_POINT
Parameters:
self (CHART_POINT) : The wrapped CHART_POINT instance.
Returns: The underlying `chart.point` value.
method from_POLYLINE(self)
Extracts the polyline object from a POLYLINE wrapper.
Namespace types: POLYLINE
Parameters:
self (POLYLINE) : The wrapped POLYLINE instance.
Returns: The underlying `polyline` object.
method from_LINEFILL(self)
Extracts the linefill object from a LINEFILL wrapper.
Namespace types: LINEFILL
Parameters:
self (LINEFILL) : The wrapped LINEFILL instance.
Returns: The underlying `linefill` object.
method has_error(self)
Returns true if the INT wrapper has an active log entry.
Namespace types: INT
Parameters:
self (INT) : The INT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the FLOAT wrapper has an active log entry.
Namespace types: FLOAT
Parameters:
self (FLOAT) : The FLOAT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the BOOL wrapper has an active log entry.
Namespace types: BOOL
Parameters:
self (BOOL) : The BOOL instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the STRING wrapper has an active log entry.
Namespace types: STRING
Parameters:
self (STRING) : The STRING instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the COLOR wrapper has an active log entry.
Namespace types: COLOR
Parameters:
self (COLOR) : The COLOR instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LINE wrapper has an active log entry.
Namespace types: LINE
Parameters:
self (LINE) : The LINE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LABEL wrapper has an active log entry.
Namespace types: LABEL
Parameters:
self (LABEL) : The LABEL instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the BOX wrapper has an active log entry.
Namespace types: BOX
Parameters:
self (BOX) : The BOX instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the TABLE wrapper has an active log entry.
Namespace types: TABLE
Parameters:
self (TABLE) : The TABLE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the CHART_POINT wrapper has an active log entry.
Namespace types: CHART_POINT
Parameters:
self (CHART_POINT) : The CHART_POINT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the POLYLINE wrapper has an active log entry.
Namespace types: POLYLINE
Parameters:
self (POLYLINE) : The POLYLINE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LINEFILL wrapper has an active log entry.
Namespace types: LINEFILL
Parameters:
self (LINEFILL) : The LINEFILL instance to check.
Returns: True if an error or message is active in the log.
void_return()
Utility function used when a return is syntactically required but functionally unnecessary.
Returns: Nothing. Function never executes its body.
argument_error(condition, function, argument, message)
Throws a runtime error when a condition is met. Used for strict argument validation.
Parameters:
condition (bool) : Boolean expression that triggers the runtime error.
function (string) : Name of the calling function (for formatting).
argument (string) : Name of the problematic argument.
message (string) : Description of the error cause.
Returns: Never returns. Halts execution if the condition is true.
argument_log_info(condition, function, argument, message)
Logs an informational message when a condition is met. Used for optional debug visibility.
Parameters:
condition (bool) : Boolean expression that triggers the log.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Informational message to log.
Returns: Nothing. Logs if the condition is true.
argument_log_warning(condition, function, argument, message)
Logs a warning when a condition is met. Non-fatal but highlights potential issues.
Parameters:
condition (bool) : Boolean expression that triggers the warning.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Warning message to log.
Returns: Nothing. Logs if the condition is true.
argument_log_error(condition, function, argument, message)
Logs an error message when a condition is met. Does not halt execution.
Parameters:
condition (bool) : Boolean expression that triggers the error log.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Error message to log.
Returns: Nothing. Logs if the condition is true.
init_static_log(error_type, message, active)
Initializes a persistent (var) Log object. Ideal for global logging in scripts or modules.
Parameters:
error_type (series ErrorType) : Initial severity level (required).
message (string) : Optional starting message string. Default value of ("").
active (bool) : Whether the log should be flagged active on initialization. Default value of (false).
Returns: A static Log object with the given parameters.
method new_line(self)
Appends a newline character to the Log message. Useful for separating entries during chained writes.
Namespace types: Log
Parameters:
self (Log) : The Log instance to modify.
Returns: The updated Log object with a newline appended.
method write(self, message, flag_active, error_type)
Appends a message to a Log object without a newline. Updates severity and active state if specified.
Namespace types: Log
Parameters:
self (Log) : The Log instance being modified.
message (string) : The text to append to the log.
flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).
error_type (series ErrorType) : Optional override for the severity level. Default value of (na).
Returns: The updated Log object.
method write_line(self, message, flag_active, error_type)
Appends a message to a Log object, prefixed with a newline for clarity.
Namespace types: Log
Parameters:
self (Log) : The Log instance being modified.
message (string) : The text to append to the log.
flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).
error_type (series ErrorType) : Optional override for the severity level. Default value of (na).
Returns: The updated Log object.
method clear(self, flag_active, error_type)
Clears a Log object’s message and optionally reactivates it. Can also update the error type.
Namespace types: Log
Parameters:
self (Log) : The Log instance being cleared.
flag_active (bool) : Whether to activate the log after clearing. Default value of (false).
error_type (series ErrorType) : Optional new error type to assign. If not provided, the previous type is retained. Default value of (na).
Returns: The cleared Log object.
method render_condition(self, flag_active, error_type)
Conditionally renders the log if it is active. Allows overriding error type and controlling active state afterward.
Namespace types: Log
Parameters:
self (Log) : The Log instance to evaluate and render.
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override. Useful for contextual formatting just before rendering. Default value of (na).
Returns: The updated Log object.
method render_now(self, flag_active, error_type)
Immediately renders the log regardless of `active` state. Allows overriding error type and active flag.
Namespace types: Log
Parameters:
self (Log) : The Log instance to render.
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override. Allows dynamic severity adjustment at render time. Default value of (na).
Returns: The updated Log object.
render(self, condition, flag_active, error_type)
Renders the log conditionally or unconditionally. Allows full control over render behavior.
Parameters:
self (Log) : The Log instance to render.
condition (bool) : If true, renders only if the log is active. If false, always renders. Default value of (false).
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override passed to the render methods. Default value of (na).
Returns: The updated Log object.
Log
A structured object used to store and render logging messages.
Fields:
error_type (series ErrorType) : The severity level of the message (from the ErrorType enum).
message (series string) : The text of the log message.
active (series bool) : Whether the log should trigger rendering when conditionally evaluated.
INT
A wrapped integer type with attached logging for validation or tracing.
Fields:
v (series int) : The underlying `int` value.
e (Log) : Optional log object describing validation status or error context.
FLOAT
A wrapped float type with attached logging for validation or tracing.
Fields:
v (series float) : The underlying `float` value.
e (Log) : Optional log object describing validation status or error context.
BOOL
A wrapped boolean type with attached logging for validation or tracing.
Fields:
v (series bool) : The underlying `bool` value.
e (Log) : Optional log object describing validation status or error context.
STRING
A wrapped string type with attached logging for validation or tracing.
Fields:
v (series string) : The underlying `string` value.
e (Log) : Optional log object describing validation status or error context.
COLOR
A wrapped color type with attached logging for validation or tracing.
Fields:
v (series color) : The underlying `color` value.
e (Log) : Optional log object describing validation status or error context.
LINE
A wrapped line object with attached logging for validation or tracing.
Fields:
v (series line) : The underlying `line` value.
e (Log) : Optional log object describing validation status or error context.
LABEL
A wrapped label object with attached logging for validation or tracing.
Fields:
v (series label) : The underlying `label` value.
e (Log) : Optional log object describing validation status or error context.
BOX
A wrapped box object with attached logging for validation or tracing.
Fields:
v (series box) : The underlying `box` value.
e (Log) : Optional log object describing validation status or error context.
TABLE
A wrapped table object with attached logging for validation or tracing.
Fields:
v (series table) : The underlying `table` value.
e (Log) : Optional log object describing validation status or error context.
CHART_POINT
A wrapped chart point with attached logging for validation or tracing.
Fields:
v (chart.point) : The underlying `chart.point` value.
e (Log) : Optional log object describing validation status or error context.
POLYLINE
A wrapped polyline object with attached logging for validation or tracing.
Fields:
v (series polyline) : The underlying `polyline` value.
e (Log) : Optional log object describing validation status or error context.
LINEFILL
A wrapped linefill object with attached logging for validation or tracing.
Fields:
v (series linefill) : The underlying `linefill` value.
e (Log) : Optional log object describing validation status or error context.
Fibonacci Optimal Entry Zone [OTE] (Zeiierman)█ Overview
Fibonacci Optimal Entry Zone (Zeiierman) is a high-precision market structure tool designed to help traders identify ideal entry zones during trending markets. Built on the principles of Smart Money Concepts (SMC) and Fibonacci retracements, this indicator highlights key areas where price is most likely to react — specifically within the "Golden Zone" (between the 50% and 61.8% retracement).
It tracks structural pivot shifts (CHoCH) and dynamically adjusts Fibonacci levels based on real-time swing tracking. Whether you're trading breakouts, pullbacks, or optimal entries, this tool brings unparalleled clarity to structure-based strategies.
Ideal for traders who rely on confluence, this indicator visually synchronizes swing highs/lows, market structure shifts, Fibonacci retracement levels, and trend alignment — all without clutter or lag.
⚪ The Structural Assumption
Price moves in waves, but key retracements often lead to continuation or reversal — especially when aligned with structure breaks and trend shifts.
The Optimal Entry Zone captures this behavior by anchoring Fibonacci levels between recent swing extremes. The most powerful area — the Golden Zone — marks where institutional re-entry is likely, providing traders with a sniper-like roadmap to structure-based entries.
█ How It Works
⚪ Structure Tracking Engine
At its core, the indicator detects pivots and classifies trend direction:
Structure Period – Determines the depth of pivots used to detect swing highs/lows.
CHoCH – Break of structure logic identifies where the trend shifts or continues, marked visually on the chart.
Bullish & Bearish Modes – Independently toggle uptrend and downtrend detection and styling.
⚪ Fibonacci Engine
Upon each confirmed structural shift, Fibonacci retracement levels are projected between swing extremes:
Custom Levels – Choose which retracements (0.50, 0.618, etc.) are shown.
Real-Time Adjustments – When "Swing Tracker" is enabled, levels and labels update dynamically as price forms new swings.
Example:
If you disable the Swing Tracker, the Golden Level is calculated using the most recent confirmed swing high and low.
If you enable the Swing Tracker, the Golden Level is calculated from the latest swing high or low, making it more adaptive as the trend evolves in real time.
█ How to Use
⚪ Structure-Based Entry
Wait for CHoCH events and use the resulting Fibonacci projection to identify entry points. Enter trades as price taps into the Golden Zone, especially when confluence forms with swing structure or order blocks.
⚪ Real-Time Reaction Tracking
Enable Swing Tracker to keep the tool live — constantly updating zones as price shifts. This is especially useful for scalpers or intraday traders who rely on fresh swing zones.
█ Settings
Structure Period – Number of bars used to define swing pivots. Larger values = stronger structure.
Swing Tracker – Auto-updates fib levels as new highs/lows form.
Show Previous Levels – Keep older fib zones on chart or reset with each structure shift.
-----------------
Disclaimer
The content provided in my scripts, indicators, ideas, algorithms, and systems is for educational and informational purposes only. It does not constitute financial advice, investment recommendations, or a solicitation to buy or sell any financial instruments. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from the use of or reliance on such information.
All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, backtest, or individual's trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs.
MACD Support and Resistance [ChartPrime]⯁ OVERVIEW
MACD Support and Resistance is a dynamic support/resistance mapping tool powered by MACD crossover logic. Each time the MACD line crosses the signal line, the indicator scans for recent price extremes and locks them in as potential support or resistance zones. These levels are automatically cleaned up if price breaks them, keeping the chart focused on active market structure. The system includes a built-in MACD display with visual markers, along with contextual highs and lows to help define the current environment.
⯁ MACD-BASED SUPPORT/RESISTANCE GENERATION
The core logic uses the MACD oscillator crossover as a trigger event to generate structural levels:
When MACD crosses above its signal line:
→ The script scans the last 5 bars for the lowest low .
→ A support level is plotted at that price.
When MACD crosses below its signal line:
→ The script scans the last 5 bars for the highest high .
→ A resistance level is plotted at that price.
These dynamic levels reflect where price recently reversed or paused, making them prime zones for reaction, continuation, or invalidation.
⯁ LEVEL MANAGEMENT AND VALIDATION
To keep the chart clean and relevant:
A maximum of 20 active levels are allowed at once.
Older levels are automatically removed if the list exceeds the limit.
If price closes below a support level or above a resistance level , the corresponding line is deleted.
This ensures that only currently respected levels remain on the chart — a major advantage for active traders.
⯁ MACD VISUALIZATION + SIGNAL MARKERS
A full MACD system is rendered on the lower panel for visual confirmation:
The MACD line and Signal line are both plotted and color-coded dynamically.
A filled area] highlights the spread between them to emphasize momentum strength.
A diamond marker is drawn each time MACD crosses its signal line, alerting traders to potential trend shifts.
These visuals make it easy to understand the timing of the support/resistance updates.
⯁ LOCAL EXTREME REFERENCE LINES
To help contextualize current price position relative to recent market extremes:
A Local High line is plotted based on the highest MACD value over the past 100 bars].
A Local Low line is plotted based on the lowest MACD value over the past 100 bars].
These levels are rendered lightly and serve as dynamic range boundaries.
They assist traders in identifying overextended or compressed MACD behavior.
⯁ USAGE
Use the generated S/R levels as breakout or reversal zones.
Watch for MACD diamond markers to confirm the timing of new levels.
Combine these reactive zones with other ChartPrime confluence tools for higher-confidence entries.
Use the Local High/Low zones as a volatility envelope to guide risk and trend continuation potential.
⯁ CONCLUSION
MACD Support and Resistance takes a classic momentum indicator and adds real-time structural awareness. By linking MACD crossover events to recent price extremes, it identifies the zones where market sentiment shifted — and continues to monitor their strength. Whether you're a breakout trader or looking to fade key reaction points, this tool delivers clean, actionable levels based on momentum and structure — not guesswork.
Higher Timeframe Market StructureHTF Market Structure – ZigZag, Break of Structure & Supply/Demand
This powerful indicator is designed to identify higher-timeframe market structure using a combination of ZigZag patterns, Break of Structure (BOS) signals, and Supply/Demand zones.
Key Features:
Automatic detection of Higher Highs (HH), Higher Lows (HL), Lower Lows (LL), and Lower Highs (LH)
Internal structure shifts based on Open or High/Low logic
Supply and Demand zones plotted on the chart
Break of Structure (BOS) lines with optional alerts
Mitigation logic to mark or delete invalidated order blocks
Customizable aggregation factor to view higher time frame structure on lower time frames
How to Use:
Focus on market structure and BOS to understand the current trend.
Watch for internal shifts as early signals of potential reversals.
Use ZigZag lines to connect swing highs and lows to visualize market rhythm.
Supply zones (red) and Demand zones (green) are automatically drawn after structure breaks:
Use Demand Zones in Bullish Markets for the highest probability entries.
Use Supply Zones in Bearish Markets to align with the prevailing trend.
Best Practices:
Only use Demand Zones in Bullish markets and Supply Zones in Bearish markets for optimal results.
Look for price action or reversal signals within these zones to refine your entries.
Enable alerts to get notified on:
New order blocks
Internal shifts
BOS events
HH, HL, LL, LH formations
Liquidity sweeps
Customization Options:
Aggregation Factor: Control how many candles are grouped for structure analysis.
Zone Duration: Define how length of plotted zones.
Mitigation Settings: Automatically delete or fade zones after mitigation.
Colors: Choose custom colors for bullish and bearish zones and structure markers.
This tool is ideal for traders who rely on price action, structure, and smart money concepts. Combine it with your own S&D strategy or integrate it with other confluence tools for even better precision.
GCM Centre Line Candle MarkerGCM Centre Line Candle Marker (GCM-CLCM) - Descriptive Notes
Indicator Overview:
The "GCM Centre Line Candle Marker" is a versatile TradingView overlay indicator designed to enhance chart analysis by drawing short horizontal lines at user-defined "centre" points of candles. These lines provide a quick visual reference to key price levels within each candle, such as midpoints, open, close, or typical prices. The indicator offers extensive customization for line appearance, positioning, and conditional display, including an option to highlight only bullish engulfing patterns.
Key Features:
1. Customizable Line Position:
o Users can choose from various methods to calculate the "centre" price for the line:
(High + Low) / 2 (Default)
(Open + Close) / 2
Close
Open
(Open + High + Low + Close) / 4 (HLCO/4)
(Open + High + Close) / 3 (Typical Price HLC/3 variation)
(Open + Close + Low) / 3 (Typical Price OCL/3 variation)
2. Line Appearance Customization:
o Visibility: Toggle lines on/off.
o Style: Solid, dotted, or dashed lines.
o Width: Adjustable line thickness (1 to 5).
o Length: Defines how many candles forward the line extends (1 to 10).
o Color: Lines are colored based on candle type (bullish/bearish), with user-selectable base colors.
o Dynamic Opacity: Line opacity is dynamically adjusted based on the candle's size relative to recent candles. Larger candles produce more opaque lines (up to the user-defined maximum opacity), while smaller candles result in more transparent lines. This helps significant candles stand out.
3. Price Labels:
o Show Labels: Option to display price labels at the end of each center line.
o Label Background Color: Customizable.
o Dynamic Text Color: Label text color can change based on the movement of the center price:
Green: Current center price is higher than the previous.
Red: Current center price is lower than the previous.
Gray: No change or first label.
o Static Text Color: Alternatively, a fixed color can be used for all labels.
4. Conditional Drawing - Bullish Engulfing Filter:
o Users can enable an option to Only Show Bullish Engulfing Candles. When active, center lines will only be drawn for candles that meet bullish engulfing criteria (current bull candle's body engulfs the previous bear candle's body).
5. Performance Management:
o Max Lines to Show: Limits the number of historical lines displayed on the chart to maintain clarity and performance. Older lines are automatically removed as new ones are drawn.
6. Alert Condition:
o Includes a built-in alert: Big Bullish Candle. This alert triggers when a bullish candle's range (high - low) is greater than the 20-period simple moving average (SMA) of candle ranges.
How It Works:
• For each new candle, the script calculates the "center" price based on the user's Line Position selection.
• If showLines is enabled and (if applicable) the bullish engulfing condition is met, a new line is drawn from the current candle's bar_index at the calculated _center price, extending lineLength candles forward.
• The line's color is determined by whether the candle is bullish (close > open) or bearish (close < open).
• Opacity is calculated dynamically: scaledOpacity = int((100 - maxUserOpacity) * (1 - dynamicFactor) + maxUserOpacity), where dynamicFactor is candleSize / maxSize (current candle size relative to the max size in the last 20 candles). This means maxUserOpacity is the least transparent the line will be (for the largest candles), and smaller candles will have lines approaching full transparency.
• Optional price labels are added at the end of these lines.
• The script manages an array of drawn lines, removing the oldest ones if the maxLines limit is exceeded.
Potential Use Cases:
• Visualizing Intra-Candle Levels: Quickly see midpoints or other key price points without manual drawing.
• Short-Term Reference Points: The extended lines can act as very short-term dynamic support/resistance or points of interest.
• Pattern Recognition: Highlight bullish engulfing patterns or simply emphasize candles based on their calculated center.
• Volatility Indication: The dynamic opacity can subtly indicate periods of larger or smaller candle ranges.
• Confirmation Tool: Use in conjunction with other indicators or trading strategies.
User Input Groups:
• Line Settings: Controls all aspects of the line's appearance and calculation.
• Label Settings: Manages the display and appearance of price labels.
• Other Settings: Contains options for line management and conditional filtering (like Bullish Engulfing).
This indicator provides a clean and customizable way to mark significant price levels within candles, aiding traders in their technical analysis.
Custom Session Tracker (KN)**Custom Session Tracker (KN)**
Visually highlight any intraday session’s high, low, and midpoint on your chart with full styling control.
**Description**
Custom Session Tracker (KN) lets you define any trading session (e.g. 09:30–16:00 NY time) and automatically draws:
* A translucent box spanning the session’s High and Low
* A horizontal line marking the session midpoint
All elements update in real time and persist after session close.
**Features**
* **Session Range Box**: Plots from session open through close
* **Mid-Price Line**: Marks the exact midpoint of High/Low
* **Timezone Input**: Aligns session to any GMT offset
* **Custom Colors**: Fill, border, and mid-line colors
* **Line & Border Styles**: Choose solid or dashed
**Inputs**
* **Timezone** – GMT offset for your market
* **Session** – Hours in `HHMM-HHMM` format
* **Fill Color** – Box interior transparency
* **Border Color** – Box outline
* **Box Border Style** – Solid or dashed
* **Midline Color** – Mid-price line color
* **Mid Price Line Style** – Solid or dashed
**How to Use**
1. Add the script to your chart.
2. Set your session hours and timezone.
3. Customize colors and styles.
4. Watch each session’s high, low, and midpoint appear automatically.
Perfect for session-overlap strategies, mean-reversion signals, or simply keeping key levels in view.
SMCFunctionsLibrary "SMCFunctions"
findSwingPoints(high, low, swing_size)
Parameters:
high (float)
low (float)
swing_size (int)
detectBOS(close, high, low, prevHigh, prevLow, highActive, lowActive, bos_conf_type)
Parameters:
close (float)
high (float)
low (float)
prevHigh (float)
prevLow (float)
highActive (bool)
lowActive (bool)
bos_conf_type (string)
getBOSDetails(highBroken, lowBroken, prevHigh, prevLow, prevSwing, prevHighIndex, prevLowIndex, input_show_choch)
Parameters:
highBroken (bool)
lowBroken (bool)
prevHigh (float)
prevLow (float)
prevSwing (int)
prevHighIndex (int)
prevLowIndex (int)
input_show_choch (bool)
calculateRetracementLevels(start_price, end_price)
Parameters:
start_price (float)
end_price (float)
Color Coded Volume IndicatorColor Coded Volume Indicator
Overview
Splits each bar’s total volume into estimated buy-side vs. sell-side components and displays them as stacked two-tone columns (red = sell, green = buy). Axis labels and tooltips use “K”/“M” formatting.
Features
Stacked Two-Tone Columns
Red Base : estimated sell volume (50% opacity)
Green Top : remaining buy volume (50% opacity)
Automatic K/M Formatting via format=format.volume
Zero Baseline for clean reference at zero
Positive-Only Bars (no negatives)
How It Works
True-Range Guard
Skips bars where high == low to avoid divide-by-zero.
Volume Split
BuyVol = Volume × (Close − Low) / (High − Low)
SellVol = Volume × (High − Close) / (High − Low)
Both series clamped ≥ 0.
Layered Plot
Draw semi-transparent green at full height, then overlay red sell portion.
Usage
Open TradingView’s Pine Editor
Paste in the full script
Click “Save & Add to Chart”
In the Publish dialog, title it “Color Coded Volume Indicator” and paste this description.
Interpretation
Green-dominant bars → strong buying pressure
Red-dominant bars → strong selling pressure
Equal halves → balanced activity
Opening Range Breakout Cloud Indicator by TenAMTraderOpening Range Breakout Cloud Indicator – by TenAMTrader
This indicator visually maps out the Opening Range of the trading day — the price high and low between a configurable start and end time (default: 9:30 AM–10:00 AM EST). It helps traders identify breakout levels, key intraday zones, and price behavior relative to the early range.
🔹 What It Shows:
Opening High, Low, and Midpoint lines for each day.
Clouds between the midpoint and high/low for visual clarity.
Optional Second Range (e.g., 9:30–9:45 AM) for more aggressive early signals.
Historical Ranges are preserved, allowing you to view previous days' levels on the chart.
Custom Alerts when price crosses the Opening High, Low, or Midpoint.
Full customization: colors, range times, and display toggles.
🔔 Use It For:
Spotting breakouts or rejections at key levels.
Finding early support/resistance zones.
Planning trades using intraday structure.
⚠️ Use this tool as part of a broader trading strategy. No indicator guarantees results — always trade at your own discretion.
Higher Timeframe TrendMap [BigBeluga]🔵HTF TrendMap
A powerful visual overlay that brings higher timeframe market structure directly onto your intraday chart.
This tool maps directional bias, trend strength, and dynamic range boundaries from a user-selected HTF (like Daily or 4H), offering a real-time confluence layer for scalpers, day traders, and swing traders.
By plotting the evolving average (HL2), it acts as a volatility-weighted trend anchor, allowing you to align lower timeframe entries with higher timeframe intent.
Technical Overview:
At the close of each higher timeframe (HTF) candle, the indicator stores the high, low, and calculates the HL2 midpoint. These values are then referenced on the lower timeframe chart to plot trend direction and price boundaries.
🔵 KEY FEATURES
Maps the selected higher timeframe (HTF) (e.g., Daily) onto your current chart.
At the close of each HTF candle , it starts to calculate and store the highest, lowest, and average (HL2) price levels .
The average (HL2) value is treated as the HTF trend baseline —plotted in orange for uptrend , blue for downtrend .
Visual curve thickens and fades to show progress through the HTF period (stronger color = fresher data).
Horizontal dashed lines show HTF high and low levels that persist until the next period closes.
On every HTF close, two price labels are printed for the high and low levels.
Vertical separators visually mark the start of each HTF candle for easy structural recognition.
A real-time dashboard shows selected HTF, current trend direction (🢁/🢃), and updates dynamically.
🔵 HOW TO USE
Use the HTF average line as a bias filter —only long when the trend is up (orange), short when down (blue).
HTF high/low labels help identify key breakout or rejection zones .
Combine with intraday systems or reversal tools for multi-timeframe confluence setups .
Ideal for scalpers and swing traders who rely on HTF momentum shifts .
🔵 CONCLUSION
HTF TrendMap provides a clean, data-rich layer of higher timeframe context to any chart. With adaptive trend coloring, volatility mapping, and real-time data labeling, it enables traders to stay in sync with macro structure while executing on the micro.
