Şimdi başlat

Göstergeler ve stratejiler

Price Step Channel [BigBeluga]Price Step Channel is designed to provide a structured look at price trends through a dynamic step line channel, highlighting trend direction and volatility boundaries. 🔵 Key Features: Step Line with Boundaries: The central step line adjusts with price movements, creating upper and lower boundaries based on price volatility. The channel is green during uptrends and red during downtrends, visually signaling the trend’s direction. Fakeout Markers: "✖" markers identify potential fakeouts—moments when the price breaches the channel boundary without confirming a trend change. These markers help you spot possible mean reversion points. Dynamic Boundary Labels: Labels at the end of the channel show the price levels of the upper and lower boundaries. In uptrends, the upper label turns green; in downtrends, the lower label turns red, providing an instant read on the trend's direction. Customizable Display: You can toggle off the boundaries and labels for a cleaner view, focusing only on the step line and its color-coded trend signals. 🔵 When to Use: Price Step Channel is ideal for traders looking to follow structured trends with defined volatility boundaries. The step line and color-coded channel provide clear trend insights, while the fakeout markers and customizable display options enhance flexibility in different market conditions. Whether you’re focusing on clean trend signals or detailed boundary interactions, this tool adapts to your style.
Pine Script™ indikatörü
BigBeluga tarafından
7
Fibonacci Volume Profiles [AlgoAlpha]Unlock a deeper understanding of price action with the Fibonacci Volume Profiles indicator by AlgoAlpha! This powerful tool blends Fibonacci retracement levels with customizable volume profiles, helping traders identify high-probability areas of support, resistance, and accumulation. Designed for both continuous dynamic levels and custom time periods, this indicator is a must-have for traders seeking confluence in market structure analysis. 🔑 Key Features 📈 Dual Mode Selection : Choose between Continuous Fibonacci levels, which adapt dynamically to pivots, or a Custom Period mode, where you set your own start and end points. 📊 Integrated Volume Profile : Visualize volume distributions at key Fibonacci retracement levels, revealing areas of strong buying/selling interest. 🎨 Customizable Colors & Transparency : Adjust Fibonacci level colors, fill zones, and profile transparency for a visually clear experience. 🔍 Profile Resolution & Scaling : Control the number of price levels and width of the volume profile for detailed market insights. 🛠 Extendable Levels : Optionally extend Fibonacci levels to the right of the chart for better visualization of future price interaction. 📌 How to Use Add the Indicator: Click on the star icon to add it to your favorites and apply it to your TradingView chart. Analyze The Market: Observe how price interacts with Fibonacci levels alongside the volume profile to confirm support/resistance zones. Switch between custom range or continuous mode to align the tool with your trading style. ⚙️ How It Works The indicator calculates pivot highs/lows dynamically (or uses user-defined time periods) to plot Fibonacci retracement levels. It then builds a volume profile by analyzing historical volume data, grouping it into price bins to highlight volume-heavy zones. The Point of Control (PoC) is identified as the level with the highest traded volume, acting as a key price magnet. The color-coded Fibonacci levels help traders spot retracement zones, while the volume profile confirms strength or weakness in those areas.
Pine Script™ indikatörü
AlgoAlpha tarafından
3
Crystal Order Block Introducing Crystal Order Block – a powerful TradingView indicator designed to identify high-probability order blocks with precision. 🚀📈 🔹 Key Features: ✅ Detects valid institutional order blocks automatically ✅ Highlights high-probability zones for entries ✅ Helps in Smart Money trading strategies (ICT, SMC, VSA) ✅ Works on all timeframes for scalping & swing trading ✅ Enhances risk management & trade accuracy This indicator is perfect for traders who want to trade like professionals by using refined order block concepts. 💡 Test it now and take your trading to the next level! #CrystalOrderBlock #OrderBlockIndicator #SmartMoneyConcepts #SMC #ICT #ForexTrading #TradingView #PriceAction #Liquidity #InstitutionalTrading #OrderBlocks
Pine Script™ indikatörü
Crystalforex22 tarafından
1
RSI/MOM/MACD/Squezee/Donchian/HULL/SUPERTREND/Waddath Attar GAOOptimized Trading Strategy with RSI, MOM, MACD, Donchian, Squeeze, HULL, Supertrend & Waddah Attar Our trading strategy combines multiple technical indicators to maximize trend identification, momentum confirmation, and trade execution precision. 📌 RSI (Relative Strength Index) – Measures overbought and oversold conditions, helping to spot potential reversals. 📌 MOM (Momentum Indicator) – Confirms price acceleration and strength, identifying possible breakouts or trend exhaustion. 📌 MACD (Moving Average Convergence Divergence) – A trend-following momentum indicator that highlights bullish or bearish crossovers. 📌 Donchian Channel – Defines support and resistance levels, signaling breakouts when price moves beyond its range. 📌 Squeeze (TTM Squeeze) – Detects periods of low volatility before explosive moves, ideal for breakout trading. 📌 HULL Moving Average – A fast and smooth moving average used to reduce lag and provide better trend direction. 📌 Supertrend – A dynamic trend indicator that adjusts based on volatility, providing clear buy and sell signals. 📌 Waddah Attar Explosion – Measures momentum and volatility, helping to confirm strong breakouts with volume-based signals. By integrating these indicators on higher timeframes (such as 4H and Daily), traders can refine entry and exit points, minimize false signals, and maximize profits. 🚀📈
Pine Script™ indikatörü
gaogabriel3 tarafından
1
KEMAD | QuantumResearchQuantumResearch KEMAD Indicator The QuantumResearch KEMAD Indicator is a sophisticated trend-following and volatility-based tool designed for traders who demand precision in detecting market trends and price reversals. By leveraging advanced techniques implemented in PineScript, this indicator integrates a Kalman filter, an Exponential Moving Average (EMA), and dynamic ATR-based deviation bands to produce clear, actionable trading signals. 1. Overview The KEMAD Indicator aims to: Reduce Market Noise: Employ a Kalman filter to smooth price data. Identify Trends: Use an EMA of the filtered price to define the prevailing market direction. Set Dynamic Thresholds: Adjust breakout levels with ATR-based deviation bands. Generate Signals: Provide clear long and short trading signals along with intuitive visual cues. 2. How It Works A. Kalman Filter Smoothing Purpose: The Kalman filter refines the selected price source (e.g., close price) by reducing short-term fluctuations, thus offering a clearer view of the underlying price movement. Customization: Users can adjust key parameters such as: Process Noise: Controls the filter’s sensitivity to recent changes. Measurement Noise: Determines how responsive the filter is to incoming price data. Filter Order: Sets the number of data points considered in the smoothing process. B. EMA-Based Trend Detection Primary Trend EMA: A 25-period EMA is applied to the Kalman-filtered price, serving as the core trend indicator. Signal Mechanism: Long Signal: Triggered when the price exceeds the EMA plus an ATR-based upper deviation. Short Signal: Triggered when the price falls below the EMA minus an ATR-based lower deviation. C. ATR Deviation Bands ATR Utilization: The Average True Range (ATR) is computed (default length of 21) to assess market volatility. Dynamic Thresholds: Upper Deviation: Calculated by adding 1.5× ATR to the EMA (for long signals). Lower Deviation: Calculated by subtracting 1.1× ATR from the EMA (for short signals). These bands adapt to current volatility, ensuring that signal thresholds are both dynamic and market-sensitive. 3. Visual Representation The indicator’s design emphasizes clarity and ease of use: Color-Coded Bar Signals: Green Bars: Indicate bullish conditions when a long signal is active. Red Bars: Indicate bearish conditions when a short signal is active. Trend Confirmation Line: A 54-period EMA is plotted to further validate trend direction. Its color dynamically changes to reflect the active trend. Background Fill: The space between a calculated price midpoint (typically the average of high and low) and the EMA is filled, visually emphasizing the prevailing market trend. 4. Customization & Parameters The KEMAD Indicator is highly configurable, allowing traders to tailor the tool to their specific trading strategies and market conditions: ATR Settings: ATR Length: Default is 21; adjusts sensitivity to market volatility. EMA Settings: Trend EMA Length: Default is 25; smooths price action for trend detection. Confirmation EMA Length: Default is 54; aids in confirming the trend. Kalman Filter Parameters: Process Noise: Default is 0.01. Measurement Noise: Default is 3.0. Filter Order: Default is 5. Deviation Multipliers: Long Signal Multiplier: Default is 1.5× ATR. Short Signal Multiplier: Default is 1.1× ATR. Appearance: Eight customizable color themes are available to suit individual visual preferences. 5. Trading Applications The versatility of the KEMAD Indicator makes it suitable for various trading strategies: Trend Following: It helps identify and ride sustained bullish or bearish trends by filtering out market noise. Breakout Trading: Detects when prices move beyond the ATR-based deviation bands, signaling potential breakout opportunities. Reversal Detection: Alerts traders to potential trend reversals when price crosses the dynamically smoothed EMA. Risk Management: Offers clearly defined entry and exit points, based on volatility-adjusted thresholds, enhancing trade precision and risk control. 6. Final Thoughts The QuantumResearch KEMAD Indicator represents a unique blend of advanced filtering (via the Kalman filter), robust trend analysis (using EMAs), and dynamic volatility assessment (through ATR deviation bands). Its PineScript implementation allows for a high degree of customization, making it an invaluable tool for traders looking to reduce noise, accurately detect trends, and manage risk effectively. Whether used for trend following, breakout strategies, or reversal detection, the KEMAD Indicator is designed to adapt to varying market conditions and trading styles. Important Disclaimer: Past data does not predict future behavior. This indicator is provided for informational purposes only; no indicator or strategy can guarantee future results. Always perform thorough analysis and use proper risk management before trading.
Pine Script™ indikatörü
QuantumResearch tarafından
Liquidations Script + buyside/sellside ratioThis enhanced version of the liquidations indicator is designed for use with Pine Script™ version 6 and provides a more detailed view of potential liquidation levels on your chart. The key features include: Volume-Based Liquidation Calculations: The script calculates a volume difference over a user-defined lookback period and uses the mean difference to filter out noise. It then determines whether the current volume difference exceeds specific thresholds (e.g., 5x, 10x, 25x, 50x, and 100x leverage conditions). Pivot Point Integration: Pivot high and low points are identified using configurable parameters. Optionally, these pivot lines can be displayed to visually aid in understanding where the price reversals occur. Dynamic Liquidation Lines: For each leverage group, the script draws corresponding liquidation lines above and below the price. The calculations adjust the liquidation level based on whether the signal is from a pivot high or pivot low, reflecting potential liquidation prices for both long and short positions. Real-Time Ratio Display: An additional feature of this version is the display of a ratio label. This label, positioned on the right side of the price (using yloc.price and label.style_label_right), shows: The number of liquidation lines above the price (from pivot highs) The number of liquidation lines below the price (from pivot lows) The ratio (or proportion) of liquidation lines above to those below the price This offers traders an at-a-glance summary of the market’s liquidation pressure. Customizability and Flexibility: Users can toggle the display of pivot settings and each leverage group’s liquidation lines individually. Colors and line extensions can be adjusted to fit the user’s charting preferences. Overall, this improved script aims to deliver clearer, more actionable information regarding potential liquidation levels while keeping the code organized and fully compliant with Pine Script™ version 6.
Pine Script™ indikatörü
avihaleviooo tarafından
1
Trader Criptom4N//@version=5 indicator("Trader Criptom4N", "🐳Criptom4N®🐳" , overlay = true , max_labels_count = 500 , max_lines_count = 500 , max_boxes_count = 500 , max_bars_back = 500) //INICIA MODULO SUPERTREND // Get user input //INICIA MODULO SUPERTREND // Get user input // Instead of inputs, define constants or variables directly // Instead of inputs, define constants or variables directly var float nsensitivity = 1 nbuysell = input.bool(true, 'Buy/Sell Signal', inline = "BSNM",group='BUY/SELL SIGNAL') // SMA sma4_strong = ta.sma(close, 8) sma5_strong = ta.sma(close, 9) // Signal Generation // Signal Generation Function supertrend(_src, factor, atrLen) => atr = ta.atr(atrLen) upperBand = _src + factor * atr lowerBand = _src - factor * atr prevLowerBand = nz(lowerBand ) prevUpperBand = nz(upperBand ) lowerBand := lowerBand > prevLowerBand or close < prevLowerBand ? lowerBand : prevLowerBand upperBand := upperBand < prevUpperBand or close > prevUpperBand ? upperBand : prevUpperBand var int direction = na var float superTrend = na prevSuperTrend = nz(superTrend ) if na(atr ) direction := 1 else if prevSuperTrend == prevUpperBand direction := close > upperBand ? -1 : 1 else direction := close < lowerBand ? 1 : -1 superTrend := direction == -1 ? lowerBand : upperBand = supertrend(close, nsensitivity*7,10) //señales bull = ta.crossover(close, supertrend) bear = ta.crossunder(close, supertrend) //FIN MODULO SUPERTREND // Risk Management levels2 = input.bool(true, "Show TP/SL Levels2" , group = "Risk Management" , inline = "MMDB2") lvlLines = input.bool(true, "Show Lines ", inline="levels2", group = "Risk Management") linesStyle = input.string("SOLID", "", , inline="levels2", group = "Risk Management") lvlDistance = input.int(40, "Distance", 1, inline="levels2", group = "Risk Management") lvlDecimals = input.int(4, "   Decimals", 1, 8, inline="levels2", group = "Risk Management") atrRisk = input.int(3, "Risk % ", 1, group = "Risk Management" , inline="levels3") atrLen = input.int(14, "  ATR Length", 1, group = "Risk Management" , inline="levels3") decimals = lvlDecimals == 1 ? "#.#" : lvlDecimals == 2 ? "#.##" : lvlDecimals == 3 ? "#.###" : lvlDecimals == 4 ? "#.####" : lvlDecimals == 5 ? "#.#####" : lvlDecimals == 6 ? "#.######" : lvlDecimals == 7 ? "#.#######" : "#.########" CirrusCloud = input(true, 'Cirrus Cloud', group='TREND FEATURES') // Plots windowsize = 100 offset = 0.9 sigma = 6 //plot(ta.alma(source, windowsize, offset, sigma)) windowsize2 = 310 offset2 = 0.85 sigma2 = 32 //plot(ta.alma(source, windowsize2, offset2, sigma2)) // Chart Features smoothrng(x, t, m) => wper = t * 2 - 1 avrng = ta.ema(math.abs(x - x ), t) smoothrng = ta.ema(avrng, wper) * m smoothrng smrng = smoothrng(close, 22, 6) rngfilt(x, r) => rngfilt = x rngfilt := x > nz(rngfilt ) ? x - r < nz(rngfilt ) ? nz(rngfilt ) : x - r : x + r > nz(rngfilt ) ? nz(rngfilt ) : x + r rngfilt filt = rngfilt(close, smrng) // ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ upward = 0.0 upward := filt > filt ? nz(upward ) + 1 : filt < filt ? 0 : nz(upward ) downward = 0.0 downward := filt < filt ? nz(downward ) + 1 : filt > filt ? 0 : nz(downward ) filtcolor = upward > 0 ? color.new(#00e2ff, 50) : downward > 0 ? color.new(#fe0100, 50) : color.new(#56328f, 0) // Trend Cloud tclength = 600 hullma = ta.wma(2*ta.wma(close, tclength/2)-ta.wma(close, tclength), math.floor(math.sqrt(tclength))) // Chart Features x1 = 22 x2 = 9 x3 = 15 x4 = 5 smoothrngX1(x, t, m) => wper = t * 2 - 1 avrng = ta.ema(math.abs(x - x ), t) smoothrngX1 = ta.ema(avrng, wper) * m smoothrngX1 smrngx1x = smoothrngX1(close, x1, x2) smrngx1x2 = smoothrngX1(close, x3, x4) rngfiltx1x1(x, r) => rngfiltx1x1 = x rngfiltx1x1 := x > nz(rngfiltx1x1 ) ? x - r < nz(rngfiltx1x1 ) ? nz(rngfiltx1x1 ) : x - r : x + r > nz(rngfiltx1x1 ) ? nz(rngfiltx1x1 ) : x + r rngfiltx1x1 filtx1 = rngfiltx1x1(close, smrngx1x) filtx12 = rngfiltx1x1(close, smrngx1x2) // ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ upwardx1 = 0.0 upwardx1 := filtx1 > filtx1 ? nz(upwardx1 ) + 1 : filtx1 < filtx1 ? 0 : nz(upwardx1 ) downwardx1 = 0.0 downwardx1 := filtx1 < filtx1 ? nz(downwardx1 ) + 1 : filtx1 > filtx1 ? 0 : nz(downwardx1 ) filtx1colorx1 = color.rgb(0, 187, 212, 100) xxx1 = plot(CirrusCloud ? filtx1 : na, color=filtx1colorx1, linewidth=1, title='Trend Tracer', editable = false) xxx2 = plot(CirrusCloud ? filtx12 : na, color=filtx1colorx1, linewidth=1, title='Trend Tracer', editable = false) fill(xxx1, xxx2, color= filtx1 > filtx12 ? color.rgb(254, 0, 0, 86) : color.rgb(21, 255, 0, 86)) trigger2 = bull ? 1 : 0 countBull = ta.barssince(bull) countBear = ta.barssince(bear) trigger = nz(countBull, bar_index) < nz(countBear, bar_index) ? 1 : 0 atrBand = ta.atr(atrLen) * atrRisk atrStop = trigger == 1 ? low - atrBand : high + atrBand // Colors green = #2BBC4D, green2 = color.rgb(0, 221, 0, 27) red = #C51D0B, red2 = #c51d0b adxlen = 15 dilen = 15 dirmov(len) => up = ta.change(high) down = -ta.change(low) plusDM = na(up) ? na : up > down and up > 0 ? up : 0 minusDM = na(down) ? na : down > up and down > 0 ? down : 0 truerange = ta.rma(ta.tr, len) plus = fixnan(100 * ta.rma(plusDM, len) / truerange) minus = fixnan(100 * ta.rma(minusDM, len) / truerange) adx(dilen, adxlen) => = dirmov(dilen) sum = plus + minus adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), adxlen) adx sig = adx(dilen, adxlen) // range ADX threshold sidewaysThreshold = input.int(title='ADX Sideways Threshold (10-30)', minval=2, defval=15) // boolean expression to see if the ADX is below tehe sideways threshold bool isSideways = sig < sidewaysThreshold // adding the option to color the bars when in a trading range useBarColor = true bColor = isSideways ? #b102fc : na barcolor(useBarColor ? bColor : na) barcolor(close > supertrend ? #3cff00 : #fe0100) percentStop = input.float(1, "Stop Loss % (0 to Disable)", 0, group="BUY & SELL SIGNALS") srcStop = close lastTrade(src) => ta.valuewhen(bull or bear, src, 0) entry_y = lastTrade(srcStop) stop_y = lastTrade(atrStop) tp1_y = (entry_y - lastTrade(atrStop)) * 1 + entry_y tp2_y = (entry_y - lastTrade(atrStop)) * 2 + entry_y tp3_y = (entry_y - lastTrade(atrStop)) * 3 + entry_y labelTpSl(y, txt, color) => label labelTpSl = percentStop != 0 ? label.new(bar_index + 1, y, txt, xloc.bar_index, yloc.price, color, label.style_label_left, #000000, size.normal) : na label.delete(labelTpSl ) if (levels2) labelTpSl(entry_y, " Entry -- " + str.tostring(entry_y, decimals), color.gray) labelTpSl(stop_y , " Stop Loss -- " + str.tostring(stop_y, decimals), #f90808) labelTpSl(tp1_y, " TP 1 -- " + str.tostring(tp1_y, decimals), #00ff08) labelTpSl(tp2_y, " TP 2 -- " + str.tostring(tp2_y, decimals), #00ff08) labelTpSl(tp3_y, " TP 3 -- " + str.tostring(tp3_y, decimals), #00ff08) style2 = linesStyle == "SOLID" ? line.style_solid : linesStyle == "DASHED" ? line.style_dashed : line.style_dotted lineTpSl(y, color) => line lineTpSl = percentStop != 0 ? line.new(bar_index - (trigger ? countBull : countBear) + 4, y, bar_index + 1, y, xloc.bar_index, extend.none, color, style2) : na line.delete(lineTpSl ) if (lvlLines) lineTpSl(entry_y, color.green) lineTpSl(stop_y, color.red) lineTpSl(tp1_y, color.green) lineTpSl(tp2_y, color.green) lineTpSl(tp3_y, color.green) y1 = low - (ta.atr(30) * 2), y1B = low - ta.atr(30) y2 = high + (ta.atr(30) * 2), y2B = high + ta.atr(30) buy = bull and nbuysell ? label.new(bar_index, y1, sma4_strong >= sma5_strong ? "🚀" : "🚀", xloc.bar_index, yloc.price, color.rgb(10, 247, 18, 60), label.style_label_up, #000000, size.normal) : na sell = bear and nbuysell ? label.new(bar_index, y2, sma4_strong <= sma5_strong ? "🐻" : "🐻", xloc.bar_index, yloc.price, color.rgb(239, 12, 12, 66), label.style_label_down, #000000, size.normal) : na int volSen = 3 plotchar(volSen, "volSen", "", location.top) // Get Components ema1 = ta.ema(ohlc4, 5*volSen) ema2 = ta.ema(ohlc4, 9*volSen) ema3 = ta.ema(ohlc4, 13*volSen) ema4 = ta.ema(ohlc4, 34*volSen) ema5 = ta.ema(ohlc4, 50*volSen) alertcondition(bull, title='Buy Signal', message = "BUY") alertcondition(bear, title='sell Signal', message = "BUY") //-----------------------------------------------------------------------------{ //Constants //-----------------------------------------------------------------------------{ color TRANSP_CSS = #ffffff00 //Tooltips string MODE_TOOLTIP = 'Allows to display historical Structure or only the recent ones' string STYLE_TOOLTIP = 'Indicator color theme' string COLOR_CANDLES_TOOLTIP = 'Display additional candles with a color reflecting the current trend detected by structure' string SHOW_INTERNAL = 'Display internal market structure' string CONFLUENCE_FILTER = 'Filter non significant internal structure breakouts' string SHOW_SWING = 'Display swing market Structure' string SHOW_SWING_POINTS = 'Display swing point as labels on the chart' string SHOW_SWHL_POINTS = 'Highlight most recent strong and weak high/low points on the chart' string INTERNAL_OB = 'Display internal order blocks on the chart Number of internal order blocks to display on the chart' string SWING_OB = 'Display swing order blocks on the chart Number of internal swing blocks to display on the chart' string FILTER_OB = 'Method used to filter out volatile order blocks It is recommended to use the cumulative mean range method when a low amount of data is available' string SHOW_EQHL = 'Display equal highs and equal lows on the chart' string EQHL_BARS = 'Number of bars used to confirm equal highs and equal lows' string EQHL_THRESHOLD = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows Lower values will return fewer but more pertinent results' string SHOW_FVG = 'Display fair values gaps on the chart' string AUTO_FVG = 'Filter out non significant fair value gaps' string FVG_TF = 'Fair value gaps timeframe' string EXTEND_FVG = 'Determine how many bars to extend the Fair Value Gap boxes on chart' string PED_ZONES = 'Display premium, discount, and equilibrium zones on chart' //-----------------------------------------------------------------------------{ //Settings //-----------------------------------------------------------------------------{ //General //----------------------------------------{ mode = input.string('Historical' , options = , group = 'Smart Money Concepts' , tooltip = MODE_TOOLTIP) style = input.string('Colored' , options = , group = 'Smart Money Concepts' , tooltip = STYLE_TOOLTIP) show_trend = input(false, 'Color Candles' , group = 'Smart Money Concepts' , tooltip = COLOR_CANDLES_TOOLTIP) //----------------------------------------} //Internal Structure //----------------------------------------{ show_internals = input(false, 'Show Internal Structure' , group = 'Real Time Internal Structure' , tooltip = SHOW_INTERNAL) show_ibull = input.string('All', 'Bullish Structure' , options = , inline = 'ibull' , group = 'Real Time Internal Structure') swing_ibull_css = input(#089981, '' , inline = 'ibull' , group = 'Real Time Internal Structure') //Bear Structure show_ibear = input.string('All', 'Bearish Structure' , options = , inline = 'ibear' , group = 'Real Time Internal Structure') swing_ibear_css = input(#f23645, '' , inline = 'ibear' , group = 'Real Time Internal Structure') ifilter_confluence = input(false, 'Confluence Filter' , group = 'Real Time Internal Structure' , tooltip = CONFLUENCE_FILTER) internal_structure_size = input.string('Tiny', 'Internal Label Size' , options = , group = 'Real Time Internal Structure') //----------------------------------------} //Swing Structure //----------------------------------------{ show_Structure = input(true, 'Show Swing Structure' , group = 'Real Time Swing Structure' , tooltip = SHOW_SWING) //Bull Structure show_bull = input.string('All', 'Bullish Structure' , options = , inline = 'bull' , group = 'Real Time Swing Structure') swing_bull_css = input(color.rgb(0, 0, 0), '' , inline = 'bull' , group = 'Real Time Swing Structure') //Bear Structure show_bear = input.string('All', 'Bearish Structure' , options = , inline = 'bear' , group = 'Real Time Swing Structure') swing_bear_css = input(#000000, '' , inline = 'bear' , group = 'Real Time Swing Structure') swing_structure_size = input.string('Small', 'Swing Label Size' , options = , group = 'Real Time Swing Structure') //Swings show_swings = input(false, 'Show Swings Points' , inline = 'swings' , group = 'Real Time Swing Structure' , tooltip = SHOW_SWING_POINTS) length = input.int(50, '' , minval = 10 , inline = 'swings' , group = 'Real Time Swing Structure') show_hl_swings = input(true, 'Show Strong/Weak High/Low' , group = 'Real Time Swing Structure' , tooltip = SHOW_SWHL_POINTS) //----------------------------------------} //Order Blocks //----------------------------------------{ show_iob = input(false, 'Internal Order Blocks' , inline = 'iob' , group = 'Order Blocks' , tooltip = INTERNAL_OB) iob_showlast = input.int(5, '' , minval = 1 , inline = 'iob' , group = 'Order Blocks') show_ob = input(true, 'Swing Order Blocks' , inline = 'ob' , group = 'Order Blocks' , tooltip = SWING_OB) ob_showlast = input.int(5, '' , minval = 1 , inline = 'ob' , group = 'Order Blocks') ob_filter = input.string('Atr', 'Order Block Filter' , options = , group = 'Order Blocks' , tooltip = FILTER_OB) ibull_ob_css = input.color(#ffdd0033, 'Internal Bullish OB' , group = 'Order Blocks') ibear_ob_css = input.color(#ffdd0033, 'Internal Bearish OB' , group = 'Order Blocks') bull_ob_css = input.color(color.rgb(255, 255, 255, 80), 'Bullish OB' , group = 'Order Blocks') bear_ob_css = input.color(color.rgb(255, 255, 255, 80), 'Bearish OB' , group = 'Order Blocks') //----------------------------------------} //EQH/EQL //----------------------------------------{ show_eq = input(false, 'Equal High/Low' , group = 'EQH/EQL' , tooltip = SHOW_EQHL) eq_len = input.int(3, 'Bars Confirmation' , minval = 1 , group = 'EQH/EQL' , tooltip = EQHL_BARS) eq_threshold = input.float(0.1, 'Threshold' , minval = 0 , maxval = 0.5 , step = 0.1 , group = 'EQH/EQL' , tooltip = EQHL_THRESHOLD) eq_size = input.string('Tiny', 'Label Size' , options = , group = 'EQH/EQL') //----------------------------------------} //Fair Value Gaps //----------------------------------------{ show_fvg = input(true, 'Fair Value Gaps' , group = 'Fair Value Gaps' , tooltip = SHOW_FVG) fvg_auto = input(true, "Auto Threshold" , group = 'Fair Value Gaps' , tooltip = AUTO_FVG) fvg_tf = input.timeframe('', "Timeframe" , group = 'Fair Value Gaps' , tooltip = FVG_TF) bull_fvg_css = input.color(#ddff006f, 'Bullish FVG' , group = 'Fair Value Gaps') bear_fvg_css = input.color(#f2ff0060, 'Bearish FVG' , group = 'Fair Value Gaps') fvg_extend = input.int(10, "Extend FVG" , minval = 0 , group = 'Fair Value Gaps' , tooltip = EXTEND_FVG) //----------------------------------------} //Previous day/week high/low //----------------------------------------{ //Daily show_pdhl = input(false, 'Daily' , inline = 'daily' , group = 'Highs & Lows MTF') pdhl_style = input.string('⎯⎯⎯', '' , options = , inline = 'daily' , group = 'Highs & Lows MTF') pdhl_css = input(#2157f3, '' , inline = 'daily' , group = 'Highs & Lows MTF') //Weekly show_pwhl = input(false, 'Weekly' , inline = 'weekly' , group = 'Highs & Lows MTF') pwhl_style = input.string('⎯⎯⎯', '' , options = , inline = 'weekly' , group = 'Highs & Lows MTF') pwhl_css = input(#2157f3, '' , inline = 'weekly' , group = 'Highs & Lows MTF') //Monthly show_pmhl = input(false, 'Monthly' , inline = 'monthly' , group = 'Highs & Lows MTF') pmhl_style = input.string('⎯⎯⎯', '' , options = , inline = 'monthly' , group = 'Highs & Lows MTF') pmhl_css = input(#2157f3, '' , inline = 'monthly' , group = 'Highs & Lows MTF') //----------------------------------------} //Premium/Discount zones //----------------------------------------{ show_sd = input(false, 'Premium/Discount Zones' , group = 'Premium & Discount Zones' , tooltip = PED_ZONES) premium_css = input.color(#f23645, 'Premium Zone' , group = 'Premium & Discount Zones') eq_css = input.color(#b2b5be, 'Equilibrium Zone' , group = 'Premium & Discount Zones') discount_css = input.color(#089981, 'Discount Zone' , group = 'Premium & Discount Zones') //-----------------------------------------------------------------------------} //Functions //-----------------------------------------------------------------------------{ n = bar_index atr = ta.atr(200) cmean_range = ta.cum(high - low) / n //HL Output function hl() => //Get ohlc values function get_ohlc()=> [close , open , high, low, high , low ] //Display Structure function display_Structure(x, y, txt, css, dashed, down, lbl_size)=> structure_line = line.new(x, y, n, y , color = css , style = dashed ? line.style_dashed : line.style_solid) structure_lbl = label.new(int(math.avg(x, n)), y, txt , color = TRANSP_CSS , textcolor = css , style = down ? label.style_label_down : label.style_label_up , size = lbl_size) if mode == 'Present' line.delete(structure_line ) label.delete(structure_lbl ) //Swings detection/measurements swings(len)=> var os = 0 upper = ta.highest(len) lower = ta.lowest(len) os := high > upper ? 0 : low < lower ? 1 : os top = os == 0 and os != 0 ? high : 0 btm = os == 1 and os != 1 ? low : 0 //Order block coordinates function ob_coord(use_max, loc, target_top, target_btm, target_left, target_type)=> min = 99999999. max = 0. idx = 1 ob_threshold = ob_filter == 'Atr' ? atr : cmean_range //Search for highest/lowest high within the structure interval and get range if use_max for i = 1 to (n - loc)-1 if (high - low ) < ob_threshold * 2 max := math.max(high , max) min := max == high ? low : min idx := max == high ? i : idx else for i = 1 to (n - loc)-1 if (high - low ) < ob_threshold * 2 min := math.min(low , min) max := min == low ? high : max idx := min == low ? i : idx array.unshift(target_top, max) array.unshift(target_btm, min) array.unshift(target_left, time ) array.unshift(target_type, use_max ? -1 : 1) //Set order blocks display_ob(boxes, target_top, target_btm, target_left, target_type, show_last, swing, size)=> for i = 0 to math.min(show_last-1, size-1) get_box = array.get(boxes, i) box.set_lefttop(get_box, array.get(target_left, i), array.get(target_top, i)) box.set_rightbottom(get_box, array.get(target_left, i), array.get(target_btm, i)) box.set_extend(get_box, extend.right) color css = na if swing if style == 'Monochrome' css := array.get(target_type, i) == 1 ? color.new(#b2b5be, 80) : color.new(#5d606b, 80) border_css = array.get(target_type, i) == 1 ? #b2b5be : #5d606b box.set_border_color(get_box, border_css) else css := array.get(target_type, i) == 1 ? bull_ob_css : bear_ob_css box.set_border_color(get_box, css) box.set_bgcolor(get_box, css) else if style == 'Monochrome' css := array.get(target_type, i) == 1 ? color.new(#b2b5be, 80) : color.new(#5d606b, 80) else css := array.get(target_type, i) == 1 ? ibull_ob_css : ibear_ob_css box.set_border_color(get_box, css) box.set_bgcolor(get_box, css) //Line Style function get_line_style(style) => out = switch style '⎯⎯⎯' => line.style_solid '----' => line.style_dashed '····' => line.style_dotted //Set line/labels function for previous high/lows phl(h, l, tf, css)=> var line high_line = line.new(na,na,na,na , xloc = xloc.bar_time , color = css , style = get_line_style(pdhl_style)) var label high_lbl = label.new(na,na , xloc = xloc.bar_time , text = str.format('P{0}H', tf) , color = TRANSP_CSS , textcolor = css , size = size.small , style = label.style_label_left) var line low_line = line.new(na,na,na,na , xloc = xloc.bar_time , color = css , style = get_line_style(pdhl_style)) var label low_lbl = label.new(na,na , xloc = xloc.bar_time , text = str.format('P{0}L', tf) , color = TRANSP_CSS , textcolor = css , size = size.small , style = label.style_label_left) hy = ta.valuewhen(h != h , h, 1) hx = ta.valuewhen(h == high, time, 1) ly = ta.valuewhen(l != l , l, 1) lx = ta.valuewhen(l == low, time, 1) if barstate.islast ext = time + (time - time )*20 //High line.set_xy1(high_line, hx, hy) line.set_xy2(high_line, ext, hy) label.set_xy(high_lbl, ext, hy) //Low line.set_xy1(low_line, lx, ly) line.set_xy2(low_line, ext, ly) label.set_xy(low_lbl, ext, ly) //-----------------------------------------------------------------------------} //Global variables //-----------------------------------------------------------------------------{ var trend = 0, var itrend = 0 var top_y = 0., var top_x = 0 var btm_y = 0., var btm_x = 0 var itop_y = 0., var itop_x = 0 var ibtm_y = 0., var ibtm_x = 0 var trail_up = high, var trail_dn = low var trail_up_x = 0, var trail_dn_x = 0 var top_cross = true, var btm_cross = true var itop_cross = true, var ibtm_cross = true var txt_top = '', var txt_btm = '' //Alerts bull_choch_alert = false bull_bos_alert = false bear_choch_alert = false bear_bos_alert = false bull_ichoch_alert = false bull_ibos_alert = false bear_ichoch_alert = false bear_ibos_alert = false bull_iob_break = false bear_iob_break = false bull_ob_break = false bear_ob_break = false eqh_alert = false eql_alert = false //Structure colors var bull_css = style == 'Monochrome' ? #b2b5be : swing_bull_css var bear_css = style == 'Monochrome' ? #b2b5be : swing_bear_css var ibull_css = style == 'Monochrome' ? #b2b5be : swing_ibull_css var ibear_css = style == 'Monochrome' ? #b2b5be : swing_ibear_css //Labels size var internal_structure_lbl_size = internal_structure_size == 'Tiny' ? size.tiny : internal_structure_size == 'Small' ? size.small : size.normal var swing_structure_lbl_size = swing_structure_size == 'Tiny' ? size.tiny : swing_structure_size == 'Small' ? size.small : size.normal var eqhl_lbl_size = eq_size == 'Tiny' ? size.tiny : eq_size == 'Small' ? size.small : size.normal //Swings = swings(length) = swings(5) //-----------------------------------------------------------------------------} //Pivot High //-----------------------------------------------------------------------------{ var line extend_top = na var label extend_top_lbl = label.new(na, na , color = TRANSP_CSS , textcolor = bear_css , style = label.style_label_down , size = size.tiny) if top top_cross := true txt_top := top > top_y ? 'HH' : 'LH' if show_swings top_lbl = label.new(n-length, top, txt_top , color = TRANSP_CSS , textcolor = bear_css , style = label.style_label_down , size = swing_structure_lbl_size) if mode == 'Present' label.delete(top_lbl ) //Extend recent top to last bar line.delete(extend_top ) extend_top := line.new(n-length, top, n, top , color = bear_css) top_y := top top_x := n - length trail_up := top trail_up_x := n - length if itop itop_cross := true itop_y := itop itop_x := n - 5 //Trailing maximum trail_up := math.max(high, trail_up) trail_up_x := trail_up == high ? n : trail_up_x //Set top extension label/line if barstate.islast and show_hl_swings line.set_xy1(extend_top, trail_up_x, trail_up) line.set_xy2(extend_top, n + 20, trail_up) label.set_x(extend_top_lbl, n + 20) label.set_y(extend_top_lbl, trail_up) label.set_text(extend_top_lbl, trend < 0 ? 'Strong High' : 'Weak High') //-----------------------------------------------------------------------------} //Pivot Low //-----------------------------------------------------------------------------{ var line extend_btm = na var label extend_btm_lbl = label.new(na, na , color = TRANSP_CSS , textcolor = bull_css , style = label.style_label_up , size = size.tiny) if btm btm_cross := true txt_btm := btm < btm_y ? 'LL' : 'HL' if show_swings btm_lbl = label.new(n - length, btm, txt_btm , color = TRANSP_CSS , textcolor = bull_css , style = label.style_label_up , size = swing_structure_lbl_size) if mode == 'Present' label.delete(btm_lbl ) //Extend recent btm to last bar line.delete(extend_btm ) extend_btm := line.new(n - length, btm, n, btm , color = bull_css) btm_y := btm btm_x := n-length trail_dn := btm trail_dn_x := n-length if ibtm ibtm_cross := true ibtm_y := ibtm ibtm_x := n - 5 //Trailing minimum trail_dn := math.min(low, trail_dn) trail_dn_x := trail_dn == low ? n : trail_dn_x //Set btm extension label/line if barstate.islast and show_hl_swings line.set_xy1(extend_btm, trail_dn_x, trail_dn) line.set_xy2(extend_btm, n + 20, trail_dn) label.set_x(extend_btm_lbl, n + 20) label.set_y(extend_btm_lbl, trail_dn) label.set_text(extend_btm_lbl, trend > 0 ? 'Strong Low' : 'Weak Low') //-----------------------------------------------------------------------------} //Order Blocks Arrays //-----------------------------------------------------------------------------{ var iob_top = array.new_float(0) var iob_btm = array.new_float(0) var iob_left = array.new_int(0) var iob_type = array.new_int(0) var ob_top = array.new_float(0) var ob_btm = array.new_float(0) var ob_left = array.new_int(0) var ob_type = array.new_int(0) //-----------------------------------------------------------------------------} //Pivot High BOS/CHoCH //-----------------------------------------------------------------------------{ //Filtering var bull_concordant = true if ifilter_confluence bull_concordant := high - math.max(close, open) > math.min(close, open - low) //Detect internal bullish Structure if ta.crossover(close, itop_y) and itop_cross and top_y != itop_y and bull_concordant bool choch = na if itrend < 0 choch := true bull_ichoch_alert := true else bull_ibos_alert := true txt = choch ? 'CHoCH' : 'BOS' if show_internals if show_ibull == 'All' or (show_ibull == 'BOS' and not choch) or (show_ibull == 'CHoCH' and choch) display_Structure(itop_x, itop_y, txt, ibull_css, true, true, internal_structure_lbl_size) itop_cross := false itrend := 1 //Internal Order Block if show_iob ob_coord(false, itop_x, iob_top, iob_btm, iob_left, iob_type) //Detect bullish Structure if ta.crossover(close, top_y) and top_cross bool choch = na if trend < 0 choch := true bull_choch_alert := true else bull_bos_alert := true txt = choch ? 'CHoCH' : 'BOS' if show_Structure if show_bull == 'All' or (show_bull == 'BOS' and not choch) or (show_bull == 'CHoCH' and choch) display_Structure(top_x, top_y, txt, bull_css, false, true, swing_structure_lbl_size) //Order Block if show_ob ob_coord(false, top_x, ob_top, ob_btm, ob_left, ob_type) top_cross := false trend := 1 //-----------------------------------------------------------------------------} //Pivot Low BOS/CHoCH //-----------------------------------------------------------------------------{ var bear_concordant = true if ifilter_confluence bear_concordant := high - math.max(close, open) < math.min(close, open - low) //Detect internal bearish Structure if ta.crossunder(close, ibtm_y) and ibtm_cross and btm_y != ibtm_y and bear_concordant bool choch = false if itrend > 0 choch := true bear_ichoch_alert := true else bear_ibos_alert := true txt = choch ? 'CHoCH' : 'BOS' if show_internals if show_ibear == 'All' or (show_ibear == 'BOS' and not choch) or (show_ibear == 'CHoCH' and choch) display_Structure(ibtm_x, ibtm_y, txt, ibear_css, true, false, internal_structure_lbl_size) ibtm_cross := false itrend := -1 //Internal Order Block if show_iob ob_coord(true, ibtm_x, iob_top, iob_btm, iob_left, iob_type) //Detect bearish Structure if ta.crossunder(close, btm_y) and btm_cross bool choch = na if trend > 0 choch := true bear_choch_alert := true else bear_bos_alert := true txt = choch ? 'CHoCH' : 'BOS' if show_Structure if show_bear == 'All' or (show_bear == 'BOS' and not choch) or (show_bear == 'CHoCH' and choch) display_Structure(btm_x, btm_y, txt, bear_css, false, false, swing_structure_lbl_size) //Order Block if show_ob ob_coord(true, btm_x, ob_top, ob_btm, ob_left, ob_type) btm_cross := false trend := -1 //-----------------------------------------------------------------------------} //Order Blocks //-----------------------------------------------------------------------------{ //Set order blocks var iob_boxes = array.new_box(0) var ob_boxes = array.new_box(0) //Delete internal order blocks box coordinates if top/bottom is broken for element in iob_type index = array.indexof(iob_type, element) if close < array.get(iob_btm, index) and element == 1 array.remove(iob_top, index) array.remove(iob_btm, index) array.remove(iob_left, index) array.remove(iob_type, index) bull_iob_break := true else if close > array.get(iob_top, index) and element == -1 array.remove(iob_top, index) array.remove(iob_btm, index) array.remove(iob_left, index) array.remove(iob_type, index) bear_iob_break := true //Delete internal order blocks box coordinates if top/bottom is broken for element in ob_type index = array.indexof(ob_type, element) if close < array.get(ob_btm, index) and element == 1 array.remove(ob_top, index) array.remove(ob_btm, index) array.remove(ob_left, index) array.remove(ob_type, index) bull_ob_break := true else if close > array.get(ob_top, index) and element == -1 array.remove(ob_top, index) array.remove(ob_btm, index) array.remove(ob_left, index) array.remove(ob_type, index) bear_ob_break := true iob_size = array.size(iob_type) ob_size = array.size(ob_type) if barstate.isfirst if show_iob for i = 0 to iob_showlast-1 array.push(iob_boxes, box.new(na,na,na,na, xloc = xloc.bar_time)) if show_ob for i = 0 to ob_showlast-1 array.push(ob_boxes, box.new(na,na,na,na, xloc = xloc.bar_time)) if iob_size > 0 if barstate.islast display_ob(iob_boxes, iob_top, iob_btm, iob_left, iob_type, iob_showlast, false, iob_size) if ob_size > 0 if barstate.islast display_ob(ob_boxes, ob_top, ob_btm, ob_left, ob_type, ob_showlast, true, ob_size) //-----------------------------------------------------------------------------} //EQH/EQL //-----------------------------------------------------------------------------{ var eq_prev_top = 0. var eq_top_x = 0 var eq_prev_btm = 0. var eq_btm_x = 0 if show_eq eq_top = ta.pivothigh(eq_len, eq_len) eq_btm = ta.pivotlow(eq_len, eq_len) if eq_top max = math.max(eq_top, eq_prev_top) min = math.min(eq_top, eq_prev_top) if max < min + atr * eq_threshold eqh_line = line.new(eq_top_x, eq_prev_top, n-eq_len, eq_top , color = bear_css , style = line.style_dotted) eqh_lbl = label.new(int(math.avg(n-eq_len, eq_top_x)), eq_top, 'EQH' , color = #00000000 , textcolor = bear_css , style = label.style_label_down , size = eqhl_lbl_size) if mode == 'Present' line.delete(eqh_line ) label.delete(eqh_lbl ) eqh_alert := true eq_prev_top := eq_top eq_top_x := n-eq_len if eq_btm max = math.max(eq_btm, eq_prev_btm) min = math.min(eq_btm, eq_prev_btm) if min > max - atr * eq_threshold eql_line = line.new(eq_btm_x, eq_prev_btm, n-eq_len, eq_btm , color = bull_css , style = line.style_dotted) eql_lbl = label.new(int(math.avg(n-eq_len, eq_btm_x)), eq_btm, 'EQL' , color = #00000000 , textcolor = bull_css , style = label.style_label_up , size = eqhl_lbl_size) eql_alert := true if mode == 'Present' line.delete(eql_line ) label.delete(eql_lbl ) eq_prev_btm := eq_btm eq_btm_x := n-eq_len //-----------------------------------------------------------------------------} //Fair Value Gaps //-----------------------------------------------------------------------------{ var bullish_fvg_max = array.new_box(0) var bullish_fvg_min = array.new_box(0) var bearish_fvg_max = array.new_box(0) var bearish_fvg_min = array.new_box(0) float bullish_fvg_avg = na float bearish_fvg_avg = na bullish_fvg_cnd = false bearish_fvg_cnd = false = request.security(syminfo.tickerid, fvg_tf, get_ohlc()) if show_fvg delta_per = (src_c1 - src_o1) / src_o1 * 100 change_tf = timeframe.change(fvg_tf) threshold = fvg_auto ? ta.cum(math.abs(change_tf ? delta_per : 0)) / n * 2 : 0 //FVG conditions bullish_fvg_cnd := src_l > src_h2 and src_c1 > src_h2 and delta_per > threshold and change_tf bearish_fvg_cnd := src_h < src_l2 and src_c1 < src_l2 and -delta_per > threshold and change_tf //FVG Areas if bullish_fvg_cnd array.unshift(bullish_fvg_max, box.new(n-1, src_l, n + fvg_extend, math.avg(src_l, src_h2) , border_color = bull_fvg_css , bgcolor = bull_fvg_css)) array.unshift(bullish_fvg_min, box.new(n-1, math.avg(src_l, src_h2), n + fvg_extend, src_h2 , border_color = bull_fvg_css , bgcolor = bull_fvg_css)) if bearish_fvg_cnd array.unshift(bearish_fvg_max, box.new(n-1, src_h, n + fvg_extend, math.avg(src_h, src_l2) , border_color = bear_fvg_css , bgcolor = bear_fvg_css)) array.unshift(bearish_fvg_min, box.new(n-1, math.avg(src_h, src_l2), n + fvg_extend, src_l2 , border_color = bear_fvg_css , bgcolor = bear_fvg_css)) for bx in bullish_fvg_min if low < box.get_bottom(bx) box.delete(bx) box.delete(array.get(bullish_fvg_max, array.indexof(bullish_fvg_min, bx))) for bx in bearish_fvg_max if high > box.get_top(bx) box.delete(bx) box.delete(array.get(bearish_fvg_min, array.indexof(bearish_fvg_max, bx))) //-----------------------------------------------------------------------------} //Previous day/week high/lows //-----------------------------------------------------------------------------{ //Daily high/low = request.security(syminfo.tickerid, 'D', hl() , lookahead = barmerge.lookahead_on) //Weekly high/low = request.security(syminfo.tickerid, 'W', hl() , lookahead = barmerge.lookahead_on) //Monthly high/low = request.security(syminfo.tickerid, 'M', hl() , lookahead = barmerge.lookahead_on) //Display Daily if show_pdhl phl(pdh, pdl, 'D', pdhl_css) //Display Weekly if show_pwhl phl(pwh, pwl, 'W', pwhl_css) //Display Monthly if show_pmhl phl(pmh, pml, 'M', pmhl_css) //-----------------------------------------------------------------------------} //Premium/Discount/Equilibrium zones //-----------------------------------------------------------------------------{ var premium = box.new(na, na, na, na , bgcolor = color.new(premium_css, 80) , border_color = na) var premium_lbl = label.new(na, na , text = 'Premium' , color = TRANSP_CSS , textcolor = premium_css , style = label.style_label_down , size = size.small) var eq = box.new(na, na, na, na , bgcolor = color.rgb(120, 123, 134, 80) , border_color = na) var eq_lbl = label.new(na, na , text = 'Equilibrium' , color = TRANSP_CSS , textcolor = eq_css , style = label.style_label_left , size = size.small) var discount = box.new(na, na, na, na , bgcolor = color.new(discount_css, 80) , border_color = na) var discount_lbl = label.new(na, na , text = 'Discount' , color = TRANSP_CSS , textcolor = discount_css , style = label.style_label_up , size = size.small) //Show Premium/Discount Areas if barstate.islast and show_sd avg = math.avg(trail_up, trail_dn) box.set_lefttop(premium, math.max(top_x, btm_x), trail_up) box.set_rightbottom(premium, n, .95 * trail_up + .05 * trail_dn) label.set_xy(premium_lbl, int(math.avg(math.max(top_x, btm_x), n)), trail_up) box.set_lefttop(eq, math.max(top_x, btm_x), .525 * trail_up + .475*trail_dn) box.set_rightbottom(eq, n, .525 * trail_dn + .475 * trail_up) label.set_xy(eq_lbl, n, avg) box.set_lefttop(discount, math.max(top_x, btm_x), .95 * trail_dn + .05 * trail_up) box.set_rightbottom(discount, n, trail_dn) label.set_xy(discount_lbl, int(math.avg(math.max(top_x, btm_x), n)), trail_dn) //-----------------------------------------------------------------------------} //Trend //-----------------------------------------------------------------------------{ var color trend_css = na if show_trend if style == 'Colored' trend_css := itrend == 1 ? bull_css : bear_css else if style == 'Monochrome' trend_css := itrend == 1 ? #b2b5be : #5d606b plotcandle(open, high, low, close , color = trend_css , wickcolor = trend_css , bordercolor = trend_css , editable = false) //-----------------------------------------------------------------------------} //Alerts //-----------------------------------------------------------------------------{ //Internal Structure alertcondition(bull_ibos_alert, 'Internal Bullish BOS', 'Internal Bullish BOS formed') alertcondition(bull_ichoch_alert, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed') alertcondition(bear_ibos_alert, 'Internal Bearish BOS', 'Internal Bearish BOS formed') alertcondition(bear_ichoch_alert, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed') //Swing Structure alertcondition(bull_bos_alert, 'Bullish BOS', 'Internal Bullish BOS formed') alertcondition(bull_choch_alert, 'Bullish CHoCH', 'Internal Bullish CHoCH formed') alertcondition(bear_bos_alert, 'Bearish BOS', 'Bearish BOS formed') alertcondition(bear_choch_alert, 'Bearish CHoCH', 'Bearish CHoCH formed') //order Blocks alertcondition(bull_iob_break, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB') alertcondition(bear_iob_break, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB') alertcondition(bull_ob_break, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB') alertcondition(bear_ob_break, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB') //EQH/EQL alertcondition(eqh_alert, 'Equal Highs', 'Equal highs detected') alertcondition(eql_alert, 'Equal Lows', 'Equal lows detected') //FVG alertcondition(bullish_fvg_cnd, 'Bullish FVG', 'Bullish FVG formed') alertcondition(bearish_fvg_cnd, 'Bearish FVG', 'Bearish FVG formed') //-----------------------------------------------------------------------------}
Pine Script™ indikatörü
worldstreet34 tarafından
MOATH EMAD 12 //@version=5 indicator("MOATH EMAD", overlay=true) enableIndicator = input.bool(true, title="تشغيل EMA") enableIndicator2 = input.bool(true, title="تشغيل RSI") // حساب EMA 200 ema200 = ta.ema(close, 200) rsi = request.security(syminfo.tickerid, "5", ta.rsi(close, 14)) // المسافة المطلوبة بين الافتتاح والـ EMA pointDistance = 2 // عدّلها حسب السوق (مثلاً 0.2 للعملات الرقمية) // التحقق من الشرط isAbove = open > ema200 + pointDistance isBelow = open < ema200 - pointDistance // تحديد اللون بناءً على الشرط // رسم EMA 200 plotrealclosedots = input(true, title = 'Show real close dots') realclosecolour = input(color.new(#41ffb0, 1), title = 'Real close dot color') // بدون شفافية real_price = syminfo.prefix + ":" + syminfo.ticker real_close = request.security(real_price, "", close, gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_off) // رسم النقاط باستخدام plot مع تكبير النقطة plot(series = plotrealclosedots ? real_close : na, title = 'Real close dots', color = realclosecolour, linewidth = 3, // زيادة حجم النقطة style = plot.style_circles) // Input variables lowhigh_long_prop = input.float(10, title="Low / High Proportion") body_prop_size = input.float(7, title="Body Proportion Size") waveLength = input(6, title="Minimum Wave Length") // Number of candles required to determine wave colorUp = color.new(color.green, 100) // Bullish wave color colorDown = color.new(color.red, 100) // Bearish wave color dojiBoxColor = color.new(color.yellow, 90) // Doji box color defineDojiExtension = 6 // Number of candles to extend the doji box // Bar calculations bar_size_h = high - close bar_size_l = math.max(open, close) - math.min(close, open) body_size_h = high - low low_body_prop = close - low high_body_prop = high - close // حساب خصائص الشمعة upper_tail = high - math.max(open, close) // طول الذيل العلوي lower_tail = math.min(open, close) - low // طول الذيل السفلي total_tails = upper_tail + lower_tail // مجموع الذيول // نسبة كل ذيل بالنسبة إلى مجموع الذيول upper_tail_ratio = (upper_tail / total_tails) * 100 lower_tail_ratio = (lower_tail / total_tails) * 100 // Wave Detection isBullish = close > open isBearish = close < open bullishStreak = ta.barssince(not isBullish) bearishStreak = ta.barssince(not isBearish) isWaveUp = isBullish and bullishStreak >= waveLength - 1 isWaveDown = isBearish and bearishStreak >= waveLength - 1 // شرط شمعة التوقف (الذيل الحالي أصغر من الذيل السابق في الاتجاه الصاعد أو أكبر في الاتجاه الهابط) previous_upper_tail = high previous_lower_tail = low is_stop_candle_up = isWaveUp and (high < high or high < high )// شمعة توقف في الاتجاه الصاعد is_stop_candle_down = isWaveDown and (low > low or low > low ) // شمعة توقف في الاتجاه الهابط // Boxes for waves var box bullishBox = na var box bearishBox = na if isWaveUp if na(bullishBox) bullishBox := box.new(bar_index , high , bar_index, low, border_color=na, bgcolor=colorUp) else box.set_right(bullishBox, bar_index) box.set_top(bullishBox, math.max(box.get_top(bullishBox), high)) box.set_bottom(bullishBox, math.min(box.get_bottom(bullishBox), low)) if not isWaveUp and not na(bullishBox) bullishBox := na if isWaveDown if na(bearishBox) bearishBox := box.new(bar_index , high , bar_index, low, border_color=na, bgcolor=colorDown) else box.set_right(bearishBox, bar_index) box.set_top(bearishBox, math.max(box.get_top(bearishBox), high)) box.set_bottom(bearishBox, math.min(box.get_bottom(bearishBox), low)) if not isWaveDown and not na(bearishBox) bearishBox := na // Doji Box Conditions isDoji = (upper_tail_ratio >= 40 and upper_tail_ratio <= 60) and (lower_tail_ratio >= 40 and lower_tail_ratio <= 60) // خطوط الدوجي بناءً على الاتجاه السابق var line dojiLineUp = na var line dojiLineDown = na var int dojiLineUpBarIndex = na var int dojiLineDownBarIndex = na var bool labelPlacedUp = false var bool labelPlacedDown = false var line dojiLineUp2 = na var line dojiLineDown2 = na var int dojiLineUpBarIndex2 = na var int dojiLineDownBarIndex2 = na var bool labelPlacedUp2 = false var bool labelPlacedDown2 = false if isDoji if isWaveUp // إذا كان الاتجاه السابق صاعدًا dojiLineUp := line.new(bar_index, low, bar_index + defineDojiExtension, low, color=color.white, width=1) line.set_color(dojiLineUp,color.new(color.red,100)) dojiLineUpBarIndex := bar_index labelPlacedUp := false // إعادة تعيين الإشارة للخط الجديد if isWaveDown // إذا كان الاتجاه السابق هابطًا dojiLineDown := line.new(bar_index, high, bar_index + defineDojiExtension, high, color=color.white, width=1) line.set_color(dojiLineDown,color.new(color.red,100)) dojiLineDownBarIndex := bar_index labelPlacedDown := false // إعادة تعيين الإشارة للخط الجديد if isDoji if isWaveUp // إذا كان الاتجاه السابق صاعدًا dojiLineUp2 := line.new(bar_index, low, bar_index + defineDojiExtension, low, color=color.white, width=1) line.set_color(dojiLineUp2,color.new(color.red,100)) dojiLineUpBarIndex2 := bar_index labelPlacedUp2 := false // إعادة تعيين الإشارة للخط الجديد if isWaveDown // إذا كان الاتجاه السابق هابطًا dojiLineDown2 := line.new(bar_index, high, bar_index + defineDojiExtension, high, color=color.white, width=1) line.set_color(dojiLineDown2,color.new(color.red,100)) dojiLineDownBarIndex2 := bar_index labelPlacedDown2 := false // إعادة تعيين الإشارة للخط الجديد // تحديد الشروط للتلامس مع الخطوط touchesGreenLine = not na(dojiLineUp) and (low <= line.get_y1(dojiLineUp) and high >= line.get_y1(dojiLineUp)) and (open > line.get_y1(dojiLineUp) and close < line.get_y1(dojiLineUp)) and // تفتح فوق الخط وتغلق تحته (real_close < line.get_y1(dojiLineUp)) and // إضافة شرط السعر الحقيقي تحت الخط الأخضر (bar_index - dojiLineUpBarIndex <= 5) and // فقط خلال 5 شموع not labelPlacedUp and // التأكد من أن الإشارة لم توضع مسبقًا (((close < ema200 - pointDistance)and enableIndicator)or not enableIndicator) and (((rsi >70 )and enableIndicator2)or not enableIndicator2) and not is_stop_candle_up // الشرط الجديد: الشمعة تحت الـ EMA بمقدار نقطتين touchesRedLine = not na(dojiLineDown) and (low <= line.get_y1(dojiLineDown) and high >= line.get_y1(dojiLineDown)) and (open < line.get_y1(dojiLineDown) and close > line.get_y1(dojiLineDown)) and // تفتح تحت الخط وتغلق فوقه (real_close > line.get_y1(dojiLineDown)) and // إضافة شرط السعر الحقيقي فوق الخط الأحمر (bar_index - dojiLineDownBarIndex <= 5) and // فقط خلال 5 شموع not labelPlacedDown and // التأكد من أن الإشارة لم توضع مسبقًا (((close > ema200 + pointDistance)and enableIndicator)or not enableIndicator) and (((rsi<30 )and enableIndicator2)or not enableIndicator2) and not is_stop_candle_down // الشرط الجديد: الشمعة فوق الـ EMA بمقدار نقطتين // تحديد الشروط للتلامس مع الخطوط touchesGreenLine2 = not na(dojiLineUp2) and (low <= line.get_y1(dojiLineUp2) and high >= line.get_y1(dojiLineUp2)) and (open > line.get_y1(dojiLineUp2) and close < line.get_y1(dojiLineUp2)) and // تفتح فوق الخط وتغلق تحته (real_close < line.get_y1(dojiLineUp2)) and // إضافة شرط السعر الحقيقي تحت الخط الأخضر (bar_index - dojiLineUpBarIndex2 <= 5) and // فقط خلال 5 شموع not labelPlacedUp and // التأكد من أن الإشارة لم توضع مسبقًا (((close < ema200 - pointDistance)and enableIndicator)or not enableIndicator) and (((rsi >70 )and enableIndicator2)or not enableIndicator2)and is_stop_candle_up // الشرط الجديد: الشمعة تحت الـ EMA بمقدار نقطتين touchesRedLine2 = not na(dojiLineDown2) and (low <= line.get_y1(dojiLineDown2) and high >= line.get_y1(dojiLineDown2)) and (open < line.get_y1(dojiLineDown2) and close > line.get_y1(dojiLineDown2)) and // تفتح تحت الخط وتغلق فوقه (real_close > line.get_y1(dojiLineDown2)) and // إضافة شرط السعر الحقيقي فوق الخط الأحمر (bar_index - dojiLineDownBarIndex2 <= 5) and // فقط خلال 5 شموع not labelPlacedDown and // التأكد من أن الإشارة لم توضع مسبقًا (((close > ema200 + pointDistance)and enableIndicator)or not enableIndicator) and (((rsi<30 )and enableIndicator2)or not enableIndicator2) and is_stop_candle_down// الشرط الجديد: الشمعة فوق الـ EMA بمقدار نقطتين if touchesGreenLine label.new(bar_index, high, text="Sell", color=color.orange, textcolor=color.white, size=size.small, style=label.style_label_down) labelPlacedUp := true if touchesRedLine label.new(bar_index, low, text="Buy", color=color.blue, textcolor=color.white, size=size.small, style=label.style_label_up) labelPlacedDown := true // تم وضع الإشارة if touchesGreenLine2 label.new(bar_index, high, text="Sell", color=color.orange, textcolor=color.white, size=size.small, style=label.style_label_down) labelPlacedUp := true if touchesRedLine2 label.new(bar_index, low, text="Buy", color=color.blue, textcolor=color.white, size=size.small, style=label.style_label_up) labelPlacedDown := true // تم وضع الإشارة alertcondition(touchesGreenLine or touchesRedLine or touchesGreenLine2 or touchesRedLine2 , title="Buy/Sell Alert", message="Signal detected: Buy or Sell") var table statsTable = table.new(position.top_right, 1, 1, border_color=color.purple, bgcolor=color.new(color.black, 90)) table.cell(statsTable, 0, 0, "Moath Emad", text_color=color.white, bgcolor=color.black, text_size=size.auto)
Pine Script™ indikatörü
emadmoath11 tarafından
IKNOW 4SMA Strategy with Targets and Stop LossDescription: The IKNOW 4SMA Strategy is a simple yet effective trading strategy designed for trend-following traders. It utilizes a 4-period Simple Moving Average (SMA) to identify trend direction and generate Buy (B) and Sell (S) signals when the price crosses the SMA. This strategy also includes a customizable Take Profit (%) and Stop Loss (%) to help traders manage risk efficiently. How It Works: ✅ Buy Signal (B - Blue): When the price crosses above the 4SMA, a long position is entered. ✅ Sell Signal (S - Red): When the price crosses below the 4SMA, a short position is entered. ✅ Take Profit & Stop Loss: The strategy automatically sets a Take Profit (default 2%) and Stop Loss (default 1%), both of which can be adjusted as per trading style. Features: ✔ Clear Buy (B) & Sell (S) Labels – Small and non-intrusive for easy chart analysis. ✔ Customizable Take Profit & Stop Loss – Adjust percentage values to fit your strategy. ✔ Simple & Effective for Trend Following – Based on SMA crossovers for quick entries and exits. ✔ Works on Multiple Timeframes – Can be used on Forex, Crypto, Stocks, and Commodities. ✔ Lightweight & Non-Lagging – Does not overload your TradingView chart. How to Use: Add to Chart: Click on "Add to Chart" after enabling the script in TradingView. Adjust Parameters: Modify Take Profit (%) and Stop Loss (%) to suit your risk appetite. Follow the Signals: Enter Long when a B (Blue) appears and enter Short when an S (Red) appears. Manage Risk: Keep an eye on the Stop Loss and Take Profit levels for controlled risk exposure. 🚀 This strategy is perfect for traders who prefer quick, trend-based entries and exits with proper risk management! 🚀 Disclaimer: This strategy is for educational purposes only. Always backtest and demo trade before using it in live markets. Trading involves risk; trade responsibly. 🔹 Created by: Kashif Abbas (IKNOW Digital Marketing & eCommerce Solution) 🔹 Trademark: IKNOW 4SMA Strategy
Pine Script™ stratejisi
kashifabbas17 tarafından
1
𝓜𝓐 𝓢𝓶𝓸𝓸𝓽𝓱𝓮𝓭 𝓡𝓢𝓘 𝓕𝓸𝓻 𝓛𝓸𝓸𝓹MA Smoothed Source For RSI Loop | Crypto_Mercenary_ Conceptual Foundation and Innovation The "MA Smoothed Source For RSI Loop" indicator developed by Crypto_Mercenary_ innovates by smoothing the source data used for RSI calculation with various moving averages before feeding it into a for-loop scoring system. Rather than smoothing the RSI itself, this approach focuses on pre-processing the price data to reduce noise, thereby providing a cleaner input for RSI computation. The for-loop then evaluates this smoothed RSI to generate momentum signals, offering traders a refined method for detecting market trends and potential reversals. Technical Composition and Calculation The indicator's functionality is divided into two main parts: Source Smoothing: Before calculating RSI, the source data (typically close price) is smoothed using one of several moving averages (EMA, SMA, WMA, VWMA, HMA, RMA, DEMA, or none) as selected by the user. This smoothing aims to filter out short-term volatility, providing a more consistent base for RSI calculation. RSI Calculation and For-Loop Scoring: RSI: Calculated using the smoothed source data over a user-defined length. For-Loop Mechanism: A loop runs from a to b, comparing the current RSI value with past values of this smoothed RSI. A score (counter) is generated, which increases or decreases based on whether the current RSI exceeds or falls below past values. If the weighted option is activated, this comparison gives more weight to recent data points, adjusting the score accordingly. The final score is then potentially normalized for better interpretation, compared against thresholds to determine market momentum signals. Features and User Inputs This indicator is highly customizable, allowing traders to tailor its behavior: Weighted Calculation: Option to adjust scoring to favor recent price action. RSI Length: Sets the period for RSI calculation. Source: The price data to be smoothed before RSI calculation, default is close. MA Type: Choice from various moving averages to smooth the source data. Smooth Length: Length of the moving average used for smoothing. For Loop Range: Defines the historical range (a to b) for the scoring loop. Thresholds: Custom thresholds to define when signals for uptrends or downtrends are generated. Practical Applications This indicator is particularly beneficial for: Identifying Momentum Shifts: The scoring system helps in detecting potential changes in market momentum. Noise Reduction: By smoothing the source data, it aims to provide more reliable RSI signals in volatile markets. Trend Analysis: Assists in confirming or challenging the current market trend based on the smoothed RSI's performance. Advantages and Strategic Value The "MA Smoothed Source For RSI Loop" offers an advantage by focusing on cleaning the input data for RSI, which can lead to more accurate momentum readings. Its flexibility in configuration allows traders to adapt the indicator to different market conditions or asset volatilities, enhancing its strategic value in trading decisions. Alerts and Visual Cues Visual Signals: The indicator plots the loop score, with colors indicating uptrends (gold) or downtrends (blue). Horizontal lines at thresholds and shaded areas between them provide visual aids for trend analysis. **No explicit alerts in the script, but users can set up custom alerts based on the signals. Summary and Usage Tips The "MA Smoothed Source For RSI Loop | Crypto_Mercenary_" provides a nuanced approach to RSI by smoothing the price data before its calculation, resulting in potentially more reliable signals. Traders can use this indicator to gain a clearer picture of market momentum, adjusting parameters to fit different market behaviors or trading strategies. Remember, the effectiveness of this tool largely depends on its customization to the specific market context. Note: Backtests are based on past results and do not guarantee future performance.
Pine Script™ indikatörü
Crypto_Mercenary_ tarafından
Blockchain Fundamentals: Global LiquidityGlobal Liquidity Indicator Overview This indicator provides a comprehensive technical analysis of liquidity trends by deriving a Global Liquidity metric from multiple data sources. It applies a suite of technical indicators directly on this liquidity measure, rather than on price data. When this metric is expanding Bitcoin and crypto tends to bullish conditions. Features: 1. Global Liquidity Calculation Data Integration: Combines multiple market data sources using a ratio-based formula to produce a unique liquidity measure. Custom Metric: This liquidity metric serves as the foundational input for further technical analysis. 2. Timeframe Customization User-Selected Period: Users can select the data timeframe (default is 2 months) to ensure consistency and flexibility in analysis. 3. Additional Technical Indicators RSI, Momentum, ROC, MACD, and Stochastic: Each indicator is computed using the Global Liquidity series rather than price. User-selectable toggles allow for enabling or disabling each individual indicator as desired. 4. Enhanced MACD Visualization Dynamic Histogram Coloring: The MACD histogram color adjusts dynamically: brighter hues indicate rising histogram values while darker hues indicate falling values. When the histogram is above zero, green is used; when below zero, red is applied, offering immediate visual insight into momentum shifts. Conclusion This indicator is an enlightening tool for understanding liquidity dynamics, aiding in macroeconomic analysis and investment decision-making by highlighting shifts in liquidity conditions and market momentum.
Pine Script™ indikatörü
theheirophant tarafından
1
Volume Delta with PVSRAVolume Delta with PVSRA Volume Delta with PVSRA is an advanced volume indicator that dissects each bar’s volume into its directional components using higher resolution data. It visually distinguishes between buying and selling volume, so that for a bullish candle the bottom portion represents buying volume and for a bearish candle it represents selling volume. A dot is plotted at the 50% mark of the candle’s total volume, serving as a clear reference point. Key Features: Directional Volume Breakdown: The indicator calculates the delta volume by analyzing lower timeframe data. The bottom portion of a bullish candle (displayed in green) represents buying volume, while that of a bearish candle (displayed in red) represents selling volume. PVSRA Analysis: Using Price-Volume Spread Range Analysis, the indicator compares the current volume to the 10-bar average. When volume is significantly higher (using thresholds of 150% and 200%), the candle borders are highlighted in custom colors, indicating medium or strong volume conditions. Volume Moving Averages: Three moving averages are plotted: Total Volume MA (yellow): Tracks overall volume. Buying Volume MA (green) and Selling Volume MA (red): These are re-centered around the total volume MA. A crossover of the green over the red typically signals rising buying pressure, while the opposite indicates increasing selling pressure. Scalable Volume Bars: The indicator scales the volume bars to provide optimal visualization on your chart. Setup Instructions: For best results, open your chart settings, navigate to the Canvas tab, and set the bottom margin to 0%. This ensures the indicator displays like a standard volume indicator without any unwanted gaps at the bottom. Customize the various settings—including colors, border opacity, and moving average parameters—to suit your trading style.
Pine Script™ indikatörü
svstaats tarafından
3
Fractal Breakout Oscillator (BETA)Fractal Breakout Oscillator (BETA) This custom indicator is designed to help traders identify local tops and local bottoms using fractal analysis, price distance, and trend direction. It combines weighted components to generate the Fractal Breakout Oscillator (FBO). The oscillator reacts to extreme levels in price and trend behavior, with the ability to adjust sensitivity and smoothing parameters. Components and Usage 1. Fractal Detection: o Detects fractal tops and bottoms using a 3-bar pattern. o The number of fractals averaged can be adjusted with the Fractals for Average parameter. 2. Oscillator Calculation: o Combines price distance, trend direction, and fractal frequency using adjustable weights. o Use the sensitivity control to tune how strictly the fractal signals respond. o Extreme values of the oscillators indicate potential overbought or oversold conditions. 3. Customization: o Customize top/bottom marker colors. o Enable multipliers (e.g., Golden Ratio) to refine component behavior. o Adjust smoothing periods and lookback to improve signal reliability. Disclaimer This indicator is provided for educational and research purposes only. It should not be considered as financial or trading advice. Always perform your own analysis and consult a financial advisor before making trading decisions. Past performance does not guarantee future results.
Pine Script™ indikatörü
Tom_Bombadyl tarafından
Turtle Soup Model [PhenLabs]📊 Turtle Soup Model Version: PineScript™ v6 Description The Turtle Soup Model is an innovative technical analysis tool that combines market structure analysis with inter-market comparison and gap detection. Unlike traditional structure indicators, it validates market movements against a comparison symbol (default: ES1!) to identify high-probability trading opportunities. The indicator features a unique “soup pattern” detection system, comprehensive gap analysis, and real-time structure breaks visualization. Innovation Points: First indicator to combine structure analysis with gap detection and inter-market validation Advanced memory management system for efficient long-term analysis Sophisticated pattern recognition with multi-market confirmation Real-time structure break detection with comparative validation 🔧 Core Components Structure Analysis: Advanced pivot detection with inter-market validation Gap Detection: Sophisticated gap identification and classification system Inversion Patterns: “Soup pattern” recognition for reversal opportunities Visual System: Dynamic rendering of structure levels and gaps Alert Framework: Multi-condition notification system 🚨 Key Features 🚨 The indicator provides comprehensive analysis through: Structure Levels: Validated support and resistance zones Gap Patterns: Identification of significant market gaps Inversion Signals: Detection of potential reversal points Real-time Comparison: Continuous inter-market analysis Visual Alerts: Dynamic structure break notifications 📈 Visualization Structure Lines: Color-coded for highs and lows Gap Boxes: Visual representation of gap zones Inversion Patterns: Clear marking of potential reversal points Comparison Overlay: Inter-market divergence visualization Alert Indicators: Visual signals for structure breaks 💡Example 📌 Usage Guidelines The indicator offers multiple customization options: Structure Settings: Pivot Period: Adjustable for different market conditions Comparison Symbol: Customizable reference market Visual Style: Configurable colors and line widths Gap Analysis: Signal Mode: Choice between close and wick-based signals Box Rendering: Automatic gap zone visualization Middle Line: Reference point for gap measurements ✅ Best Practices: 🚨Use comparison symbol from related market🚨 Monitor both structure breaks and gap inversions Combine signals for higher probability trades Pay attention to inter-market divergences ⚠️ Limitations Requires comparison symbol data Performance depends on market correlation Best suited for liquid markets What Makes This Unique Inter-market Validation: Uses comparison symbol for signal confirmation Gap Integration: Combines structure and gap analysis Soup Pattern Detection: Identifies specific reversal patterns Dynamic Structure Management: Automatically updates and removes invalid levels Memory-Efficient Design: Optimized for long-term chart analysis 🔧 How It Works The indicator processes market data through three main components: 1. Structure Analysis: Detects pivot points with comparison validation Tracks structure levels with array management Identifies and processes structure breaks 2. Gap Analysis: Identifies significant market gaps Processes gap inversions Manages gap zones visualization 3. Pattern Recognition: Detects “soup” patterns Validates with comparison market Generates structure break signals 💡 Note: The indicator performs best when used with correlated comparison symbols and appropriate timeframe selection. Its unique inter-market validation system provides additional confirmation for traditional structure-based trading strategies.
Pine Script™ indikatörü
PhenLabs tarafından
Excess Liquidity IndicatorExcess Liquidity Indicator This script visualizes excess liquidity trends in relation to risk assets. It estimates excess liquidity by combining various macroeconomic factors such as WW M2 money supply, central bank balance sheets, and interest rates, oil, and the dollar index, and it substracts WW GDP. The tool helps traders analyze liquidity-driven market trends in a structured manner. Note: This script is for research purposes only and does not provide financial advice. I cannot point names cause I get banned but work is inspired by others...
Pine Script™ indikatörü
mks17 tarafından
Maverick Henderson Strategy Maverick Henderson Strategy A comprehensive technical analysis indicator that combines several powerful tools: 1. Volume Profile with POC (Point of Control) - Displays volume distribution across price levels - Shows value areas and POC line - Helps identify key support/resistance levels 2. Multiple EMAs (10, 50, 100, 200) - Trend identification and dynamic support/resistance - Price action confirmation - Works best with Heikin Ashi candles 3. Swing Detection & Counting System - Identifies and counts higher highs/lower lows - Dynamic trend strength measurement - Automatically resets on EMA200 crossovers 4. RSI Divergence Detection - Regular bullish/bearish divergences - Hidden bullish/bearish divergences - Filtered by EMA200 position 5. Multi-Timeframe Squeeze Momentum - Analyzes momentum across 1H, 2H, 3H, and 4H timeframes - Shows momentum convergence/divergence - Visual color-coded momentum representation Usage Tips: - Best performance with Heikin Ashi candles - Use EMA crossovers for trend confirmation - Watch for momentum convergence signals - Monitor RSI divergences for potential reversals // ═══════════════════════════════════════════════════════════ Estrategia Maverick Henderson Un indicador de análisis técnico completo que combina varias herramientas poderosas: 1. Perfil de Volumen con POC - Muestra la distribución del volumen por niveles de precio - Visualiza áreas de valor y línea POC - Ayuda a identificar niveles clave de soporte/resistencia 2. Múltiples EMAs (10, 50, 100, 200) - Identificación de tendencias y soporte/resistencia dinámica - Confirmación de acción del precio - Funciona mejor con velas Heikin Ashi 3. Sistema de Detección y Conteo de Swings - Identifica y cuenta máximos más altos/mínimos más bajos - Medición dinámica de la fuerza de la tendencia - Se reinicia automáticamente en cruces de EMA200 4. Detección de Divergencias RSI - Divergencias regulares alcistas/bajistas - Divergencias ocultas alcistas/bajistas - Filtradas por posición respecto a EMA200 5. Momentum Multi-Temporal - Analiza momentum en marcos de 1H, 2H, 3H y 4H - Muestra convergencia/divergencia de momentum - Representación visual codificada por colores Consejos de Uso: - Mejor rendimiento con velas Heikin Ashi - Usar cruces de EMA para confirmación de tendencia - Observar señales de convergencia de momentum - Monitorear divergencias RSI para posibles reversiones // ═══════════════════════════════════════════════════════════ Stochastic Divergence Detection New feature added! The indicator now includes Stochastic divergence detection, just like the RSI, providing additional tools for identifying potential reversals and trend confirmations. Regular Divergences: -Bullish: Signals a potential upward reversal when price makes lower lows, but the Stochastic shows higher lows. -Bearish: Signals a potential downward reversal when price makes higher highs, but the Stochastic shows lower highs. Hidden Divergences (optional): -Bullish: Occurs during uptrends when price makes higher lows, but the Stochastic shows lower lows. -Bearish: Occurs during downtrends when price makes lower highs, but the Stochastic shows higher highs. Detección de Divergencias en el Estocástico ¡Nueva función añadida! Ahora el indicador incluye detección de divergencias en el Estocástico, al igual que en el RSI, ofreciendo herramientas adicionales para identificar posibles reversiones y confirmaciones de tendencia. Divergencias regulares: -Alcistas: Señala una posible reversión al alza cuando el precio marca mínimos más bajos y el Estocástico muestra mínimos más altos. -Bajistas: Señala una posible reversión a la baja cuando el precio marca máximos más altos y el Estocástico muestra máximos más bajos. Divergencias ocultas (opcional): -Alcistas: Ocurre en tendencias alcistas cuando el precio hace mínimos más altos, pero el Estocástico muestra mínimos más bajos. -Bajistas: Ocurre en tendencias bajistas cuando el precio marca máximos más bajos, pero el Estocástico muestra máximos más altos.
Pine Script™ indikatörü
Maverick_Henderson tarafından