Get started

Indicators and strategies

Opening Price Signal (Text-Based)Overview: This simple yet powerful indicator quickly identifies the intraday trend direction by comparing the current price to the day’s opening price. How it Works: • Bullish Signal: Last price is at least +0.25 points above today’s open—suggests buying (Long). • Bearish Signal: Last price is at least -0.25 points below today’s open—suggests selling (Short). • Neutral: Price remains within ±0.25 points of today’s open—no trade recommended. What’s Displayed: • Open Price: Today’s opening price. • Last Price: Current trading price. • Signal: Difference between last price and today’s open. • Sentiment: Clearly labeled as Bullish, Bearish, or Neutral. • Action: Recommended trade direction (Long, Short, or None). Recommended Timeframes: • 5-Minute (ideal for precise intraday trading) • 15-Minute (balanced clarity and noise reduction) • 30-Minute (reduced noise, smoother signals) Ideal Usage: Perfect for day traders looking for a quick and clear gauge of intraday market sentiment. Use it to confirm momentum and trade confidently in the direction of the daily trend. Happy trading! 📈✨
Pine Script® indicator
by spystalker
Portfolio Monitor - DolphinTradeBot1️⃣ Overview ▪️This indicator unifies the value of all your investments—whether stocks, currencies, or cryptocurrencies—in your chosen currency. This tool not only provides a clear snapshot of your overall portfolio performance but also highlights the individual growth of each asset with intuitive visualizations and an easy-to-understand performance report. 2️⃣ What sets this indicator apart ▪️is its ability to convert values from various currency pairs into any currency you choose. This means you can monitor your portfolio's performance against any currency pair you prefer, offering a flexible and comprehensive view of your investments. 3️⃣ How Is It Work ?  🔍The indicator can be analyzed under two main categories: visual representations and   tables.   1- Visual representations ;   The indicator includes three different types of lines:     1. 1 - Reference Line  → This represents the cost of all assets we hold, based on the selected date.     1. 2 - Total Assets Line  → Displays the real-time value of all assets in our possession, including cash value, in the selected trading pair.     The area between the reference line is filled with green and red. The section above the reference line is represented in green, while the section below is shown in red.     1. 3 - Performance Lines  → These visualize the performance of the assets, starting from the reference line and taking into account their weights in the portfolio. (Note: The lines are scaled for visualization purposes, so their absolute values should not be considered.)    "The names of the lines are shown in the image below."⤵️   2- Tables   The indicator includes three different types of tables:    2. 1 - Analysis Table  : It provides a superficial overview of wallet statistics and values.   ▪️TOTAL ASSETS → The current equivalent of all assets in the target currency   ▪️CASH VALUE → The current value of the amount "Cash Value", in the target currency.   ▪️PORTFOLIO VALUE → The total value of assets excluding Cash, in the target currency.   ▪️POSTFOLIO COST → The cost of assets excluding Cash, in the target currency.   ▪️PORTFOLIO ABSOLUTE RETURN → It shows the profit or loss relative to the cost of assets   ▪️PORTFOLIO RETURN % →It shows the profit or loss relative to the cost of assets on a percentage basis       2. 2 - Performance Table  : It displays the names of assets excluding Cash and their profit amounts, sorted from highest to lowest profit. If "Show as Percentage" is selected in the settings, it shows the percentage profit or loss relative to the cost. Profits are represented in green, while losses are represented in red.    "You can see the visual showing the tables below"⤵️ 4️⃣How to Use ?   1- Choose the date on which the visualization will begin (📌The start date only affects the exchange rate used for calculating the reference line in the target currency.)   2- If you have cash holdings, enter the amount and specify the currency.   3- Select the currency in which your portfolio value will be displayed.(Default value is USD)   4- To set up your portfolio;     SYMBOLS     -       QUANTITY       -     PURCHASE PRICE Enter the symbols of your assets - the number of units you hold - and their cost levels.     5- If you have cash, be sure to include your cash balance. If you also hold other currencies,  enter them as separate assets with their corresponding quantities and purchase prices.   6- If you want to see the percentage returns of the assets in the performance table relative to their cost, select the "Show as Percent" option.   7- If you want to see the performance visuals of the assets, click on the "Show Asset Performance" option. You can find an image of the settings section where the numbers above are used as references below.⤵️    📌 NOTE → By default, a few assets and their values have been pre-added in the initial settings. This is to ensure that you don’t see an empty screen when adding the indicator to the chart. Please remember to enter your own assets and values. The default settings are only provided as an example.
Pine Script® indicator
by DolphinTradeBot
Fuerza relativa vs SP500This TradingView indicator analyzes the daily relative strength of a selected asset compared to the SP500, and provides both a visual histogram and a scoring system based on recent performance over the last 10 candles. ✅ Green: SP500 is down, but the asset is up (strong bullish signal). 🟧 Orange: SP500 is down, asset also down but performing better than the SP500 (mild strength). 🔴 Red: SP500 is down, and the asset performs even worse (clear weakness). 🟩 Light green: SP500 is up, and the asset performs better (moderate strength). 🟧 Light orange: SP500 is up, but the asset performs worse (mild weakness)
Pine Script® indicator
by er_pepe
ICT Order Blocks v2 (Debug)Josh has a very large PP xD Understanding Order Blocks (OBs) - The ICT Perspective This document delves into the concept of Order Blocks (OBs) from the perspective of the ICT methodology. It outlines what OBs are, their significance in trading, and how the "ICT Order Blocks v2 (Refined)" indicator functions to identify and visualize these critical price levels. By understanding OBs, traders can better navigate market movements and make informed decisions based on institutional trading behavior. What is an Order Block (OB)? Within ICT methodology, an Order Block represents a specific price candle where significant buying or selling interest from institutions (Smart Money) is believed to have occurred. They are potential areas where price might return and react. Bullish Order Block: Typically the last down-closing candle before a strong, impulsive upward move (displacement). It suggests institutions may have absorbed selling pressure and initiated long positions here. Bearish Order Block: Typically the last up-closing candle before a strong, impulsive downward move (displacement). It suggests institutions may have distributed long positions or initiated short positions here. Why are OBs Significant (ICT View)? Institutional Footprint: They mark potential zones of large order execution. Support/Resistance: Unmitigated OBs can act as sensitive price levels where reactions are expected. Bullish OBs may provide support; Bearish OBs may provide resistance. Origin of Moves: They often mark the origin point of significant price swings. Liquidity Engineering: Institutions might drive price back to OBs to mitigate earlier positions or to engineer liquidity before continuing a move. Common Refinements ICT often emphasizes higher probability OBs that are associated with: Displacement: The move away from the OB is sharp and decisive. Fair Value Gaps (FVGs): An FVG forming immediately after the OB strengthens its validity. OB Mitigation: This refers to price returning to the level of the Order Block after its formation. Price might react at the edge (proximal line) or the 50% level (mean threshold) of the OB. An OB is often considered fully mitigated or invalidated if price trades decisively through its entire range, especially with a candle body closing beyond it. How the "ICT Order Blocks v2 (Refined)" Indicator Works This indicator automates the detection and visualization of the most recent unmitigated Order Block of each type (Bullish/Bearish), incorporating optional filters. Detection: It looks at the relationship between the candle two bars ago ( ), the previous candle ( ), and potentially the current candle ( ). Bullish OB: Identifies if candle was a down-close (close < open ) AND candle broke above the high of candle (high > high ). Bearish OB: Identifies if candle was an up-close (close > open ) AND candle broke below the low of candle (low < low ). Accuracy Filters (Optional Inputs): These filters help identify potentially higher-probability OBs: Require Fair Value Gap (FVG)?: If enabled, the indicator checks if an FVG formed immediately after the OB candle ( ). Specifically, it looks for a gap between candle and candle (low > high for Bullish OB confirmation, high < low for Bearish). Require Strong Close Breakout?: If enabled, it requires the breakout candle ( ) to close beyond the range of the OB candle ( ). (close > high for Bullish, close < low for Bearish). This suggests stronger confirmation. Storing the Most Recent OB: When an OB is detected and passes any enabled filters, its details (high, low, formation bar index) are stored. Crucially, this indicator only tracks the single most recent valid unmitigated OB of each type (one Bullish, one Bearish) using var variables. If a newer valid OB forms, it replaces the previously stored one. Drawing Boxes: If a valid Bullish OB is being tracked (and Show Bullish OBs is enabled), it draws a box (box.new) using the high and low of the identified OB candle ( ). The same process applies to Bearish OBs (Show Bearish OBs enabled). The boxes automatically extend to the right (extend.right) and their right edge is updated on each new bar (box.set_right) until they are mitigated. Labels ("Bull OB" / "Bear OB") are displayed inside the boxes. Mitigation & Box Deletion: The indicator checks if the current closing price (close ) has moved entirely beyond the range of the tracked OB. Mitigation Rule Used: A Bullish OB is considered mitigated if close < bull_ob_low. A Bearish OB is considered mitigated if close > bear_ob_high. Once an OB is marked as mitigated, the indicator stops tracking it and its corresponding box is automatically deleted (box.delete) from the chart. This indicator provides a dynamic visualization of the most recent, potentially significant Order Blocks that meet the specified criteria, helping traders identify key areas of interest based on ICT principles.
Pine Script® indicator
by joshuaburton096
BTC SCALPERS By Anup## *BTC Scalper by Anup – Precision Trading for BTC Scalpers* 🔹 *BTC Scalper by Anup* is a high-accuracy scalping indicator designed specifically for Bitcoin traders. This tool combines multiple confirmations to ensure precise entry and exit points, reducing false signals and improving profitability. ### *🚀 Key Features:* ✅ *EMA Crossover Strategy* – Uses * TWO EMA* to identify trend reversals. ✅ *ATR Volatility Filter* – Ensures trades are executed only in high-volatility conditions. ✅ *RSI Confirmation* – Prevents overbought/oversold entries by confirming trend strength. ✅ *Stochastic Momentum Check* – Filters weak signals and confirms valid trade setups. ✅ *Buy & Sell Signals By arrow* – Clearly marked entries and exits for easy decision-making. ### *📈 How It Works:* 📌 *BUY Signal* – When the *EMA to EMA crosses up*, ATR confirms volatility, RSI is above 50, and Stochastic shows momentum. 📌 *SELL Signal* – When the *EMA to ema crosses down*, ATR confirms volatility, RSI is below 50, and Stochastic indicates bearish momentum. 🚀 Perfect for *scalpers and day traders* looking for *fast & reliable trade signals* on BTC only! 📍 *Timeframe Recommendation:* Best suited for *M5 to M15 charts* for short-term trades. 🔔 *Try BTC Scalper by Anup and take your BTC trading to the next level!*
Pine Script® indicator
by anup2
BTC SCALPERS By Anup## *BTC Scalper by Anup – Precision Trading for BTC Scalpers* 🔹 *BTC Scalper by Anup* is a high-accuracy scalping indicator designed specifically for Bitcoin traders. This tool combines multiple confirmations to ensure precise entry and exit points, reducing false signals and improving profitability. ### *🚀 Key Features:* ✅ *EMA Crossover Strategy* – Uses EMA to identify trend reversals. ✅ *ATR Volatility Filter* – Ensures trades are executed only in high-volatility conditions. ✅ *RSI Confirmation* – Prevents overbought/oversold entries by confirming trend strength. ✅ *Stochastic Momentum Check* – Filters weak signals and confirms valid trade setups. ✅ *Buy & Sell Signals* – Clearly marked entries and exits for easy decision-making. ### *📈 How It Works:* 📌 *BUY Signal* – When the EMA crosses above , ATR confirms volatility, RSI is above 50, and Stochastic shows momentum. 📌 *SELL Signal* – When the EMA crosses below , ATR confirms volatility, RSI is below 50, and Stochastic indicates bearish momentum. 🚀 Perfect for *scalpers and day traders* looking for *fast & reliable trade signals* on BTC ONLY! 📍 *Timeframe Recommendation:* Best suited for *M5 to M15 charts* for short-term trades. 🔔 *Try BTC Scalper by Anup and take your BTC trading to the next level!*
Pine Script® indicator
by anup2
Malama's Candle SniperMalama's Candle Sniper - Indicator Description Purpose "Malama's Candle Sniper" is a powerful TradingView indicator designed to help traders identify key candlestick patterns that signal potential reversals or continuations in price action. Whether you're looking to catch the start of a bullish uptrend or spot a bearish downturn before it happens, this tool simplifies the process by automatically detecting and labeling a wide range of classic candlestick formations. It solves a common problem for traders: the time-consuming task of manually scanning charts for reliable patterns, making it easier to focus on decision-making and strategy execution. How It Works The indicator uses predefined logic to analyze candlestick data—open, high, low, and close prices—across multiple bars to detect specific patterns. It’s split into two categories: bullish patterns (e.g., Bullish Engulfing, Morning Star, Hammer) that suggest upward momentum, and bearish patterns (e.g., Bearish Engulfing, Three Black Crows, Hanging Man) that hint at downward pressure. Each pattern is coded with conditions based on price relationships, such as the size of candle bodies, wicks, or gaps between bars. When a pattern forms, the indicator places a clear label directly on your chart, color-coded green for bullish and red for bearish, so you can spot opportunities at a glance. The script ensures accuracy by only triggering a label when a pattern transitions from "not present" to "detected," avoiding clutter from repetitive signals. This focus on precision makes it a reliable companion for timing entries and exits. How to Use It Adding to TradingView: Open TradingView, click "Indicators" at the top, search for "Malama's Candle Sniper," and add it to your chart. Since it’s an overlay indicator, it works directly on your price candles without cluttering a separate panel. Configuring Settings: There are no adjustable inputs by default, making it beginner-friendly—just apply it and start trading! For pros, you can dive into the script to tweak pattern definitions (e.g., adjusting wick-to-body ratios) if you prefer custom sensitivity. Interpreting Signals: Look for green labels above candles for bullish setups—these suggest potential buying opportunities. Red labels below candles indicate bearish setups, signaling possible sell or short positions. Pair these signals with your existing strategy, like support/resistance levels or trend direction, for confirmation. Beginner Tip: Start with a daily or 4-hour chart to practice spotting patterns in less noisy conditions before moving to shorter timeframes. Pro Tip: Combine with volume analysis or a trend indicator (like a moving average) to filter out weaker signals and boost reliability. Originality What makes "Malama's Candle Sniper" stand out is its comprehensive coverage and user-friendly design. While many indicators focus on just one or two candlestick patterns, this script packs over 20 patterns—both bullish and bearish—into a single tool, from common ones like the Hammer to rarer setups like the Abandoned Baby or Three Line Strike. The clean, color-coded labeling system also sets it apart, offering instant visual clarity without overwhelming your chart. Unlike generic pattern scanners, it’s built to minimize false positives by only highlighting newly formed patterns, giving traders a sharper edge in fast-moving markets. Whether you’re a newbie learning the ropes or a seasoned trader refining your edge, this indicator delivers a unique blend of simplicity, depth, and precision.
Pine Script® indicator
by makenlegacy
ATRs in Days📌 ATR in Days This script tracks how price moves in relation to ATR over multiple days, providing a powerful volatility framework for traders. 🔹 Key Features: ✅ 4 ATRs in 5 Days – Measures if a stock has moved 4x its ATR within the last 5 days, identifying extreme volatility zones. ✅ Daily ATR Calculation – Tracks average true range over time to gauge market conditions. ✅ Clear Table Display – Real-time ATR readings for quick decision-making. ✅ Intraday & Swing Trading Compatible – Works across multiple timeframes for day traders & swing traders. 📊 How to Use: Look for stocks that exceed 4 ATRs in 5 days to spot extended moves. Use ATR as a reversion or continuation signal depending on market structure. 🚀 Perfect for traders looking to quantify volatility & structure trades effectively!
Pine Script® indicator
by Yanni_Nicolaides
Rainbow EMA Areas [Hypersonic]This indicator provides a nice visual representation of 6 EMA lines on your chart without adding to the clutter of other indicating lines. The starting values are 1, 9, 21, 55, 100, and 200. By default, the lines are hidden but they can be turned on in the Settings section. You can change the colors but not the gradient/transparency. There's nothing else to this indicator other than being a different visual representation of 6 EMA lines.
Pine Script® indicator
by Hypersonic_0
CPR BEAST with Previous Day High/Low, SMA, EMA, VWAP by MRS*Indicator Name: **CPR BEAST with EMAs, VWAP & Previous Day High/Low by Rajasekhar Muvvala** Description: This powerful indicator combines **Central Pivot Range (CPR)**, **Daily/Weekly/Monthly Pivot Points**, **Moving Averages (SMA, EMA, 200-Day EMA)**, **Volume Weighted Average Price (VWAP)**, and **Previous Day High/Low** into a single, easy-to-use tool for traders. It is designed to help traders identify key support and resistance levels, trends, and potential reversal zones across multiple timeframes. Key Features: 1. Central Pivot Range (CPR): - CPR is calculated based on daily pivot points and includes three lines: "Central Pivot (CP)", "Bottom Central Pivot (BC)", and "Top Central Pivot (TC)". - Enabled by default but can be toggled off from the settings. - Customizable colors for all three lines. 2. Daily Pivot Points: - Includes **Support (S1, S2, S3)** and **Resistance (R1, R2, R3)** levels. - Levels 1 and 2 (S1/R1, S2/R2) are enabled by default, while Level 3 (S3/R3) can be optionally displayed. - Resistance lines are red, and Support lines are green by default (colors customizable). 3. Weekly and Monthly Pivot Points: - Weekly and Monthly pivots include **Pivot**, **Support (S1, S2, S3)**, and **Resistance (R1, R2, R3)** levels. - Weekly levels are displayed as crossed (`+`) lines, while Monthly levels are displayed as circled (`o`) lines for better visual distinction. - All weekly and monthly levels are optional and can be toggled on/off. 4. Moving Averages: - Includes **Simple Moving Average (SMA)**, **Exponential Moving Average (EMA)**, and **200-Day EMA**. - Customizable lengths and colors for each moving average. - Helps identify trends and potential entry/exit points. 5. Volume Weighted Average Price (VWAP): - Displays VWAP for intraday trading. - Can be toggled on/off and customized for color. 6. Previous Day High/Low: - Highlights the "Previous Day High" and "Previous Day Low" on the chart. - Useful for identifying breakout or reversal zones. - Customizable colors for both high and low levels. 7. Visibility Settings: - All pivot points, CPR, VWAP, and previous day high/low are "hidden on daily and above timeframes" by default. - Ensures the indicator is optimized for intraday trading. 8. Customization Options: - Toggle visibility of CPR, pivot points, moving averages, VWAP, and previous day high/low. - Customize colors, lengths, and styles for all elements. - Adjust input sources for calculations (e.g., close, open, etc.). --- How to Use: Intraday Trading: Use the CPR and daily pivot points to identify key support and resistance levels. Combine these with VWAP and moving averages to confirm trends and find potential entry/exit points. Swing Trading: Use weekly and monthly pivot points to identify longer-term support and resistance zones. Breakout Trading: Monitor the previous day's high and low for potential breakout opportunities. Trend Analysis: Use the moving averages (SMA, EMA, 200-Day EMA) to identify the overall trend direction. --- Default Settings: - **CPR**: Enabled by default (Central Pivot line cannot be disabled). - **Daily Pivot Points**: Levels 1 and 2 (S1/R1, S2/R2) are enabled by default. - **Weekly/Monthly Pivot Points**: Disabled by default (can be enabled from settings). - **Moving Averages**: SMA (20), EMA (21), and 200-Day EMA are enabled by default. - **VWAP**: Enabled by default. - **Previous Day High/Low**: Enabled by default. --- Customization Options: - **CPR**: - Enable/Disable CPR lines. - Customize colors for CP, BC, and TC lines. - **Pivot Points**: - Enable/Disable daily, weekly, and monthly pivot points. - Customize colors for support and resistance levels. - **Moving Averages**: - Adjust lengths for SMA, EMA, and 200-Day EMA. - Customize colors for each moving average. - **VWAP**: - Enable/Disable VWAP. - Customize color. - **Previous Day High/Low**: - Enable/Disable previous day high/low. - Customize colors for high and low levels. --- Best Practices: 1. **Combine Indicators**: Use CPR and pivot points in conjunction with moving averages and VWAP to confirm trends and identify high-probability trading setups. 2. **Timeframe Optimization**: The indicator is designed for intraday trading, so it hides unnecessary elements on daily and above timeframes. 3. **Color Coding**: Customize colors to match your chart theme and improve readability. 4. **Backtesting**: Test the indicator on historical data to understand how it behaves in different market conditions. --- Disclaimer: This indicator is intended for educational and informational purposes only. It does not provide financial advice or guarantee profits. Always conduct your own research and consult with a professional before making trading decisions.
Pine Script® indicator
by mrsekhar
PunkAlgo Oscillator [1.0]//@version=5 indicator(title='PunkAlgo Oscillator ', shorttitle='Punk Oscillator') n1 = input(4, 'Channel Length') n2 = input(15, 'Average Length') obLevel1 = input(88, 'Over Bought Level 1') obLevel2 = input(81, 'Over Bought Level 2') osLevel1 = input(-83, 'Over Sold Level 1') osLevel2 = input(-76, 'Over Sold Level 2') ap = hlc3 esa = ta.ema(ap, n1) d = ta.ema(math.abs(ap - esa), n1) ci = (ap - esa) / (0.015 * d) tci = ta.ema(ci, n2) wt1 = tci wt2 = ta.sma(wt1, 4) var indbot=0 var indtop=0 if wt1 > wt2 and wt1 < wt2 indbot := bar_index if wt1 < wt2 and wt1 > wt2 indtop := bar_index bott = bar_index - indbot topp = bar_index - indtop // Histogram lookbackPeriod = input(35, "Lookback Period") // Calculate the percentage change in price for each bar priceChange = close - close priceChangePercentage = priceChange / close * 100 // Calculate the average volume over the lookback period averageVolume = ta.ema(volume, lookbackPeriod) // Initialize the counters for upward and downward trends upwardTrends = 0 downwardTrends = 0 // Iterate over the lookback period and count the number of upward and downward trends for i = 1 to lookbackPeriod if priceChangePercentage > 0 upwardTrends := upwardTrends + 1 else if priceChangePercentage < 0 downwardTrends := downwardTrends + 1 // Calculate the probabilities of upward, downward, and neutral trends totalTrends = upwardTrends + downwardTrends probabilityUpward = math.round(upwardTrends / totalTrends, 2) * 100 probabilityDownward = math.round(downwardTrends / totalTrends, 2) * 100 // Determine the probability trend based on the probabilities probabilityTrend = "" if probabilityUpward > probabilityDownward probabilityTrend := "Upward" else if probabilityUpward < probabilityDownward probabilityTrend := "Downward" // Calculate the oscillator value based on the difference between upward and downward trends oscillatorValue = probabilityUpward - probabilityDownward // Determine the histogram color based on the difference between the oscillator value and zero line histogramColor = oscillatorValue >= 0 ? (oscillatorValue < oscillatorValue ? color.new(#089981, 50) : color.new(#089981, 50)) : (oscillatorValue < oscillatorValue ? color.new(#f23645, 50) : color.new(#f23645, 50)) // Smoothning the Histogram smooth_hist = input.bool(true, "Smoothen Histogram", inline="smooth_hist") smoothning_scale = input.int(defval=3, title="", minval=1, maxval=10, step=1, inline="smooth_hist") smooth_len = smoothning_scale * 2 smooth_hist_val = smooth_hist ? ta.ema(oscillatorValue, smooth_len) : oscillatorValue // Plot the histogram plot(smooth_hist_val, color=histogramColor, style=plot.style_area, linewidth=1, title="Probability Histogram") // Histogram plot(0, color=color.new(#787b86, 100)) top1 = plot(obLevel1, color=color.new(#4caf4f, 100)) top2 = plot(osLevel1, color=color.new(#ff5252, 100)) bottom1 = plot(obLevel2, color=color.new(#4caf4f, 100)) bottom2 = plot(osLevel2, color=color.new(#ff5252, 100)) fill(plot1=top1, plot2=bottom1, color=wt2 > 0 and (wt1 - wt2) > 0 ? #089981 : wt2 > 0 or (wt1 - wt2) > 0 ?color.new(#363a45, 60) : color.new(#363a45, 70)) fill(plot1=top2, plot2=bottom2, color=wt2 < 0 and (wt1 - wt2) < 0 ? #f23645 : wt2 < 0 or (wt1 - wt2) < 0 ? color.new(#363a45, 60) : color.new(#363a45, 70)) plot1 = plot(wt1, color=wt1 > wt2 ? color.new(color.green, 0) : color.gray ,title="Signal") plot2 = plot(wt2, color=color.new(#ff5252, 100),title="Signal Dots") fill(plot1=plot1, plot2=plot2, color=wt1 > wt2 ? color.rgb(8, 153, 129, 80) : color.rgb(120, 123, 134, 80),title="Signal Shadow") plot(ta.cross(wt1, wt2) ? wt2 : na, color=color.new(color.black, 0), style=plot.style_circles, linewidth=3,title="Dot Shadows") plot(ta.cross(wt1, wt2) ? wt2 : na, color=wt2 - wt1 > 0 ? color.gray : color.green , style=plot.style_circles, linewidth=2) // Divergences Module tsi1 = wt1 tsi2 = ta.sma(wt2, 4) long = n1 short = n2 signal22 = n2 price = hlc3 src2 = hlc3 src = hlc3 input_src = tsi1 // Divergences Options up = ta.rma(math.max(ta.change(src), 0), short) down = ta.rma(-math.min(ta.change(src), 0), short) lbR = input(title='Divergence Pivot Lookback Right', defval=1) lbL = input(title='Divergence Pivot Lookback Left', defval=5) rangeUpper = input(title='Max of Lookback Range', defval=100) rangeLower = input(title='Min of Lookback Range', defval=2) plotBull = input(title='Plot Bullish', defval=true) plotHiddenBull = input(title='Plot Hidden Bullish', defval=false) plotBear = input(title='Plot Bearish', defval=true) plotHiddenBear = input(title='Plot Hidden Bearish', defval=false) bearColor = color.new(#f23645, 10) bullColor = color.new(#2157f3, 10) hiddenBullColor = color.new(color.aqua, 0) hiddenBearColor = color.new(color.orange, 0) textColor = color.new(color.white, 0) noneColor = color.new(color.white, 100) osc = tsi1 plFound = na(ta.pivotlow(osc, lbL, lbR)) ? false : true phFound = na(ta.pivothigh(osc, lbL, lbR)) ? false : true _inRange(cond) => bars = ta.barssince(cond == true) rangeLower <= bars and bars <= rangeUpper //------------------------------------------------------------------------------ // Regular Bullish // Osc: Higher Low oscHL = osc > ta.valuewhen(plFound, osc , 1) and _inRange(plFound ) // Price: Lower Low priceLL = low < ta.valuewhen(plFound, low , 1) bullCond = plotBull and priceLL and oscHL and plFound plot(plFound ? osc : na, offset=-lbR, title='Regular Bullish', linewidth=1, color=bullCond ? bullColor : noneColor, transp=0) //------------------------------------------------------------------------------ // Hidden Bullish // Osc: Lower Low oscLL = osc < ta.valuewhen(plFound, osc , 1) and _inRange(plFound ) // Price: Higher Low priceHL = low > ta.valuewhen(plFound, low , 1) hiddenBullCond = plotHiddenBull and priceHL and oscLL and plFound plot(plFound ? osc : na, offset=-lbR, title='Hidden Bullish', linewidth=1, color=hiddenBullCond ? hiddenBullColor : noneColor, transp=0) //------------------------------------------------------------------------------ // Regular Bearish // Osc: Lower High oscLH = osc < ta.valuewhen(phFound, osc , 1) and _inRange(phFound ) // Price: Higher High priceHH = high > ta.valuewhen(phFound, high , 1) bearCond = plotBear and priceHH and oscLH and phFound plot(phFound ? osc : na, offset=-lbR, title='Regular Bearish', linewidth=1, color=bearCond ? bearColor : noneColor, transp=0) //------------------------------------------------------------------------------ // Hidden Bearish // Osc: Higher High oscHH = osc > ta.valuewhen(phFound, osc , 1) and _inRange(phFound ) // Price: Lower High priceLH = high < ta.valuewhen(phFound, high , 1) hiddenBearCond = plotHiddenBear and priceLH and oscHH and phFound plot(phFound ? osc : na, offset=-lbR, title='Hidden Bearish', linewidth=1, color=hiddenBearCond ? hiddenBearColor : noneColor, transp=0) // Signals Module string TT_HARSI = 'Period for the RSI calculations used to generate the' + 'candles. This seperate from the RSI plot/histogram length.' string TT_PBIAS = 'Smoothing feature for the OPEN of the HARSI candles.' + ' Increases bias toward the prior open value which can' + ' help provide better visualisation of trend strength.' + ' ** By changing the Open values, High and Low can also' + ' be distorted - however Close will remain unchanged.' string TT_SMRSI = 'This option smoothes the RSI in a manner similar to HA' + ' open, but uses the realtime rsi rather than the prior' + ' close value.' string TT_STOCH = 'Uses the RSI generated by the above settings, and as such' + ' will be affected by the smoothing option.' string TT_STFIT = 'Adjusts the vertical scaling of the stochastic, can help' + ' to prevent distortion of other data in the channel.' + ' Has no impact cross conditions.' //////////////////////////////////////////////////////////////////////////////// // // // ====== INPUTS ====== // // // //////////////////////////////////////////////////////////////////////////////// // -- Candle config string GROUP_CAND = 'Config » HARSI Candles' i_lenHARSI = input.int(10, 'Length', group=GROUP_CAND, minval=1, tooltip=TT_HARSI) i_smoothing = input.int(5, 'Open Smoothing', group=GROUP_CAND, minval=1, maxval=100, tooltip=TT_PBIAS) string INLINE_COL = 'Colour Pallette' i_colUp = input.color(color.teal, 'Colour Pallette  ', group=GROUP_CAND, inline=INLINE_COL) i_colDown = input.color(color.red, ' ', group=GROUP_CAND, inline=INLINE_COL) i_colWick = input.color(color.gray, ' ', group=GROUP_CAND, inline=INLINE_COL) // -- RSI plot config string GROUP_PLOT = 'Config » RSI Plot' i_source = input.source(ohlc4, 'Source', group=GROUP_PLOT) i_lenRSI = input.int(7, 'Length', group=GROUP_PLOT, minval=1) i_mode = input.bool(true, 'Smoothed Mode RSI?', group=GROUP_PLOT, tooltip=TT_SMRSI) i_showPlot = input.bool(true, 'Show RSI Plot?', group=GROUP_PLOT) i_showHist = input.bool(true, 'Show RSI Histogram?', group=GROUP_PLOT) // -- Channel OB/OS config string GROUP_CHAN = 'Config » OB/OS Boundaries' i_upper = input.int(50, 'OB', group=GROUP_CHAN, inline='OB', minval=1, maxval=50) i_upperx = input.int(30, 'OB Extreme', group=GROUP_CHAN, inline='OB', minval=1, maxval=50) i_lower = input.int(-50, 'OS', group=GROUP_CHAN, inline='OS', minval=-50, maxval=-1) i_lowerx = input.int(-30, 'OS Extreme', group=GROUP_CHAN, inline='OS', minval=-50, maxval=-1) // Settins // WaveTrend wwttShow = input(false, title='Show WaveTrend') wwttBuyShow = input(true, title='Show Buy dots') wwttGoldShow = input(true, title='Show Gold dots') wwttSellShow = input(true, title='Show Sell dots') wwttDivShow = input(true, title='Show Div. dots') vwapShow = input(true, title='Show Fast wwtt') wwttChannelLen = input(9, title='wwtt Channel Length') wwttAverageLen = input(12, title='wwtt Average Length') wwttMASource = input(hlc3, title='wwtt MA Source') wwttMALen = input(3, title='wwtt MA Length') // WaveTrend Overbought & Oversold lines OOBBLevel = input(53, title='wwtt Overbought Level 1') OOBBLevel2 = input(60, title='wwtt Overbought Level 2') OOBBLevel3 = input(100, title='wwtt Overbought Level 3') oosLevel = input(-53, title='wwtt Oversold Level 1') oosLevel2 = input(-60, title='wwtt Oversold Level 2') oosLevel3 = input(-75, title='wwtt Oversold Level 3') // Divergence wwtt wwttShowDiv = input(true, title='Show wwtt Regular Divergences') wwttShowHiddenDiv = input(false, title='Show wwtt Hidden Divergences') showHiddenDiv_nl = input(true, title='Not apply OB/OS Limits on Hidden Divergences') wwttDivOOBBLevel = input(45, title='wwtt Bearish Divergence min') wwttDivoosLevel = input(-65, title='wwtt Bullish Divergence min') // Divergence extra range wwttDivOOBBLevel_addshow = input(true, title='Show 2nd wwtt Regular Divergences') wwttDivOOBBLevel_add = input(15, title='wwtt 2nd Bearish Divergence') wwttDivoosLevel_add = input(-40, title='wwtt 2nd Bullish Divergence 15 min') // RSI+MFI rsiMFIShow = input(true, title='Show MFI') rsiMFIperiod = input(60, title='MFI Period') rsiMFIMultiplier = input.float(150, title='MFI Area multiplier') rsiMFIPosY = input(2.5, title='MFI Area Y Pos') // RSI rsiShow = input(false, title='Show RSI') rsiSRC = input(close, title='RSI Source') rsiLen = input(14, title='RSI Length') rsiOversold = input.int(30, title='RSI Oversold', minval=29, maxval=100) rsiOverbought = input.int(60, title='RSI Overbought', minval=0, maxval=60) // Divergence RSI rsiShowDiv = input(false, title='Show RSI Regular Divergences') rsiShowHiddenDiv = input(false, title='Show RSI Hidden Divergences') rsiDivOOBBLevel = input(60, title='RSI Bearish Divergence min') rsiDivoosLevel = input(30, title='RSI Bullish Divergence min') // Colors colorRed = #ff0000 colorPurple = #e600e6 colorGreen = #3fff00 colorOrange = #e2a400 colorYellow = #ffe500 colorWhite = #ffffff colorPink = #ff00f0 colorBluelight = #31c0ff colorwwtt1 = #49536195 colorwwtt2 = #7b9fd596 colorwwtt2_ = #131722 colormacdwwtt1a = #4caf58 colormacdwwtt1b = #af4c4c colormacdwwtt1c = #7ee57e colormacdwwtt1d = #ff3535 colormacdwwtt2a = #305630 colormacdwwtt2b = #310101 colormacdwwtt2c = #132213 colormacdwwtt2d = #770000 //////////////////////////////////////////////////////////////////////////////// // // // ====== FUNCTIONS ====== // // // //////////////////////////////////////////////////////////////////////////////// // FUNCTIONS // zero median rsi helper function, just subtracts 50. f_zrsi(_source, _length) => ta.rsi(_source, _length) - 50 // zero median stoch helper function, subtracts 50 and includes % scaling f_zstoch(_source, _length, _smooth, _scale) => float _zstoch = ta.stoch(_source, _source, _source, _length) - 50 float _smoothed = ta.sma(_zstoch, _smooth) float _scaled = _smoothed / 100 * _scale _scaled // mode selectable rsi function for standard, or smoothed output f_rsi(_source, _length, _mode) => // get base rsi float _zrsi = f_zrsi(_source, _length) // smoothing in a manner similar to HA open, but rather using the realtime // rsi in place of the prior close value. var float _smoothed = na _smoothed := na(_smoothed ) ? _zrsi : (_smoothed + _zrsi) / 2 // return the requested mode _mode ? _smoothed : _zrsi // RSI Heikin-Ashi generation function f_rsiHeikinAshi(_length) => // get close rsi float _closeRSI = f_zrsi(close, _length) // emulate "open" simply by taking the previous close rsi value float _openRSI = nz(_closeRSI , _closeRSI) // the high and low are tricky, because unlike "high" and "low" by // themselves, the RSI results can overlap each other. So first we just go // ahead and get the raw results for high and low, and then.. float _highRSI_raw = f_zrsi(high, _length) float _lowRSI_raw = f_zrsi(low, _length) // ..make sure we use the highest for high, and lowest for low float _highRSI = math.max(_highRSI_raw, _lowRSI_raw) float _lowRSI = math.min(_highRSI_raw, _lowRSI_raw) // ha calculation for close float _close = (_openRSI + _highRSI + _lowRSI + _closeRSI) / 4 // ha calculation for open, standard, and smoothed/lagged var float _open = na _open := na(_open ) ? (_openRSI + _closeRSI) / 2 : (_open * i_smoothing + _close ) / (i_smoothing + 1) // ha high and low min-max selections float _high = math.max(_highRSI, math.max(_open, _close)) float _low = math.min(_lowRSI, math.min(_open, _close)) // return the OHLC values // Divergences f_top_fractal(src) => src < src and src < src and src > src and src > src f_bot_fractal(src) => src > src and src > src and src < src and src < src f_fractalize(src) => f_top_fractal(src) ? 1 : f_bot_fractal(src) ? -1 : 0 f_findDivs(src, topLimit, botLimit, useLimits) => fractalTop = f_fractalize(src) > 0 and (useLimits ? src >= topLimit : true) ? src : na fractalBot = f_fractalize(src) < 0 and (useLimits ? src <= botLimit : true) ? src : na highPrev = ta.valuewhen(fractalTop, src , 0) highPrice = ta.valuewhen(fractalTop, high , 0) lowPrev = ta.valuewhen(fractalBot, src , 0) lowPrice = ta.valuewhen(fractalBot, low , 0) bearSignal = fractalTop and high > highPrice and src < highPrev bullSignal = fractalBot and low < lowPrice and src > lowPrev bearDivHidden = fractalTop and high < highPrice and src > highPrev bullDivHidden = fractalBot and low > lowPrice and src < lowPrev // RSI+MFI f_rsimfi(_period, _multiplier, _tf) => request.security(syminfo.tickerid, _tf, ta.sma((close - open) / (high - low) * _multiplier, _period) - rsiMFIPosY) // WaveTrend f_wavetrend(src, chlen, avg, malen, tf) => tfsrc = request.security(syminfo.tickerid, tf, src) esa = ta.ema(tfsrc, chlen) de = ta.ema(math.abs(tfsrc - esa), chlen) ci = (tfsrc - esa) / (0.015 * de) wwtt1 = request.security(syminfo.tickerid, tf, ta.ema(ci, avg)) wwtt2 = request.security(syminfo.tickerid, tf, ta.sma(wwtt1, malen)) wwttVwap = wwtt1 - wwtt2 wwttOversold = wwtt2 <= oosLevel wwttOverbought = wwtt2 >= OOBBLevel wwttCross = ta.cross(wwtt1, wwtt2) wwttCrossUp = wwtt2 - wwtt1 <= 0 wwttCrossDown = wwtt2 - wwtt1 >= 0 wwttCrosslast = ta.cross(wwtt1 , wwtt2 ) wwttCrossUplast = wwtt2 - wwtt1 <= 0 wwttCrossDownlast = wwtt2 - wwtt1 >= 0 // MACD f_macd(src, fastlen, slowlen, sigsmooth, tf) => fast_ma = request.security(syminfo.tickerid, tf, ta.ema(src, fastlen)) slow_ma = request.security(syminfo.tickerid, tf, ta.ema(src, slowlen)) macd = fast_ma - slow_ma signal = request.security(syminfo.tickerid, tf, ta.sma(macd, sigsmooth)) hist = macd - signal // Get higher timeframe candle f_getTFCandle(_tf) => _open = request.security(ticker.heikinashi(syminfo.tickerid), _tf, open, barmerge.gaps_off, barmerge.lookahead_on) _close = request.security(ticker.heikinashi(syminfo.tickerid), _tf, close, barmerge.gaps_off, barmerge.lookahead_on) _high = request.security(ticker.heikinashi(syminfo.tickerid), _tf, high, barmerge.gaps_off, barmerge.lookahead_on) _low = request.security(ticker.heikinashi(syminfo.tickerid), _tf, low, barmerge.gaps_off, barmerge.lookahead_on) hl2 = (_high + _low) / 2.0 newBar = ta.change(_open) candleBodyDir = _close > _open //////////////////////////////////////////////////////////////////////////////// // // // ====== SERIES, LINES and LABELS ====== // // // //////////////////////////////////////////////////////////////////////////////// // CALCULATE INDICATORS { // RSI rsi = ta.rsi(rsiSRC, rsiLen) rsiColor = rsi <= rsiOversold ? colorGreen : rsi >= rsiOverbought ? colorRed : colorPurple // Calculates WaveTrend = f_wavetrend(wwttMASource, wwttChannelLen, wwttAverageLen, wwttMALen, timeframe.period) // wwtt Divergences = f_findDivs(wwtt2, wwttDivOOBBLevel, wwttDivoosLevel, true) = f_findDivs(wwtt2, wwttDivOOBBLevel_add, wwttDivoosLevel_add, true) = f_findDivs(wwtt2, 0, 0, false) wwttBearDivHidden_ = showHiddenDiv_nl ? wwttBearDivHidden_nl : wwttBearDivHidden wwttBullDivHidden_ = showHiddenDiv_nl ? wwttBullDivHidden_nl : wwttBullDivHidden wwttBearDivColor = wwttShowDiv and wwttBearDiv or wwttShowHiddenDiv and wwttBearDivHidden_ ? colorRed : na wwttBullDivColor = wwttShowDiv and wwttBullDiv or wwttShowHiddenDiv and wwttBullDivHidden_ ? colorGreen : na wwttBearDivColor_add = wwttShowDiv and wwttDivOOBBLevel_addshow and wwttBearDiv_add or wwttShowHiddenDiv and wwttDivOOBBLevel_addshow and wwttBearDivHidden_add ? #9a0202 : na wwttBullDivColor_add = wwttShowDiv and wwttDivOOBBLevel_addshow and wwttBullDiv_add or wwttShowHiddenDiv and wwttDivOOBBLevel_addshow and wwttBullDivHidden_add ? #1b5e20 : na // RSI Divergences = f_findDivs(rsi, rsiDivOOBBLevel, rsiDivoosLevel, true) = f_findDivs(rsi, 0, 0, false) rsiBearDivHidden_ = showHiddenDiv_nl ? rsiBearDivHidden_nl : rsiBearDivHidden rsiBullDivHidden_ = showHiddenDiv_nl ? rsiBullDivHidden_nl : rsiBullDivHidden rsiBearDivColor = rsiShowDiv and rsiBearDiv or rsiShowHiddenDiv and rsiBearDivHidden_ ? colorRed : na rsiBullDivColor = rsiShowDiv and rsiBullDiv or rsiShowHiddenDiv and rsiBullDivHidden_ ? colorGreen : na // Buy signal. buySignal = wwttCross and wwttCrossUp and wwttOversold buySignalDiv = wwttShowDiv and wwttBullDiv or wwttShowDiv and wwttBullDiv_add or rsiShowDiv and rsiBullDiv buySignalDiv_color = wwttBullDiv ? colorGreen : wwttBullDiv_add ? color.new(colorGreen, 60) : rsiShowDiv ? colorGreen : na // Sell signal sellSignal = wwttCross and wwttCrossDown and wwttOverbought sellSignalDiv = wwttShowDiv and wwttBearDiv or wwttShowDiv and wwttBearDiv_add or rsiShowDiv and rsiBearDiv sellSignalDiv_color = wwttBearDiv ? colorRed : wwttBearDiv_add ? color.new(colorRed, 60) : rsiBearDiv ? colorRed : na // standard, or ha smoothed rsi for the line plot and/or histogram float RSI = f_rsi(i_source, i_lenRSI, i_mode) // get OHLC values to use in the plotcandle() = f_rsiHeikinAshi(i_lenHARSI) // shadow, invisible color colShadow = color.rgb(0, 0, 0, 100) color colNone = color.rgb(0, 0, 0, 100) // rsi color //color colRSI = RSI >=30 ? color.red : color.gray color colRSI = RSI < -31 ? color.lime : RSI > 31 ? color.red : color.gray cross_up = RSI > 30 cross_down = RSI < -30 // candle body colouring color bodyColour = C > O ? i_colUp : i_colDown color wickColour = i_colWick //////////////////////////////////////////////////////////////////////////////// // // // ====== DRAWING and PLOTTING ====== // // // //////////////////////////////////////////////////////////////////////////////// plotchar(cross_down and wwttBuyShow and buySignal ? -107 : na, title='Buy circle', char='·', color=color.new(colorGreen, 10), location=location.absolute, size=size.small) plotchar(cross_up and wwttSellShow and sellSignal ? 105 : na, title='Sell circle', char='·', color=color.new(colorRed, 10), location=location.absolute, size=size.small) plotchar(cross_down and wwttDivShow and buySignalDiv and wwttBuyShow and buySignal ? -106 : na, title='Divergence buy circle', char='▲', color=buySignalDiv_color, location=location.absolute, size=size.tiny, offset=-2, transp=10) plotchar(cross_up and wwttDivShow and sellSignalDiv and wwttSellShow and sellSignal ? 106 : na, title='Divergence sell circle', char='▼', color=sellSignalDiv_color, location=location.absolute, size=size.tiny, offset=-2, transp=10) //Alerts alertcondition((cross_down and wwttBuyShow and buySignal and wwttDivShow and buySignalDiv) or (cross_up and wwttSellShow and sellSignal and wwttDivShow and sellSignalDiv), title='Buy/Sell Signal', message='Buy/Sell Signal')
Pine Script® indicator
by slvkmr82
OG Candlestick Pattern Finder [Ultimate Edition]🕵️‍♂️ OG Candlestick Pattern Finder By @OG_Wealth This powerful Pine Script v5 indicator is designed to help traders visually identify high-probability candlestick patterns and chart formations on any timeframe. 🔍 What It Detects: ✅ Classic Candlestick Patterns Bullish/Bearish Engulfing Hammer / Shooting Star Morning Star / Evening Star Doji 3 White Soldiers / 3 Black Crows ✅ Chart Formations Falling Wedge / Rising Wedge Bullish & Bearish Flag Cup & Handle (simplified) 🎯 Features: Clean, color-coded arrow labels with pattern names Small arrows avoid clutter and highlight candles without overlapping Lightweight performance with real-time detection Subtle trendlines for chart formations using thin, semi-transparent overlays Built fully in Pine Script v5 Works across all assets and timeframes Note: This script is for educational and informational purposes only. It does not constitute financial advice or a recommendation to buy or sell any asset. 📌 Want to enhance it with toggles, alerts, or volume filters? Follow me and stay tuned for updates. If you find it helpful, leave a like ❤️ and drop a comment to support future tools!
Pine Script® indicator
by OG_Wealth
Cyclical Momentum Pivots V2Cyclical Momentum Pivots V2 /b] Overview Welcome to Cyclical Momentum Pivots V2—a next-generation momentum indicator engineered to surpass traditional tools like MACD and standard cRSI with its dynamic adaptability and cutting-edge cycle analysis. Optimized for volatile assets like XRP on a 2-hour (2H) timeframe, this indicator leverages advanced Hurst cycle integration and a dual-signal system (intent and confirmation) to pinpoint momentum shifts with unparalleled accuracy. Below, we’ll explore its operation using a 2H XRP chart as a live example, showcasing why it’s a game-changer for crypto trading and beyond. Key Features & Benefits a) Dynamic Nature for Superior Accuracy Unlike static indicators like MACD or traditional cRSI, Cyclical Momentum Pivots V2 dynamically adjusts its cycle length based on real-time price action. On a 2H XRP chart, the dominant cycle length (domCycle) adapts between 10 and 30 bars, reflecting XRP’s rapid momentum shifts. This fluidity ensures signals align with the market’s current rhythm—far more precise than MACD’s fixed periods or cRSI’s rigid lookbacks. b) Hurst Cycles for Enhanced Precision The indicator incorporates Hurst exponent analysis, a powerful tool for identifying cyclical patterns in price data. On XRP 2H, Hurst cycles refine momentum signals by filtering noise, ensuring trend changes—like those in early March 2025—align with underlying market rhythms. This precision catches reversals that simpler indicators miss, giving traders a deeper edge. c) Intent and Confirmation Signals Explained The dual-signal system is a standout feature: Intent Signals: Appear instantly at crossover points as early warnings. On XRP 2H, a solid turquoise upward marker (#82D5F6) below the bar signals a potential low band crossover (bullish), while a solid yellow downward marker (#FFFF00) above flags a high band crossover (bearish). For example, on March 19th, 2025, a yellow intent signal hinted at a top-band crossunder. Confirmation Signals: Follow one bar later if cRSI moves >3%, locking in the trend. Larger solid turquoise or yellow markers confirm the move—see March 25th, 2025, where a confirmed yellow signal validated a bearish shift. Additionally, 50% band crossovers (mid-range pivots) use semi-transparent markers (55% transparency) for nuanced momentum insights. d) Cycle Changes as Bear/Bull Indicators Cycle length shifts (domCycle) reveal market regimes. On XRP 2H, an increase (green circle with white number below the bar) signals lengthening cycles, often tied to bullish consolidation—check the buildup before March’s rally. A decrease (red circle above) indicates shortening cycles, typical of bearish exhaustion—visible post-March 25th downturn. These shifts guide your bias in real time. e) Multiple Signals in Close Proximity When signals cluster, they amplify confidence. On XRP 2H around mid-March 2025, a flurry of intent signals, confirmed crossovers, and a domCycle decrease within a few bars screamed bearish momentum—confirmed by XRP’s drop. This convergence, paired with whale-driven pumps (dark green flags) or dumps (dark red flags), is your cue to trust the trend. f) Crypto-Optimized Design with Multi-Asset Flexibility Built for cryptocurrencies like XRP, the indicator thrives in high-volatility environments. Its default settings are tuned for 2H crypto charts, balancing responsiveness and stability. However, it adapts to stocks, forex, and commodities via customizable inputs—see the table below for tailored values. Input Values for Different Timeframes (Crypto-Optimized) www.dropbox.com Customizing Inputs for Asset Classes The Inputs tab offers flexibility: Use Auto Dominant Cycle Length: Default true for crypto’s dynamic cycles (e.g., XRP). Set to false and adjust Manual Dominant Cycle Length (e.g., 50) for slower assets like stocks. Cycle Smoothing EMA Period: Default 3 for XRP’s volatility—try 5-7 for smoother markets like forex. Volume/Price Thresholds: Base Volume Threshold (2.0) and Base Price Change % Threshold (1.5) suit XRP 2H. Increase for high-volume assets (e.g., BTC) or decrease for low-volatility (e.g., forex). Use Volume Weighted Candles: Default true—prompts a switch to VWC for optimal XRP 2H results. Toggle off if volume data is sparse (e.g., forex line charts). How to Use on XRP 2H Apply the Indicator: Add Cyclical Momentum Pivots V2 to your 2H XRP chart. Watch Intent Signals: Turquoise upward markers (bullish) or yellow downward markers (bearish) offer early heads-ups. Confirm with Larger Signals: Solid markers one bar later validate momentum—key on March 19th/25th, 2025. Track Cycle Changes: Green (bullish lengthening) or red (bearish shortening) circles signal regime shifts. Combine Signals: Clusters near whale flags (dark green/dark red) confirm XRP’s direction. Adjust Inputs: Fine-tune for XRP or adapt for other assets. Why It Beats MACD & cRSI On XRP 2H, MACD lags with fixed EMAs, missing rapid swings, while standard cRSI lacks cycle depth. Cyclical Momentum Pivots V2 adapts dynamically, integrates Hurst cycles, and delivers intent/confirmation precision—offering actionable insights where others falter.
Pine Script® indicator
by albertmay
ADR Nivele Horizontale dhe EMAThe user provided a Pine Script code for an indicator called "ADR Nivele Horizontale dhe EMA". The task is to explain how this code works. Hmm, first, I need to understand what this indicator does. The title mentions ADR levels and EMA, so it's probably combining horizontal lines based on Average Daily Range and some Exponential Moving Averages. Looking at the code, the first part is the indicator declaration with version 6. The settings include an ADR period, levels above and below the mid, and line style. Then there's a section for calculations. They request daily high and low to compute the daily range. The ADR is the SMA of the daily range over the specified period. The mid is the average of daily high and low. The adr_val is half of ADR, maybe to create symmetrical levels around the mid. Next, they create arrays for lines and labels above and below the mid. The loops go from 1 to levels_above/below, calculate each level, draw lines and labels. The mid line is also drawn with a different color. Then, there are several EMAs plotted: 13, 50, 200, 400, 600, 800, each with different colorsWait, but in Pine Script, when you use arrays to store lines and labels, you have to manage them properly to avoid repainting or memory issues. The code uses array.concat to add new lines and labels each bar. However, since this code is running on each bar, the for loops might be creating multiple lines each time, leading to too many objects. Oh right, but they use var to initialize the arrays, so they are only initialized once. Wait, no. The var keyword initializes the variable once, but in each iteration, they are concatenating new lines. Wait, no: the for loops are inside the main script, which runs on each bar. So every time a new bar is processed, the loops will run again, adding new lines and labels. That's a problem because each bar would create new lines, leading to an ever-increasing number of lines, which could hit the maximum limit (max_lines_count is set to 20, but maybe they have more bars). Oh, the indicator has max_lines_count=20, but the code might be creating multiple lines per bar. So maybe the code isn't handling the line management correctly. For example, if levels_above is 2, then each bar would create 2 new lines above and 2 below, plus the mid line. Over 20 bars, that's way over 20 lines. So this could cause the indicator to stop drawing after 20 lines. The user might not have realized that the lines are being recreated every bar, leading to a buildup. But perhaps the original code intended to have the lines update each bar, extending to the current bar. Let's see: in line.new, they use bar_index as the starting x1 and bar_index as x2. So each line is drawn from the previous bar's index to the current one. But since this is done on every bar, each line is only one bar long. Wait, no. Because on each new bar, the code creates a new line from the previous bar's index (bar_index , which is now the bar before the current one) to the current bar_index. So each line is just a segment from the previous bar to the current bar. But when the next bar comes, a new line is created again. So the result is that each level line is a series of one-bar-length segments, which might not be intended. The user probably wants continuous lines that extend from the left to the right, not just per bar. So this approach is incorrect. The correct way would be to have a line that starts at the first bar of the calculation and extends to the right, updating each bar. But the current code creates a new line each bar, leading to multiple short lines instead of one continuous line. That's a mistake. So the main issue here is that the code is generating a new line segment for each bar, which is not efficient and would quickly hit the line limit. To fix this, instead of creating a new line every bar, they should create the line once and then update its position each bar. But in Pine Script, you can't directly update a line after it's created; instead, you need to track the line ID and use line.set_xy() to extend it. However, the current code uses array.concat to add new lines each bar, which isn't the right approach. Therefore, the code as written will create multiple short lines instead of continuous horizontal lines. The correct approach for horizontal levels that extend to the right is to create the line once, starting at a certain bar and extending indefinitely, or to update the line's end point each new bar. But in Pine Script, you can't extend lines infinitely; you have to manage them each bar. Alternatively, using the 'line.extend' style might help, but I think the original code's logic is flawed here. Additionally, the EMA part is straightforward: plotting multiple EMAs with different periods. That part should work as expected. So the explanation should mention that the ADR levels are calculated based on the daily high and low, then the code attempts to draw horizontal lines above and below the mid-point. However, the way the lines are drawn may lead to multiple short segments instead of continuous lines, potentially causing performance issues or hitting the maximum line count. The EMAs are plotted correctly with various periods..
Pine Script® indicator
by AldiPlaku