Candle Momentum ExhaustionCandle Momentum Exhaustion
The Candle Momentum Exhaustion indicator is designed to help traders spot potential turning points in a trend by identifying when the prevailing momentum may be “running on empty.” The indicator works by comparing the size of each candle’s body (the absolute difference between the open and close) to the average body size over a recent period. When a candle’s body exceeds a user‐defined multiple of this average, it is flagged as an “exhaustion” candle.
• A bullish exhaustion (shown with a red down–facing triangle above the bar) occurs when a very large bullish candle (close > open) is detected, suggesting that buyers may have pushed the price too far and the rally could be near its end.
• A bearish exhaustion (shown with a green up–facing triangle below the bar) occurs when a very large bearish candle (close < open) is detected, implying that selling pressure might be overdone.
These signals can alert you to a potential reversal or consolidation point. The script also includes alert conditions so that you can set up notifications whenever an exhaustion signal is generated.
How It Works
1. Average Candle Body:
The script computes a simple moving average (SMA) of the absolute candle bodies over a user-defined period (default is 14 bars).
2. Exhaustion Candidate:
A candle is flagged as an exhaustion candidate if its body size exceeds the average by more than the set multiplier (default is 2.0).
3. Signal Identification:
• If the exhaustion candle is bullish (close > open), it is marked with a red down–facing triangle above the bar.
• If it is bearish (close < open), it is marked with a green up–facing triangle below the bar.
4. Alerts:
The built-in alertcondition() calls allow you to set alerts (via TradingView’s alert system) so that you can be notified when an exhaustion event occurs.
Risk Disclaimer:
This indicator is provided for educational and informational purposes only and does not constitute financial, investment, or trading advice. Trading and investing involve significant risk, and you should not rely solely on this indicator when making any trading decisions. Past performance is not indicative of future results. Always perform your own due diligence and consult with a qualified financial advisor before making any financial decisions. The creator of this indicator shall not be held responsible for any losses incurred through its use.
Pine utilities
Starfield Scroller█ OVERVIEW
This script creates a visually appealing starfield effect on your chart. It generates and animates multiple star fields, each customizable with its own parameters. Explore the input options to adjust the number of stars, their speed, and color.
█ CONCEPTS
The script is a simple demonstration, and utilizes a custom `starfield` function and my `geo` library for point management. It simulates a parallax effect by creating stars at random positions and moving them across the chart at varying speeds.
Star Creation
• Stars are generated with random X and Y coordinates within defined boundaries.
• Each star is assigned a random speed factor, influencing its movement speed.
• Star color is also influenced by its speed; faster stars appear more transparent.
Star Movement & Management
• The script maintains a dynamic array of Star structures. Each Star structure holds the star's creation bar index, location (as a Point ), speed factor, and the label used to display it.
• On each new bar, new stars are created and added to the array.
• Stars are moved horizontally based on their speed factor.
• Stars that move off-screen are deleted to manage resource usage.
• The maximum number of stars for each starfield instance is controlled by an input parameter.
Parallax Effect
• The varying speeds of the stars create a parallax effect, giving the illusion of depth to the starfield.
█ FEATURES
This script includes two independent starfield instances, each configurable via inputs.
Starfield 1:
• Max Stars 1: Maximum number of stars in the first starfield.
• New Stars Per Bar 1: Number of new stars created per bar for the first starfield.
• Max Star Speed 1: Maximum speed of the stars in the first starfield.
• Star Color 1: Color of the stars in the first starfield.
Starfield 2:
• Max Stars 2: Maximum number of stars in the second starfield.
• New Stars Per Bar 2: Number of new stars created per bar for the second starfield.
• Max Star Speed 2: Maximum speed of the stars in the second starfield.
• Star Color 2: Color of the stars in the second starfield.
█ HOW TO USE
1 — Add the script to your chart.
2 — Adjust the input parameters for each starfield to customize its appearance and behavior.
3 — Observe the animated starfield effect.
█ LIMITATIONS
• Excessive numbers of stars may impact performance. Adjust the maximum number of stars and new stars per bar accordingly.
• The script uses labels for rendering stars, which can have limitations on certain chart timeframes and settings.
█ NOTES
This script is intended for visual enhancement and does not provide trading signals. It demonstrates the use of custom types, arrays, and functions for creating complex visual effects in Pine Script™. The `geo` library is used for consistent point calculations.
█ THANKS
Thanks to the TradingView community for inspiration and support.
KEMAD | QuantumResearchQuantumResearch KEMAD Indicator
The QuantumResearch KEMAD Indicator is a sophisticated trend-following and volatility-based tool designed for traders who demand precision in detecting market trends and price reversals. By leveraging advanced techniques implemented in PineScript, this indicator integrates a Kalman filter, an Exponential Moving Average (EMA), and dynamic ATR-based deviation bands to produce clear, actionable trading signals.
1. Overview
The KEMAD Indicator aims to:
Reduce Market Noise: Employ a Kalman filter to smooth price data.
Identify Trends: Use an EMA of the filtered price to define the prevailing market direction.
Set Dynamic Thresholds: Adjust breakout levels with ATR-based deviation bands.
Generate Signals: Provide clear long and short trading signals along with intuitive visual cues.
2. How It Works
A. Kalman Filter Smoothing
Purpose: The Kalman filter refines the selected price source (e.g., close price) by reducing short-term fluctuations, thus offering a clearer view of the underlying price movement.
Customization: Users can adjust key parameters such as:
Process Noise: Controls the filter’s sensitivity to recent changes.
Measurement Noise: Determines how responsive the filter is to incoming price data.
Filter Order: Sets the number of data points considered in the smoothing process.
B. EMA-Based Trend Detection
Primary Trend EMA: A 25-period EMA is applied to the Kalman-filtered price, serving as the core trend indicator.
Signal Mechanism:
Long Signal: Triggered when the price exceeds the EMA plus an ATR-based upper deviation.
Short Signal: Triggered when the price falls below the EMA minus an ATR-based lower deviation.
C. ATR Deviation Bands
ATR Utilization: The Average True Range (ATR) is computed (default length of 21) to assess market volatility.
Dynamic Thresholds:
Upper Deviation: Calculated by adding 1.5× ATR to the EMA (for long signals).
Lower Deviation: Calculated by subtracting 1.1× ATR from the EMA (for short signals).
These bands adapt to current volatility, ensuring that signal thresholds are both dynamic and market-sensitive.
3. Visual Representation
The indicator’s design emphasizes clarity and ease of use:
Color-Coded Bar Signals:
Green Bars: Indicate bullish conditions when a long signal is active.
Red Bars: Indicate bearish conditions when a short signal is active.
Trend Confirmation Line: A 54-period EMA is plotted to further validate trend direction. Its color dynamically changes to reflect the active trend.
Background Fill: The space between a calculated price midpoint (typically the average of high and low) and the EMA is filled, visually emphasizing the prevailing market trend.
4. Customization & Parameters
The KEMAD Indicator is highly configurable, allowing traders to tailor the tool to their specific trading strategies and market conditions:
ATR Settings:
ATR Length: Default is 21; adjusts sensitivity to market volatility.
EMA Settings:
Trend EMA Length: Default is 25; smooths price action for trend detection.
Confirmation EMA Length: Default is 54; aids in confirming the trend.
Kalman Filter Parameters:
Process Noise: Default is 0.01.
Measurement Noise: Default is 3.0.
Filter Order: Default is 5.
Deviation Multipliers:
Long Signal Multiplier: Default is 1.5× ATR.
Short Signal Multiplier: Default is 1.1× ATR.
Appearance: Eight customizable color themes are available to suit individual visual preferences.
5. Trading Applications
The versatility of the KEMAD Indicator makes it suitable for various trading strategies:
Trend Following: It helps identify and ride sustained bullish or bearish trends by filtering out market noise.
Breakout Trading: Detects when prices move beyond the ATR-based deviation bands, signaling potential breakout opportunities.
Reversal Detection: Alerts traders to potential trend reversals when price crosses the dynamically smoothed EMA.
Risk Management: Offers clearly defined entry and exit points, based on volatility-adjusted thresholds, enhancing trade precision and risk control.
6. Final Thoughts
The QuantumResearch KEMAD Indicator represents a unique blend of advanced filtering (via the Kalman filter), robust trend analysis (using EMAs), and dynamic volatility assessment (through ATR deviation bands).
Its PineScript implementation allows for a high degree of customization, making it an invaluable tool for traders looking to reduce noise, accurately detect trends, and manage risk effectively.
Whether used for trend following, breakout strategies, or reversal detection, the KEMAD Indicator is designed to adapt to varying market conditions and trading styles.
Important Disclaimer: Past data does not predict future behavior. This indicator is provided for informational purposes only; no indicator or strategy can guarantee future results. Always perform thorough analysis and use proper risk management before trading.
Walk Forward PatternsINTRO
In Euclidean geometry, every mathematical output has a planar projection. 'Walk Forward Patterns' can be considered a practical example of this concept. On the other hand, this indicator might also be viewed as an experiment in 'how playing with Lego as a child contributes to time series analysis' :)
OVERVIEW
This script dynamically generates the necessary optimization and testing ranges for Walk Forward Analysis based on user-defined bar count and length inputs. It performs automatic calculations for each step, offers 8 different window options depending on the inputs, and visualizes the results dynamically. I should also note that most of the window models consist of original patterns I have created.
ADDITIONAL INFO : WHAT IS WALK FORWARD ANALYSIS?
Although it is not the main focus of this indicator, providing a brief definition of Walk Forward Analysis can be helpful in correctly interpreting the results it generates. Walk Forward Analysis (WFA) is a systematic method for optimizing parameters and validating trading strategies. It involves dividing historical data into variable segments, where a strategy is first optimized on an in-sample period and then tested on an out-of-sample period. This process repeats by shifting the windows forward, ensuring that each test evaluates the strategy on unseen data, helping to assess its robustness and adaptability in real market conditions.
ORIGINALITY
There are very few studies on Walk Forward Analysis in TradingView. Even worse, there are no any open-source studies available. Someone has to start somewhere, I suppose. And in my personal opinion, determining the optimization and backtest intervals is the most challenging part of WFA. These intervals serve as a prerequisite for automated parameter optimization. I felt the need to publish this pattern module, which I use in my own WFA models, partly due to this gap on community scripts.
INDICATOR MECHANICS
To use the indicator effectively, you only need to perform four simple tasks:
Specify the total number of bars in your chart in the 'Bar Index' parameter.
Define the optimization (In-Sample Test) length.
Define the testing (Out-Of-Sample Test) length.
Finally, select the window type.
The indicator automatically models everything else (including the number of steps) based on your inputs. And the result; you now have a clear idea of which bars to use for your Walk Forward tests!
A COMMONLY USED WINDOW SELECTION METHOD: ROLLING
A more concrete definition of Walk Forward Analysis, specifically for the widely used Rolling method, can be described as follows:
Parameters that have performed well over a certain period are identified (Optimization: In-Sample).
These parameters are then tested on a shorter, subsequent period (Backtest: Out-of-Sample).
The process is repeated forward in time (At each step, the optimization and backtest periods are shifted by the backtest length).
If the cumulative percentage profit obtained from the backtest results is greater than half of the historical optimization profit, the strategy is considered "successful."
If the strategy is successful, the most recent (untested) optimization values are used for live trading.
OTHER WINDOW OPTIONS
ANCHORED: That's a pattern based on progressively expanding optimization ranges at each step. Backtest ranges move forward in a staircase-like manner.
STATIC: Optimization ranges remain fixed, while backtest ranges are shifted forward.
BLOCKED: Optimization ranges are shifted forward in groups of three blocks. Backtest ranges are also shifted in a staircase manner, even at the cost of creating gaps from the optimization end bars.
TRIANGULAR: Optimization ranges are shifted forward in triangular regions, while backtest ranges move in a staircase pattern.
RATIO: The optimization length increases by 25% of the initial step’s fixed length at each step. In other words, the length grows by 25% of the first step's length incrementally. Backtest ranges always start from the bar where the optimization ends.
FIBONACCI: A variation of the Ratio method, where the optimization shift factor is set to 0.618
RANDOM WALK
Unlike the window models explained above, we can also generate optimization and backtest ranges completely randomly—offering almost unlimited variations! When you select the "Random" option in the "Window" parameter on the indicator interface, random intervals are generated based on various trigonometric calculations. By changing the numerical value in the '🐒' parameter, you can create entirely unique patterns.
WHY THE 🐒 EMOJI?
Two reasons.
First, I think that as humanity, we are a species of tailless primates who become happy when we understand things :). At least evolutionarily. The entire history of civilization is built on the effort to express the universe in a scale we can comprehend. 'Knowledge' is an invention born from this effort, which is why we feel happiness when we 'understand'. Second, I can't think of a better metaphor for randomness than a monkey sitting at a keyboard. See: Monkey Test.
Anyway, I’m rambling :)
NOTES
The indicator generates results for up to 100 steps. As the number of steps increases, the table may extend beyond the screen—don’t forget to zoom out!
FINAL WORDS
I haven’t published a Walk Forward script yet . However, there seem to be examples that can perform parameter optimization in the true sense of the word, producing more realistic results without falling into overfitting in my library. Hopefully, I’ll have the chance to publish one in the coming weeks. Sincerely thanks to Kıvanç Özbilgiç, Robert Pardo, Kevin Davey, Ernest P. Chan for their inspiring publishments.
DISCLAIMER
That's just a script, nothing more. I hope it helps everyone. Do not forget to manage your risk. And trade as safely as possible. Best of luck!
© dg_factor
Moving Averages With Continuous Periods [macp]This script reimagines traditional moving averages by introducing floating-point period calculations, allowing for fractional lengths rather than being constrained to whole numbers. At its core, it provides SMA, WMA, and HMA variants that can work with any decimal length, which proves especially valuable when creating dynamic indicators or fine-tuning existing strategies.
The most significant improvement lies in the Hull Moving Average implementation. By properly handling floating-point mathematics throughout the calculation chain, this version reduces the overshoot tendencies that often plague integer-based HMAs. The result is a more responsive yet controlled indicator that better captures price action without excessive whipsaw.
The visual aspect incorporates a trend gradient system that can adapt to different trading styles. Rather than using fixed coloring, it offers several modes ranging from simple solid colors to more nuanced three-tone gradients that help identify trend transitions. These gradients are normalized against ATR to provide context-aware visual feedback about trend strength.
From a practical standpoint, the floating-point approach eliminates the subtle discontinuities that occur when integer-based moving averages switch periods. This makes the indicator particularly useful in systems where the MA period itself is calculated from market conditions, as it can smoothly transition between different lengths without artificial jumps.
At the heart of this implementation lies the concept of continuous weights rather than discrete summation. Traditional moving averages treat each period as a distinct unit with integer indexing. However, when we move to floating-point periods, we need to consider how fractional periods should behave. This leads us to some interesting mathematical considerations.
Consider the Weighted Moving Average kernel. The weight function is fundamentally a slope: -x + length where x represents the position in the averaging window. The normalization constant is calculated by integrating (in our discrete case, summing) this slope across the window. What makes this implementation special is how it handles the fractional component - when the length isn't a whole number, the final period gets weighted proportionally to its fractional part.
For the Hull Moving Average, the mathematics become particularly intriguing. The standard HMA formula HMA = WMA(2*WMA(price, n/2) - WMA(price, n), sqrt(n)) is preserved, but now each WMA calculation operates in continuous space. This creates a smoother cascade of weights that better preserves the original intent of the Hull design - to reduce lag while maintaining smoothness.
The Simple Moving Average's treatment of fractional periods is perhaps the most elegant. For a length like 9.7, it weights the first 9 periods fully and the 10th period at 0.7 of its value. This creates a natural transition between integer periods that traditional implementations miss entirely.
The Gradient Mathematics
The trend gradient system employs normalized angular calculations to determine color transitions. By taking the arctangent of price changes normalized by ATR, we create a bounded space between 0 and 1 that represents trend intensity. The formula (arctan(Δprice/ATR) + 90°)/180° maps trend angles to this normalized space, allowing for smooth color transitions that respect market volatility context.
This mathematical framework creates a more theoretically sound foundation for moving averages, one that better reflects the continuous nature of price movement in financial markets. The implementation recognizes that time in markets isn't truly discrete - our sampling might be, but the underlying process we're trying to measure is continuous. By allowing for fractional periods, we're creating a better approximation of this continuous reality.
This floating-point moving average implementation offers tangible benefits for traders and analysts who need precise control over their indicators. The ability to fine-tune periods and create smooth transitions makes it particularly valuable for automated systems where moving average lengths are dynamically calculated from market conditions. The Hull Moving Average calculation now accurately reflects its mathematical formula while maintaining responsiveness, making it a practical choice for both systematic and discretionary trading approaches. Whether you're building dynamic indicators, optimizing existing strategies, or simply want more precise control over your moving averages, this implementation provides the mathematical foundation to do so effectively.
[AcerX] Leverage, TP & Optimal TP CalculatorHow It Works
Inputs:
Portfolio Allocation (%): The percentage of your portfolio you're willing to risk on the trade.
Stop Loss (%): The stop loss distance below the entry price.
Taker Fee (%) and Maker Fee (%): The fees applied on entry and exit.
Calculations:
The script calculates the required "raw" leverage to risk 1% of your portfolio.
It floors the computed leverage to an integer ("effectiveLeverage").
If the computed leverage is less than 1, it shows an error message (and suggests the maximum allocation for at least 1× leverage).
Otherwise, it calculates the TP levels for target profits of 1.2%, 1.5%, and 2%, and an "Optimal TP" that nets a 1% profit after fees.
Display:
A table is drawn on the top right corner of your chart displaying the effective leverage, the TP levels, and an error message if applicable.
Simply add this script as a new indicator in TradingView, and adjust the inputs as needed.
Happy trading!
RT + TL v12This is a script to populate gamma/vanna/charm levels from option greeks heatmaps in Vexly. Heavy levels indicate levels with highest confluence. TLU and TLL are upper and lower levels. The levels are posted everyday on their discord server.
Range Trader another tool in Vexly, the levels from which can be plotted as well. Just copy the headline from range trader into "RT Range" and the modes into "RT mode"
Example:
RT Mode will take this string as input and plot the levels:
upper_mode
6049.037
mp_mode
6035.407
lower_mode
6021.776
RT Range will take this string as input and plot the levels:
6044.893 - 6017.652
Hope this helps
QoQ Economic & Financial Indicator ChangesA straightforward indicator for analyzing quarter-over-quarter (QoQ) percentage changes in economic and financial data series. Perfect for visualizing dynamic changes in:
Economic Indicators (GDP, House Price Indices, Employment Figures)
Company Financial Metrics (Revenue, EPS, Operating Margins)
Balance Sheet Items (Assets, Liabilities, Equity)
Cash Flow Statement Components
Other Quarterly Economic & Financial Data
Features:
Automatically calculates QoQ percentage changes
Color-coded visualization (green for positive, red for negative changes)
Displays exact percentage values
Includes adjustable scale factor for different data series
Zero line reference for easy trend identification
EUR/USD vs USD/CHF SpreadA typical Pine Script for spread trading would include:
Fetching Data: Getting the real-time price of EUR/USD and USD/CHF.
Calculating the Synthetic EUR/CHF Price: Since EUR/USD * USD/CHF ≈ EUR/CHF, we use this relation to analyze deviations.
Computing the Spread: Taking the difference between EUR/USD and the synthetic EUR/CHF price.
Z-Score Normalization: Measuring how far the spread deviates from the mean (Mean Reversion).
Overlay and Visuals: Plotting the spread and key levels to visualize trading signals.
TOTAL3/BTC This Pine Script™ code, named "TOTAL3/BTC with Arrow," is designed for cryptocurrency analysis on TradingView.
This script essentially provides a visual tool for traders to gauge when altcoins might be gaining or losing ground relative to Bitcoin through moving average analysis and color-coded trend indication.
Intention was to help the community with a script based on classic TA only.
Use it with SASDv2r indicator.
Feel free to make it better. If you did so, please let me know.
Main elements:
Data Fetching: It retrieves market cap data for all cryptocurrencies excluding Bitcoin and Ethereum (TOTAL3) and for Bitcoin (BTC).
Ratio Calculation: The script calculates the ratio of TOTAL3 to BTC market caps, which indicates how altcoins (excluding ETH) are performing relative to Bitcoin.
Plotting the Ratio: This ratio is plotted on the chart with a blue line, allowing traders to see the relative performance visually.
Moving Averages: Two Simple Moving Averages (SMA) are calculated for this ratio, one for 20 periods (ma20) and another for 50 periods (ma50), though these are not plotted in the current version of the code.
Reference Lines: Horizontal lines are added at ratios of 0.3 and 0.8 to serve as visual equilibrium points or thresholds for analysis.
Complex Moving Average: The script uses constants (len, len2, cc, smoothe) from another script, suggesting it's adapting or simplifying another's logic for multi-timeframe analysis.
Average Calculation: Two SMAs (avg and avg2) are computed using the constants defined, focusing on different lengths for trend analysis.
Direction Determination: It checks if the moving average is trending up or down by comparing the current value with its value smoothe bars earlier.
Color Coding: The color of the plotted moving average changes based on its direction (lime for up, red for down, aqua if no clear direction), aiding in quick visual interpretation of trends.
Plotting: Finally, the script plots this multi-timeframe moving average with a dynamic color to reflect the current market trend of the TOTAL3/BTC ratio, with a thicker line for visibility.
SASDv2rSensitive Altcoin Season Detector V2
This Pine Script™ code, titled "SASDv2r" (Sensitive Altcoin Season Detector version 2 revised), is designed for cryptocurrency trading analysis on the TradingView platform and tailored for those interested in tracking when altcoins might be outperforming Bitcoin, potentially indicating a market shift towards altcoins.
Feel free to use and modify. If you made it better, please let me know. Intention was to help the community with a tool for retail traders have no access to advanced, MV indicators. Solution uses classic TA only.
Use it witl TOTAL3/BTC indicator.
Please check: it gave signal just before last alt season % rose more than 250%.
Market Cap Data Fetching: The script fetches market capitalization data for Bitcoin, Ethereum, and all other altcoins (excluding Bitcoin and Ethereum) using request.security function.
Altcoin to Bitcoin Ratio: It calculates the ratio of total market cap of altcoins to Bitcoin's market cap (altToBtcRatio), which is central to identifying an "altcoin season."
Moving Averages: Several moving averages are computed for different time frames (50-day SMA, 200-day SMA, 20-day SMA, and 10-day EMA) to analyze trends in the altcoin to Bitcoin ratio.
Momentum Indicators: The script uses RSI (Relative Strength Index) and MACD (Moving Average Convergence Divergence) to gauge momentum and potential reversal points in the market.
Custom Indicators: It includes Volume Weighted Moving Average (VWMA) and a custom momentum indicator (altMomentum and altMomentumAvg) to provide additional insights into market movements.
Volatility Measurement: Bollinger Bands are calculated to assess volatility in the altcoin to Bitcoin ratio, which helps identify periods of high or low market activity.
Visual Analysis: Various plots are added to the chart for visual interpretation, including the altcoin to Bitcoin ratio, different moving averages, and Bollinger Bands.
Alt Season Detection: The script defines conditions for detecting when an "altcoin season" might be starting, based on crossovers of moving averages, RSI levels, MACD signals, and other custom criteria.
Performance Tracking: After signaling an alt season, the script evaluates the performance over the next 30 days by checking if there's been an increase in the altcoin to Bitcoin ratio, adding labels for positive or negative trends.(this one is in progress). Logic still gives false signals and aim is to identify failed signals.
Visual Signals: Labels are placed on the chart to visually indicate the beginning of a potential alt season or the performance outcome after a signal, aiding traders in making informed decisions.
IBOX For the indicator to appear correctly on the DE40's 5-minute char t, set it to overlay mode.
Variables: Variables are declared to store the high and low points of the first trading hour.
Draw box:
The box representing the range of the first trading hour is drawn in gray.
First trading hour range:
The code checks if it is the first trading hour (9-10 am). If so, the high and low points are stored.
Fibonacci calculation: Based on the range of the first trading hour, the Fibonacci levels 1,61, 2, 2,61, 4,61 above and below the box are calculated.
Litecoin LTC Logarithmic Fibonacci Growth CurvesHOW THIS SCRIPT IS ORIGINAL: there is no similar script dedicated to LTC, although there are similar ones dedicated to BTC. (This was created by modifying an old public and open source similar script dedicated to BTC.)
WHAT THIS SCRIPT DOES: draws a channel containing the price of LTC within which the Fibonacci extensions are highlighted. The reference chart to use is LTC/USD on Bitfinex (because it has the oldest data, given that Tradingview has not yet created an LTC index), suggested with weekly or monthly timeframe.
HOW IT DOES IT: starting from two basic curves that average the upper and lower peaks of the price, the relative Fibonacci extensions are then built on the basis of these: 0.9098, 0.8541, 0.7639, 0.618, 0.5, 0.382, 0.2361, 0.1459, 0.0902.
HOW TO USE IT: after activating the script you will notice the presence of two areas of particular interest, the upper area, delimited in red, which follows the upper peaks of the price, and the lower area, delimited in green, which follows the lower peaks of the price. Furthermore, the main curves, namely the two extremes and the median, are also projected into the future to predict an indicative trend. This script is therefore useful for understanding where the price will go in the future and can be useful for understanding when to buy (near the green lines) or when to sell (near the red lines). It is also possible to configure the script by choosing the colors and types of lines, as well as the main parameters to define the upper and lower curve, from which the script deduces all the other lines that are in the middle.
Very easy to read and interpret. I hope this description is sufficient, but it is certainly easier to use it than to describe it.
CAD CHF JPY (Index) vs USDDescription:
Analyze the combined performance of CAD, CHF, and JPY against the USD with this customized Forex currency index. This tool enables traders to gain a broader perspective of how these three currencies behave relative to the US Dollar by aggregating their movements into a single index. It’s a versatile tool designed for traders seeking actionable insights and trend identification.
Core Features:
Flexible Display Options:
Choose between Line Mode for a simplified view of the index trend or Candlestick Mode for detailed analysis of price action.
Custom Weight Adjustments:
Fine-tune the weight of each currency pair (USD/CAD, USD/CHF, USD/JPY) to better reflect your trading priorities or market expectations.
Moving Average Integration:
Add a moving average to smooth the data and identify trends more effectively. Choose your preferred type: SMA, EMA, WMA, or VWMA, and configure the number of periods to suit your strategy.
Streamlined Calculation:
The index aggregates data from USD/CAD, USD/CHF, and USD/JPY using a weighted average of their OHLC (Open, High, Low, Close) values, ensuring accuracy and adaptability to different market conditions.
Practical Applications:
Trend Identification:
Use the Line Mode with a moving average to confirm whether CAD, CHF, and JPY collectively show strength or weakness against the USD. A rising trendline signals currency strength, while a declining line suggests USD dominance.
Weight-Based Analysis:
If CAD is expected to lead, adjust its weight higher relative to CHF and JPY to emphasize its influence in the index. This customization makes the indicator adaptable to your market outlook.
Actionable Insights:
Identify key reversal points or breakout opportunities by analyzing the interaction of the index with its moving average. Combined with other technical tools, this indicator becomes a robust addition to any trader’s toolkit.
Additional Notes:
This indicator is a valuable resource for comparing the collective behavior of CAD, CHF, and JPY against the USD. Pair it with additional oscillators or divergence tools for a comprehensive market overview.
Perfect for both intraday analysis and swing trading strategies. Combine it with EUR GPB AUD (Index) indicator.
Good Profits!
Repeating Vertical LinesThe "Repeating Vertical Lines" indicator visualizes recurring points in time on the chart by drawing background highlights based on user-defined conditions, including specific weekdays, times, or their combination. Users can customize the color and transparency of the lines for seamless chart integration.
[Helper] Trade Journal TableThis indicator serves as a starting point for creating a customized trade journal that meets individual requirements. It provides a basic structure for visualizing trade data in table form which can be adapt to specific needs. The trade data must be maintained directly within the script using the Pine Editor.
Basic Structure:
The example table consists of six columns: Date, Entry Price, Exit Price, Profit/Loss (color-coded), Strategy, and Notes. It is displayed centrally on the chart and dynamically adjusts to the number of recorded trades.
Example Data:
To demonstrate its functionality, the indicator includes predefined example trades, which should be replaced with actual trading data. Additional information, such as strategies and notes, can be added to improve trade documentation.
Price Level Break & Candle Pattern DetectorPrice Level Break & Candle Pattern Detector
A powerful and customizable indicator that combines price level breakout detection with candlestick pattern analysis to generate precise trading signals.
Key Features
Monitors user-defined price levels for breakouts
Identifies bullish and bearish candle patterns
Generates real-time alerts when both conditions are met
Customizable alert settings for improved trade management
How It Works
The indicator continuously monitors price action around specified price levels. When price breaks through these levels AND forms either a bullish or bearish candle pattern (based on your settings), it triggers an alert. This dual-confirmation approach helps reduce false signals and provides more reliable trading opportunities.
Use Cases
Support/Resistance breakout trading
Key price level monitoring
Trend reversal identification
Breakout confirmation
Risk management tool
Benefits
Reduces false breakout signals through pattern confirmation
Saves time by automating price level monitoring
Helps identify higher-probability trading setups
Customizable to fit various trading strategies
Perfect for both day trading and swing trading
Alert Types
Price level break alerts
Candlestick pattern formation alerts
Combined confirmation alerts
Suggested Settings
Set price levels at major support/resistance zones
Adjust candle pattern sensitivity based on timeframe
Use with multiple timeframes for confirmation
Combine with volume analysis for better accuracy
Geo. Geo.
This library provides a comprehensive set of geometric functions based on 2 simple types for point and line manipulation, point array calculations, some vector operations (Borrowed from @ricardosantos ), angle calculations, and basic polygon analysis. It offers tools for creating, transforming, and analyzing geometric shapes and their relationships.
View the source code for detailed documentation on each function and type.
═════════════════════════════════════════════════════════════════════════
█ OVERVIEW
This library enhances TradingView's Pine Script with robust geometric capabilities. It introduces the Point and Line types, along with a suite of functions for various geometric operations. These functionalities empower you to perform advanced calculations, manipulations, and analyses involving points, lines, vectors, angles, and polygons directly within your Pine scripts. The example is at the bottom of the script. ( Commented out )
█ CONCEPTS
This library revolves around two fundamental types:
• Point: Represents a point in 2D space with x and y coordinates, along with optional 'a' (angle) and 'v' (value) fields for versatile use. Crucially, for plotting, utilize the `.to_chart_point()` method to convert Points into plottable chart.point objects.
• Line: Defined by a starting Point and a slope , enabling calculations like getting y for a given x, or finding intersection points.
█ FEATURES
• Point Manipulation: Perform operations like addition, subtraction, scaling, rotation, normalization, calculating distances, dot products, cross products, midpoints, and more with Point objects.
• Line Operations: Create lines, determine their slope, calculate y from x (and vice versa), and find the intersection points of two lines.
• Vector Operations: Perform vector addition, subtraction, multiplication, division, negation, perpendicular vector calculation, floor, fractional part, sine, absolute value, modulus, sign, round, scaling, rescaling, rotation, and ceiling operations.
• Angle Calculations: Compute angles between points in degrees or radians, including signed, unsigned, and 360-degree angles.
• Polygon Analysis: Calculate the area, perimeter, and centroid of polygons. Check if a point is inside a given polygon and determine the convex hull perimeter.
• Chart Plotting: Conveniently convert Point objects to chart.point objects for plotting lines and points on the chart. The library also includes functions for plotting lines between individual and series of points.
• Utility Functions: Includes helper functions such as square root, square, cosine, sine, tangent, arc cosine, arc sine, arc tangent, atan2, absolute distance, golden ratio tolerance check, fractional part, and safe index/check for chart plotting boundaries.
█ HOW TO USE
1 — Include the library in your script using:
import kaigouthro/geo/1
2 — Create Point and Line objects:
p1 = geo.Point(bar_index, close)
p2 = geo.Point(bar_index , open)
myLine = geo.Line(p1, geo.slope(p1, p2))
// maybe use that line to detect a crossing for an alert ... hmmm
3 — Utilize the provided functions:
distance = geo.distance(p1, p2)
intersection = geo.intersection(line1, line2)
4 — For plotting labels, lines, convert Point to chart.point :
label.new(p1.to_chart_point(), " Hi ")
line.new(p1.to_chart_point(),p2.to_chart_point())
█ NOTES
This description provides a concise overview. Consult the library's source code for in-depth documentation, including detailed descriptions, parameter types, and return values for each function and method. The source code is structured with comprehensive comments using the `//@` format for seamless integration with TradingView's auto-documentation features.
█ Possibilities..
Library "geo"
This library provides a comprehensive set of geometric functions and types, including point and line manipulation, vector operations, angle calculations, and polygon analysis. It offers tools for creating, transforming, and analyzing geometric shapes and their relationships.
sqrt(value)
Square root function
Parameters:
value (float) : (float) - The number to take the square root of
Returns: (float) - The square root of the input value
sqr(x)
Square function
Parameters:
x (float) : (float) - The number to square
Returns: (float) - The square of the input value
cos(v)
Cosine function
Parameters:
v (float) : (series float) - The value to find the cosine of
Returns: (series float) - The cosine of the input value
sin(v)
Sine function
Parameters:
v (float) : (series float) - The value to find the sine of
Returns: (series float) - The sine of the input value
tan(v)
Tangent function
Parameters:
v (float) : (series float) - The value to find the tangent of
Returns: (series float) - The tangent of the input value
acos(v)
Arc cosine function
Parameters:
v (float) : (series float) - The value to find the arc cosine of
Returns: (series float) - The arc cosine of the input value
asin(v)
Arc sine function
Parameters:
v (float) : (series float) - The value to find the arc sine of
Returns: (series float) - The arc sine of the input value
atan(v)
Arc tangent function
Parameters:
v (float) : (series float) - The value to find the arc tangent of
Returns: (series float) - The arc tangent of the input value
atan2(dy, dx)
atan2 function
Parameters:
dy (float) : (float) - The y-coordinate
dx (float) : (float) - The x-coordinate
Returns: (float) - The angle in radians
gap(_value1, __value2)
Absolute distance between any two float values
Parameters:
_value1 (float) : First value
__value2 (float)
Returns: Absolute Positive Distance
phi_tol(a, b, tolerance)
Check if the ratio is within the tolerance of the golden ratio
Parameters:
a (float) : (float) The first number
b (float) : (float) The second number
tolerance (float) : (float) The tolerance percennt as 1 = 1 percent
Returns: (bool) True if the ratio is within the tolerance, false otherwise
frac(x)
frad Fractional
Parameters:
x (float) : (float) - The number to convert to fractional
Returns: (float) - The number converted to fractional
safeindex(x, limit)
limiting int to hold the value within the chart range
Parameters:
x (float) : (float) - The number to limit
limit (int)
Returns: (int) - The number limited to the chart range
safecheck(x, limit)
limiting int check if within the chartplottable range
Parameters:
x (float) : (float) - The number to limit
limit (int)
Returns: (int) - The number limited to the chart range
interpolate(a, b, t)
interpolate between two values
Parameters:
a (float) : (float) - The first value
b (float) : (float) - The second value
t (float) : (float) - The interpolation factor (0 to 1)
Returns: (float) - The interpolated value
gcd(_numerator, _denominator)
Greatest common divisor of two integers
Parameters:
_numerator (int)
_denominator (int)
Returns: (int) The greatest common divisor
method set_x(self, value)
Set the x value of the point, and pass point for chaining
Namespace types: Point
Parameters:
self (Point) : (Point) The point to modify
value (float) : (float) The new x-coordinate
method set_y(self, value)
Set the y value of the point, and pass point for chaining
Namespace types: Point
Parameters:
self (Point) : (Point) The point to modify
value (float) : (float) The new y-coordinate
method get_x(self)
Get the x value of the point
Namespace types: Point
Parameters:
self (Point) : (Point) The point to get the x-coordinate from
Returns: (float) The x-coordinate
method get_y(self)
Get the y value of the point
Namespace types: Point
Parameters:
self (Point) : (Point) The point to get the y-coordinate from
Returns: (float) The y-coordinate
method vmin(self)
Lowest element of the point
Namespace types: Point
Parameters:
self (Point) : (Point) The point
Returns: (float) The lowest value between x and y
method vmax(self)
Highest element of the point
Namespace types: Point
Parameters:
self (Point) : (Point) The point
Returns: (float) The highest value between x and y
method add(p1, p2)
Addition
Namespace types: Point
Parameters:
p1 (Point) : (Point) - The first point
p2 (Point) : (Point) - The second point
Returns: (Point) - the add of the two points
method sub(p1, p2)
Subtraction
Namespace types: Point
Parameters:
p1 (Point) : (Point) - The first point
p2 (Point) : (Point) - The second point
Returns: (Point) - the sub of the two points
method mul(p, scalar)
Multiplication by scalar
Namespace types: Point
Parameters:
p (Point) : (Point) - The point
scalar (float) : (float) - The scalar to multiply by
Returns: (Point) - the multiplied point of the point and the scalar
method div(p, scalar)
Division by scalar
Namespace types: Point
Parameters:
p (Point) : (Point) - The point
scalar (float) : (float) - The scalar to divide by
Returns: (Point) - the divided point of the point and the scalar
method rotate(p, angle)
Rotate a point around the origin by an angle (in degrees)
Namespace types: Point
Parameters:
p (Point) : (Point) - The point to rotate
angle (float) : (float) - The angle to rotate by in degrees
Returns: (Point) - the rotated point
method length(p)
Length of the vector from origin to the point
Namespace types: Point
Parameters:
p (Point) : (Point) - The point
Returns: (float) - the length of the point
method length_squared(p)
Length squared of the vector
Namespace types: Point
Parameters:
p (Point) : (Point) The point
Returns: (float) The squared length of the point
method normalize(p)
Normalize the point to a unit vector
Namespace types: Point
Parameters:
p (Point) : (Point) - The point to normalize
Returns: (Point) - the normalized point
method dot(p1, p2)
Dot product
Namespace types: Point
Parameters:
p1 (Point) : (Point) - The first point
p2 (Point) : (Point) - The second point
Returns: (float) - the dot of the two points
method cross(p1, p2)
Cross product result (in 2D, this is a scalar)
Namespace types: Point
Parameters:
p1 (Point) : (Point) - The first point
p2 (Point) : (Point) - The second point
Returns: (float) - the cross of the two points
method distance(p1, p2)
Distance between two points
Namespace types: Point
Parameters:
p1 (Point) : (Point) - The first point
p2 (Point) : (Point) - The second point
Returns: (float) - the distance of the two points
method Point(x, y, a, v)
Point Create Convenience
Namespace types: series float, simple float, input float, const float
Parameters:
x (float)
y (float)
a (float)
v (float)
Returns: (Point) new point
method angle(p1, p2)
Angle between two points in degrees
Namespace types: Point
Parameters:
p1 (Point) : (Point) - The first point
p2 (Point) : (Point) - The second point
Returns: (float) - the angle of the first point and the second point
method angle_between(p, pivot, other)
Angle between two points in degrees from a pivot point
Namespace types: Point
Parameters:
p (Point) : (Point) - The point to calculate the angle from
pivot (Point) : (Point) - The pivot point
other (Point) : (Point) - The other point
Returns: (float) - the angle between the two points
method translate(p, from_origin, to_origin)
Translate a point from one origin to another
Namespace types: Point
Parameters:
p (Point) : (Point) - The point to translate
from_origin (Point) : (Point) - The origin to translate from
to_origin (Point) : (Point) - The origin to translate to
Returns: (Point) - the translated point
method midpoint(p1, p2)
Midpoint of two points
Namespace types: Point
Parameters:
p1 (Point) : (Point) - The first point
p2 (Point) : (Point) - The second point
Returns: (Point) - The midpoint of the two points
method rotate_around(p, angle, pivot)
Rotate a point around a pivot point by an angle (in degrees)
Namespace types: Point
Parameters:
p (Point) : (Point) - The point to rotate
angle (float) : (float) - The angle to rotate by in degrees
pivot (Point) : (Point) - The pivot point to rotate around
Returns: (Point) - the rotated point
method multiply(_a, _b)
Multiply vector _a with _b
Namespace types: Point
Parameters:
_a (Point) : (Point) The first point
_b (Point) : (Point) The second point
Returns: (Point) The result of the multiplication
method divide(_a, _b)
Divide vector _a by _b
Namespace types: Point
Parameters:
_a (Point) : (Point) The first point
_b (Point) : (Point) The second point
Returns: (Point) The result of the division
method negate(_a)
Negative of vector _a
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to negate
Returns: (Point) The negated point
method perp(_a)
Perpendicular Vector of _a
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
Returns: (Point) The perpendicular point
method vfloor(_a)
Compute the floor of argument vector _a
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
Returns: (Point) The floor of the point
method fractional(_a)
Compute the fractional part of the elements from vector _a
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
Returns: (Point) The fractional part of the point
method vsin(_a)
Compute the sine of argument vector _a
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
Returns: (Point) The sine of the point
lcm(a, b)
Least common multiple of two integers
Parameters:
a (int) : (int) The first integer
b (int) : (int) The second integer
Returns: (int) The least common multiple
method vabs(_a)
Compute the absolute of argument vector _a
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
Returns: (Point) The absolute of the point
method vmod(_a, _b)
Compute the mod of argument vector _a
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
_b (float) : (float) The mod
Returns: (Point) The mod of the point
method vsign(_a)
Compute the sign of argument vector _a
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
Returns: (Point) The sign of the point
method vround(_a)
Compute the round of argument vector _a
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
Returns: (Point) The round of the point
method normalize_y(p, height)
normalizes the y value of a point to an input height
Namespace types: Point
Parameters:
p (Point) : (Point) - The point to normalize
height (float) : (float) - The height to normalize to
Returns: (Point) - the normalized point
centroid(points)
Calculate the centroid of multiple points
Parameters:
points (array) : (array) The array of points
Returns: (Point) The centroid point
random_point(_height, _width, _origin, _centered)
Random Point in a given height and width
Parameters:
_height (float) : (float) The height of the area to generate the point in
_width (float) : (float) The width of the area to generate the point in
_origin (Point) : (Point) The origin of the area to generate the point in (default: na, will create a Point(0, 0))
_centered (bool) : (bool) Center the origin point in the area, otherwise, positive h/w (default: false)
Returns: (Point) The random point in the given area
random_point_array(_origin, _height, _width, _centered, _count)
Random Point Array in a given height and width
Parameters:
_origin (Point) : (Point) The origin of the area to generate the array (default: na, will create a Point(0, 0))
_height (float) : (float) The height of the area to generate the array
_width (float) : (float) The width of the area to generate the array
_centered (bool) : (bool) Center the origin point in the area, otherwise, positive h/w (default: false)
_count (int) : (int) The number of points to generate (default: 50)
Returns: (array) The random point array in the given area
method sort_points(points, by_x)
Sorts an array of points by x or y coordinate
Namespace types: array
Parameters:
points (array) : (array) The array of points to sort
by_x (bool) : (bool) Whether to sort by x-coordinate (true) or y-coordinate (false)
Returns: (array) The sorted array of points
method equals(_a, _b)
Compares two points for equality
Namespace types: Point
Parameters:
_a (Point) : (Point) The first point
_b (Point) : (Point) The second point
Returns: (bool) True if the points are equal, false otherwise
method max(origin, _a, _b)
Maximum of two points from origin, using dot product
Namespace types: Point
Parameters:
origin (Point)
_a (Point) : (Point) The first point
_b (Point) : (Point) The second point
Returns: (Point) The maximum point
method min(origin, _a, _b)
Minimum of two points from origin, using dot product
Namespace types: Point
Parameters:
origin (Point)
_a (Point) : (Point) The first point
_b (Point) : (Point) The second point
Returns: (Point) The minimum point
method avg_x(points)
Average x of point array
Namespace types: array
Parameters:
points (array) : (array) The array of points
Returns: (float) The average x-coordinate
method avg_y(points)
Average y of point array
Namespace types: array
Parameters:
points (array) : (array) The array of points
Returns: (float) The average y-coordinate
method range_x(points)
Range of x values in point array
Namespace types: array
Parameters:
points (array) : (array) The array of points
Returns: (float) The range of x-coordinates
method range_y(points)
Range of y values in point array
Namespace types: array
Parameters:
points (array) : (array) The array of points
Returns: (float) The range of y-coordinates
method max_x(points)
max of x values in point array
Namespace types: array
Parameters:
points (array) : (array) The array of points
Returns: (float) The max of x-coordinates
method min_y(points)
min of x values in point array
Namespace types: array
Parameters:
points (array) : (array) The array of points
Returns: (float) The min of x-coordinates
method scale(_a, _scalar)
Scale a point by a scalar
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to scale
_scalar (float) : (float) The scalar value
Returns: (Point) The scaled point
method rescale(_a, _length)
Rescale a point to a new magnitude
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to rescale
_length (float) : (float) The new magnitude
Returns: (Point) The rescaled point
method rotate_rad(_a, _radians)
Rotate a point by an angle in radians
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to rotate
_radians (float) : (float) The angle in radians
Returns: (Point) The rotated point
method rotate_degree(_a, _degree)
Rotate a point by an angle in degrees
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to rotate
_degree (float) : (float) The angle in degrees
Returns: (Point) The rotated point
method vceil(_a, _digits)
Ceil a point to a certain number of digits
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to ceil
_digits (int) : (int) The number of digits to ceil to
Returns: (Point) The ceiled point
method vpow(_a, _exponent)
Raise both point elements to a power
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
_exponent (float) : (float) The exponent
Returns: (Point) The point with elements raised to the power
method perpendicular_distance(_a, _b, _c)
Distance from point _a to line between _b and _c
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
_b (Point) : (Point) The start point of the line
_c (Point) : (Point) The end point of the line
Returns: (float) The perpendicular distance
method project(_a, _axis)
Project a point onto another
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to project
_axis (Point) : (Point) The point to project onto
Returns: (Point) The projected point
method projectN(_a, _axis)
Project a point onto a point of unit length
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to project
_axis (Point) : (Point) The unit length point to project onto
Returns: (Point) The projected point
method reflect(_a, _axis)
Reflect a point on another
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to reflect
_axis (Point) : (Point) The point to reflect on
Returns: (Point) The reflected point
method reflectN(_a, _axis)
Reflect a point to an arbitrary axis
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to reflect
_axis (Point) : (Point) The axis to reflect to
Returns: (Point) The reflected point
method angle_rad(_a)
Angle in radians of a point
Namespace types: Point
Parameters:
_a (Point) : (Point) The point
Returns: (float) The angle in radians
method angle_unsigned(_a, _b)
Unsigned degree angle between 0 and +180 by given two points
Namespace types: Point
Parameters:
_a (Point) : (Point) The first point
_b (Point) : (Point) The second point
Returns: (float) The unsigned angle in degrees
method angle_signed(_a, _b)
Signed degree angle between -180 and +180 by given two points
Namespace types: Point
Parameters:
_a (Point) : (Point) The first point
_b (Point) : (Point) The second point
Returns: (float) The signed angle in degrees
method angle_360(_a, _b)
Degree angle between 0 and 360 by given two points
Namespace types: Point
Parameters:
_a (Point) : (Point) The first point
_b (Point) : (Point) The second point
Returns: (float) The angle in degrees (0-360)
method clamp(_a, _vmin, _vmax)
Restricts a point between a min and max value
Namespace types: Point
Parameters:
_a (Point) : (Point) The point to restrict
_vmin (Point) : (Point) The minimum point
_vmax (Point) : (Point) The maximum point
Returns: (Point) The restricted point
method lerp(_a, _b, _rate_of_move)
Linearly interpolates between points a and b by _rate_of_move
Namespace types: Point
Parameters:
_a (Point) : (Point) The starting point
_b (Point) : (Point) The ending point
_rate_of_move (float) : (float) The rate of movement (0-1)
Returns: (Point) The interpolated point
method slope(p1, p2)
Slope of a line between two points
Namespace types: Point
Parameters:
p1 (Point) : (Point) - The first point
p2 (Point) : (Point) - The second point
Returns: (float) - The slope of the line
method gety(self, x)
Get y-coordinate of a point on the line given its x-coordinate
Namespace types: Line
Parameters:
self (Line) : (Line) - The line
x (float) : (float) - The x-coordinate
Returns: (float) - The y-coordinate
method getx(self, y)
Get x-coordinate of a point on the line given its y-coordinate
Namespace types: Line
Parameters:
self (Line) : (Line) - The line
y (float) : (float) - The y-coordinate
Returns: (float) - The x-coordinate
method intersection(self, other)
Intersection point of two lines
Namespace types: Line
Parameters:
self (Line) : (Line) - The first line
other (Line) : (Line) - The second line
Returns: (Point) - The intersection point
method calculate_arc_point(self, b, p3)
Calculate a point on the arc defined by three points
Namespace types: Point
Parameters:
self (Point) : (Point) The starting point of the arc
b (Point) : (Point) The middle point of the arc
p3 (Point) : (Point) The end point of the arc
Returns: (Point) A point on the arc
approximate_center(point1, point2, point3)
Approximate the center of a spiral using three points
Parameters:
point1 (Point) : (Point) The first point
point2 (Point) : (Point) The second point
point3 (Point) : (Point) The third point
Returns: (Point) The approximate center point
createEdge(center, radius, angle)
Get coordinate from center by radius and angle
Parameters:
center (Point) : (Point) - The center point
radius (float) : (float) - The radius of the circle
angle (float) : (float) - The angle in degrees
Returns: (Point) - The coordinate on the circle
getGrowthFactor(p1, p2, p3)
Get growth factor of spiral point
Parameters:
p1 (Point) : (Point) - The first point
p2 (Point) : (Point) - The second point
p3 (Point) : (Point) - The third point
Returns: (float) - The growth factor
method to_chart_point(point)
Convert Point to chart.point using chart.point.from_index(safeindex(point.x), point.y)
Namespace types: Point
Parameters:
point (Point) : (Point) - The point to convert
Returns: (chart.point) - The chart.point representation of the input point
method plotline(p1, p2, col, width)
Draw a line from p1 to p2
Namespace types: Point
Parameters:
p1 (Point) : (Point) First point
p2 (Point) : (Point) Second point
col (color)
width (int)
Returns: (line) Line object
method drawlines(points, col, ignore_boundary)
Draw lines between points in an array
Namespace types: array
Parameters:
points (array) : (array) The array of points
col (color) : (color) The color of the lines
ignore_boundary (bool) : (bool) The color of the lines
method to_chart_points(points)
Draw an array of points as chart points on the chart with line.new(chartpoint1, chartpoint2, color=linecolor)
Namespace types: array
Parameters:
points (array) : (array) - The points to draw
Returns: (array) The array of chart points
polygon_area(points)
Calculate the area of a polygon defined by an array of points
Parameters:
points (array) : (array) The array of points representing the polygon vertices
Returns: (float) The area of the polygon
polygon_perimeter(points)
Calculate the perimeter of a polygon
Parameters:
points (array) : (array) Array of points defining the polygon
Returns: (float) Perimeter of the polygon
is_point_in_polygon(point, _polygon)
Check if a point is inside a polygon
Parameters:
point (Point) : (Point) The point to check
_polygon (array)
Returns: (bool) True if the point is inside the polygon, false otherwise
method perimeter(points)
Calculates the convex hull perimeter of a set of points
Namespace types: array
Parameters:
points (array) : (array) The array of points
Returns: (array) The array of points forming the convex hull perimeter
Point
A Point, can be used for vector, floating calcs, etc. Use the cp method for plots
Fields:
x (series float) : (float) The x-coordinate
y (series float) : (float) The y-coordinate
a (series float) : (float) An Angle storage spot
v (series float) : (float) A Value
Line
Line
Fields:
point (Point) : (Point) The starting point of the line
slope (series float) : (float) The slope of the line
GOMTRY.
Lost Bar Locator v1 [Yaphott]Lost Bar Locator v1 helps you locate missing data on your chart.
It does this by looking for consecutive bars that have a delta time greater than the current interval.
Two lines are drawn for each group of one or more missing bars:
Bar before the missing bar(s).
Bar after the missing bar(s).
Chart InfoOVERVIEW
What would a general summary of the symbol on the chart look like? Here’s an example: This script was created to help you easily access the essential details of a symbol, which I believe are critical for daily use.
CONCEPTS
When using any indicator or analysing price movement, the characteristics of the chart become important. Each symbol has a unique character and the more we can quickly find out about it, the better. Instead of embedding those details within each individual indicator, it is often more practical to access these data through an external tool. This indicator presents the following results related to the symbol on your chart in a table format:
ID : Ticker ID (Exchange, Base Currency, and Quote Currency)
TIMEFRAME : The chart's time period
START : The starting date of the chart
FINISH : The finishing date of the chart
INTERVAL : The total time between the start and finish dates (based on timeframe). The current bar is not included in the total time until it is closed.
BAR INDEX : The total number of bars on the chart (can also be viewed in both forward and backward directions in the data window as a series type).
VOLATILITY : Percentage ratio of 14-bar ATR to close.
CHANGE : The daily percentage change.
HODL : The percentage return that would be gained if the symbol had been bought and held since the first bar.
DAILY BUY : The percentage return that would be gained if the same amount of buying was made daily (a kind of DCA).
MECHANICS
This is a very simple script. I didn't add user-defined timestamp inputs because I didn’t want to overwhelm the indicator with parameters. However, if requested, i can make improvements in this direction in a second version.
NOTES
I live in Istanbul, so I designed the default timezone offset as GMT+3. Please remember to adjust it according to your own timezone to ensure the date results are accurate.
I hope it helps everyone. Do not forget to manage your risk. And trade as safely as possible. Best of luck!
[Helper] Color Table for Manual SelectionThis indicator displays the colors of the color picker from the indicator configuration menu on a large scale. It also shows the RGB values in decimal and as a hexadecimal code for each color. This color table provides a better overview of different colors compared to the color picker built into the Pine Editor, making it a useful alternative. Since cell contents cannot yet be selected with the mouse, the desired color code must be manually transferred to the Pine code.
TTZConcept GOLD XAUUSD Lot CalculatorThe Gold Lot Size Calculator for XAU/USD on TradingView is a powerful and user-friendly tool designed by TTZ Concept to help traders calculate the optimal lot size for their Gold trades based on their account size, risk tolerance, and the price movement of Gold (XAU/USD). Whether you're a beginner or an experienced trader, this tool simplifies position sizing, ensuring that your trades align with your risk management strategy.
Key Features:
Accurate Lot Size Calculation: Calculates the optimal lot size for XAU/USD trades based on your specified account balance and the percentage of risk per trade.
Flexible Risk Management**: Input your desired risk percentage (e.g., 1%, 2%) to ensure that you are not risking more than you're comfortable with on any single trade.
Customizable Inputs: Enter your account balance, risk percentage, stop loss (in pips), and leverage to get an accurate lot size recommendation.
Real-Time Data The tool uses real-time Gold price data to calculate the position size, ensuring that your risk management is always up to date with market conditions.
-Simple Interface: With easy-to-use sliders and input fields, you can quickly adjust your parameters and get the required lot size in seconds.
No Complicated Calculations Automatically factors in the pip value and contract specifications for XAU/USD, eliminating the need for manual calculations.
How It Works:
1. Input your trading account balance: The tool calculates based on your total equity.
2. Set your risk percentage: Choose how much of your account you want to risk on a single trade.
3. Define your stop loss in pips: Specify the distance of your stop loss from the entry point.
4. Get your recommended lot size: Based on your inputs, the tool will calculate the ideal lot size for your trade.
Why Use This Tool?
Precise Risk Management: Take control of your trading risk by ensuring that each trade is positioned according to your risk tolerance.
Save Time: No need for manual calculations — let the calculator handle the complex math and focus on your strategy.
Adapt to Changing Market Conditions: As the price of Gold (XAU/USD) fluctuates, your lot size adapts to ensure consistent risk management across different market conditions.
Perfect for:
- Gold traders (XAU/USD)
- Beginners seeking to understand position sizing and risk management
- Experienced traders looking to streamline their trading process
- Anyone who trades Gold futures, CFDs, or spot Gold in their trading account
Session Bar/Candle ColoringChange the color of candles within a user-defined trading session. Borders and wicks can be changed as well, not just the body color.
PREFACE
This script can be used an educational resource for those who are interested in learning Pine Script. Therefore, the script is published open source and is organized in a manner that follows the recommended Style Guide .
While the main premise of the indicator is rather simple, the script showcases various things that can be achieved such as conditional plotting, alignment of indicator settings, user input validation, script optimization, and more. The script also has examples of taking into consideration the chart timeframe and/or different chart types (Heikin Ashi, Renko, etc.) that a user might be running it on. Note: for complete beginners, I strongly suggest going through the Pine Script User Manual (possibly more than once).
FEATURES
Besides being able to select a specific time window, the indicator also provides additional color settings for changing the background color or changing the colors of neutral/indecisive candles, as shown in the image below.
This allows for a higher level of customization beyond the TradingView chart settings or other similar scripts that are currently available.
HOW TO USE
First, define the intraday trading session that will contain the candles to modify. The session can be limited to specific days of the week.
Next, select the parts of the candles that should be modified: Body, Borders, Wick, and/or Background.
For each of the candle parts that were enabled, you can select the colors that will be used depending on whether a candle is bullish (⇧), bearish (⇩), or neutral (⇆).
All other indicator settings will have a detailed tooltip to describe its usage and/or effect.
LIMITATIONS
The indicator is not intended to function on Daily or higher timeframes due to the intraday nature of session time windows.
The indicator cannot always automatically detect the chart type being used, therefore the user is requested to manually input the chart type via the " Chart Style " setting.
Depending on the available historical data and the selected choice for the " Portion of bar in session " setting, the indicator may not be able to update very old candles on the chart.
EXAMPLE USAGE
This section will show examples of different scenarios that the indicator can be used for.
Emphasizing a main trading session.
Defining a "Pre/post market hours background" like is available for some symbols (e.g., NASDAQ:AAPL ).
Highlighting in which bar the midnight candle occurs.
Hiding indecision bars (neutral candles).
Showing only "Regular Trading Hours" for a chart that does not have the option to toggle ETH/RTH. To achieve this, the actual chart data is hidden, and only the indicator is visible; alternatively, a 2nd instance of the indicator could change colors to match the chart background.
Using a combination of Bars and Japanese Candlesticks. Alternatively, this could be done by hiding the main chart data and using 2 instances of the indicator (one with " Chart Style " setting as Bars , and the other set to Candles ).
Using a combination of thin and thick bars on Range charts. Note: requires disabling the "Thin Bars" setting for Bar charts in the TradingView chart settings.
NOTES
If using more than one instance of this indicator on the same chart, you can use the TradingView "Save Indicator Template" feature to avoid having to re-configure the multiple indicators at a later time.
This indicator is intended to work "out-of-the-box" thanks to the behind_chart option introduced to Pine Script in October 2024. But you can always manually bring the indicator to the front just in case the color changes are not being seen (using the "More" option in the indicator status line: More > Visual Order > Bring to front ).
Many thanks to fikira for their help and inspiring me to create open source scripts.
Any feedback including bug reports or suggestions for improving the indicator (or source code itself) are always welcome in the comments section.
