Get started

Candlestick analysis

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
Pine Script® indicator
by billy10384
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
Pine Script® indicator
by afiqnajid994
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.
Pine Script® indicator
by a_jabbaroff
High-volume buy and sell signals with OB and FVGBuy and sell signals on ob Pivot Point Usage: Instead of detecting each candle of an opposite color, the script uses `ta.pivothigh/low`. This means it only marks a Pivot Point if the price has actually made a significant high or low relative to the 10 preceding and following candles. Dynamic Cleanup (Mitigation): As soon as the price returns to "fill" the area (depending on your choice: simple contact or close), the box disappears from the chart. This keeps your view clean and focused on the remaining untouched areas. Period Setting: You can increase the "Detection Period" (e.g., from 10 to 20) in the settings to filter out even more noise and keep only the major areas. How to use it?
Pine Script® indicator
by peacefulOil34051
Pattern Pro [Josh]1. Overview Pattern Pro is a hybrid technical analysis suite designed to bridge the gap between Classic Chart Patterns and Smart Money Concepts (SMC). Reimagined with a high-contrast "Alien HUD" visual style, this script helps traders identify structural breaks, reversal patterns, and institutional zones with clarity. 2. How it Works (Methodology & Calculations) The core engine of this script relies on identifying significant market swings using ta.pivothigh and ta.pivotlow functions. These pivot points are stored in dynamic arrays to perform geometric calculations: Geometric Pattern Recognition: The script calculates the slope between historical pivots using linear regression logic. Double Tops/Bottoms: Detects equal highs/lows within a user-defined tolerance (default 0.25%) and validates them with RSI Divergence logic. Head & Shoulders: Validates the structural hierarchy (Left Shoulder < Head > Right Shoulder) relative to the neckline. Wedges & Flags: Analyzes trendlines connecting multiple pivots. Converging slopes indicate Wedges, while parallel slopes indicate Flags. Smart Money Concepts (SMC): BOS (Break of Structure): Automatically draws lines where price closes beyond a key pivot, signaling trend continuation. FVG (Fair Value Gaps): Scans for 3-candle price imbalances and projects the 50% equilibrium level. Supply & Demand Zones: Highlights order blocks derived from the specific candles that formed a confirmed pivot. Confidence Score: An internal algorithm assigns a percentage score based on pattern clarity and momentum divergence (RSI). 3. Visual Features (Alien HUD) Neon & Glow Effects: Lines are rendered with multi-layered transparency to create a "glowing" effect, ensuring visibility on dark themes. Fog/Smoke FX: Adds depth to critical levels without cluttering the chart. Customization: Users can toggle specific patterns, adjust pivot sensitivity (Lookback), and customize colors. Disclaimer: This indicator is developed strictly for educational purposes regarding chart behavior and algorithmic pattern recognition. The signals and patterns generated do not guarantee profitability or future accuracy. Past performance is not indicative of future results. Trading involves significant risk. Users should always practice proper risk management and use their own judgment.
Pine Script® indicator
by JOSHSniper4569
Multi-Timeframe Open Levels [Vertical Rays]█ OVERVIEW This indicator displays higher timeframe open levels using a unique vertical ray design. It draws vertical separators above and below the opening candle, clearly marking the higher timeframe session boundaries on the lower timeframe without interfering with price action or altering chart scale. Supports up to 5 timeframes with full control over styling and history depth. █ KEY FEATURES - Up to 5 independent timeframes — combine any timeframe (minutes, hours, days, weeks) with individual styling - Vertical ray design — marks timeframe transitions without obscuring price action or distorting chart scale - Smart overlap handling — when multiple timeframes align (e.g., Daily and 4H), the higher timeframe takes visual priority - Performance optimized — efficient processing that only calculates what's needed based on visible history - Minimal footprint — preserves your chart's natural aspect ratio - Fully customizable — colors, line styles, thickness, and label formatting per timeframe █ HOW IT WORKS At each higher timeframe open, the indicator draws two vertical rays: • One extending upward from above opening candle • One extending downward from below the opening candle This creates visual "bookends" that instantly identify where new sessions or timeframe periods begin on the lower timeframe. █ SETTINGS Each timeframe slot includes: • Enable/disable toggle • Timeframe value and unit (M/H/D/W) • Color, style (solid/dashed/dotted), and line width • Maximum historical levels to display Label options include timezone selection, optional price display, and positioning adjustments.
Pine Script® indicator
by Mr_NSFT
Mayor Trend Phase Schedule PAI (2025-2026) - Close 23:00 + TableA proprietary time-based analytical tool designed to identify predetermined cyclical windows where major market movements exhibit heightened statistical probability. This indicator synthesizes chronological patterns with price structure confirmation to provide traders with temporally optimized decision frameworks. Core Components 1. Chronological Phase Mapping Pre-calibrated 3-day windows across 2025-2026 identified through historical cyclical analysis Visual background highlighting of active phase periods Systematic scheduling of potential volatility expansion periods 2. Dynamic Session Reference Real-time tracking of critical session closing levels (configurable time zone) Continuous plotting of reference price levels that adapt to market conditions Integration of temporal price behavior into phase analysis 3. Multi-Timeframe Context Framework Proprietary EMA combination (157, 200, 257 periods) representing institutional, macro, and intermediate trend perspectives Visual trend structure assessment during active phases Confluence verification between temporal and technical factors 4. Informative Dashboard Real-time phase status monitoring Active schedule visualization Reference level tracking with timestamp verification Analytical Methodology Phase-Confluence Trading Approach The indicator operates on the principle of temporal-technical confluence, where trades are considered only when multiple analytical dimensions align: Primary Conditions: Temporal Alignment - Active phase window confirmation Structural Alignment - Price positioned relative to institutional trend framework Session Alignment - Price interaction with critical session reference levels Operational Logic Identification: Automatic detection of active phase windows Verification: Multi-factor confirmation of trading environments Visualization: Clear graphical representation of confluence conditions Monitoring: Real-time tracking of phase progression and price interaction Application Framework Strategic Implementation Phase Awareness - Monitor upcoming windows for preparation Confluence Verification - Confirm multiple alignment conditions Reference Level Analysis - Assess price behavior relative to session dynamics Context Integration - Evaluate within broader market structure Risk Management Considerations Temporal-based position sizing adjustments Phase-duration aware trade management Confluence-level dependent risk parameters Technical Specifications Customization Options Adjustable session time references Configurable visual display parameters Selective component activation/deactivation Table presentation customization Compatibility Multi-asset class applicability Various timeframe adaptability Integration with existing trading frameworks Theoretical Foundation Underlying Principles Cyclical market behavior patterns Institutional trading periodicity Session-based price memory effects Multi-timeframe confluence significance Analytical Value Proposition Reduced temporal uncertainty Enhanced timing precision Structured decision frameworks Objective phase identification Usage Guidelines Optimal Implementation As a Timing Filter - Primary use for trade timing optimization As a Context Tool - Supplementary market condition assessment As a Planning Aid - Forward schedule awareness and preparation Integration Recommendations Combine with price action analysis Correlate with fundamental catalysts Align with broader market cycles Validate with volume and volatility metrics Performance Characteristics Analytical Strengths Objective temporal identification Clear visual communication Systematic approach to timing Historical pattern recognition Practical Limitations Requires supplementary technical analysis Not a standalone trading system Dependent on proper interpretation Historical performance not indicative of future results Professional Applications Institutional Use Cases Portfolio rebalancing timing Option expiration planning Risk window identification Strategic entry/exit scheduling Retail Trader Applications Trade timing optimization Market condition awareness Risk period identification Planning and preparation tool Conclusion The Mayor Trend Phase Schedule indicator represents a sophisticated approach to temporal market analysis, providing traders with structured frameworks for identifying statistically significant time windows. By focusing on chronological patterns and their interaction with price structure, the tool offers a unique perspective on market timing that complements traditional technical analysis methods. Note: This tool is designed for analytical purposes and should be used as part of a comprehensive trading methodology with appropriate risk management protocols.
Pine Script® indicator
by priceactionindonesia
KAPISH Professional Trend Re-entry SystemThe Professional Trend Re-entry System is a high-precision momentum-trading tool designed to identify high-probability entries within established trends. Unlike standard lagging indicators, this system utilizes a 5-Point Multi-Data Consensus engine to verify trend health before issuing any signals. By combining the power of volatility-adjusted trend tracking with mean-reversion logic, it helps traders "buy the dip" in uptrends and "sell the rip" in downtrends with surgical timing.
Pine Script® indicator
by kandoikapish47
Phantom UltimatePhantom Ultimate: The Professional’s Head-Up Display (HUD) Headline: Clarity in a Chaotic Market. The Problem: Modern markets are noisy. Most indicators are fragmented—you have one script for trends, one for divergences, and another for support/resistance. Your chart becomes a mess of conflicting lines, and you spend more time managing indicators than trading price. The Solution: Phantom Ultimate isn't just an indicator; it is a complete trading operating system. It consolidates an entire institutional trading desk into a single, clean interface. It synthesizes Trend, Momentum, Volume, and Structure into one "Head-Up Display" so you can execute with precision. Why You Need It: Zero-Clutter "Smart-Line" Technology: Our dynamic engine keeps your chart pristine. Moving Averages and S&R lines only appear when price is interacting with them. If a line isn't relevant to the current price action, it vanishes. You trade what matters, not the noise. Institutional Price Action & Alerts: Phantom doesn't just draw lines; it watches them for you. It automatically detects and alerts on high-probability interactions across every level (MAs, Fibs, and Fractal S&R): Pin Bar Rejections: Catch "Perfect" rejections (Top 34% body rule) the moment a candle closes. Level Retests: Know immediately when a broken level is being tested as support. Zone Reclaims: Get alerted instantly when price reclaims a key level after a deviation. The Market HUD: A professional dashboard pinned to your chart. Instantly see the trend status, signal strength, and RSI conditions for the 1H, 4H, and Daily timeframes simultaneously. Never flip tabs again to check the trend. The "Wizard" Signal Engine: A composite algorithm that detects "Mega" entries by aligning Momentum (CCI), Trend (EMAs), and Volume (VFI). It doesn't guess; it calculates confluence. 🎁 Bonus: Full Discord Ecosystem Access Your license to Phantom Ultimate includes exclusive access to our Discord Community. Get real-time server-side alerts (powered by Phantom God Mode). Join a community of serious traders executing the same strategies. Never miss a setup, even when you are away from your charts. Upgrade your vision. Trade with Phantom Ultimate.
Pine Script® indicator
by PHANT0M
9-20 STRADDLE FOR INTRADAY TRADING9-20 STRADDLE FOR INTRADAY TRADING The 9–20 Straddle Strategy is a popular intraday options trading setup that focuses on capturing volatility after the market opens. In this strategy, traders place a straddle at 9:20 AM by buying or selling both ATM Call and Put options of the same strike and expiry. The objective is to benefit from strong directional moves or time decay, depending on execution style. Risk management is crucial, with predefined stop-loss and profit targets to control losses. This strategy works best on high-liquidity indices like Nifty and Bank Nifty, especially on volatile trading days.
Pine Script® indicator
by Latesh_Narula
A-A-M Dots + Failed Acceptance (Gold) [CLEAN v6]What this indicator does This indicator visualizes real market behavior using an Order Flow logic sequence: Absorption → Acceptance → Momentum (A-A-M) plus a critical Failed Acceptance condition (trap detection). It is designed specifically to help traders: Validate price movement quality Detect traps early Avoid false continuation signals This indicator does not predict price. It highlights what the market is doing right now based on volume behavior and price response. Core Concepts Explained 1️⃣ Absorption Appears when: Volume is high Price fails to move far Long wicks + small body This suggests large passive orders absorbing aggression. Absorption is often where moves start or fail — but never confirmation by itself. 2️⃣ Acceptance Occurs when price: Breaks above/below the absorption zone Closes and holds beyond that level Acceptance confirms the market is willing to trade at a new price. 3️⃣ Momentum Triggered when: Strong candle body Clear follow-through after acceptance Momentum confirms continuation strength, not entry timing. 4️⃣ Failed Acceptance (Trap) Appears when: Acceptance happens Price then returns back into the absorption zone This signals a trap: Failed bullish acceptance → potential downside Failed bearish acceptance → potential upside This is one of the most powerful reversal validations in order flow trading. How to Use This Indicator Use it as a confirmation tool, not a standalone entry signal Best combined with: Market structure Higher-timeframe bias Risk management rules Recommended for: Gold (XAUUSD / Gold Futures) Intraday & swing traders Traders who want context, not signals What This Indicator Is NOT ❌ Not a signal generator ❌ Not a prediction tool ❌ Not a shortcut to profits It is a market behavior validator. Final Note If you understand why price moves, you no longer need to chase where price might go.
Pine Script® indicator
by HafizSynergyFx
D1 High/LowThis indicator automatically plots the previous day’s high and low (D1) as thin dashed horizontal lines on the chart. The levels are calculated strictly from yesterday’s daily candle only. The lines are anchored directly at the previous day’s candle and extend to the right, matching institutional-style reference levels. Visible on Daily (D1) and all lower timeframes (H4, H1, M15, etc.). The lines reset at the start of each new trading day to reflect the latest completed session. Designed as a context and liquidity reference, not as a predictive indicator.
Pine Script® indicator
by bacle8899
CISD PRO MAX [Ultimate Edition]CISD PRO+ is an all-in-one trading toolkit designed for precision and efficiency. It combines the power of Smart Money Concepts (SMC) with a robust Tunnel Trend Filter to identify high-probability setups. Unlike standard indicators, this tool features a built-in Win Rate Statistics Engine, allowing you to see the historical performance of the strategy in real-time without manual backtesting. It provides everything you need—Trend, Entry, POI, Liquidity, and Stats—on a single chart. Key Features 1. CISD Entry System (Change in State of Delivery) Auto MSS Detection: Automatically detects Market Structure Shifts and structural breaks based on Swing Highs/Lows. Setup Identification: 🟩 Bullish: Triggers when price breaks above a key Swing High. 🟥 Bearish: Triggers when price breaks below a key Swing Low. Auto Trade Management: Draws Entry lines, Stop Loss, and Take Profit levels instantly based on your defined Risk:Reward ratio. FVG Visualization: Highlights Fair Value Gaps formed immediately after the structure break. 2. Tunnel Trend Filter (Confluence) Uses a dynamic EMA 34 High/Low Tunnel to filter out low-quality signals and counter-trend noise. Logic: Longs are only valid when Price is Above the Tunnel. Shorts are only valid when Price is Below the Tunnel. Result: Significantly improves the win rate by aligning with the dominant momentum. 3. Smart Supply & Demand (POI) Automatically plots Supply (Grey) and Demand (Blue) zones based on swing pivots. Auto-Cleanup: The indicator automatically removes invalid or broken zones to keep your chart clean and focused on fresh levels. 4. Liquidity Levels Displays critical liquidity levels where price often reverses or accelerates. Daily: Previous Day High (PDH) & Low (PDL). Weekly: Previous Week High (PWH) & Low (PWL). 5. Dual Dashboards Trend Dashboard: Multi-timeframe trend analysis (M15 to Weekly) combined with RSI status (OB/OS). Win Rate Stats: Real-time backtesting statistics based on your current settings. It shows Total Trades, Win Rate %, and Win/Loss count. How to Trade 📈 Bullish Setup (Buy) Ensure price is trading ABOVE the Orange Tunnel. Wait for a Green CISD Box (Structure Break to the upside). Enter at the close or wait for a retrace to the box/FVG. SL: Red dashed line | TP: Blue dashed line. 📉 Bearish Setup (Sell) Ensure price is trading BELOW the Orange Tunnel. Wait for a Red CISD Box (Structure Break to the downside). Enter at the close or wait for a retrace to the box/FVG. SL: Red dashed line | TP: Blue dashed line. Recommended Settings Pivot Lookback: 3 (Optimized for Scalping/Day Trading). Visual RR: 1.1.5 (Targets a 1:1.5 Risk-to-Reward ratio). Tunnel Filter: Enabled (Recommended for higher win rates). Backtest RR: Set this equal to your Visual RR to get accurate win rate statistics. ⚠️ Disclaimer: This tool is for educational purposes only. Past performance (Win Rate Stats) does not guarantee future results. Always practice proper risk management.
Pine Script® indicator
by DoNotFollowMeGod
AlphaScalp SNIPER FREEAlphaScalp SNIPER FREE is a precision scalping indicator designed to deliver clear, fast, and reliable entry signals with minimal noise. This FREE version uses a core sniper logic to capture strong momentum moves, making it ideal for traders who want a simple, effective, and easy-to-use scalping tool. Perfect for testing performance before upgrading to the Premium version. ✅ Key Features (FREE) Clear BUY & SELL signals directly on the chart 1 Take Profit (TP1) and Stop Loss (SL) automatically plotted Trend filter to reduce false signals Non-repaint (based on candle close) Lightweight & fast on all pairs and timeframes ⚠️ FREE Version Limitations ❌ No TP2 & TP3 ❌ No advanced sniper filters ❌ Standard win rate (safe, but not aggressive) ❌ No professional trading modes ⭐ Best For Learning sniper-style scalping Manual scalping entries Backtesting & replay testing Trying before upgrading to Premium 🚀 Upgrade to SNIPER PREMIUM The SNIPER PREMIUM version unlocks: Higher win rate with advanced filtering TP1 / TP2 / TP3 for scaling profits Stronger sniper confirmation logic Designed for serious and consistent traders FREE to learn. PREMIUM to trade with confidence.
Pine Script® indicator
by kaffahstorage