Inizia

Indicatori e strategie

Fibonacci Stochastic + HMA + EMA Fibonacci Stochastic + HMA + EMA This indicator is designed to help identify trends and entry timing by combining three main indicators. It filters out false signals and increases the accuracy of decision-making. Key Components of the Indicator: Hull Moving Average (HMA) Shows the main price trend. Green = Uptrend Red = Downtrend Used to confirm that the trade is following the market direction (Trend Following). Fibonacci Stochastic Measures the buying and selling pressure of the market. Uses Fibonacci levels: 0.236 / 0.382 / 0.5 / 0.618 / 0.786 The system will interpret this as a Bullish/Bearish signal. Used to find "entry points," not to predict highs or lows. Display Results: Green candlestick → Buy momentum Red candlestick → Sell momentum EMA Short/Long (Multi-Timeframe) Uses EMA values ​​from a smaller timeframe (e.g., 1 minute). Compares short-term and long-term EMAs. Used to confirm trend strength and short-term reversals. EMA values ​​are hidden by default for a cleaner chart. Signal Conditions BUY Signal The system will give a BUY signal when: The HMA trend is upward. The short-term EMA is above the EMA average. The Stochastic is in the bullish zone. Display: The word BUY is below the candlestick. SELL Signal The system will give a SELL signal when: The HMA trend is downward. The short-term EMA is below the EMA average. The Stochastic is in the bearish zone. Display: The word SELL is above the candlestick. Recommended Usage Approach Suitable Timeframe Scalping: 1m – 5m Intraday: 5m – 15m Trend Trade: 15m – 1h Notes Should be used in conjunction with: Support / Resistance Price Action Risk Management
Indicatore Pine Script®
di alphaemateam8
Volume Balance ZonesVolume Balance Zones Volume Balance Zones is an indicator that visualizes directional volume balance over a user-defined lookback period. The indicator evaluates volume based on candle direction to provide contextual insight into market participation around the current price area. Results are displayed as zones on the price chart. Calculation Logic Volume is calculated from the selected lookback period. Volume is separated based on candle behavior: Bullish Volume: Candles that close higher than they open. Bearish Volume: Candles that close lower than they open. Volume from each side is summed independently. Visualization Results are displayed as rectangular zones on the price chart. Zone Length represents the relative dominance of volume. The side with higher volume is displayed with a longer zone. Zone Position: Bearish volume zone is displayed above the current price. Bullish volume zone is displayed below the current price. ATR (Average True Range) is used to determine the vertical distance of the zones from price. Usage Notes This indicator is intended to provide market context only, such as: Comparing relative bullish and bearish participation. Identifying areas of directional volume concentration. It should be used in conjunction with other forms of analysis such as: Price action Market structure Support and resistance This indicator does not provide trade entry or exit signals. Inputs Lookback Number of previous bars used in volume calculation. Lower values emphasize short-term activity, while higher values provide broader context. Bar Width Maximum horizontal length of the volume zones. ATR Length Used to calculate the distance between the zones and the current price.
Indicatore Pine Script®
di alphaemateam8
CRR Trend Conformator v1CRR Trend Conformator v1 CRR Trend Conformator v1 is a proprietary momentum-based trend confirmation oscillator designed to help analyze directional strength and structural momentum shifts in any market and timeframe. This indicator uses a non-repainting Heikin-Ashi derived momentum engine, normalized with ATR, to visualize trend conformity through oscillator candles, zero-line transitions, and momentum expansion behavior. Key Features Normalized momentum oscillator with smooth adaptive behavior Zero-line crossing logic to identify momentum phase shifts Persistent trend state for visual conformity analysis Structural swing-break detection for momentum continuation or failure Fixed upper and lower zones for over-extension awareness Clear momentum candle visualization in a separate indicator pane Background highlighting during momentum break events How to Use Observe oscillator behavior around the zero line to assess momentum bias Study momentum candles for strength, weakness, or consolidation Use swing break highlights to understand momentum continuation dynamics Zones help identify stretched or extreme momentum conditions This tool is intended to support market analysis only and does not generate trade instructions. Important Notes Non-repainting logic (confirmed bars only) Parameters are internally optimized and intentionally locked Works across all instruments and timeframes Designed for trend conformity and momentum structure study Disclaimer This indicator is provided for educational and analytical purposes only. It does not constitute financial advice or a recommendation to buy or sell any instrument. Users are responsible for their own trading decisions and risk management
Indicatore Pine Script®
di rajesswarrav
Chip Distribution Pro// This source code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org // Enhanced Position Cost Distribution - Auto-adaptive with improved visualization // Works with ETFs, commodities, forex, crypto, stocks - any instrument // @version=5 indicator('Chip Distribution Pro', overlay = true, max_lines_count = 500, max_bars_back = 500) //#region Inputs string GRP_GENERAL = "General Settings" int LOOKBACK = input.int(1000, 'Lookback Bars', maxval = 20000, minval = 500, step = 250, group = GRP_GENERAL) int CHART_X_OFFSET = input.int(100, 'Chart Offset', step = 10, group = GRP_GENERAL) int LABEL_X_OFFSET = CHART_X_OFFSET + 4 int CHART_MAX_WIDTH = input.int(80, 'Max Width', maxval = 500, minval = 10, step = 10, group = GRP_GENERAL) int NUM_BUCKETS = input.int(400, 'Price Buckets', maxval = 500, minval = 50, step = 50, group = GRP_GENERAL) string GRP_AUTO = "Auto-Tuning" bool AUTO_TUNE = input.bool(true, 'Enable Auto-Tuning', group = GRP_AUTO, tooltip = 'Automatically adjusts turnover rate based on volatility and volume characteristics') float MANUAL_DECAY = input.float(0.1, 'Manual Turnover Rate', minval = 0.01, maxval = 0.5, step = 0.01, group = GRP_AUTO, tooltip = 'Only used when Auto-Tuning is disabled') int VOLATILITY_PERIOD = input.int(20, 'Volatility Period', minval = 5, maxval = 100, group = GRP_AUTO) string GRP_VISUAL = "Visualization" string COLOR_SCHEME = input.string("Rainbow", "Color Scheme", options = , group = GRP_VISUAL) color PROFIT_COLOR_LIGHT = input.color(#26a69a, 'Profit Light', group = GRP_VISUAL) color PROFIT_COLOR_DARK = input.color(#004d40, 'Profit Dark', group = GRP_VISUAL) color LOSS_COLOR_LIGHT = input.color(#ef5350, 'Loss Light', group = GRP_VISUAL) color LOSS_COLOR_DARK = input.color(#b71c1c, 'Loss Dark', group = GRP_VISUAL) color CURRENT_PRICE_COLOR = input.color(color.yellow, 'Current Price', group = GRP_VISUAL) color AVG_PRICE_COLOR = input.color(#2196F3, 'Average Cost', group = GRP_VISUAL) color PEAK_COLOR = input.color(#FF9800, 'Peak Concentration', group = GRP_VISUAL) color STATS_COLOR = input.color(#434651, 'Stats Background', group = GRP_VISUAL) string GRP_LEVELS = "Key Levels" bool SHOW_SUPPORT_RESISTANCE = input.bool(true, 'Show Support/Resistance Zones', group = GRP_LEVELS) bool SHOW_PEAK = input.bool(true, 'Show Peak Concentration', group = GRP_LEVELS) float SR_THRESHOLD = input.float(0.7, 'S/R Detection Threshold', minval = 0.3, maxval = 0.95, step = 0.05, group = GRP_LEVELS, tooltip = 'Minimum concentration (relative to peak) to mark as support/resistance') string GRP_SIGNALS = "Signals Panel" bool SHOW_SIGNALS = input.bool(true, 'Show Signal Panel', group = GRP_SIGNALS) bool SHOW_KEY_LEVELS = input.bool(true, 'Show Key Price Levels', group = GRP_SIGNALS) bool SHOW_TREND_ARROW = input.bool(true, 'Show Trend Arrow', group = GRP_SIGNALS) bool SHOW_PRESSURE_BAR = input.bool(true, 'Show Pressure Bar', group = GRP_SIGNALS) // Colors for key levels color SUPPORT_COLOR = input.color(#00E676, 'Support Level', group = GRP_LEVELS) color RESISTANCE_COLOR = input.color(#FF5252, 'Resistance Level', group = GRP_LEVELS) color BREAKOUT_COLOR = input.color(#FFD600, 'Breakout Level', group = GRP_LEVELS) //#endregion //#region Candle Type type Candle int idx float hi float lo float vol float relativeVol float atrPct //#endregion //#region PCD Type type PCD array candles float minPrice float maxPrice float priceStep array lines label currentPriceLabel label avgPriceLabel label peakLabel label statsLabel label signalLabel array srZones float calculatedTurnover // New visualization elements line supportLine line resistanceLine line avgCostLine label trendArrow box pressureBar box pressureFill label pressureLabel // Create a new price label newPriceLabel(color bg, color txtColor) => label.new(0, 0, '', style = label.style_label_left, color = bg, textcolor = txtColor, size = size.small) // Create a new PCD instance newPCD() => array lns = array.new(NUM_BUCKETS) for i = 0 to NUM_BUCKETS - 1 array.set(lns, i, line.new(0, 0, 0, 0)) PCD.new( candles = array.new(0), lines = lns, currentPriceLabel = newPriceLabel(color.new(#00BCD4, 0), color.white), avgPriceLabel = newPriceLabel(AVG_PRICE_COLOR, color.white), peakLabel = newPriceLabel(PEAK_COLOR, color.white), statsLabel = label.new(0, 0, '', style = label.style_label_up, size = size.small, textalign = text.align_left, color = color.new(STATS_COLOR, 20), textcolor = color.white), signalLabel = label.new(0, 0, '', style = label.style_label_left, size = size.small, textalign = text.align_left, color = color.new(#1a1a2e, 20), textcolor = color.white), srZones = array.new(0), calculatedTurnover = 0.1, minPrice = na, maxPrice = na, priceStep = na, supportLine = line.new(0, 0, 0, 0, color = SUPPORT_COLOR, width = 2, style = line.style_dashed), resistanceLine = line.new(0, 0, 0, 0, color = RESISTANCE_COLOR, width = 2, style = line.style_dashed), avgCostLine = line.new(0, 0, 0, 0, color = AVG_PRICE_COLOR, width = 2, style = line.style_dotted), trendArrow = label.new(0, 0, '', style = label.style_label_center, size = size.large, textcolor = color.white), pressureBar = box.new(0, 0, 0, 0, bgcolor = color.new(#424242, 50), border_color = color.gray), pressureFill = box.new(0, 0, 0, 0, bgcolor = color.green, border_color = na), pressureLabel = label.new(0, 0, '', style = label.style_label_right, size = size.tiny, color = color.new(#000000, 100), textcolor = color.white)) // Auto-calculate turnover rate based on instrument characteristics calcAdaptiveTurnover(float atrPct, float volRatio) => float safeAtrPct = na(atrPct) or atrPct <= 0 ? 0.02 : atrPct float safeVolRatio = na(volRatio) or volRatio <= 0 ? 1.0 : volRatio float volBasedTurnover = math.max(0.03, math.min(0.3, safeAtrPct * 3)) float volAdjustment = math.max(0.5, math.min(2.0, safeVolRatio)) float turnover = volBasedTurnover * volAdjustment math.max(0.02, math.min(0.4, turnover)) // Store candle method method storeCandle(PCD this, int barIdx, float hiPrice, float loPrice, float volVal, float avgVol, float atrPct) => if not na(hiPrice) and not na(loPrice) and not na(volVal) and volVal > 0 float safeAvgVol = na(avgVol) or avgVol <= 0 ? volVal : avgVol float relVol = volVal / safeAvgVol float safeAtrPct = na(atrPct) ? 0.02 : atrPct bool modified = false int candleSize = array.size(this.candles) if candleSize > 0 Candle c = array.get(this.candles, candleSize - 1) if c.idx == barIdx c.hi := hiPrice c.lo := loPrice c.vol := volVal c.relativeVol := relVol c.atrPct := safeAtrPct modified := true if not modified Candle c = Candle.new(barIdx, hiPrice, loPrice, volVal, relVol, safeAtrPct) array.push(this.candles, c) this.minPrice := na(this.minPrice) ? loPrice : math.min(this.minPrice, loPrice) this.maxPrice := na(this.maxPrice) ? hiPrice : math.max(this.maxPrice, hiPrice) float priceRange = this.maxPrice - this.minPrice this.priceStep := priceRange > 0 ? priceRange / NUM_BUCKETS : 0.0001 // Get bucket index for price method getBucketIndex(PCD this, float price) => if na(this.priceStep) or this.priceStep <= 0 or na(this.minPrice) 0 else int idx = int(math.floor((price - this.minPrice) / this.priceStep)) math.max(0, math.min(idx, NUM_BUCKETS - 1)) // Get price for bucket index method getBucketedPrice(PCD this, int bucketIdx) => int safeIndex = math.max(0, math.min(bucketIdx, NUM_BUCKETS - 1)) float safeStep = na(this.priceStep) or this.priceStep <= 0 ? 0.0001 : this.priceStep float safeMin = na(this.minPrice) ? 0.0 : this.minPrice (safeIndex + 0.5) * safeStep + safeMin // Get rainbow color based on position (0.0 = bottom/red, 1.0 = top/violet) getRainbowColor(float position, float intensityRatio) => float pos = math.max(0.0, math.min(1.0, position)) int transparency = int(math.round((1.0 - intensityRatio) * 50)) // Rainbow spectrum: red -> orange -> yellow -> green -> cyan -> blue -> violet if pos < 0.166 color.new(color.from_gradient(pos, 0.0, 0.166, #FF0000, #FF7F00), transparency) else if pos < 0.333 color.new(color.from_gradient(pos, 0.166, 0.333, #FF7F00, #FFFF00), transparency) else if pos < 0.5 color.new(color.from_gradient(pos, 0.333, 0.5, #FFFF00, #00FF00), transparency) else if pos < 0.666 color.new(color.from_gradient(pos, 0.5, 0.666, #00FF00, #00FFFF), transparency) else if pos < 0.833 color.new(color.from_gradient(pos, 0.666, 0.833, #00FFFF, #0000FF), transparency) else color.new(color.from_gradient(pos, 0.833, 1.0, #0000FF, #8B00FF), transparency) // Get color based on scheme and intensity getColor(bool isProfitable, float intensity, float maxIntensity, int bucketIdx) => float safeMax = maxIntensity > 0 ? maxIntensity : 1.0 float ratio = math.max(0.0, math.min(1.0, intensity / safeMax)) float positionRatio = bucketIdx / math.max(1.0, NUM_BUCKETS - 1.0) if COLOR_SCHEME == "Rainbow" getRainbowColor(positionRatio, ratio) else if COLOR_SCHEME == "Gradient" if isProfitable color.from_gradient(ratio, 0.0, 1.0, PROFIT_COLOR_DARK, PROFIT_COLOR_LIGHT) else color.from_gradient(ratio, 0.0, 1.0, LOSS_COLOR_DARK, LOSS_COLOR_LIGHT) else if COLOR_SCHEME == "Heatmap" color.from_gradient(ratio, 0.0, 1.0, #1a237e, #f44336) else if isProfitable color.new(#5d606b, int(math.round((1.0 - ratio) * 70))) else color.new(#e91e63, int(math.round((1.0 - ratio) * 70))) // Update method method update(PCD this) => int candleCount = array.size(this.candles) if candleCount > 0 and not na(this.priceStep) and this.priceStep > 0 // Create distribution array array dist = array.new_float(NUM_BUCKETS, 0.0) // Process each candle for candleIdx = 0 to candleCount - 1 Candle candle = array.get(this.candles, candleIdx) bool isFirstCandle = candleIdx == 0 float turnover = AUTO_TUNE ? calcAdaptiveTurnover(candle.atrPct, candle.relativeVol) : MANUAL_DECAY * candle.relativeVol turnover := math.min(turnover, 0.95) this.calculatedTurnover := turnover int startIdx = this.getBucketIndex(candle.lo) int endIdx = this.getBucketIndex(candle.hi) int buckets = math.max(1, endIdx - startIdx + 1) if isFirstCandle float initialWeight = 1.0 / buckets for i = startIdx to endIdx array.set(dist, i, initialWeight) else float decayedAmount = 0.0 for i = 0 to NUM_BUCKETS - 1 float oldVal = array.get(dist, i) float newVal = oldVal * (1.0 - turnover) array.set(dist, i, newVal) decayedAmount += oldVal - newVal float addPerBucket = decayedAmount / buckets for i = startIdx to endIdx array.set(dist, i, array.get(dist, i) + addPerBucket) // Normalize distribution float totalWeight = 0.0 for i = 0 to NUM_BUCKETS - 1 totalWeight += array.get(dist, i) if totalWeight > 0 for i = 0 to NUM_BUCKETS - 1 array.set(dist, i, array.get(dist, i) / totalWeight) // Find peak float maxWeight = array.max(dist) if na(maxWeight) or maxWeight <= 0 maxWeight := 0.001 int peakIndex = array.indexof(dist, maxWeight) if peakIndex < 0 peakIndex := 0 float peakPrice = this.getBucketedPrice(peakIndex) // Find support/resistance zones array srIndices = array.new(0) if SHOW_SUPPORT_RESISTANCE bool inZone = false int zoneStart = 0 for i = 0 to NUM_BUCKETS - 1 bool isHighConcentration = array.get(dist, i) >= maxWeight * SR_THRESHOLD if isHighConcentration and not inZone inZone := true zoneStart := i else if not isHighConcentration and inZone inZone := false array.push(srIndices, int(math.floor((zoneStart + i) / 2))) if inZone array.push(srIndices, int(math.floor((zoneStart + NUM_BUCKETS - 1) / 2))) // Clear old SR zones int srZoneSize = array.size(this.srZones) if srZoneSize > 0 for i = 0 to srZoneSize - 1 box b = array.get(this.srZones, i) box.set_lefttop(b, 0, 0) box.set_rightbottom(b, 0, 0) // Draw the distribution float lowestDisplayedPrice = na float highestDisplayedPrice = na for i = 0 to NUM_BUCKETS - 1 float weight = array.get(dist, i) float price = (i + 0.5) * this.priceStep + this.minPrice int width = int(math.round(weight / maxWeight * CHART_MAX_WIDTH)) line ln = array.get(this.lines, i) if width > 0 if na(lowestDisplayedPrice) lowestDisplayedPrice := price highestDisplayedPrice := price int x1 = bar_index + CHART_X_OFFSET int x2 = x1 - width bool isProfitable = price < close color c = getColor(isProfitable, weight, maxWeight, i) line.set_xy1(ln, x1, price) line.set_xy2(ln, x2, price) line.set_color(ln, c) else line.set_xy1(ln, 0, 0) line.set_xy2(ln, 0, 0) // Draw S/R zones if SHOW_SUPPORT_RESISTANCE int srCount = array.size(srIndices) int leftBar = math.max(0, bar_index - LOOKBACK) if srCount > 0 for i = 0 to srCount - 1 int idx = array.get(srIndices, i) float zonePrice = this.getBucketedPrice(idx) float zoneHalfHeight = this.priceStep * 3 box b = na if i < array.size(this.srZones) b := array.get(this.srZones, i) box.set_lefttop(b, leftBar, zonePrice + zoneHalfHeight) box.set_rightbottom(b, bar_index, zonePrice - zoneHalfHeight) else b := box.new(leftBar, zonePrice + zoneHalfHeight, bar_index, zonePrice - zoneHalfHeight, bgcolor = color.new(PEAK_COLOR, 85), border_color = color.new(PEAK_COLOR, 60)) array.push(this.srZones, b) // Calculate cumulative distribution array cumdist = array.copy(dist) for i = 1 to NUM_BUCKETS - 1 array.set(cumdist, i, array.get(cumdist, i - 1) + array.get(cumdist, i)) // Highlight current price int closeIndex = this.getBucketIndex(close) if closeIndex >= 0 and closeIndex < NUM_BUCKETS line.set_color(array.get(this.lines, closeIndex), CURRENT_PRICE_COLOR) // Calculate stats float totalShares = array.get(cumdist, NUM_BUCKETS - 1) int profitIndex = math.min(closeIndex + 1, NUM_BUCKETS - 1) float profitRatio = totalShares > 0 ? array.get(cumdist, profitIndex) / totalShares : 0.0 // Calculate average price float avg = 0.0 for i = 0 to NUM_BUCKETS - 1 float weight = array.get(dist, i) float price = this.getBucketedPrice(i) avg += price * weight int avgIndex = this.getBucketIndex(avg) if avgIndex >= 0 and avgIndex < NUM_BUCKETS line.set_color(array.get(this.lines, avgIndex), AVG_PRICE_COLOR) // Peak concentration - highlight line if SHOW_PEAK and peakIndex >= 0 and peakIndex < NUM_BUCKETS line.set_color(array.get(this.lines, peakIndex), PEAK_COLOR) // Smart label positioning - avoid overlaps float priceRange = na(highestDisplayedPrice) or na(lowestDisplayedPrice) ? close * 0.01 : (highestDisplayedPrice - lowestDisplayedPrice) float minLabelSpacing = priceRange * 0.025 // Sort prices and assign staggered X offsets float currentY = close float avgY = avg float peakY = peakPrice // Adjust avg label if too close to current if math.abs(avgY - currentY) < minLabelSpacing avgY := currentY > avgY ? avgY - minLabelSpacing : avgY + minLabelSpacing // Adjust peak label if too close to current or avg if SHOW_PEAK if math.abs(peakY - currentY) < minLabelSpacing peakY := currentY > peakY ? peakY - minLabelSpacing : peakY + minLabelSpacing if math.abs(peakY - avgY) < minLabelSpacing peakY := avgY > peakY ? peakY - minLabelSpacing : peakY + minLabelSpacing // Position price labels - compact format, right side of distribution label.set_text(this.currentPriceLabel, str.format('{0,number,#.##}', close)) label.set_xy(this.currentPriceLabel, bar_index + LABEL_X_OFFSET + 2, close) label.set_style(this.currentPriceLabel, label.style_label_left) label.set_size(this.currentPriceLabel, size.tiny) label.set_text(this.avgPriceLabel, str.format('{0,number,#.##} AVG', avg)) label.set_xy(this.avgPriceLabel, bar_index + LABEL_X_OFFSET + 2, avgY) label.set_style(this.avgPriceLabel, label.style_label_left) label.set_size(this.avgPriceLabel, size.tiny) if SHOW_PEAK label.set_text(this.peakLabel, str.format('{0,number,#.##} PEAK', peakPrice)) label.set_xy(this.peakLabel, bar_index + LABEL_X_OFFSET + 2, peakY) label.set_style(this.peakLabel, label.style_label_left) label.set_size(this.peakLabel, size.tiny) // Calculate ranges safely float safeTotalShares = totalShares > 0 ? totalShares : 1.0 int idx05 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.05) int idx95 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.95) int idx15 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.15) int idx85 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.85) float ninetyPctLow = this.getBucketedPrice(idx05) float ninetyPctHigh = this.getBucketedPrice(idx95) float seventyPctLow = this.getBucketedPrice(idx15) float seventyPctHigh = this.getBucketedPrice(idx85) float rangeDenom = ninetyPctHigh - ninetyPctLow float rangeOverlap = rangeDenom != 0 ? (seventyPctHigh - seventyPctLow) / rangeDenom : 0.0 // Calculate chip concentration float concentration = rangeOverlap * 100 string concentrationDesc = concentration < 50 ? "High" : concentration < 70 ? "Medium" : "Dispersed" // Pressure analysis float safeAvg = avg > 0 ? avg : close float priceVsAvg = ((close - safeAvg) / safeAvg) * 100 string pressure = priceVsAvg > 5 ? "Strong Bullish" : priceVsAvg > 1 ? "Bullish" : priceVsAvg < -5 ? "Strong Bearish" : priceVsAvg < -1 ? "Bearish" : "Neutral" // Price vs Peak float safePeak = peakPrice > 0 ? peakPrice : close float priceVsPeak = ((close - safePeak) / safePeak) * 100 string peakRelation = close > peakPrice ? "Above Peak" : close < peakPrice ? "Below Peak" : "At Peak" // Stats panel - positioned at bottom, compact float displayedRange = na(highestDisplayedPrice) or na(lowestDisplayedPrice) ? close * 0.02 : highestDisplayedPrice - lowestDisplayedPrice label.set_text(this.statsLabel, str.format( '90%: {0,number,#.##} - {1,number,#.##} | 70%: {2,number,#.##} - {3,number,#.##}', ninetyPctLow, ninetyPctHigh, seventyPctLow, seventyPctHigh)) if not na(lowestDisplayedPrice) and displayedRange > 0 label.set_y(this.statsLabel, lowestDisplayedPrice - displayedRange * 0.05) label.set_style(this.statsLabel, label.style_label_up) label.set_x(this.statsLabel, bar_index + CHART_X_OFFSET - 30) label.set_size(this.statsLabel, size.tiny) // Signal panel - hidden (info moved to trend arrow and pressure bar) label.set_text(this.signalLabel, "") label.set_xy(this.signalLabel, bar_index, close) // === NEW PROFESSIONAL VISUALIZATIONS === // 1. Key Level Lines - Support, Resistance, and Average Cost extending across chart if SHOW_KEY_LEVELS int chartLeft = math.max(0, bar_index - LOOKBACK) int chartRight = bar_index + CHART_X_OFFSET - 5 // Average cost line (horizontal dotted blue line) line.set_xy1(this.avgCostLine, chartLeft, avg) line.set_xy2(this.avgCostLine, chartRight, avg) line.set_color(this.avgCostLine, AVG_PRICE_COLOR) // Find strongest support (highest concentration below current price) float strongestSupport = na float strongestSupportWeight = 0.0 float strongestResistance = na float strongestResistanceWeight = 0.0 for i = 0 to NUM_BUCKETS - 1 float bucketPrice = this.getBucketedPrice(i) float bucketWeight = array.get(dist, i) if bucketPrice < close and bucketWeight > strongestSupportWeight strongestSupport := bucketPrice strongestSupportWeight := bucketWeight if bucketPrice > close and bucketWeight > strongestResistanceWeight strongestResistance := bucketPrice strongestResistanceWeight := bucketWeight // Support line (green dashed) if not na(strongestSupport) line.set_xy1(this.supportLine, chartLeft, strongestSupport) line.set_xy2(this.supportLine, chartRight, strongestSupport) line.set_color(this.supportLine, SUPPORT_COLOR) else line.set_xy1(this.supportLine, bar_index, close) line.set_xy2(this.supportLine, bar_index, close) line.set_color(this.supportLine, color.new(SUPPORT_COLOR, 100)) // Resistance line (red dashed) if not na(strongestResistance) line.set_xy1(this.resistanceLine, chartLeft, strongestResistance) line.set_xy2(this.resistanceLine, chartRight, strongestResistance) line.set_color(this.resistanceLine, RESISTANCE_COLOR) else line.set_xy1(this.resistanceLine, bar_index, close) line.set_xy2(this.resistanceLine, bar_index, close) line.set_color(this.resistanceLine, color.new(RESISTANCE_COLOR, 100)) // 2. Trend Direction Arrow if SHOW_TREND_ARROW string trendSymbol = priceVsAvg > 5 ? "▲▲" : priceVsAvg > 1 ? "▲" : priceVsAvg < -5 ? "▼▼" : priceVsAvg < -1 ? "▼" : "◆" color trendColor = priceVsAvg > 5 ? color.new(#00E676, 0) : priceVsAvg > 1 ? color.new(#4CAF50, 0) : priceVsAvg < -5 ? color.new(#FF1744, 0) : priceVsAvg < -1 ? color.new(#EF5350, 0) : color.new(#9E9E9E, 0) string trendText = trendSymbol + " " + pressure label.set_text(this.trendArrow, trendText) float arrowY = na(highestDisplayedPrice) ? close : highestDisplayedPrice + displayedRange * 0.12 label.set_xy(this.trendArrow, bar_index + CHART_X_OFFSET - 40, arrowY) label.set_color(this.trendArrow, color.new(trendColor, 70)) label.set_textcolor(this.trendArrow, trendColor) label.set_size(this.trendArrow, size.large) // 3. Pressure Bar (Profit/Loss ratio visualization) if SHOW_PRESSURE_BAR float barWidth = 8.0 float barHeight = displayedRange * 0.25 float barX = bar_index + CHART_X_OFFSET + 5 float barTop = na(highestDisplayedPrice) ? close + barHeight/2 : highestDisplayedPrice - displayedRange * 0.02 float barBottom = barTop - barHeight // Background bar box.set_lefttop(this.pressureBar, int(barX), barTop) box.set_rightbottom(this.pressureBar, int(barX + barWidth), barBottom) box.set_bgcolor(this.pressureBar, color.new(#424242, 60)) // Fill based on profit ratio (green from bottom) float fillHeight = barHeight * profitRatio float fillTop = barBottom + fillHeight color fillColor = profitRatio > 0.7 ? color.new(#00E676, 30) : profitRatio > 0.5 ? color.new(#4CAF50, 30) : profitRatio > 0.3 ? color.new(#FFC107, 30) : color.new(#FF5252, 30) box.set_lefttop(this.pressureFill, int(barX), fillTop) box.set_rightbottom(this.pressureFill, int(barX + barWidth), barBottom) box.set_bgcolor(this.pressureFill, fillColor) // Pressure label string pressureText = str.format('{0,number,#}%', profitRatio * 100) label.set_text(this.pressureLabel, pressureText) label.set_xy(this.pressureLabel, int(barX - 1), barTop + displayedRange * 0.01) label.set_textcolor(this.pressureLabel, fillColor) //#endregion //#region Main = request.security(syminfo.tickerid, 'D', , lookahead = barmerge.lookahead_off) float atrPercent = dailyClose > 0 ? dailyATR / dailyClose : 0.02 if timeframe.in_seconds(timeframe.period) <= timeframe.in_seconds('D') var PCD pcd = newPCD() if last_bar_index - bar_index < LOOKBACK pcd.storeCandle(dailyBarIdx, dailyHigh, dailyLow, dailyVolume, avgVolume, atrPercent) if barstate.islast pcd.update() //#endregion
Indicatore Pine Script®
di billy10384
CRT ALEX + Turtle Soup 1h 3h 4h 6h 12h 1d + Closest FVG with BPRCRT TURTLE SOUP 1H + 3H + 4H + 6H + 12H + 1D Liquidity Sweep Indicator is an advanced tool designed to detect liquidity sweeps across multiple key higher timeframes. The indicator identifies when price sweeps a previous high or low from a higher timeframe and only confirms the sweep if price closes back inside the range within a configurable number of candles. This logic helps filter false breakouts and low-quality liquidity grabs. 🔹 Key Features: Detection of High Sweeps and Low Sweeps on: 1H, 3H, 4H, 6H, 12H, and 1D Smart confirmation logic: Break of previous high/low Rejection and close in the opposite direction Adjustable confirmation candle limit Individual on/off control for each timeframe Fully customizable line colors and thickness Clean labels for fast and clear chart reading Works on all markets: Forex, indices, gold, futures, and crypto 🔄 Update: FVG & BPR Overlay Integration Fair Value Gap (FVG) and Balanced Price Range (BPR) overlay allowing traders to view key imbalance areas and price balance zones without loading multiple indicators on the chart. Auto Closest Bullish FVG Automatically displays the nearest bullish Fair Value Gap relative to current price. Auto Closest Bearish FVG Automatically displays the nearest bearish Fair Value Gap relative to current price. Balanced Price Range (BPR) When the nearest bullish and bearish FVGs overlap, a BPR is detected and displayed, highlighting areas of price balance and potential reaction zones. 🔹 Benefits Immediate visibility of nearest imbalances and balance zones. Improved contextual awareness around price action after liquidity sweeps. Suitable for scalping, intraday, and swing trading across all markets. This integration enhances chart readability and workflow efficiency.
Indicatore Pine Script®
di damieanalexandru
Analyze**Smart Money & OB Finder (MTF)** is a professional trading indicator designed to help traders identify high-probability **Buy Zones and Sell Zones** based on **Smart Money Concepts (SMC)** and **Order Blocks (OB)** across multiple timeframes. This indicator automatically marks **institutional Order Blocks**, allowing traders to see where **big players enter the market**, instead of chasing price in the middle of nowhere. ### 🔍 Key Features • Automatic **Buy & Sell Order Block detection** • **Multi-Timeframe (MTF)** analysis for higher-timeframe confirmation • Clear **zone marking** (no late signals, no repaint) • Works on **all markets** (Forex, Gold, Indices, Crypto) • Suitable for **scalping, intraday, and swing trading** ### 🎯 How to Use • Mark zones on higher timeframe (H1 / H4) • Execute entries on lower timeframe (M5 / M15) • Use Order Blocks as **reaction areas**, not ins
Indicatore Pine Script®
di afiqnajid994
FXWMarkets.comFXWMarkets.com is a next‑generation trading ecosystem built for traders who demand clarity, speed, and institutional‑grade insights. Our mission is to empower global traders with advanced analytics, multi‑asset research, and AI‑enhanced market intelligence — all delivered through a modern, intuitive platform designed for real‑world performance. We combine professional‑level tools, transparent market analysis, and cutting‑edge technology to help traders navigate Forex, commodities, indices, and crypto with confidence. At FXWMarkets.com, we believe in precision, reliability, and trader‑first innovation. 🚀 Join FXWMarkets.com — Be Part of the Launch Become one of the first to join FXWMarkets.com and unlock exclusive early‑access benefits. We’re preparing to launch a powerful new trading platform — and early members will receive priority access, premium insights, and a chance to earn a 100% bonus at launch. Don’t miss the opportunity to be part of a platform built for serious traders. 👉 Join us today at FXWMarkets.com and secure your advantage before the doors open.
Indicatore Pine Script®
di FXWMarkets
Beirami (Open BETA)🏆 BEIRAMI – Professional Trading Indicator 13 years of market experience in one powerful tool. 💎 Who is BEIRAMI for? BEIRAMI is a comprehensive trading system created by two brothers with 13 years of experience in financial markets. All our knowledge, failures, and successes have been distilled into one powerful indicator. ✅ Beginners – clear signals, ready-to-use alerts ✅ Advanced traders – Gann cycles, Elliott Waves, multi-timeframe analysis ✅ Day traders – fast signals, impulses, chart patterns ✅ Swing traders – long-term trends, zones, time cycles 🎯 What makes BEIRAMI stand out? 9 systems in one indicator Instead of buying multiple tools, you get a complete trading arsenal: 🔹 Moving Averages – carefully selected Fibonacci numbers 🔹 Dynamic Fibonacci Zones – automatic support & resistance 🔹 Choppiness Index – instantly see if the market is trending or ranging 🔹 RSI + Stochastic POP – ultra-precise entry signals 🔹 ATR Impulses (🐂🐻) – catch breakouts before the crowd 🔹 W/M Patterns – automatic reversal detection 🔹 Elliott Waves – the system automatically counts waves 1-2-3-4-5 🔹 Gann Time Cycles – predict reversals with day-level accuracy 🔹 Future Projections – see WHEN a move is likely to happen 🚀 Key Features 🎿 W/M Patterns Automatic detection of double bottoms and double tops: “W” = buy signal (bullish reversal) “M” = sell signal (bearish reversal) Blue lines draw the entire pattern automatically. 🐂🐻 ATR Impulses Emojis highlight sudden market impulses: 🐂 = strong bullish impulse 🐻 = strong bearish impulse Perfect for catching breakouts early. 🎯 Stochastic POP (Ultra Edition) This is NOT a standard Stochastic: • Requires a crossover in extreme zones • Confirmed by volume expansion • Built-in cooldown – fewer false signals POP↑ = Buy | POP↓ = Sell 🔺 Fibonacci Zones – Alive, Not Static Forget manual drawing: • Automatic support & resistance zones • Thick green 0.618 line = the “Golden Level” • Color-coded zones show instantly where to act 🌊 Elliott Waves – Fully Automatic! No expert knowledge required: • SAM system detects and numbers waves 1-2-3-4-5 • Red waves = warning of a potential drop • Green waves = warning of a potential rise • White numbers & lines = full structural clarity 🔮 GANN Time Cycles (Weekly+) The black magic of trading: • Works on Weekly and Monthly timeframes only • Time cycles accurate to the day • Future projections with exact DATES • When a cycle approaches — prepare for a trend reversal 📊 Dashboard – Everything in One Place LEGEND – clean, minimalist signal legend METRICS – live data: CHOP, RSI, Stoch, Gann countdown GANN Status – shows if active + timeframe reminder ⚙️ Full Customization You are in control: • Enable/disable any component • Customize colors and dashboard positions • Adjust signal sensitivity • Choose which Gann cycles to display • Debug mode for advanced users The tool grows together with you. 🎁 SUMMARY BEIRAMI is 13 years of experience packed into one indicator. We don’t promise 100% accuracy. We promise a professional system that cuts through noise and highlights the best opportunities. From scalping to swing trading — BEIRAMI has your back. | This indicator is not financial advice. Trading involves risk.
Indicatore Pine Script®
di Beirami_Trading
Neeson bitcoin Dynamic ATR Trailing SystemNeeson bitcoin Dynamic ATR Trailing System: A Comprehensive Guide to Volatility-Adaptive Trend Following Introduction The Dynamic ATR Trailing System (DATR-TS) represents a sophisticated approach to trend following that transcends conventional moving average or breakout-based methodologies. Unlike standard trend-following systems that rely on price pattern recognition or fixed parameter oscillators, this system operates on the principle of volatility-adjusted position management—a nuanced approach that dynamically adapts to changing market conditions rather than imposing rigid rules on market behavior. Originality and Innovation Distinct Methodological Approach What sets DATR-TS apart from hundreds of existing trend-following systems is its dual-layered conditional execution framework. While most trend-following systems fall into one of three broad categories—moving average crossovers, channel breakouts, or momentum oscillators—this system belongs to the more specialized category of volatility-normalized trailing stop systems. Key Original Contributions: Volatility-Threshold Signal Filtering: Most trend systems generate signals continuously, leading to overtrading during low-volatility periods. DATR-TS implements a proprietary volatility filter that requires minimum market movement before generating signals, effectively separating high-probatility trend opportunities from market noise. Self-Contained Position State Management: Unlike traditional systems that require external position tracking, DATR-TS maintains an internal position state that prevents contradictory signals and creates a closed-loop decision framework. Dynamic Risk Parameter Adjustment: The system doesn't use fixed percentage stops or rigid ATR multiples. Instead, it implements a responsive adjustment mechanism that widens stops during high volatility and tightens them during low volatility, creating an optimal balance between risk protection and opportunity capture. Trader-Centric Visualization Philosophy: Beyond mere signal generation, the system provides a comprehensive visual feedback system designed to align with human cognitive patterns, reducing emotional decision-making through consistent color coding and information hierarchy. Technical Implementation and Functionality Core Operational Mechanism DATR-TS implements a volatility-adjusted trend persistence model that operates on the principle that trending markets exhibit characteristic volatility signatures. The system specifically targets medium-term directional movements (typically lasting 5-20 days) rather than short-term scalping opportunities or long-term position trades. The Four-Pillar Architecture: Volatility Measurement and Normalization Calculates Average True Range (ATR) over a user-defined period Converts absolute volatility to percentage terms relative to price Compares current volatility against user-defined thresholds to filter suboptimal conditions Dynamic Trailing Stop Algorithm Establishes an initial stop distance based on current volatility Implements a four-state adjustment mechanism that responds to price action Maintains stop position during trend continuation while allowing for trend reversal detection Conditional Signal Generation Generates entry signals only when price action meets both directional and volatility criteria Produces exit signals based on trailing stop penetration Incorporates position state awareness to prevent conflicting signals Comprehensive Feedback System Provides multi-layer visual information including dynamic stop lines, signal labels, and color-coded price action Displays real-time metrics through an integrated dashboard Offers configurable visualization options for different trading styles Specific Trend-Following Methodology DATR-TS employs a volatility-normalized trailing stop breakout approach, which differs significantly from common trend identification methods: Not a moving average crossover system (like MACD or traditional MA crosses) Not a channel breakout system (like Bollinger Band or Donchian Channel breaks) Not a momentum oscillator system (like RSI or Stochastic trend following) Not a price pattern recognition system (like head-and-shoulders or triangle breaks) Instead, it belongs to the more specialized category of volatility-adjusted stop-and-reverse systems that: Wait for market volatility to reach actionable levels Establish positions when price confirms directional bias through stop penetration Manage risk dynamically based on evolving market conditions Exit positions when the trend exhausts itself through stop violation Practical Application and Usage Market Environment Optimization Ideal Conditions: Trending markets with sustained directional movement Medium volatility environments (neither excessively calm nor chaotic) Timeframes: 4-hour to daily charts for optimal signal quality Instruments: Forex majors, commodity futures, equity indices Suboptimal Conditions: Ranging or consolidating markets Extreme volatility events or news-driven spikes Very short timeframes (below 1-hour) Illiquid or highly manipulated instruments Parameter Configuration Strategy Core Parameter Philosophy: ATR Length (Default: 21 periods) Controls the system's memory of volatility Shorter lengths increase sensitivity but may cause overtrading Longer lengths provide smoother signals but may lag during volatility shifts ATR Multiplier (Default: 6.3x) Determines the initial risk buffer Lower values (4-5x) create tighter stops for conservative trading Higher values (6-8x) allow for larger trends but increase drawdown risk Volatility Threshold (Default: 1.5%) Filters out low-quality trading environments Adjust based on market characteristics (higher for volatile markets) Acts as a quality control mechanism for signals Trading Workflow and Execution Signal Interpretation and Action: Entry Protocol: Wait for BLUE "BUY" signal label appearance Confirm volatility conditions meet threshold requirements Enter long position at market or next reasonable opportunity Set initial stop at displayed dynamic stop level Position Management: Monitor dynamic stop line for position adjustment Allow profits to run while stop protects capital No manual adjustment required—system manages stop automatically Exit Protocol: Exit on ORANGE "SELL" signal label appearance Alternative exit if price hits dynamic stop level System will generate new entry signal if conditions warrant re-entry Risk Management Integration: Position sizing based on distance to dynamic stop Volatility filter prevents trades during unfavorable conditions Clear visual feedback on current risk exposure Built-in protection against overtrading Philosophical Foundation and Market Theory Core Trading Principles DATR-TS embodies several foundational market principles: Volatility Defines Opportunity Markets don't trend continuously—they alternate between trending and ranging phases Volatility provides the energy for trends to develop and sustain By measuring and filtering volatility, we can focus on high-probability trend phases Risk Should Be Proportional Fixed percentage stops ignore market context Dynamic stops that adjust with volatility provide more appropriate risk management Position sizing should reflect current market conditions, not arbitrary rules Simplicity Through Sophistication Complex systems often fail in real-world conditions A simple core algorithm with intelligent filtering outperforms complex multi-indicator approaches Clear visual feedback reduces cognitive load and emotional interference Trends Persist Until Proven Otherwise Markets exhibit momentum characteristics Once a trend establishes itself, it tends to continue The trailing stop methodology captures this persistence while providing exit mechanisms Mathematical and Statistical Foundation The system operates on several statistical market observations: Volatility Clustering Phenomenon High volatility periods tend to follow high volatility periods Low volatility periods tend to follow low volatility periods By filtering for adequate volatility, we increase the probability of capturing meaningful trends Trend Magnitude Distribution Most trends are small to medium in magnitude Very large trends are rare but account for disproportionate returns The dynamic stop methodology allows capture of varying trend magnitudes Autocorrelation in Price Movements Price movements exhibit short-term positive autocorrelation during trends This persistence allows trailing stops to capture continued movement The system leverages this characteristic without requiring explicit autocorrelation calculation Performance Characteristics and Expectations Typical System Behavior Signal Frequency: Low to moderate signal generation (prevents overtrading) Signals concentrated during trending market phases Extended periods without signals during ranging conditions Risk-Reward Profile: Win rate typically 40-60% in trending conditions Average win larger than average loss Risk-reward ratios of 1:2 to 1:3 achievable Drawdown Patterns: Controlled through volatility adjustment Larger drawdowns during extended ranging periods Recovery typically follows when trending conditions resume Comparison with Alternative Approaches Versus Moving Average Systems: Less prone to whipsaws during ranging markets Better adaptation to changing volatility conditions Clearer exit signals through stop levels Versus Channel Breakout Systems: More responsive to emerging trends Lower false breakout probability Dynamic risk adjustment rather than fixed parameters Versus Momentum Oscillator Systems: Better trend persistence capture Less susceptible to overbought/oversold false signals Clearer position management rules Educational Value and Skill Development Learning Opportunities DATR-TS serves as more than just a trading tool—it provides educational value through: Market Condition Awareness Teaches traders to distinguish between trending and ranging markets Develops understanding of volatility's role in trading opportunities Encourages patience and selectivity in trade execution Risk Management Discipline Demonstrates dynamic position sizing principles Illustrates the importance of adaptive stops Reinforces the concept of risk-adjusted returns Psychological Skill Development Reduces emotional trading through clear rules Builds patience through conditional execution Develops discipline through systematic approach Customization and Evolution The system provides a foundation for further development: Beginner Level: Use default parameters for initial learning Focus on signal recognition and execution discipline Develop understanding of system behavior across market conditions Intermediate Level: Adjust parameters based on specific market characteristics Combine with complementary analysis techniques Develop personal variations based on trading style Advanced Level: Integrate with portfolio management systems Develop automated execution frameworks Create derivative systems for specialized applications Conclusion: The Modern Trend-Following Paradigm The Dynamic ATR Trailing System represents a significant evolution in trend-following methodology. By moving beyond simple price pattern recognition or fixed parameter oscillators, it embraces the complex reality of financial markets where volatility, trend persistence, and risk management interact dynamically. This system doesn't claim to predict market direction or identify tops and bottoms. Instead, it provides a systematic framework for participating in trends when they emerge, managing risk appropriately as conditions change, and preserving capital during unfavorable environments. For traders seeking a methodology that combines mathematical rigor with practical execution, adapts to changing market conditions rather than fighting against them, and provides clear, actionable information without cognitive overload, DATR-TS offers a sophisticated yet accessible approach to modern trend following. The true value lies not in any single signal or parameter setting, but in the comprehensive philosophy of volatility-aware, risk-adjusted, conditionally-executed trend participation that the system embodies—a philosophy that aligns with how markets actually behave rather than how we might wish them to behave.
Indicatore Pine Script®
di neeson1987
Timbuktu V - Average percentage of absolute price movementTimbuktu V - Average percentage of absolute price movement between the specified date/time and the last candle This Pine Script v5 indicator calculates and displays in a table the average percentage of absolute price movement per candle from a user-defined start date/time up to the most recent candle on the chart. Technical Description The user sets a start time (startTime) and display parameters such as table position and text size. For each candle, the script computes the absolute percentage change: |(close – open) / open × 100|. Up to 5000 candles back are evaluated, and only those occurring after the chosen start time are included. The script accumulates the values and calculates the average absolute percentage change. A table is drawn on the chart showing: the label “Average % (abs)”, the calculated average percentage (two decimals), and the number of candles used in the calculation. Practical Trading Applications Volatility measurement: assess the average volatility of an asset over a chosen period. Strategy selection: identify whether conditions favor range-bound strategies (low volatility) or breakout/momentum strategies (high volatility). Risk management: adjust stop loss, take profit, and position sizing based on the average price movement. Asset comparison: compare different instruments (stocks, crypto, futures) to find those with higher or lower average movement. Event impact analysis: set the start time at a major event (earnings, rate decision) to measure how volatility evolved afterward. Backtesting conditions: evaluate historical market environments to validate whether a strategy performs better in high- or low-volatility phases. In summary, Timbuktu V provides a clear and visual way to quantify relative market volatility, helping traders make more informed decisions about which assets to trade, how to size positions, and which strategies to apply under different market conditions.
Indicatore Pine Script®
di mrossi71
FXWMarkets.comFXWMarkets.com is a next‑generation trading ecosystem built for traders who demand clarity, speed, and institutional‑grade insights. Our mission is to empower global traders with advanced analytics, multi‑asset research, and AI‑enhanced market intelligence — all delivered through a modern, intuitive platform designed for real‑world performance. We combine professional‑level tools, transparent market analysis, and cutting‑edge technology to help traders navigate Forex, commodities, indices, and crypto with confidence. At FXWMarkets.com, we believe in precision, reliability, and trader‑first innovation. 🚀 Join FXWMarkets.com — Be Part of the Launch Become one of the first to join FXWMarkets.com and unlock exclusive early‑access benefits. We’re preparing to launch a powerful new trading platform — and early members will receive priority access, premium insights, and a chance to earn a 100% bonus at launch. Don’t miss the opportunity to be part of a platform built for serious traders. 👉 Join us today at FXWMarkets.com and secure your advantage before the doors open.
Indicatore Pine Script®
di FXWMarkets
CRT Turtle Soup Alex 1H + 3H + 4H + 6H + 12H + 1D 1H + 3H + 4H + 6H + 12H + 1D Turtle Soup is an advanced tool designed to detect liquidity sweeps across multiple key higher timeframes. The indicator identifies when price sweeps a previous high or low from a higher timeframe and only confirms the sweep if price closes back inside the range within a configurable number of candles. This logic helps filter false breakouts and low-quality liquidity grabs. 🔹 Key Features: Detection of High Sweeps and Low Sweeps on: 1H, 3H, 4H, 6H, 12H, and 1D Smart confirmation logic: Break of previous high/low Rejection and close in the opposite direction Adjustable confirmation candle limit Individual on/off control for each timeframe Works on all markets: Forex, indices, gold, futures, and crypto 🎯 Ideal for: Fully customizable line colors and thickness Clean labels for fast and clear chart reading Traders using SMC CRT ICT Identifying liquidity zones, stop hunts, and inducement Scalping, day trading, and swing trading High-probability reversal and continuation setups after liquidity grabs This indicator provides a clear and structured way to visualize where real liquidity has been taken, offering traders a strong contextual and execution edge. ============================================================================
Indicatore Pine Script®
di damieanalexandru
Smart Money Timing ProSmart Money Timing Pro is a market-context and timing indicator designed to classify when market conditions are supportive for participation and when risk is elevated. Rather than generating buy or sell signals, the script evaluates trend behavior, volatility regime, participation quality, and institutional value acceptance to determine: • the current market phase • whether an execution window is open or forming • and whether exit risk is increasing The indicator is non-repainting and updates in real time to provide objective structural context, not trading instructions. Core concept Markets do not move randomly. Institutional participation typically progresses through recognizable phases: • accumulation • directional expansion • distribution • markdown Smart Money Timing Pro models these phases quantitatively using price structure, volatility normalization, volume participation, and anchored value reference points. The output is a timing framework that helps traders avoid low-quality environments and focus attention only when structural conditions are favorable. How the indicator works The script combines four independent analytical layers into a unified timing engine: 1. Trend & structural direction A dual-EMA structure (20 / 50) classifies directional pressure: • bullish structure • bearish structure • or neutral balance This is used to determine whether price is trending or rotating. 2. Volatility regime filtering ATR is compared against its own historical average to detect: • stable conditions (controlled auction) • or unstable expansion (risk regime) This prevents execution windows from being labeled during abnormal volatility. 3. Participation quality (volume behavior) Volume is evaluated relative to its moving average to determine whether: • movement is supported by participation • or driven by low-quality activity This avoids timing execution during thin or deceptive moves. 4. Institutional value reference (AVWAP + rolling POC) The script automatically builds: • a phase-anchored VWAP (AVWAP) • and a rolling Point of Control (POC) These represent evolving institutional value zones. Execution conditions require price to accept value relative to these references, not merely touch them. Market phase classification Using the layers above, each candle is classified into one of: • Accumulation – low volatility, neutral structure • Markup – bullish structure • Distribution – neutral structure with rising volatility • Markdown – bearish structure This forms the base market context. Execution window logic An execution window is labeled: • OPEN – when trend, volatility, participation, and value acceptance align • FORMING – when some conditions exist but structure is incomplete • CLOSED – when volatility or participation invalidates timing This allows traders to separate market direction from market quality. Exit risk detection The script also evaluates: • abnormal candle ranges • high-volume / low-result behavior to identify rising probability of exhaustion or supply pressure. Exit risk is classified as: • LOW • RISING • SUPPLY_PRESSURE How to use Typical usage: • Focus on trade planning only during OPEN execution windows • Be cautious when execution is FORMING • Avoid initiating new trades when execution is CLOSED • Monitor Exit Risk to manage existing positions The indicator is designed to be used alongside: • your own entry model • market structure • higher-timeframe bias • and risk management rules What this indicator is not • Not a buy/sell signal generator • Not an automated strategy • Not a scalping system • Not predictive or future-looking It provides context and timing quality only. Limitations • AVWAP anchoring depends on detected phase transitions • POC is approximated using rolling volume bins • Performance is best on liquid markets • Extreme news events can temporarily distort volatility and participation logic Intended users Discretionary traders who: • trade trends or swing setups • care about execution quality • want to avoid manipulation-driven environments • prefer objective context over indicator stacking Disclaimer • This indicator is provided for educational and informational purposes only. • It does not constitute financial advice, investment recommendations, or trading signals. The script does not generate buy or sell instructions and should not be used as a standalone trading system. • All trading involves risk. Users are solely responsible for their trading decisions, risk management, and compliance with applicable regulations.
Indicatore Pine Script®
di gpanjwani1979
SMT by AlgoKingsSmart Money Technique - Spot Institutional Divergence MULTI-SYMBOL DIVERGENCE ANALYSIS SMT by AlgoKings reveals when correlated markets diverge - a key signal used to identify market weakness and potential reversals. AUTOMATIC SYMBOL PAIRING: Auto-compares correlated assets: NQ vs ES / YM, EURUSD vs GBPUSD / DXY, BTCUSD vs ETHUSD, Gold vs Silver, and more. Works with futures, forex, crypto, and stocks. Manual mode for custom pairs. MULTI-TIMEFRAME CYCLES: Track divergences across 11 time cycles: from 1-minute to yearly. Includes sessions (Asia, London, NY), intraday (90m, 30m, 10m, 3m, 1m), and swing cycles (daily through yearly). INTELLIGENT FILTERING: Auto-hide overlapping divergences. Optional hierarchy filtering removes lower-timeframe noise when higher-timeframe SMT is active. REAL-TIME TRACKING: Watch divergences form and extend live. Color-coded bull/bear signals show which market is weaker. VISUAL CLARITY: Customizable colors, line styles, and text sizes. Optional labels for instant cycle recognition. WHO IT'S FOR: ICT/SMC traders using Smart Money Concepts to identify institutional footprints across correlated markets. DISCLAIMER: Educational training tool for learning Smart Money Technique analysis. Not trading signals or financial advice. Trading involves substantial risk. Correlation breaks. Institutions reveal. One indicator.
Indicatore Pine Script®
di AlgoKings_Official
PXX Levels by AlgoKingsPXX - Multi-Timeframe Levels MULTI-TIMEFRAME KEY LEVEL TRACKING PXX Levels by AlgoKings automatically marks previous highs and lows across time cycles - institutional levels for support, resistance, and liquidity identification. COMPREHENSIVE COVERAGE: Track 9 timeframe cycles - Yearly, Quarterly, Monthly, Weekly, Daily, Session, 90m, 30m, and 10m. All institutional reference points on one chart. LIVE LEVEL FORMATION: Current cycle highs and lows update in real-time as they form. INTELLIGENT PURGING: Auto-removes lower timeframe levels when higher cycles reset. Optional purge keeps charts focused on active levels. MITIGATION TRACKING: Levels turn dotted once mitigated. Optional auto-removal of mitigated levels. OVERLAP DETECTION: Auto-consolidates identical levels when multiple timeframes share the same price, keep chart clean. PROFESSIONAL CUSTOMIZATION: Adjustable history, colors, line widths, and sizes. Toggle timeframes on/off. Extend or stop at mitigation. WHO IT'S FOR: ICT/SMC traders using previous highs and lows for entries, targets, and liquidity analysis. DISCLAIMER: Educational training tool for learning PXX level analysis. Not trading signals or financial advice. Trading involves substantial risk. Every level. Every timeframe. One chart.
Indicatore Pine Script®
di AlgoKings_Official
Support & Resistance Detector [PRO]Professional Support & Resistance Detector 🟠 Executive Summary 🟠 The **Professional Support & Resistance Detector ** is an institutional-grade technical analysis instrument built for precision traders. It automates the complex task of identifying significant market structure by detecting valid Swing Highs (Resistance) and Swing Lows (Support) using a customizable dynamic lookback algorithm. Unlike basic indicators that clutter the chart with irrelevant lines, this tool employs smart filtration and FIFO (First-In, First-Out) logic to present only the most actionable price levels. Whether you are a scalper needing real-time feedback or a swing trader looking for confirmed structural levels, this indicator adapts to your workflow with "Confirmed Only" and "Realtime" calculation modes. Why Standard Indicators Fail 🟠 Most Support & Resistance indicators suffer from two major problems: 1. **Noise**: They identify too many insignificant levels, making the chart unreadable. 2. **Rigidity**: They fail to account for "Role Reversal" (where old Resistance becomes new Support). The Solution: Advanced Feature Set 🟠 This script addresses these issues with a suite of advanced features designed for the modern market environment: 1. **Dynamic Algorithmic Detection**: * The core engine uses a user-defined `Left` and `Right` bar lookback system. This allows you to differentiate between "Major" structural pivots (high lookback) and "Minor" intraday levels (low lookback). * **Zone Visualization**: Prices rarely turn at an exact micro-level. The indicator draws a transparent "Zone" around the key level to visualize the area of liquidity, helping you avoid premature entries during wick tests. 2. **Smart Breakout Logic (The "Brain" of the Indicator)**: * **History Mode (Faded)**: When a level is broken, it doesn't just vanish. It stays on the chart but fades out. This is critical for backtesting to see how price reacted to past levels. * **Role Reversal (Flip) Mode**: This is for active trading. When price breaks Resistance, the line automatically flips color to Support (and vice versa). This allows you to trade the "Break & Retest" strategy effortlessly. 3. **Active Chart Management**: * Markets evolve. Old levels become irrelevant. The built-in **FIFO Memory System** ensures that you never have more than your specified limit (e.g., 25 lines) on the chart. As new structure forms, the oldest irrelevant data is recycled, keeping your workspace pristine. 4. **Multi-Mode Calculation Engine**: * **Confirmed Only (Default)**: The professional standard. Levels are only drawn/updated when the candle closes. This guarantees zero repainting and reliable signals. * **Realtime (Tick-by-Tick)**: Designed for aggressive scalpers who need to see potential pivots forming before the candle closes. Comprehensive Settings & Customization 🟠 Every aspect of the indicator is customizable to fit your trading style. Logic & Calculation 🟠 * **Max Active Lines**: Set the buffer size for active levels. Recommended: 20-30 for clean analysis. * **Line Extension**: Choose "Right" (standard), "Both" (chart-wide context), or "Segment Only" (local structure). Pivot Identification 🟠 * **Lookback Left/Right**: The sensitivity dial. * *Scalping Setup*: Left 10 / Right 5. * *Swing Setup*: Left 50 / Right 25. * **Zone Width**: Controls the vertical thickness of the S/R zone. Visual Aesthetics 🟠 * **Markers**: Select from a library of professionally designed Unicode symbols (Diamonds ◈, Arrows ⯅/⯆, Stars ★, etc.) to mark the exact pivot candle. * **Breakout Markers**: Visual confirmation icons (Crosses ✖, Checks ✔) appear exactly where the breakout occurred. Professional Trading Strategies 🟠 **Strategy 1: The S/R Flip (Break & Retest)** 1. Set **Breakout Behavior** to "Role Reversal (Flip)". 2. Wait for price to break a **Red Resistance Zone**. 3. Watch the Zone turn **Blue (Support)**. 4. **Entry**: Wait for price to pull back and touch the new Blue Support zone. Look for a rejection wick. 5. **Stop Loss**: Just below the zone. Strategy 2: Range Containment 1. Identify a market moving sideways between a parallel Blue Support and Red Resistance. 2. **Sell** at the Red Zone touch (Resistance). 3. **Buy** at the Blue Zone touch (Support). 4. **Filter**: Use the "Confirmed Only" mode to ensure the candle closes inside the range before taking a trade. Alert System 🟠 Never miss a move. The indicator offers fully integrated alerts for automation: * **New Level Found**: Instant notification when fresh structure is identified. * **Breakout Alert**: When a level is breached. * **Flip Alert**: Specific notification when Resistance becomes Support (or vice versa). Disclaimer 🟠 This tool is provided for educational and analytical purposes. Financial trading carries a high level of risk. Past performance of any trading system is not indicative of future results. Please trade responsibly.
Indicatore Pine Script®
di a_jabbaroff