Şimdi başlat

Göstergeler ve stratejiler

EMA 8 x EMA 80 Indicator Trend Filter for the 123 PatternEMA 8 x EMA 80 Indicator Trend Filter for the 123 Pattern This indicator displays two Exponential Moving Averages EMA with 8 and 80 periods, designed to assist in trend identification and to act as a filter for trading the 123 buy and sell pattern. General usage rules 123 Buy: recommended only when trading in an uptrend 123 Sell: recommended only when trading in a downtrend Moving average filter Buy setups 123 Buy tend to be more reliable when price is above the 80 period EMA Sell setups 123 Sell tend to be more reliable when price is below the 8 period EMA Neutral zone attention The area between the EMA 8 and EMA 80 is considered a neutral zone Trading the 123 pattern within this range is riskier, as it often indicates consolidation or lack of clear trend direction Important disclaimer This indicator does not generate buy or sell signals by itself. It should be used as a supporting tool, together with proper risk management, market context, and additional analysis. This is not financial advice.
Pine Script® göstergesi
artur_bonaf tarafından
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
Pine Script® göstergesi
rajesswarrav tarafından
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® göstergesi
billy10384 tarafından
XAUUSD Lot Size Calculator1. What This Indicator Does This tool is a Visual Risk Management System. Instead of using a calculator on your phone or switching tabs, it allows you to calculate the exact lot size for your trade directly on the TradingView chart by dragging lines. It automates the math for: Lot Size: How big your position should be to risk exactly X% of your account. Take Profit: Where your target should be based on your Risk-to-Reward ratio. Safety Checks: It warns you if your stop loss is too tight for the minimum lot size (0.01). 2. Visual Features 🔴 The Red Line (Stop Loss): This is your interactive line. You can grab it with your mouse and drag it to your desired invalidation point (e.g., below a support wick). 🟢 The Green Line (Take Profit): This line moves automatically. You cannot drag it. It calculates where your Take Profit must be to satisfy your Risk:Reward ratio (Default 1:1) based on where you placed the Red line. ⚫ The Info Table: A high-contrast black box in the corner that displays your calculated Lot Size, Risk amount, and Trade direction (Long/Short). 3. How to Use It (Step-by-Step) Step 1: Initial Setup When you first add the indicator to the chart, you need to tell it about your account: Double-click the Black Table (or the Red Line) to open Settings. Inputs Tab: Account Balance: Enter your current trading balance (e.g., 10,000). Risk %: Enter how much you want to lose per trade (e.g., 1.0%). Contract Size: Keep this at 100 for Gold (XAUUSD) or standard Forex pairs. Risk : Reward Ratio: Set your target (e.g., 1.0 for 1:1, or 2.0 for 1:2). Step 2: Planning a Trade Look at the chart and identify where you want to enter (current price) and where you want your Stop Loss. Find the Red Line on your chart. (If you don't see it, go to Settings and change "Stop Loss Level" to a price near the current candle). Click and Drag the Red Line to your specific Stop Loss price. Step 3: Reading the Signals Direction: If you drag the Red Line below the price, the table shows LONG. If you drag it above, it shows SHORT. Lot Size: Read the big green number in the table (e.g., 0.55). This is the exact lot size you should enter in your broker. TP Target: Look at the Green Line on the chart. That is your exit price. Step 4: The "Orange Warning" If you place your Stop Loss very close to the entry, or if your account is small, the math might suggest a lot size smaller than is possible (e.g., 0.004). The table text will turn ORANGE. The Lot Size will stick to 0.01 (the minimum). The "Risk ($)" row will show you the actual risk. (Example: Instead of risking your desired $100, you might be forced to risk $105 because you can't trade smaller than 0.01 lots).
Pine Script® göstergesi
Zeeshan_Miran tarafından
Professional Price Action AnalysisProfessional Price Action Analysis - Advanced S/R & Pattern Detection A comprehensive technical analysis tool combining dynamic support/resistance zones, candlestick pattern recognition, trend analysis, and volume insights. KEY FEATURES: ✓ Dynamic Support & Resistance Zones - Automatically identifies swing highs/lows - Classifies levels based on current price position - Support zones display BELOW price (green) - Resistance zones display ABOVE price (red) - Adjustable zone thickness and lookback period ✓ Candlestick Pattern Detection - Bullish/Bearish Engulfing patterns - Pin bars (reversal signals) - Inside bars (consolidation) - Rejection candles (wick analysis) - Visual markers on chart with labels ✓ Trend Analysis - Customizable moving average (default 50-period SMA) - Background color zones for trend direction - Price vs MA percentage calculation - Bullish/Bearish/Neutral classification ✓ Volume Analysis - Volume spike detection (configurable multiplier) - Highlights unusual volume with bar colors - Helps identify institutional activity ✓ Information Dashboard - Clean, readable display (top-right corner) - Current trend status - Distance to nearest support/resistance - Volume status (High/Normal) - Price deviation from moving average ✓ Alert System - Alerts for all candlestick patterns - Volume spike notifications - Customizable alert conditions CUSTOMIZABLE INPUTS: • Swing detection length (3-50 bars) • S/R lookback period (20-200 bars) • Zone thickness percentage • Maximum zones displayed • Trend MA length • Volume spike multiplier • Toggle individual pattern types BEST FOR: - Swing traders identifying key levels - Day traders spotting reversal patterns - Price action enthusiasts - Multi-timeframe analysis This indicator does not repaint. All signals are confirmed after candle close. Suitable for all markets: stocks, forex, crypto, commodities. Educational tool for technical analysis. Not financial advice.
Pine Script® göstergesi
D4V3YZ tarafından
1
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® göstergesi
afiqnajid994 tarafından
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.
Pine Script® göstergesi
FXWMarkets tarafından
Adaptive RSI [BOSWaves]Adaptive RSI - Percentile-Based Momentum Detection with Dynamic Regime Thresholds Overview Adaptive RSI is a self-calibrating momentum oscillator that identifies overbought and oversold conditions through historical percentile analysis, constructing dynamic threshold boundaries that adjust to evolving market volatility and momentum characteristics. Instead of relying on traditional fixed RSI levels (30/70 or 20/80) or static overbought/oversold zones, regime detection, threshold placement, and signal generation are determined through rolling percentile calculation, smoothed momentum measurement, and divergence pattern recognition. This creates adaptive boundaries that reflect actual momentum distribution rather than arbitrary fixed levels - tightening during low-volatility consolidation periods, widening during trending environments, and incorporating divergence analysis to reveal momentum exhaustion or continuation patterns. Momentum is therefore evaluated relative to its own historical context rather than universal fixed thresholds. Conceptual Framework Adaptive RSI is founded on the principle that meaningful momentum extremes emerge relative to recent price behavior rather than at predetermined numerical levels. Traditional RSI implementations identify overbought and oversold conditions using fixed thresholds that remain constant regardless of market regime, often generating premature signals in strong trends or missing reversals in range-bound markets. This framework replaces static threshold logic with percentile-driven adaptive boundaries informed by actual momentum distribution. Three core principles guide the design: Threshold placement should correspond to historical momentum percentiles, not fixed numerical levels. Regime detection must adapt to current market volatility and momentum characteristics. Divergence patterns reveal momentum exhaustion before price reversal becomes visible. This shifts oscillator analysis from universal fixed levels into adaptive, context-aware regime boundaries. Theoretical Foundation The indicator combines smoothed RSI calculation, rolling percentile tracking, adaptive threshold construction, and multi-pattern divergence detection. A Hull Moving Average (HMA) pre-smooths the price source to reduce noise before RSI computation, which then undergoes optional post-smoothing using configurable moving average types. Confirmed oscillator values populate a rolling historical buffer used for percentile calculation, establishing upper and lower thresholds that adapt to recent momentum distribution. Regime state persists until the oscillator crosses the opposing threshold, preventing whipsaw during consolidation. Pivot detection identifies swing highs and lows in both price and oscillator values, enabling regular divergence pattern recognition through comparative analysis. Five internal systems operate in tandem: Smoothed Momentum Engine : Computes HMA-preprocessed RSI with optional post-smoothing using multiple MA methodologies (SMA, EMA, HMA, WMA, DEMA, RMA, LINREG, TEMA). Historical Buffer Management : Maintains a rolling array of confirmed oscillator values for percentile calculation with configurable lookback depth. Percentile Threshold Calculation : Determines upper and lower boundaries by extracting specified percentile values from sorted historical distribution. Persistent Regime Detection : Establishes bullish/bearish/neutral states based on threshold crossings with state persistence between signals. Divergence Pattern Recognition : Identifies regular bullish and bearish divergences through synchronized pivot analysis of price and oscillator values with configurable range filtering. This design allows momentum interpretation to adapt to market conditions rather than reacting mechanically to universal thresholds. How It Works Adaptive RSI evaluates momentum through a sequence of self-calibrating processes: Source Pre-Smoothing: Input price undergoes 4-period HMA smoothing to reduce bar-to-bar noise before oscillator calculation. RSI Calculation: Standard RSI computation applied to smoothed source over configurable length period. Optional Post-Smoothing: Raw RSI value undergoes additional smoothing using selected MA type and length for cleaner regime detection. Historical Buffer Population: Confirmed oscillator values accumulate in a rolling array with size limit determined by adaptive lookback parameter. Percentile Threshold Extraction: Array sorts on each bar to calculate upper percentile (bullish threshold) and lower percentile (bearish threshold) values. Regime State Persistence: Bullish regime activates when oscillator crosses above upper threshold, bearish regime activates when crossing below lower threshold, neutral regime persists until directional threshold breach. Pivot Identification: Swing highs and lows detected in both oscillator and price using configurable left/right parameters. Divergence Pattern Matching: Compares pivot relationships between price and oscillator within min/max bar distance constraints to identify regular bullish (price LL, oscillator HL) and bearish (price HH, oscillator LH) divergences. Together, these elements form a continuously updating momentum framework anchored in statistical context. Interpretation Adaptive RSI should be interpreted as context-aware momentum boundaries: Bullish Regime (Blue): Activated when oscillator crosses above upper percentile threshold, indicating momentum strength relative to recent distribution favors upside continuation. Bearish Regime (Red): Established when oscillator crosses below lower percentile threshold, identifying momentum weakness relative to recent distribution favors downside continuation. Upper Threshold Line (Blue)**: Dynamic resistance level calculated from upper percentile of historical oscillator distribution - adapts higher during trending markets, lower during ranging conditions. Lower Threshold Line (Red): Dynamic support level calculated from lower percentile of historical oscillator distribution - adapts lower during downtrends, higher during consolidation. Regime Fill: Gradient coloring between oscillator and baseline (50) visualizes current momentum intensity - stronger color indicates greater distance from neutral. Extreme Bands (15/85): Upper and lower extreme zones with strength-modulated transparency reveal momentum extremity - darker shading during powerful moves, lighter during moderate momentum. Divergence Lines: Connect price and oscillator pivots when divergence pattern detected, appearing on both price chart and oscillator pane for confluence identification. Reversal Markers (✦): Diamond signals appear at 80+ (bearish extreme) and sub-15 (bullish extreme) levels, marking potential exhaustion zones independent of regime state. Percentile context, divergence confirmation, and regime persistence outweigh isolated oscillator readings. Signal Logic & Visual Cues Adaptive RSI presents four primary interaction signals: Regime Switch - Long : Oscillator crosses above upper percentile threshold after previously being in bearish or neutral regime, suggesting momentum strength shift favoring bullish continuation. Regime Switch - Short : Oscillator crosses below lower percentile threshold after previously being in bullish or neutral regime, indicating momentum weakness shift favoring bearish continuation. Regular Bullish Divergence (𝐁𝐮𝐥𝐥) : Price forms lower low while oscillator forms higher low, revealing positive momentum divergence during downtrends - often precedes reversal or consolidation. Regular Bearish Divergence (𝐁𝐞𝐚𝐫) : Price forms higher high while oscillator forms lower high, revealing negative momentum divergence during uptrends - often precedes reversal or correction. Alert generation covers regime switches, threshold crossings, and divergence detection for systematic monitoring. Strategy Integration Adaptive RSI fits within momentum-informed and mean-reversion trading approaches: Adaptive Regime Following : Use threshold crossings as primary trend inception signals where momentum confirms directional breakouts within statistical context. Divergence-Based Reversals : Enter counter-trend positions when divergence patterns appear at extreme oscillator levels (above 80 or below 20) for high-probability mean-reversion setups. Threshold-Aware Scaling : Recognize that tighter percentile spreads (e.g., 45/50) generate more signals suitable for ranging markets, while wider spreads (e.g., 30/70) filter for stronger trend confirmation. Extreme Zone Confluence : Combine reversal markers (✦) with divergence signals for maximum-conviction exhaustion entries. Multi-Timeframe Regime Alignment : Apply higher-timeframe regime context to filter lower-timeframe entries, taking only setups aligned with dominant momentum direction. Smoothing Optimization : Increase smoothing length in choppy markets to reduce false signals, decrease in trending markets for faster response. Technical Implementation Details Core Engine : HMA-preprocessed RSI with configurable smoothing (SMA, HMA, EMA, WMA, DEMA, RMA, LINREG, TEMA) Adaptive Model : Rolling percentile calculation over confirmed oscillator values with size-limited historical buffer Threshold Construction : Linear interpolation percentile extraction from sorted distribution array Regime Detection : State-persistent threshold crossing logic with confirmed bar validation Divergence Engine : Pivot-based pattern matching with range filtering and duplicate prevention Visualization : Gradient-filled regime zones, adaptive threshold lines, strength-modulated extreme bands, dual-pane divergence lines Performance Profile : Optimized for real-time execution with efficient array management and minimal computational overhead Optimal Application Parameters Timeframe Guidance: 1 - 5 min : Micro-structure momentum detection for scalping and intraday reversals 15 - 60 min : Intraday regime identification with divergence-validated turning points 4H - Daily : Swing and position-level momentum analysis with macro divergence context Suggested Baseline Configuration: RSI Length : 18 Source : Close Smooth Oscillator : Enabled Smoothing Length : 20 Smoothing Type : SMA Adaptive Lookback : 1000 Upper Percentile : 50 Lower Percentile : 45 Divergence Pivot Left : 15 Divergence Pivot Right : 15 Min Pivot Distance : 5 Max Pivot Distance : 60 These suggested parameters should be used as a baseline; their effectiveness depends on the asset's volatility profile, momentum characteristics, and preferred signal frequency, so fine-tuning is expected for optimal performance. Parameter Calibration Notes Use the following adjustments to refine behavior without altering the core logic: Too many whipsaw signals : Widen percentile spread (e.g., 40/60 instead of 45/50) to demand stronger momentum confirmation, or increase "Smoothing Length" to filter noise. Missing legitimate regime changes : Tighten percentile spread (e.g., 48/52 instead of 45/50) for earlier detection, or decrease "Smoothing Length" for faster response. Oscillator too choppy : Increase "Smoothing Length" for cleaner readings, or switch "Smoothing Type" to RMA/TEMA for heavier smoothing. Thresholds not adapting properly : Reduce "Adaptive Lookback" to emphasize recent behavior (500-800 bars), or increase it for more stable thresholds (1500-2000 bars). Too many divergence signals : Increase "Pivot Left/Right" values to demand stronger swing confirmation, or widen "Min Pivot Distance" to space out detections. Missing significant divergences : Decrease "Pivot Left/Right" for faster pivot detection, or increase "Max Pivot Distance" to compare more distant swings. Prefer different momentum sensitivity : Adjust "RSI Length" - lower values (10-14) for aggressive response, higher values (21-28) for smoother trend confirmation. Divergences appearing too late : Reduce "Pivot Right" parameter to detect divergences closer to current price action. Adjustments should be incremental and evaluated across multiple session types rather than isolated market conditions. Performance Characteristics High Effectiveness: Markets with mean-reverting characteristics and consistent momentum cycles Instruments where momentum extremes reliably precede reversals or consolidations Ranging environments where percentile-based thresholds adapt to volatility contraction Divergence-driven strategies targeting momentum exhaustion before price confirmation Reduced Effectiveness: Extremely strong trending markets where oscillator remains persistently extreme Low-liquidity environments with erratic momentum readings News-driven or gapped markets where momentum disconnects from price temporarily Markets with regime shifts faster than adaptive lookback can recalibrate Integration Guidelines Confluence : Combine with BOSWaves structure, volume analysis, or traditional support/resistance Threshold Respect : Trust signals that occur after clean threshold crossings with sustained momentum Divergence Context : Prioritize divergences appearing at extreme oscillator levels (80+/15-) over those in neutral zones Regime Awareness : Consider whether current market regime matches historical momentum patterns used for calibration Multi-Pattern Confirmation : Seek divergence patterns coinciding with reversal markers or threshold rejections for maximum conviction Disclaimer Adaptive RSI is a professional-grade momentum and divergence analysis tool. It uses percentile-based threshold calculation that adapts to recent market behavior but cannot predict future regime shifts or guarantee reversal timing. Results depend on market conditions, parameter selection, lookback period appropriateness, and disciplined execution. BOSWaves recommends deploying this indicator within a broader analytical framework that incorporates price structure, volume context, and comprehensive risk management.
Pine Script® göstergesi
BOSWaves tarafından
1
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.
Pine Script® göstergesi
neeson1987 tarafından
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.
Pine Script® göstergesi
mrossi71 tarafından
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.
Pine Script® göstergesi
FXWMarkets tarafından
Daily Support/Resistance Points (Historical Days)indicator plots support and resistance levels derived from historical price action. It analyzes higher‑timeframe candles (Daily/Weekly/Monthly) and ranks levels by strength and number of touches, then draws the most relevant levels around the current price. If no strong levels are found, it falls back to touch‑based levels so you still get meaningful lines. How to Use: Add the script to any chart. Choose Levels Timeframe: Auto (recommended): follows the chart timeframe (D/W/M). D / W / M: force a specific timeframe. Set lookback windows: Lookback Days (D) – default 200 Lookback Weeks (W) – default 104 Lookback Months (M) – default 60 Adjust sensitivity: Min Strength – filters weaker levels. Volume Multiplier – requires higher volume for stronger levels. Time Decay – gives more weight to recent data. Min Touches (Fallback) – used when no strong levels are found. Optional: enable Show Debug Info to see how many levels are detected. Open Source & License: This script is open source under the MIT License. You are свободно to use, modify, and share it with attribution. Author / Contact: Ron Belson For questions or requests, contact: ronbelson@gmail.com
Pine Script® göstergesi
ronibelson tarafından
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.
Pine Script® göstergesi
gpanjwani1979 tarafından
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.
Pine Script® göstergesi
AlgoKings_Official tarafından
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.
Pine Script® göstergesi
AlgoKings_Official tarafından
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® göstergesi
a_jabbaroff tarafından
Smart Money Trap Radar ProSmart Money Trap Radar Pro is a market context and behavior classification indicator designed to distinguish between: Liquidity-driven stop hunts (false breakouts / traps) Genuine price acceptance driven by professional participation. This script does not generate buy or sell signals. Instead, it classifies each candle into one of three states: TRAP – liquidity taken but value rejected EXECUTION – price accepted after volatility & volume confirmation NEUTRAL – no professional activity detected The goal is to help traders avoid entering during manipulation and focus only on periods where price shows structural commitment. How the indicator works (core logic) The script combines three independent market dimensions into a single state engine: 1. Liquidity Displacement Detection The script identifies potential stop-hunts by detecting: breaks above recent swing highs or breaks below recent swing lows followed by failure to hold those levels on the same candle. This detects situations where price moves to collect orders but does not sustain acceptance. Logic used: Highest / lowest price over a configurable lookback window Immediate rejection via candle close This produces the TRAP state. 2. Value Acceptance Engine (volatility-normalized) To avoid random noise, execution is confirmed only when price: remains within a volatility-adjusted acceptance band (ATR based) shows above-average participation (volume OR strong real-body expansion) demonstrates directional stability This prevents labeling small candles or low-liquidity movement as professional activity. This produces the EXECUTION state. 3. Trend Context Filter A dual EMA structure (20 / 50) is used only as a context filter, not as a signal generator. Execution states are allowed only when: price aligns with short-term structural direction This avoids classifying counter-trend noise as professional execution. How the components interact The indicator operates as a finite state engine: 1.First checks for liquidity sweep → possible TRAP 2.If no trap exists, checks for value acceptance conditions 3.Applies trend alignment as a soft filter 4.Outputs one of three states per candle: TRAP EXECUTION NEUTRAL This interaction is what makes the script different from simply plotting multiple indicators. Dashboard interpretation The dashboard summarizes: •Trading Mode (affects volatility & liquidity sensitivity) •Risk Profile (affects acceptance thresholds) •Market State (Trap / Execution / Neutral) •Liquidity condition •Professional bias These values are derived from the same state engine and are not separate indicators. How to use Recommended usage: •Avoid opening new trades during TRAP states •Focus on trade planning during EXECUTION states •Remain inactive during NEUTRAL periods Best used with: •market structure •higher timeframe bias •your own entry model What this script is NOT •Not a buy/sell signal generator •Not a scalping system •Not a strategy or automated trading system •Not a repainting indicator Limitations •Uses historical swing levels for liquidity detection •ATR-based normalization may lag during sudden volatility regime changes •Works best on liquid instruments (indices, FX majors, large-cap stocks) Intended audience Discretionary traders who: •use price action •study market structure •want to filter manipulation vs participation Disclaimer •This indicator is provided for educational and informational purposes only. •It does not constitute financial advice, investment recommendations, or trade signals. The script does not provide 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 local regulations.
Pine Script® göstergesi
gpanjwani1979 tarafından