Trending Market Toolkit [LuxAlgo]The Trending Market Toolkit focuses exclusively on trending market structures and high-confluence, high-risk-to-reward entry models. It is designed to complement discretionary trading by offering different entry strategies based on market structure.
🔶 USAGE
In the chart above we can see how the tool detects several reversals, draws the broken trendlines, the reversal areas from which the tool starts looking for a trigger, and when it finally happens, a potential trade with risk and reward areas and the risk/reward ratio.
🔹 Detection Mode
Traders can choose between three different modes: trend only, reversal only, or both.
If both are active, reversals have priority over trends, so the tool will not detect a trend if a reversal is active.
In the chart above we can see all three modes.
🔹 Detection on Higher Timeframes
Traders can choose to identify structures on the chart timeframe or on a higher timeframe.
In the chart above, we have the SP500 futures on the 5m timeframe with different settings: chart timeframe, 30m, and 1H.
🔹 Risk And Targets
Depending on whether the high-risk/reward parameter is enabled, traders can choose between three different targets and two different stops.
The chart above shows how different choices affect the risk/reward ratio for the same potential trade on the Gold Futures 2m chart.
🔶 SETTINGS
Show: Traders can choose between Trends, Reversals or Both.
🔹 Structures
Swing Length: Number of candles to confirm a swing high or swing low. A higher number detects larger swings.
Custom Timeframe: Traders can make use of the current chart timeframe, or choose a custom timeframe.
Reversal Area Threshold: A higher number increases the reversal area.
🔹 Trades
Trade Trigger Length: Number of candles to confirm an internal high or internal low. A lower number detects smaller swings. It must be the same size or smaller than the swing length.
Target: Traders can choose between the default target (0) or two extended targets (0.27 or 0.618).
Risk to Reward Threshold: Set the minimum risk-to-reward ratio to detect trades. Use the 0 value to detect all trades.
High Risk to Reward: Enable/Disable the high risk to reward mode.
Indicatori e strategie
Uptrick: Alpha TrendIntroduction
Uptrick: Alpha Trend is a comprehensive technical analysis indicator designed to provide traders with detailed insights into market trends, momentum, and risk metrics. It adapts to various trading styles—from quick scalps to longer-term positions—by dynamically adjusting its calculations and visual elements. By combining multiple smoothing techniques, advanced color schemes, and customizable data tables, the indicator offers a holistic view of market behavior.
Originality
The Alpha Trend indicator distinguishes itself by blending established technical concepts with innovative adaptations. It employs three different smoothing techniques tailored to specific trading modes (Scalp, Swing, and Position), and it dynamically adjusts its parameters to match the chosen mode. The indicator also offers a wide range of color palettes and multiple on-screen tables that display key metrics. This unique combination of features, along with its ability to adapt in real time, sets it apart as a versatile tool for both novice and experienced traders.
Features
1. Multi-Mode Trend Line
The indicator automatically selects a smoothing method based on the trading mode:
- Scalp Mode uses the Hull Moving Average (HMA) for rapid responsiveness.
- Swing Mode employs the Exponential Moving Average (EMA) for balanced reactivity.
- Position Mode applies the Weighted Moving Average (WMA) for smoother, long-term trends.
Each method is chosen to best capture the price action dynamics appropriate to the trader’s timeframe.
2. Adaptive Momentum Thresholds
It tracks bullish and bearish momentum with counters that increment as the trend confirms directional movement. When these counters exceed a user-defined threshold, the indicator generates optional buy or sell signals. This approach helps filter out minor fluctuations and highlights significant market moves.
3. Gradient Fills
Two types of fills enhance visual clarity:
- Standard Gradient Fill displays ATR-based zones above and below the trend line, indicating potential bullish and bearish areas.
- Fading Gradient Fill creates a smooth transition between the trend line and the price, visually emphasizing the distance between them.
4. Bar Coloring and Signal Markers
The indicator can color-code bars based on market conditions—bullish, bearish, or neutral—allowing for immediate visual assessment. Additionally, signal markers such as buy and sell arrows are plotted when momentum thresholds are breached.
5. Comprehensive Data Tables
Uptrick: Alpha Trend offers several optional tables for detailed analysis:
- Insider Info: Displays key metrics like the current trend value, bullish/bearish momentum counts, and ATR.
- Indicator Metrics: Lists input settings such as trend length, damping, signal threshold, and net momentum.
- Market Analysis: Summarizes overall trend direction, trend strength, Sortino ratio, return, and volatility.
- Price & Trend Dynamics: Details price deviation from the trend, trend slope, and ATR ratio.
- Momentum & Volatility Insights: Presents RSI, standard deviation (volatility), and net momentum.
- Performance & Acceleration Metrics: Focuses on the Sortino ratio, trend acceleration, return, and trend strength.
Each table can be positioned flexibly on the chart, allowing traders to customize the layout according to their needs.
Why It Combines Specific Smoothing Techniques
Smoothing techniques are essential for filtering out market noise and revealing underlying trends. The indicator combines three smoothing methods for the following reasons:
- The Hull Moving Average (HMA) in Scalp Mode minimizes lag and responds quickly to price changes, which is critical for short-term trading.
- The Exponential Moving Average (EMA) in Swing Mode gives more weight to recent data, striking a balance between speed and smoothness. This makes it suitable for mid-term trend analysis.
- The Weighted Moving Average (WMA) in Position Mode smooths out short-term fluctuations, offering a clear view of longer-term trends and reducing the impact of transient market volatility.
By using these specific methods in their respective trading modes, the indicator ensures that the trend line is appropriately responsive for the intended time frame, enhancing decision-making while maintaining clarity.
Inputs
1. Trend Length (Default: 30)
Defines the lookback period for the smoothing calculation. A shorter trend length results in a more responsive line, while a longer length produces a smoother, less volatile trend.
2. Trend Damping (Default: 0.75)
Controls the degree of smoothing applied to the trend line. Lower values lead to a smoother curve, whereas higher values increase sensitivity to price fluctuations.
3. Signal Strength Threshold (Default: 5)
Specifies the number of consecutive bullish or bearish bars required to trigger a signal. Higher thresholds reduce the frequency of signals, focusing on stronger moves.
4. Enable Bar Coloring (Default: True)
Toggles whether each price bar is colored to indicate bullish, bearish, or neutral conditions.
5. Enable Signals (Default: True)
When enabled, this option plots buy or sell arrows on the chart once the momentum thresholds are met.
6. Enable Standard Gradient Fill (Default: False)
Activates ATR-based gradient fills around the trend line to visualize potential support and resistance zones.
7. Enable Fading Gradient Fill (Default: True)
Draws a gradual color transition between the trend line and the current price, emphasizing their divergence.
8. Trading Mode (Options: Scalp, Swing, Position)
Determines which smoothing method and ATR period to use, adapting the indicator’s behavior to short-term, medium-term, or long-term trading.
9. Table Position Inputs
Allows users to select from nine possible chart positions (top, middle, bottom; left, center, right) for each data table.
10. Show Table Booleans
Separate toggles control the display of each table (Insider Info, Indicator Metrics, Market Analysis, and the three Deep Tables), enabling a customized view of the data.
Color Schemes
(Default) - The colors in the preview image of the indicator.
(Emerald)
(Sapphire)
(Golden Blaze)
(Mystic)
(Monochrome)
(Pastel)
(Vibrant)
(Earth)
(Neon)
Calculations
1. Trend Line Methods
- Scalp Mode: Utilizes the Hull Moving Average (HMA), which computes two weighted moving averages (one at half the length and one at full length), subtracts them, and then applies a final weighted average based on the square root of the length. This method minimizes lag and increases responsiveness.
- Swing Mode: Uses the Exponential Moving Average (EMA), which assigns greater weight to recent prices, thus balancing quick reaction with smoothness.
- Position Mode: Applies the Weighted Moving Average (WMA) to focus on longer-term trends by emphasizing the entire lookback period and reducing the impact of short-term volatility.
2. Momentum Tracking
The indicator maintains separate counters for bullish and bearish momentum. These counters increase as the trend confirms directional movement and reset when the trend reverses. When a counter exceeds the defined signal strength threshold, a corresponding signal (buy or sell) is triggered.
3. Volatility and ATR Zones
The Average True Range (ATR) is calculated using a period that adapts to the selected trading mode (shorter for Scalp, longer for Position). The ATR value is then used to define upper and lower zones around the trend line, highlighting the current level of market volatility.
4. Return and Trend Acceleration
- Return is calculated as the difference between the current and previous closing prices, providing a simple measure of price change.
- Trend Acceleration is derived from the change in the trend line’s movement (its first derivative) compared to the previous bar. This metric indicates whether the trend is gaining or losing momentum.
5. Sortino Ratio and Standard Deviation
- The Sortino Ratio measures risk-adjusted performance by comparing returns to downside volatility (only considering negative price changes).
- Standard Deviation is computed over the lookback period to assess the extent of price fluctuations, offering insights into market stability.
Usage
This indicator is suitable for various time frames and market instruments. Traders can enable or disable specific visual elements such as gradient fills, bar coloring, and signal markers based on their preference. For a minimalist approach, one might choose to display only the primary trend line. For a deeper analysis, enabling multiple tables can provide extensive data on momentum, volatility, trend dynamics, and risk metrics.
Important Note on Risk
Trading involves inherent risk, and no indicator can eliminate the uncertainty of the markets. Past performance is not indicative of future results. It is essential to use proper risk management, test any new tool thoroughly, and consult multiple sources or professional advice before making trading decisions.
Conclusion
Uptrick: Alpha Trend unifies a diverse set of calculations, adaptive smoothing techniques, and customizable visual elements into one powerful tool. By combining the Hull, Exponential, and Weighted Moving Averages, the indicator is able to provide a trend line that is both responsive and smooth, depending on the trading mode. Its advanced color schemes, gradient fills, and detailed data tables deliver a comprehensive analysis of market trends, momentum, and risk. Whether you are a short-term trader or a long-term investor, this indicator aims to clarify price action and assist you in making more informed trading decisions.
HyperTrend [LuxAlgo]
//@version=5
indicator("HyperTrend ", overlay=true, max_lines_count=500, max_labels_count=500, max_boxes_count=350)
bullcolor = #16e045
bearcolor = #e1320f
gr_customalert = "CUSTOM ALERTS CREATOR"
gr_signal = "MAIN SETTINGS"
gr_Basic_Settings = "BASIC SETTINGS"
gr_PullBacksignal = "PULLBACK SIGNALS SETTINGS"
gr_Other_Settings = "CLOUD SETTINGS"
gr_TrendTracer = "TREND TRACER SETTINGS"
gr_signalfilter = "SIGNAL FILTERS"
gr_candle = "CANDLE COLORING"
gr_RiskManage = "RISK MANAGEMENT"
gr_dash = "SMART PANEL"
gr_Conso = "CONSOLIDATION ZONE"
// Get user input
showSignals = input(true, "Show Signal's", group=gr_signal)
//showSignals = true
sensitivity = input.float(3.1, "Sensitivity", 0.1, step=0.1, group=gr_signal)
STuner = input.int(25, "Signal Tuner(1-25)", minval = 1, maxval = 25, group=gr_signal)
Presets = input.string("All Signals", "Presets", , group=gr_signal)
TextStyle = input.string("Minimal", "Signal Style", , group=gr_signal)
consSignalsFilter = input(false, "Trending Signal Only", group=gr_signalfilter ,inline = "F1")
StrongSignalsOnly = input(false, "Strong Signals Only", group=gr_signalfilter ,inline = "F1")
highVolSignals = input(false, "High Volume Signals only", group=gr_signalfilter ,inline = "F2")
signalsTrendCloud = input(false, "Cloud Signals only", group=gr_signalfilter ,inline = "F2")
ContrarianOnly = input(false, "Contrarian Signals Only ", group=gr_signalfilter ,inline = "F3")
Show_PR = input.bool(true, title="Show PullBack Signals", group = gr_PullBacksignal , inline = "Features1")
MSTuner = input.int(5, "PullBack Tuner(2-30)", minval = 2, maxval = 30, group=gr_PullBacksignal)
TrendMap = input.string(title='Heatmap Mode', defval='Trend Gradient', options= ,group=gr_candle,tooltip="Use to adjust the bar coloring to indicate market sentiment")
momentumCandles = input(false, "No Momentum Candles", group=gr_candle)
LongTrendAverage = input(true, 'Trend Tracer', group = gr_TrendTracer, tooltip='Places A EMA Which have a trend filtering capability Trend Cloud Line (EMA), Will Be Shown On The Chart')
LTAsensitivity = input.int(250, 'Trend Tracer Length', group=gr_TrendTracer)
showTrendCloud = input(true, "Show Trend cloud", group=gr_Other_Settings)
periodTrendCloud = input.string("Smooth", "Trend Cloud Style", , group=gr_Other_Settings)
//ScalpingPlus = input(false, "Fast trend cloud", group=gr_Other_Settings)
//fastTrendCloudLen = input.int(55, "Fast trend cloud", 2, group=gr_Other_Settings)
fastTrendCloudLen = 55
showDashboard = input(true, "Smart Panel", group = gr_dash , inline = "Features1")
locationDashboard = input.string("Bottom Right", "Table Location", , group = gr_dash , tooltip="Smart Panel")
sizeDashboard = input.string("Small", "Table Size", , group = gr_dash , tooltip="Smart Panel")
tpLabels = input(true, "Dynamic Take Profit Lables", group=gr_RiskManage)
ShowTpSlAreas = input(true, "Show take Profit/Stop-loss Area", group=gr_RiskManage)
ShowTrailingSL = input(false, "Show trailing Stop-loss", group=gr_RiskManage)
usePercSL = input(false, "SL/TRAILING", inline="1", group=gr_RiskManage)
percTrailingSL = input.float(1, "", 0, step=0.1, inline="1", group=gr_RiskManage)
useTP1 = input(true, "", inline="1", group=gr_RiskManage)
multTP1 = input.float(1, "TP 1", 0, inline="1", group=gr_RiskManage)
useTP2 = input(true, "", inline="4", group=gr_RiskManage)
multTP2 = input.float(2, "TP 2 ", 0, inline="4", group=gr_RiskManage)
useTP3 = input(true, "", inline="4", group=gr_RiskManage)
multTP3 = input.float(3, "TP 3", 0, inline="4", group=gr_RiskManage)
ShowSwings = input(false, "Show Market Structure ", inline="3", group=gr_RiskManage)
periodSwings = input.int(10, " ", 2, inline="3", group=gr_RiskManage)
//showTS = input(title='Show Trend Shifter', defval=false, group='Contrarian SIGNALS')
length = input.int(50, 'Length', minval=1, group='Contrarian SIGNALS')
SSF = input.int(30, 'Smoothing Factor ', minval=1, group='Contrarian SIGNALS')
CSFSELL = input.int(60, 'OB', minval=1, group='Contrarian SIGNALS' , inline = "SEXY")
CSFBUY = input.int(40, 'OS', minval=1, group='Contrarian SIGNALS', inline = "SEXY")
// showsignals = input(title='Show Signals', defval=false, group='Contrarian SIGNALS')
// Alerts Managemnt
Normalbuy_alert = input.bool(title='Buy Signal ', defval=false, inline = "NB", group=gr_customalert)
Strongbuy_alert = input.bool(title='Strong Buy', defval=false, inline = "NB", group=gr_customalert)
Normalsell_alert = input.bool(title='Sell Signal ', defval=false , inline = "NS", group=gr_customalert)
Strongsell_alert = input.bool(title='Strong Sell', defval=false , inline = "NS", group=gr_customalert)
slalert = input.bool(title='Stop-Loss ', defval=false , inline = "SLTP1", group=gr_customalert)
tp1alert = input.bool(title='Target 1', defval=false , inline = "SLTP1", group=gr_customalert)
tp2alert = input.bool(title='Target 2 ', defval=false , inline = "TP2TP3", group=gr_customalert)
tp3alert = input.bool(title='Target 3', defval=false , inline = "TP2TP3", group=gr_customalert)
bullcrosscloud_alert = input.bool(title='Bullish Cloud', defval=false, inline = "CD", group=gr_customalert)
bearcrosscloud_alert = input.bool(title='Bearish Cloud', defval=false, inline = "CD", group=gr_customalert)
showCons = false
paintCons = false
colorZone = color.white
lbPeriod = 10
lenCons = 5
// Signal Text
SimpleBuy = "Buy"
StrongB = "Strong Buy"
SimpleSell = "Sell"
StrongS = "Strong Sell"
if TextStyle == "Normal"
SimpleBuy := "Buy"
StrongB := "Strong Buy"
SimpleSell:= "Sell"
StrongS := "Strong Sell"
if TextStyle == "Minimal"
SimpleBuy := "Buy"
StrongB := "Strong Buy"
SimpleSell:= "Sell"
StrongS := "Strong Sell"
// Signal Text Color
bullsignalcolor = color.rgb(0, 0, 0)
bearsignalcolor = color.rgb(0, 0, 0)
if TextStyle == "Normal"
bullsignalcolor := color.rgb(0, 0, 0)
bearsignalcolor := color.rgb(0, 0, 0)
if TextStyle == "Minimal"
bullsignalcolor := color.rgb(0, 0, 0)
bearsignalcolor := color.rgb(0, 0, 0)
src = close
RSII = ta.ema(ta.rsi(src, length), SSF)
TR = math.abs(RSII - RSII )
wwalpha = 1 / length
WWMA = 0.0
WWMA := wwalpha * TR + (1 - wwalpha) * nz(WWMA )
ATRRSI = 0.0
ATRRSI := wwalpha * WWMA + (1 - wwalpha) * nz(ATRRSI )
TsFast = ta.ema(ta.rsi(src, length), SSF)
TsUP = TsFast + ATRRSI * 4.236
TsDN = TsFast - ATRRSI * 4.236
TsSlow = 0.0
TsSlow := TsUP < nz(TsSlow ) ? TsUP : TsFast > nz(TsSlow ) and TsFast < nz(TsSlow ) ? TsDN : TsDN > nz(TsSlow ) ? TsDN : TsFast < nz(TsSlow ) and TsFast > nz(TsSlow ) ? TsUP : nz(TsSlow )
Colorh = TsFast > 55 ? color.rgb(255, 0, 0) : TsFast < 45 ? color.rgb(0, 255, 8) : #ffffff
//QQF = plot(TsFast, 'TS FAST', color=color.new(color.maroon, 100), linewidth=2, display=display.none, editable = false)
//QQS = plot(TsSlow, 'TS SLOW', color=color.new(color.white, 100), linewidth=2, display=display.none , editable = false)
//plot(TsFast, color=Colorh, linewidth=2, style=plot.style_area, histbase=50)
//BearLimit = hline(60, color=color.gray, linestyle=hline.style_dashed)
//BullLimt = hline(40, color=color.gray, linestyle=hline.style_dashed)
bulllim = 45
bearlim = 55
BullSignalr = ta.crossover(TsFast, TsSlow) and TsFast < bulllim
BearSignallr = ta.crossunder(TsFast, TsSlow) and TsFast > bearlim
/////////////////////////////////////////////////////////
// Trap Detector
////////////////////////////////////////////////////////
// Functions
wavetrend(src, chlLen, avgLen) =>
esa = ta.ema(src, chlLen)
d = ta.ema(math.abs(src - esa), chlLen)
ci = (src - esa) / (0.015 * d)
wt1 = ta.ema(ci, avgLen)
wt2 = ta.sma(wt1, 3)
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) =>
fractalTop = f_fractalize(src) > 0 and src >= topLimit ? src : na
fractalBot = f_fractalize(src) < 0 and src <= botLimit ? 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
// Get components
= wavetrend(close, 5*MSTuner, 10*MSTuner)
= f_findDivs(wt2, 10, -35)
= f_findDivs(wt2, 40, -70)
wtDivBull = wtDivBull1 or wtDivBull2
wtDivBear = wtDivBear1 or wtDivBear2
plotshape(ta.crossover(wt1, wt2) and Show_PR and wt2 <= -60, "PullBack Buy" , shape.circle, location.belowbar, color.new(bullcolor,60), size=size.tiny)
plotshape(ta.crossunder(wt1, wt2) and Show_PR and wt2 >= 60, "PullBack Sell", shape.circle, location.abovebar, color.new(bearcolor,60), size=size.tiny)
rsi = ta.rsi(close ,14)
// Functions
f_chartTfInMinutes() =>
float _resInMinutes = timeframe.multiplier * (
timeframe.isseconds ? 1. / 60 :
timeframe.isminutes ? 1. :
timeframe.isdaily ? 60. * 24 :
timeframe.isweekly ? 60. * 24 * 7 :
timeframe.ismonthly ? 60. * 24 * 30.4375 : na)
atr(len) =>
tr = ta.tr
atr = 0.0
atr := nz(atr + (tr - atr ) / len, tr)
supertrend(src, factor, len) =>
atr = ta.atr(len)
upperBand = src + factor * atr
lowerBand = src - factor * atr
prevLowerBand = nz(lowerBand )
prevUpperBand = nz(upperBand )
lowerBand := lowerBand > prevLowerBand or close < prevLowerBand ? lowerBand : prevLowerBand
upperBand := upperBand < prevUpperBand or close > prevUpperBand ? upperBand : prevUpperBand
int direction = na
float superTrend = na
prevSuperTrend = superTrend
if prevSuperTrend == prevUpperBand
direction := close > upperBand ? 1 : -1
else
direction := close < lowerBand ? -1 : 1
superTrend := direction == 1 ? lowerBand : direction == -1 ? upperBand : na
dchannel(len)=>
hh = ta.highest(len)
ll = ta.lowest (len)
trend = 0
trend := close > hh ? 1 : close < ll ? -1 : nz(trend )
trendScalper(show, len1, len2, len3, colorBull, colorBear, colorBarBull, colorBarBear) =>
avgOC = math.avg(open, close)
ha_o = 0.0, ha_o := na(ha_o ) ? avgOC : (ha_o + ohlc4 ) / 2
ema1 = ta.ema(ha_o, len1), ema2 = ta.ema(ha_o, len2), ema3 = ta.ema(ha_o, len3)
ris1 = ema1 > ema1 , ris2 = ema2 > ema2 , ris3 = ema3 > ema3
fal1 = ema1 < ema1 , fal2 = ema2 < ema2 , fal3 = ema3 < ema3
colorEma1 = ris1 ? colorBull : fal1 ? colorBear : na, colorEma2 = ris2 ? colorBull : fal2 ? colorBear : na, colorEma3 = ris3 ? colorBull : fal3 ? colorBear : na
fillEma1 = avgOC > ema1 ? colorBull : avgOC < ema1 ? colorBear : na, fillEma2 = ema1 > ema2 ? colorBull : ema1 < ema2 ? colorBear : na, fillEma3 = ema2 > ema3 ? colorBull : ema2 < ema3 ? colorBear : na
colorBar = close < ema1 and close < ema2 ? colorBarBear : colorBarBull
candlesMom() =>
= ta.macd(close, 2, 4, 3)
(macd > 10 and macd > macd ) or (macd < 10 and macd < macd )
trailingSL(buy, sell, factor, len, usePerc, perc) =>
atr = atr(len)
upperBand = high + (usePerc ? high * (perc / 100) : factor * atr)
lowerBand = low - (usePerc ? low * (perc / 100) : factor * atr)
prevLowerBand = nz(lowerBand )
prevUpperBand = nz(upperBand )
lowerBand := lowerBand > prevLowerBand or buy ? lowerBand : prevLowerBand
upperBand := upperBand < prevUpperBand or sell ? upperBand : prevUpperBand
int direction = na
float stop = na
prevSuperTrend = stop
if prevSuperTrend == prevUpperBand
direction := buy ? 1 : -1
else
direction := sell ? -1 : 1
stop := direction == 1 ? lowerBand : direction == -1 ? upperBand : na
add_to_zz(zz, val, bi) =>
array.unshift(zz, bi)
array.unshift(zz, val)
if array.size(zz) > 12
array.pop(zz)
update_zz(zz, val, bi, dir) =>
if array.size(zz) == 0
add_to_zz(zz, val, bi)
else
if dir == 1 and val > array.get(zz, 0) or dir == -1 and val < array.get(zz, 0)
array.set(zz, 0, val)
array.set(zz, 1, bi)
0
// Get components
vosc = ta.obv - ta.ema(ta.obv, 20)
bs = ta.ema(nz(math.abs((open - close) / (high - low) * 100)), 3)
ema = ta.ema(close, 200)
emaBull = close > ema
equal_tf(res) => str.tonumber(res) == f_chartTfInMinutes()
higher_tf(res) => str.tonumber(res) > f_chartTfInMinutes()
too_small_tf(res) => (timeframe.isweekly and res=="1") or (timeframe.ismonthly and str.tonumber(res) < 10)
securityNoRep(sym, res, src) =>
bool bull = na
bull := equal_tf(res) ? src : bull
bull := higher_tf(res) ? request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on) : bull
bull_array = request.security_lower_tf(syminfo.tickerid, higher_tf(res) ? str.tostring(f_chartTfInMinutes()) : too_small_tf(res) ? (timeframe.isweekly ? "3" : "10") : res, src)
if array.size(bull_array) > 1 and not equal_tf(res) and not higher_tf(res)
bull := array.pop(bull_array)
array.clear(bull_array)
bull
TF1Bull = securityNoRep(syminfo.tickerid, "1" , emaBull)
TF3Bull = securityNoRep(syminfo.tickerid, "3" , emaBull)
TF5Bull = securityNoRep(syminfo.tickerid, "5" , emaBull)
TF10Bull = securityNoRep(syminfo.tickerid, "10" , emaBull)
TF15Bull = securityNoRep(syminfo.tickerid, "15" , emaBull)
TF30Bull = securityNoRep(syminfo.tickerid, "30" , emaBull)
TF60Bull = securityNoRep(syminfo.tickerid, "60" , emaBull)
TF120Bull = securityNoRep(syminfo.tickerid, "120" , emaBull)
TF240Bull = securityNoRep(syminfo.tickerid, "240" , emaBull)
TF720Bull = securityNoRep(syminfo.tickerid, "720" , emaBull)
TFDBull = securityNoRep(syminfo.tickerid, "1440", emaBull)
ema150 = ta.ema(close, 150)
ema250 = ta.ema(close, 250)
hma55 = ta.hma(close, 55 )
= ta.macd(close, 12, 26, 9)
supertrend = supertrend(close, sensitivity, STuner)
maintrend = dchannel(30)
confBull = (ta.crossover (close, supertrend) or (ta.crossover (close, supertrend) and maintrend < 0)) and macd > 0 and macd > macd and ema150 > ema250 and hma55 > hma55 and maintrend > 0
confBear = (ta.crossunder(close, supertrend) or (ta.crossunder(close, supertrend) and maintrend > 0)) and macd < 0 and macd < macd and ema150 < ema250 and hma55 < hma55 and maintrend < 0
trendcloud = supertrend(ohlc4, periodTrendCloud == "Swing" ? 7 : 4, 10)
hma = periodTrendCloud == "Scalping+" ? ta.hma(close, fastTrendCloudLen) : na
none = close > 0
= ta.dmi(14, 14)
consFilter = adx > 20
ContBear = TsFast > CSFSELL
ContBull = TsFast < CSFBUY
StrongFilter = ta.ema(close, 200)
//volFilter = (ta.ema(volume, 25) - ta.ema(volume, 26)) / ta.ema(volume, 26) > 0
volFilter = (ta.ema(volume, 15) - ta.ema(volume, 20)) / ta.ema(volume, 25) > 0
trendFilter = trendcloud
bull = (Presets == "All Signals" ? ta.crossover (close, supertrend) : confBull and not confBull ) and Presets != "Trend Scalper" and (StrongSignalsOnly ? close > StrongFilter : none) and (ContrarianOnly ? ContBull : none) and (consSignalsFilter ? consFilter : none) and (highVolSignals ? volFilter : none) and (signalsTrendCloud ? (periodTrendCloud == "Smooth" ? ema150 > ema250 : close > trendFilter) : none)
bear = (Presets == "All Signals" ? ta.crossunder(close, supertrend) : confBear and not confBear ) and Presets != "Trend Scalper" and (StrongSignalsOnly ? close < StrongFilter : none) and (ContrarianOnly ? ContBear : none) and (consSignalsFilter ? consFilter : none) and (highVolSignals ? volFilter : none) and (signalsTrendCloud ? (periodTrendCloud == "Smooth" ? ema150 < ema250 : close < trendFilter) : none)
countBull = ta.barssince(bull)
countBear = ta.barssince(bear)
trigger = nz(countBull, bar_index) < nz(countBear, bar_index) ? 1 : 0
= trendScalper(Presets == "Trend Scalper" ? true : false, 5, 9, 21, bullcolor, bearcolor, bullcolor, bearcolor)
trailingStop = trailingSL(bull, bear, 2.2, 14, usePercSL, percTrailingSL)
float _ph = ta.highestbars(high, periodSwings) == 0 ? high : na
float _pl = ta.lowestbars (low, periodSwings) == 0 ? low : na
var _dir = 0, dir_ = _pl and na(_ph) ? -1 : _dir, _dir := _ph and na(_pl) ? 1 : dir_, dirChg = ta.change(_dir)
var zz = array.new_float(0), zzOld = array.copy(zz)
float zzLive = _ph or _pl ? (dirChg ? add_to_zz(zz, _dir == 1 ? _ph : _pl, bar_index) : update_zz(zz, _dir == 1 ? _ph : _pl, bar_index, _dir)) : na
float hb_ = ta.highestbars(lbPeriod) == 0 ? high : na
float lb_ = ta.lowestbars (lbPeriod) == 0 ? low : na
var int dir = 0
float zz_ = na
float pp = na
var int consCnt = 0
var float condHi = na
var float condLo = na
float H_ = ta.highest(lenCons)
float L_ = ta.lowest (lenCons)
var line lineUp = na
var line lineDn = na
bool breakUp = false
bool breakDn = false
var float pvh1_price = array.new_float(1000, na)
var int pvh1_time = array.new_int (1000, na)
var float pvl1_price = array.new_float(1000, na)
var int pvl1_time = array.new_int (1000, na)
var float pvh2_price = array.new_float(1000, na)
var int pvh2_time = array.new_int (1000, na)
var float pvl2_price = array.new_float(1000, na)
var int pvl2_time = array.new_int (1000, na)
var float htcmrll_price = na
var int htcmrll_time = na
var float ltcmrhh_price = na
var int ltcmrhh_time = na
var box long_boxes = array.new_box()
var box short_boxes = array.new_box()
var float temp_pv_0 = na
var float temp_pv_1 = na
var float temp_pv_2 = na
bool pvh = high < high and high > high
bool pvl = low > low and low < low
int pv1_time = bar_index
float pv1_high = high
float pv1_low = low
var buyBars = array.new_box(365, na)
for i = 0 to 364
box.delete(array.get(buyBars, i))
var sellBars = array.new_box(365, na)
for i = 0 to 364
box.delete(array.get(sellBars, i))
// Colors
green = bullcolor, green50 = color.new(green, 50), green20 = color.new(green, 80)
red = bearcolor, red50 = color.new(red, 50), red20 = color.new(red, 80)
silver = #B2B5BE, silver50 = color.new(silver, 50), silver20 = color.new(silver, 80)
// Plots
atrBand = usePercSL ? (trigger ? low : high) * (percTrailingSL / 100) : ta.atr(14) * 2.2
atrStop = trigger ? low - atrBand : high + atrBand
lastTrade(src) => ta.valuewhen(bull or bear, src, 0)
entry_y = lastTrade(close)
stop_y = lastTrade(atrStop)
tp1_y = (entry_y-lastTrade(atrStop))*multTP1 + entry_y
tp2_y = (entry_y-lastTrade(atrStop))*multTP2 + entry_y
tp3_y = (entry_y-lastTrade(atrStop))*multTP3 + entry_y
labelTpSl(cond, y, txt, color) =>
label labelTpSl = ShowTpSlAreas and cond ? label.new(bar_index + 1, y, txt, xloc.bar_index, yloc.price, color, label.style_label_left, color.white, size.normal) : na
label.delete(labelTpSl )
labelTpSl(none, entry_y, "Entry : " + str.tostring(math.round_to_mintick(entry_y)), color.orange)
labelTpSl(none, stop_y , "Stop loss : " + str.tostring(math.round_to_mintick(atrStop)), bearcolor)
labelTpSl(useTP1 and multTP1 != 0, tp1_y, "TP 1 : " + str.tostring(math.round_to_mintick(tp1_y)), bullcolor)
labelTpSl(useTP2 and multTP2 != 0, tp2_y, "TP 2 : " + str.tostring(math.round_to_mintick(tp2_y)), bullcolor)
labelTpSl(useTP3 and multTP3 != 0, tp3_y, "TP 3 : " + str.tostring(math.round_to_mintick(tp3_y)), bullcolor)
lineTpSl(cond, y, color, style) =>
line lineTpSl = ShowTpSlAreas and cond ? line.new(bar_index - (trigger ? countBull : countBear), y, bar_index + 1, y, xloc.bar_index, extend.none, color, style) : na
line.delete(lineTpSl )
lineTpSl(none, entry_y, color.orange, line.style_dashed)
lineTpSl(none, stop_y , bearcolor , line.style_solid )
lineTpSl(useTP1 and multTP1 != 0, tp1_y, bullcolor, line.style_dotted)
lineTpSl(useTP2 and multTP2 != 0, tp2_y, bullcolor, line.style_dotted)
lineTpSl(useTP3 and multTP3 != 0, tp3_y, bullcolor, line.style_dotted)
buy = showSignals and bull ? label.new(bar_index, low , close > StrongFilter ? StrongB : SimpleBuy , xloc.bar_index, yloc.belowbar, bullcolor, label.style_label_up , bullsignalcolor, size.normal) : na
sell = showSignals and bear ? label.new(bar_index, high, close < StrongFilter ? StrongS : SimpleSell , xloc.bar_index, yloc.abovebar, bearcolor , label.style_label_down, bearsignalcolor, size.normal) : na
tpLabels(tp) =>
tp1Bull = ta.crossover (rsi, 70), tp2Bull = ta.crossover (rsi, 75), tp3Bull = ta.crossover (rsi, 80)
tp1Bear = ta.crossunder(rsi, 30), tp2Bear = ta.crossunder(rsi, 25), tp3Bear = ta.crossunder(rsi, 20)
tp1Bull := tp1Bull and (nz(ta.barssince(tp1Bull) , 9999) > countBull), tp2Bull := tp2Bull and (ta.barssince(tp1Bull) <= countBull), tp2Bull := tp2Bull and (nz(ta.barssince(tp2Bull) , 9999) > countBull), tp3Bull := tp3Bull and (ta.barssince(tp2Bull) <= countBull), tp3Bull := tp3Bull and (nz(ta.barssince(tp3Bull) , 9999) > countBull)
tp1Bear := tp1Bear and (nz(ta.barssince(tp1Bear) , 9999) > countBear), tp2Bear := tp2Bear and (ta.barssince(tp1Bear) <= countBear), tp2Bear := tp2Bear and (nz(ta.barssince(tp2Bear) , 9999) > countBear), tp3Bear := tp3Bear and (ta.barssince(tp2Bear) <= countBear), tp3Bear := tp3Bear and (nz(ta.barssince(tp3Bear) , 9999) > countBear)
if Presets != "Trend Scalper" and tpLabels
trigger ? (tp == 1 ? tp1Bull : tp == 2 ? tp2Bull : tp3Bull) : (tp == 1 ? tp1Bear : tp == 2 ? tp2Bear : tp3Bear)
plotshape(tpLabels(1), "", shape.xcross, location.abovebar, trigger ? green : na , 0, "TP 1", trigger ? green : na , false)
plotshape(tpLabels(2), "", shape.xcross, location.abovebar, trigger ? green : na , 0, "TP 2", trigger ? green : na , false)
plotshape(tpLabels(3), "", shape.xcross, location.abovebar, trigger ? green : na , 0, "TP 3", trigger ? green : na , false)
plotshape(tpLabels(1), "", shape.xcross, location.belowbar, trigger ? na : red, 0, "TP 1", trigger ? na : red, false)
plotshape(tpLabels(2), "", shape.xcross, location.belowbar, trigger ? na : red, 0, "TP 2", trigger ? na : red, false)
plotshape(tpLabels(3), "", shape.xcross, location.belowbar, trigger ? na : red, 0, "TP 3", trigger ? na : red, false)
var label zzLabel = na
if array.size(zz) > 12 and ShowSwings
if array.get(zz, 0) != array.get(zzOld, 0) or array.get(zz, 1) != array.get(zzOld, 1)
if array.get(zz, 2) == array.get(zzOld, 2) and array.get(zz, 3) == array.get(zzOld, 3)
label.delete(zzLabel)
zzLabel := label.new(math.round(array.get(zz, 1)), array.get(zz, 0), _dir == 1 ? array.get(zz, 0) > array.get(zz, 4) ? ((array.get(zz, 4) < array.get(zz, 8)) ? "High" : "HH") : "LH" : array.get(zz, 0) < array.get(zz, 4) ? ((array.get(zz, 4) > array.get(zz, 8)) ? "Low" : "LL") : "HL", xloc.bar_index, yloc.price, color.new(color.white, 100), _dir == 1 ? label.style_label_down : label.style_label_up, _dir == 1 ? bullcolor : bearcolor)
if showCons and barstate.isconfirmed
dir := hb_ and na(lb_) ? 1 : lb_ and na(hb_) ? -1 : dir
if hb_ and lb_
if dir == 1
zz_ := hb_
else
zz_ := lb_
else
zz_ := hb_ ? hb_ : lb_ ? lb_ : na
for x = 0 to 1000
if na(close) or dir != dir
break
if zz_
if na(pp)
pp := zz_
else
if dir == 1 and zz_ > pp
pp := zz_
if dir == -1 and zz_ < pp
pp := zz_
if pp != pp
if consCnt > lenCons
if pp > condHi
breakUp := true
if pp < condLo
breakDn := true
if consCnt > 0 and pp <= condHi and pp >= condLo
consCnt += 1
else
consCnt := 0
else
consCnt += 1
if consCnt >= lenCons
if consCnt == lenCons
condHi := H_
condLo := L_
else
line.delete(lineUp)
line.delete(lineDn)
condHi := math.max(condHi, high)
condLo := math.min(condLo, low )
lineUp := line.new(bar_index, condHi , bar_index - consCnt, condHi , color=bearcolor , style=line.style_dashed)
lineDn := line.new(bar_index, condLo , bar_index - consCnt, condLo , color=color.lime, style=line.style_dashed)
fill(plot(condHi, "", na, 1, plot.style_stepline, editable=false), plot(condLo, "", na, 1, plot.style_stepline, editable=false), paintCons and consCnt > lenCons ? colorZone : na, "", false)
buy_col = color.new(#0ac20a,0)
sell_col = color.new(#fd1605,0)
text_col = color.new(#FFFFFF,0)
// -------- Bearish trend (blue) color selection --------
getSellColor(count) =>
if count == 1
color.new(#11e7f2,0)
else
if count == 2
color.new(#11d9f2,0)
else
if count == 3
color.new(#11cbf2,0)
else
if count == 4
color.new(#11aff2,0)
else
if count == 5
color.new(#1193f2,0)
else
if count == 6
color.new(#1176f2,0)
else
if count == 7
color.new(#105df4,0)
else
if count == 8
color.new(#1051f5,0)
else
if count == 9
color.new(#0f44f5,0)
else
if count == 10
color.new(#0c3de0,0)
else
if count == 11
color.new(#0935ca,0)
else
if count == 12
color.new(#062eb4,0)
else
if count == 13
color.new(#02269e,0)
// -------- Bullish trend (blue) color selection --------
getBuyColor(count) =>
if count == 1
color.new(#eef211,0)
else
if count == 2
color.new(#efdc11,0)
else
if count == 3
color.new(#f0c511,0)
else
if count == 4
color.new(#f1af11,0)
else
if count == 5
color.new(#f29811,0)
else
if count == 6
color.new(#f28811,0)
else
if count == 7
color.new(#f27811,0)
else
if count == 8
color.new(#f26811,0)
else
if count == 9
color.new(#f25811,0)
else
if count == 10
color.new(#ea420d,0)
else
if count == 11
color.new(#e12c09,0)
else
if count == 12
color.new(#d81605,0)
else
if count == 13
color.new(#cf0000,0)
// -------- Calculate bearish trend sequence --------
buySetup = 0
buySetup := close < close ? buySetup == 13 ? 1 : buySetup + 1 : 0
// -------- Calculate bullish trend sequence --------
sellSetup = 0
sellSetup := close > close ? sellSetup == 13 ? 1 : sellSetup + 1 : 0
// -------- Paint bars --------
barColour = buySetup >= 1 ? getBuyColor(buySetup) : sellSetup >= 1 ? getSellColor(sellSetup) : na
// Candle Coloring
// Input
FastteyLength = 12
SjlowLeyLength = 26
srrrc = close
signalXLength = 9
// Data reference
= ta.macd(srrrc, FastteyLength, SjlowLeyLength, signalXLength)
// 4 level of green
greenHigh = #eeff00
greenMidHigh = #c7ca00
greenMidLow = #ddb500
greenLow = #8635ff
// Yellow
yellowLow = #8635ff
// 4 level of red
redHigh = color.rgb(255, 255, 255)
redMidHigh = #cecece
redMidLow = #dbdbdb
redLow = #8635ff
// Default color
candleBody = yellowLow
// Ranging trend
if histX > 0
if histX > histX and histX > 0
candleBody := greenLow
if histX < 0
if histX < histX and histX < 0
candleBody := redLow
// Bullish trend
if MacdX > 0 and histX > 0
candleBody := greenMidLow
if histX > histX and MacdX > 0 and histX > 0
candleBody := greenMidHigh
if histX > histX and MacdX > 0 and histX > 0
candleBody := greenHigh
// Bearish trend
if MacdX < 0 and histX < 0
candleBody := redMidLow
if histX < histX and MacdX < 0 and histX < 0
candleBody := redMidHigh
if histX < histX and MacdX < 0 and histX < 0
candleBody := redHigh
//barcolor(candleBody)
//barcolor(TrendMap == 'RSI Gradient' ? barColour : na, title='Bar colors (heatmap)',editable=false)
barcolor(momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false)
//plotcandle(open, high, low, close , color = momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false , wickcolor = momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false , bordercolor = momentumCandles and candlesMom() ? color.rgb(187, 187, 187) : TrendMap == 'Signal Based' ? (Presets == "Trend Scalper" ? colorBar : na(countBull) and na(countBear) ? color.gray : trigger ? bullcolor : bearcolor) : TrendMap == 'RSI Gradient' ? barColour : TrendMap == 'Trend Gradient' ? candleBody : na , editable=false , editable = false)
fill(plot(showTrendCloud and periodTrendCloud == "Smooth" ? ema150 : na, "", na, editable=false), plot(showTrendCloud and periodTrendCloud == "Smooth" ? ema250 : na, "", na, editable=false), ema150 > ema250 ? color.new(bullcolor, 70) : ema150 < ema250 ? color.new(bearcolor, 70) : na)
plot(ShowTrailingSL and trigger and nz(ta.barssince(low < trailingStop), bar_index) > countBull ? trailingStop : na, "", green, 1, plot.style_linebr, editable=false)
plot(ShowTrailingSL and not trigger and nz(ta.barssince(high > trailingStop), bar_index) > countBear ? trailingStop : na, "", red , 1, plot.style_linebr, editable=false)
p0 = plot(avgOC, "", na , editable=false)
p1 = plot(ema5 , "", colorEma5 , editable=false)
p2 = plot(ema9 , "", colorEma9 , editable=false)
p3 = plot(ema21, "", colorEma21, editable=false)
plot(LongTrendAverage ? ta.ema(close, LTAsensitivity) : na, 'Trend Tracer', linewidth=2, color=close > ta.ema(close, LTAsensitivity) ? color.new(bullcolor, 45) : color.new(bearcolor, 45))
fill(p0, p1, fillEma5 )
fill(p1, p2, fillEma9 )
fill(p2, p3, fillEma21)
fill(plot(showTrendCloud and periodTrendCloud != "Smooth" and periodTrendCloud != "Scalping+" and trendcloud != 0 and close > trendcloud ? trendcloud : na, "", bullcolor, 1, plot.style_linebr, editable=false), p0, color.new(bullcolor, 90))
fill(plot(showTrendCloud and periodTrendCloud != "Smooth" and periodTrendCloud != "Scalping+" and trendcloud != 0 and close < trendcloud ? trendcloud : na, "", bearcolor , 1, plot.style_linebr, editable=false), p0, color.new(bearcolor , 90))
fill(plot(hma, "", hma > hma ? green : hma < hma ? red : na, editable=false), plot(hma , "", hma > hma ? green : hma < hma ? red : na, editable=false), hma > hma ? green : hma < hma ? red : na)
/////////////////////////////////////////////////////////
// Money Moves
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
// Get user input
indicatorTF = "Chart"
// Functions
sqz(bbLen, bbMult, kcLen, kcMult, source) =>
upperBB = ta.sma(source, bbLen) + ta.stdev(source, bbLen) * bbMult
lowerBB = ta.sma(source, bbLen) - ta.stdev(source, bbLen) * bbMult
upperKC = ta.sma(source, kcLen) + ta.sma(ta.tr, kcLen) * kcMult
lowerKC = ta.sma(source, kcLen) - ta.sma(ta.tr, kcLen) * kcMult
sqzOn = lowerBB > lowerKC and upperBB < upperKC
sqzOff = lowerBB < lowerKC and upperBB > upperKC
qqe(rsiLen, rsiSmooth, factor, source, bbLen, bbMult) =>
rsiMa = ta.ema(ta.rsi(source, rsiLen), rsiSmooth)
delta = ta.ema(ta.ema(math.abs(ta.mom(rsiMa, 1)), rsiLen * 2 - 1), rsiLen * 2 - 1) * factor
longBand = 0.0, longBand := rsiMa > longBand and rsiMa > longBand ? math.max(longBand , rsiMa - delta) : rsiMa - delta
shortBand = 0.0, shortBand := rsiMa < shortBand and rsiMa < shortBand ? math.min(shortBand , rsiMa + delta) : rsiMa + delta
cross1 = ta.cross(rsiMa, shortBand )
cross2 = ta.cross(rsiMa, longBand )
trend = 0.0, trend := cross1 ? 1 : cross2 ? -1 : nz(trend , 1)
fastDelta = trend == 1 ? longBand : shortBand
_hist = rsiMa - 50
_line = fastDelta - 50
= ta.bb(_line, bbLen, bbMult)
// Get components
cond(_offset) =>
top = ta.highest(high, 10)
bot = ta.lowest(low, 10)
osc = ta.ema(hlc3, 5) - ta.ema(ohlc4, 20)
oscRis = osc > osc
oscFal = osc < osc
oscA0 = osc > 0
oscB0 = osc < 0
oscTop = oscFal and oscRis
oscBot = oscRis and oscFal
bullR = oscB0 and oscBot and ((osc > ta.valuewhen(oscB0 and oscBot, osc, 1) and bot < ta.valuewhen(oscB0 and oscBot, bot, 1)))
bearR = oscA0 and oscTop and ((osc < ta.valuewhen(oscA0 and oscTop, osc, 1) and top > ta.valuewhen(oscA0 and oscTop, top, 1)))
bullH = oscB0 and oscBot and ((osc < ta.valuewhen(oscB0 and oscBot, osc, 1) and bot > ta.valuewhen(oscB0 and oscBot, bot, 1)))
bearH = oscA0 and oscTop and ((osc > ta.valuewhen(oscA0 and oscTop, osc, 1) and top < ta.valuewhen(oscA0 and oscTop, top, 1)))
= sqz(20, 2, 20, 2, close)
= qqe(6, 6, 3, close, 50, 0.001)
= qqe(6, 5, 1.618, close, 50, 1)
= ta.dmi(14, 14)
[osc , oscRis , oscFal , oscA0 , oscB0 , oscTop , oscBot , bullR , bearR , bullH , bearH , sqzOn , sqzOff , _hist1 , upper1 , lower1 , _hist2 , _line2 , tvr ]
tf = indicatorTF == "Chart" ? timeframe.period : indicatorTF == "1 minute" ? "1" : indicatorTF == "3 minutes" ? "3" : indicatorTF == "5 minutes" ? "5" : indicatorTF == "10 minutes" ? "10" : indicatorTF == "15 minutes" ? "15" : indicatorTF == "30 minutes" ? "30" : indicatorTF == "45 minutes" ? "45" : indicatorTF == "1 hour" ? "60" : indicatorTF == "2 hours" ? "120" : indicatorTF == "3 hours" ? "180" : indicatorTF == "4 hours" ? "240" : indicatorTF == "12 hours" ? "720" : indicatorTF == "1 day" ? "1D" : indicatorTF == "1 week" ? "1W" : indicatorTF == "1 month" ? "1M" : na
= request.security(syminfo.tickerid, tf, cond(indicatorTF != "Chart" and barstate.isrealtime ? 1 : 0))
colorTVR = tvr < 15 ? #F6525F : tvr > 15 and tvr < 25 ? #B2B5BE : #66BB6A
// Plots
//plot(Presets == "Money Moves TrendVR" ? tvr : na, "", colorTVR, editable=false)
TrendText = "Trending"
if tvr < 15 and tvr < 25
TrendText := "No trend"
if tvr > 15 and tvr < 25
TrendText := "Ranging"
//------------------------------------------------------------------------------------------------------- Volatitiry
//Calculates Volatility for Dashboard
atrr = 3 * ta.atr(10)
stdAtr = 2 * ta.stdev(atrr, 20)
smaAtr = ta.sma(atrr, 20)
topAtrDev = smaAtr + stdAtr
bottomAtrDev = smaAtr - stdAtr
calcDev = (atrr - bottomAtrDev) / (topAtrDev - bottomAtrDev)
percentVol = 40 * calcDev + 30
AvrLength = 21
PercentFilter = 144
xAavrVolume = ta.rma(volume, AvrLength)
nResLess = volume * 100 / xAavrVolume < PercentFilter ? 0 : volume
nRes = nResLess
clr = close < open ? color.red : color.green
//plot(nRes, color=clr, style=plot.style_columns, title='Volume Filter', transp=20)
VolitiText = "Inactive"
if nRes
VolitiText := "Active"
//////////////////////////////////////////
ema69 = ta.ema(close, 9)
totalSentTxt = ema69 > ema69 ? 'Bullish' : ema69 < ema69 ? 'Bearish' : 'Flat'
// INputs
//Timezones
tz_incr = 0
use_exchange = false
//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
//Session A
NYSes = true
NYTxt = 'New York'
NYTime = '1300-2200'
//Session B
LDSes = true
sesb_txt = 'London'
sesb_ses = '0700-1600'
//Session C
show_sesc = true
sesc_txt = 'Tokyo'
sesc_ses = '0000-0900'
//Session D
show_sesd = true
sesd_txt = 'Sydney'
sesd_ses = '2100-0600'
//-----------------------------------------------------------------------------}
//Sessions
//-----------------------------------------------------------------------------{
tff = timeframe.period
var tz = use_exchange ? syminfo.timezone :
str.format('UTC{0}{1}', tz_incr >= 0 ? '+' : '-', math.abs(tz_incr))
is_sesa = math.sign(nz(time(tff, NYTime, tz)))
is_sesb = math.sign(nz(time(tff, sesb_ses, tz)))
is_sesc = math.sign(nz(time(tff, sesc_ses, tz)))
is_sesd = math.sign(nz(time(tff, sesd_ses, tz)))
////////////////////////////////////////////
SessionText = "Default"
//Session a = Newyork
//Session b = London
//Session c = Tokyo
//Session d = Sydney
if is_sesd
SessionText := sesd_txt
if is_sesc
SessionText := sesc_txt
if is_sesb
SessionText := sesb_txt
if is_sesa
SessionText := NYTxt
if is_sesd and is_sesc
SessionText := "Sydney/Tokyo"
if is_sesb and is_sesc
SessionText := "Tokyo/London"
if is_sesb and is_sesa
SessionText := "London/Newyork"
if is_sesa and is_sesd
SessionText := "Newyork/Sydney"
//-----------------------------------------------------------------------------}
//Overlays color.green : color.red
//-----------------------------------------------------------------------------{
//
var dashboard_loc = locationDashboard == "Top Right" ? position.top_right : locationDashboard == "Middle Right" ? position.middle_right : locationDashboard == "Bottom Right" ? position.bottom_right : locationDashboard == "Top Center" ? position.top_center : locationDashboard == "Middle Center" ? position.middle_center : locationDashboard == "Bottom Center" ? position.bottom_center : locationDashboard == "Top Left" ? position.top_left : locationDashboard == "Middle Left" ? position.middle_left : position.bottom_left
var dashboard_size = sizeDashboard == "Large" ? size.large : sizeDashboard == "Normal" ? size.normal : sizeDashboard == "Small" ? size.small : size.tiny
var dashboard = showDashboard ? table.new(dashboard_loc, 3, 7, color.rgb(30, 34, 45 , 60), #3d384300, 2, color.rgb(30, 34, 45 , 60), 1) : na
dashboard_cell(column, row, txt, signal=false) => table.cell(dashboard, column, row, txt, 0, 0, signal ? #000000 : color.white, text_size=dashboard_size)
dashboard_cell_bg(column, row, col) => table.cell_set_bgcolor(dashboard, column, row, col)
if barstate.islast and showDashboard
// MTF Trend
dashboard_cell(0, 0 , "MTF")
dashboard_cell(0, 2 , "M5") , dashboard_cell_bg(0, 2 , TF5Bull ? color.green : color.red)
dashboard_cell(0, 3 , "M15") , dashboard_cell_bg(0, 3 , TF15Bull ? color.green : color.red)
dashboard_cell(0, 4 , "M30") , dashboard_cell_bg(0, 4 , TF30Bull ? color.green : color.red)
dashboard_cell(0, 5 , "1H") , dashboard_cell_bg(0, 5 , TF60Bull ? color.green : color.red)
dashboard_cell(0, 6 , "4H") , dashboard_cell_bg(0, 6 , TF240Bull ? color.green : color.red)
// Middel part
dashboard_cell(1, 0 , " MONEYHACKSRWANDA STRATEGY ")
dashboard_cell(1, 2 , "🔥 Market State ")
dashboard_cell(1, 3 , "⚠️ Volatility ")
dashboard_cell(1, 4 , "🏦 Institutional Activity ")
dashboard_cell(1, 5 , "🕒 Current Session (UTC) ")
dashboard_cell(1, 6 , "🌊 Trend Pressure ")
// End part
dashboard_cell(2, 0 , "")
dashboard_cell(2, 2 , TrendText)
dashboard_cell(2, 3 , str.tostring(percentVol, '##.##') + '%')
dashboard_cell(2, 4 , VolitiText)
dashboard_cell(2, 5 , SessionText)
dashboard_cell(2, 6 , totalSentTxt)
// Alerts
f_sl_crossed() =>
ret = false
stop = ShowTrailingSL ? trailingStop : stop_y
crossBull = low >= stop and low < stop and ta.barssince(low >= stop and low < stop ) >= countBull - 1
crossBear = high <= stop and high > stop and ta.barssince(high <= stop and high > stop ) >= countBear - 1
ret := trigger ? crossBull : crossBear
f_tp_crossed(tp) =>
ret = false
profit = tp
crossBull = high <= profit and high > profit and ta.barssince(high <= profit and high > profit ) >= countBull - 1
crossBear = low >= profit and low < profit and ta.barssince(low >= profit and low < profit ) >= countBear - 1
ret := trigger ? crossBull : crossBear
alert01 = (bull and close <= StrongFilter) or (bear and close >= StrongFilter)
alert02 = bull or bear
alert03 = (bull and close > StrongFilter) or (bear and close < StrongFilter)
alert04 = bull and close <= StrongFilter
alert06 = bear and close >= StrongFilter
alert07 = bull and close > StrongFilter
alert08 = bear and close < StrongFilter
alert09 = f_sl_crossed()
alert11 = f_tp_crossed(tp1_y)
alert12 = f_tp_crossed(tp2_y)
alert13 = f_tp_crossed(tp3_y)
alert14 = periodTrendCloud == "Smooth" ? ta.crossunder(ema150, ema250) : (close < trendcloud) and (close > trendcloud)
alert15 = periodTrendCloud == "Smooth" ? ta.crossover (ema150, ema250) : (close > trendcloud) and (close < trendcloud)
//alerts(sym) =>
// if alert01 or alert02 or alert03 or alert04 or alert05 or alert06 or alert07 or alert08 or alert09 or alert10 or alert11 or alert12 or alert13 or alert14 or alert15
// alert("NEW ALERT", alert.freq_once_per_bar_close)
//alerts(syminfo.tickerid)
// Signal Alerts
if alert04 and Normalbuy_alert
alert('Buy Signal Alert !!!' , alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert07 and Strongbuy_alert
alert('Strong Buy Signal Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if (bear and close >= StrongFilter) and Normalsell_alert
alert('Sell Signal Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if (bear and close < StrongFilter) and Strongsell_alert
alert('Strong Sell Signal Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
// Risk Management Alerts
if alert09 and slalert
alert('SL Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert11 and tp1alert
alert('Target 1 Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert12 and tp2alert
alert('Target 2 Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert13 and tp3alert
alert('Target 3 Alert !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
// Cloud Alert
if alert15 and bullcrosscloud_alert
alert('Cloud Turned Bullish !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
if alert14 and bearcrosscloud_alert
alert('Cloud Turned Bearish !!!', alert.freq_once_per_bar_close)
alert(syminfo.tickerid)
alertcondition(alert01, "Any Signal Contrarian Buy / Contrarian sell", "Buy or Sell")
alertcondition(alert04, "Contrarian Buy alert", "Buy")
alertcondition(alert06, "Contrarian Sell alert", "Sell")
Liquidity Sweep Filter [AlgoAlpha]Unlock a deeper understanding of market liquidity with the Liquidity Sweep Filter by AlgoAlpha. This indicator identifies liquidity sweeps, highlighting key price levels where large liquidations have occurred. By visualizing major and minor liquidation events, traders can better anticipate potential reversals and market structure shifts, making this an essential tool for those trading in volatile conditions.
Key Features :
🔍 Liquidity Sweep Detection – Identifies and highlights areas where liquidity has been swept, distinguishing between major and minor liquidation events.
📊 Volume Profile Integration – Displays a volume profile overlay, helping traders spot high-activity price zones where the market is likely to react.
📈 Trend-Based Filtering – Utilizes an adaptive trend detection algorithm to refine liquidity sweeps based on market direction, reducing noise.
🎨 Customizable Visualization – Modify colors, thresholds, and display settings to tailor the indicator to your trading style.
🔔 Alerts for Liquidity Sweeps & Trend Changes – Stay ahead of the market by receiving alerts when significant liquidity events or trend shifts occur.
How to Use:
🛠 Add the Indicator : Add the Liquidity Sweep Filter to your chart and configure the settings based on your preferred sensitivity. Adjust the major sweep threshold to filter out smaller moves.
📊 Analyze Liquidity Zones and trend direction : Look for liquidation levels where large buy or sell stops have been triggered. Major sweeps indicate strong reactions, while minor sweeps show gradual liquidity absorption. You can also see which levels are high in liquidity by the transparency of the levels.
🔔 Set-Up Alerts : Use the in-built alerts so you don't miss a trading opportunity
How It Works :
The Liquidity Sweep Filter detects liquidity events by tracking swing highs and lows (defined as a pivot where neighboring candles are lower/higher than it) where traders are likely to have placed stop-loss orders. It evaluates volume and price action, marking areas where liquidity has been absorbed by the market. Additionally, the integrated trend filter ensures that only relevant liquidity sweeps are highlighted based on market direction, lows in an uptrend and highs in a downtrend. The trend filter works by calculating a basis, and defining trend shifts when the closing price crosses over the upper or lower bands.The included volume profile further enhances analysis by displaying key trading zones where price may react.
Innovative VWAP Trend Indicator by KertThis simple VWAP indicator lets the trader know how far above or below where the price should be fairly valued, so if price is well below VWAP you might consider a price rebound to the upside to at least VWAP.
My Madam Dior....The Madam Dior indicator focuses on detecting RBR and DBD patterns, which signify periods of increased momentum and potential continuation or reversal of the prevailing trend.
The RBR pattern consists of a rally (upward movement), followed by a base (consolidation or retracement), and then another rally. It suggests that the upward momentum may persist and provide trading opportunities.
On the other hand, the DBD pattern comprises a drop (downward movement), followed by a base, and then another drop. It indicates that the downward momentum might continue, offering potential shorting opportunities.
Bullish(RBR)
Bearish(DBD)
1. The bullish (RBR) and bearish (DBD) patterns share the same underlying logic, only differing in their directionality.
2. For both RBR and DBD patterns, the first rise/drop can consist of one or multiple candles. However, in the case of multiple candles, all candles must exhibit a bullish nature for RBR and a bearish nature for DBD.
3. It is a prerequisite for the first rise/drop to include at least one candle with a defined percentage of health, as determined by the user.
4. The base, following the first rise/drop, may comprise one or multiple candles.
5. To maintain consistency, the base is not allowed to retrace beyond 80%, although this value can be adjusted by the user.
6. Similar to the first rise/drop, the second rise/drop in both RBR and DBD patterns can consist of one or multiple candles. However, all candles within this phase must demonstrate a bullish nature for RBR and a bearish nature for DBD.
7. Confirmation of the bullish (RBR) pattern occurs when a candle closes above the high of the first rise. Conversely, the bearish (DBD) pattern is confirmed when a candle closes below the low of the first drop.
Alerts can be set for all bullish and bearish pattern or for the first pattern in the range of similar pattern.
PRC-ALMA | QuantEdgeBIntroducing PRC-ALMA by QuantEdgeB
Overview
The PRC-ALMA (Percentile Adaptive ALMA) is an advanced dynamic trend and volatility filtering indicator that leverages the Arnaud Legoux Moving Average (ALMA) combined with Percentile Rank Filtering and Median Absolute Deviation (MAD) Bands. It is designed to enhance market structure clarity, detect breakout zones, and provide trade signals by dynamically adjusting its filtering based on recent price action.
____
Key Features
1. 📈 Adaptive ALMA Smoothing:
- Uses ALMA for smoothing price action while reducing lag.
- Provides a more responsive moving average than traditional EMAs and SMAs.
2. 📊 Percentile Rank-Based Thresholds:
- Determines upper and lower regions using 75th and 25th percentile ranks.
- Allows for adaptive thresholding based on historical price movements.
3. 🎯 Median Absolute Deviation (MAD) Volatility Filtering:
- Filters out noise using robust statistical deviation measures.
- MAD Bands dynamically adjust based on volatility expansion and contraction.
4. 🔄 Dynamic Trade Signals:
- Generates long signals when price exceeds the upper threshold.
- Generates short signals when price drops below the lower threshold.
5. 🎨 Customizable Color Modes & Visual Enhancements:
- Choose between multiple color schemes to match trading preferences.
- Optional candlestick coloring to indicate market sentiment shifts.
____
How It Works
1. ALMA Calculation:
- The indicator starts by computing the ALMA (Arnaud Legoux Moving Average) with a customizable length, offset, and sigma.
2. Percentile Rank Filtering:
- It then calculates the 75th and 25th percentile ranks over a selected period, determining dynamic levels for trend identification.
3. Volatility Adjustment Using Median Absolute Deviation (MAD):
- MAD is applied to filter noise and adapt the upper/lower bands based on market volatility.
- The higher the MAD multiplier, the wider the bands, allowing more price fluctuations before a signal triggers.
4. Entry & Exit Conditions:
- Long Entry: When price crosses above the upper percentile band + MAD filter.
- Short Entry: When price crosses below the lower percentile band - MAD filter.
5. Visual Enhancements:
- Dynamic band plotting with shading between percentile ranks.
- Candlestick coloring to visually indicate long/short sentiment shifts.
____
Practical Applications
✅ Trend Following & Momentum Trading – Uses ALMA for trend smoothing and percentile-based breakouts.
✅ Mean Reversion Strategies – Adaptive MAD filtering ensures only significant deviations trigger signals.
✅ Multi-Timeframe Trading – Works on intraday, daily, and weekly timeframes based on user customization.
✅ Noise Reduction – Eliminates minor fluctuations while capturing meaningful market moves.
____
🛠 Settings
-ALMA Length: 24 – Defines the smoothing period for the Arnaud Legoux Moving Average.
-ALMA Offset: 0.7 – Adjusts the shift factor, controlling responsiveness.
-ALMA Sigma: 4 – Determines the smoothing strength, balancing trend-following and noise reduction.
-Percentile Length: 21 – Lookback period for calculating percentile rank levels.
-Median Period: 21 – The period used for the Median Absolute Deviation (MAD) filter.
-Median Multiplier: 1.8 – Adjusts the sensitivity of the MAD filter, impacting how signals are generated.
-Color Mode: Strategy – Various visual themes available for better chart readability.
-Signal Label: Off - If turned off the indicator produced a Long or Cash signal when the trend changes.
📌 Conclusion
The PRC-ALMA | QuantEdgeB is an advanced valuation and signal generation tool that dynamically adjusts based on market conditions. By combining ALMA for trend smoothing, percentile rank thresholds, and MAD-based volatility filtering, it provides traders with a versatile indicator for momentum, breakout, and mean reversion strategies.
Key Takeaways:
✔ Smooth & Adaptive – ALMA ensures minimal lag while maintaining trend responsiveness.
✔ Dynamic Overbought/Oversold Zones – Adjusts to real-time market conditions using percentile-based bands.
✔ Volatility-Aware Filtering – Uses MAD to eliminate market noise, making signals more reliable.
✔ Customizable & Multi-Timeframe Ready – Works on various asset classes and timeframes with adjustable settings.
🔹 Disclaimer: Past performance is not indicative of future results. No trading strategy can guarantee success in financial markets.
🔹 Strategic Advice: Always backtest, optimize, and align parameters with your trading objectives and risk tolerance before live trading.
O'NegoziatoreasasasaDomine a leitura do mercado com o NEGOZIATORE!
Descubra o poder de uma ferramenta que transforma dados em decisões estratégicas. Desenvolvido para traders de todos os níveis, este indicador é uma fusão inteligente de análise técnica, fornecendo clareza absoluta sobre a direção do mercado.
Combinando múltiplos fatores-chave, ele:
Identifica fluxos de compra e venda com precisão.
Destaca zonas críticas de volume e áreas de reversão potencial.
Conflui sinais de diversos indicadores para criar um panorama unificado e assertivo.
Se você é iniciante, ganhe confiança ao interpretar os movimentos do mercado como nunca antes.
Se você é experiente, otimize seu timing de entrada e saída com dados que complementam sua estratégia avançada.
Com o NEGOZIATORE, o movimento te conta uma história – e agora você tem as ferramentas para entendê-la completamente a direção do mercado.
Aperfeiçoe sua leitura, expanda suas possibilidades e conquiste resultados consistentes.
Dashboard Table by KGHow It Works
The script calculates the required indicators (RSI, Volatility, Volume Average, Momentum).
It creates a table at the user-specified position with the specified text size.
The table is populated with the indicator values, and conditional formatting is applied based on predefined conditions.
The dashboard can be toggled on or off using the dashboard input.
Customization
Position: The user can choose where the table appears on the chart (e.g., Top-Left, Bottom-Right).
Text Size: The user can adjust the text size for better readability.
Indicators: The script can be extended to include additional indicators by modifying the calculations and adding more rows to the table.
Example Use Case
One can use this dashboard to quickly monitor key metrics like RSI, Volatility, Volume, and Momentum without cluttering the chart with multiple indicators.
The conditional formatting helps identify bullish or bearish conditions at a glance.Do your own research along with other indicators.
JJ's Key Levels with dynamic alerts V2.0This indicator displays Key levels of significant price points which give potential reaction zones for support and resistance. It allows traders to set alerts when price reaches the following:
Daily Open
Current Weekly Open
Current Weekly Low
Current Weekly Middle
Current Weekly High
Previous Day Open
Previous Day Low
Previous Day Middle
Previous Day High
Previous Week Open
Previous Week Low
Previous Week Middle
Previous Week High
Previous Month Open
Previous Month Low
Previous Month Middle
Previous Month High
Previous Quarter Open
Previous Quarter Low
Previous Quarter Middle
Previous Quarter High
Current Year Open
Current Year Low
Current Year Middle
Current Year High
Additionally. it also has a London ORB (Opening Range Breakout) function which can assist in determining short-term price direction.
DataDoodles SD + ProbabilityDataDoodles SD + Probability
Overview:
The “DataDoodles SD + Probability” indicator is designed to provide traders with a statistical edge by leveraging standard deviation and probability metrics. This advanced tool calculates the annualized standard deviation, Z-score, and probability of price movements, offering insights into potential market direction with customizable alert thresholds.
Key Features:
1. Annualized Standard Deviation (Volatility) Calculation:
• Uses a user-defined period to compute the rolling standard deviation of daily returns.
• Annualizes the volatility, giving a clear picture of expected price fluctuations.
2. Probability of Price Movement:
• Calculates the probability of price moving up or down using a corrected Z-Score.
• Displays the probability percentage for both upward and downward movements.
3. Dynamic Alerts:
• Configurable alerts for upward and downward price movement probabilities.
• Receive alerts when the probability exceeds user-defined thresholds.
4. Projections and Visuals:
• Plots projected high and low price levels based on annualized volatility.
• Displays Z-Score and probability metrics on the chart for quick reference.
5. Comprehensive Data Table:
• Bottom-center table displays key metrics:
• Daily Return
• Standard Deviation (SD)
• Annualized Standard Deviation (Yearly SD)
User Inputs:
• Annualization Period: Set the time frame for volatility annualization (Default: 252 days).
• SD Period: Define the rolling window for calculating standard deviation (Default: 252 days).
• Alert Probability Up/Down: Customize the probability thresholds for alerts (Default: 90%).
How It Works:
• Data Request and Calculation:
• Uses daily close prices to ensure consistent timeframe calculations.
• Calculates daily returns and annualizes the volatility using the square root of the time frame.
• Probability Computation:
• Employs a normal distribution CDF approximation to compute the probability of upward and downward price movements.
• Adjusts probabilities based on Z-Score to ensure accuracy.
• High and Low Projections:
• Utilizes the annualized volatility to estimate high and low price projections for the year.
• Visual Indicators and Alerts:
• Plots projected high (green) and low (red) levels on the chart.
• Displays Z-Score, probability percentages, and dynamically updates a statistics table.
Use Cases:
• Trend Analysis: Identify high-probability market movements using the probability metrics.
• Volatility Insights: Understand annualized volatility to gauge market risk and potential price ranges.
• Strategic Trading Decisions: Set alerts for high-probability scenarios to optimize entry and exit points.
Why Use “DataDoodles SD + Probability”?
This indicator provides a powerful combination of statistical analysis and visual representation. It empowers traders with:
• Quantitative Edge: By leveraging probability metrics and standard deviation, users can make informed trading decisions.
• Risk Management: Annualized volatility projections help in setting realistic stop-loss and take-profit levels.
• Actionable Alerts: Customizable probability alerts ensure users are notified of potential market moves, allowing proactive trading strategies.
Recommended Settings:
• Annualization Period: 252 (Ideal for daily data representing a trading year)
• SD Period: 252 (One trading year for consistent volatility calculations)
• Alert Probability: Set to 90% for conservative signals or lower for more frequent alerts.
Final Thoughts:
The “DataDoodles SD + Probability” indicator is a robust tool for traders looking to integrate statistical analysis into their trading strategies. It combines volatility measurement, probability calculations, and dynamic alerts to provide a comprehensive market overview.
Whether you’re a day trader or a long-term investor, this indicator can enhance your market insight and improve decision-making accuracy.
Disclaimer:
This indicator is a technical analysis tool designed for educational purposes. Past performance is not indicative of future results. Traders are encouraged to perform their own analysis and manage risk accordingly.
Volatility Drift [7 Dreams India Official]elite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learnings
elite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learningselite learnings
Themp StrategyThis is my Trade strategy setup base on SMC
my Setup
SMC + IDM + Order block + Fair value gap + Imbalance candle
Price and Longitude Angles Planetary Price & Longitude Angles Indicator
This indicator plots planetary price and longitude angles starting from a user-selected date and time, offering a distinctive lens to explore the relationship between price and planetary timing. It supports both heliocentric and geocentric, enabling flexible and in-depth planetary analysis. The angles can be plotted across any time frame for maximum versatility.
How to Use
Once the indicator is loaded, you’ll be prompted to select a starting date and time for your analysis. From there, customize it as follows:
Select Planetary Options:
To plot the price and longitude for a single planet, choose the same planet in both dropdown menus.
To plot the average of two planets, select a different planet in each dropdown.
Set the Price Per Degree of Longitude: Adjust this value to define the scaling of the planetary angles relative to price.
Customize Fan Settings:
Toggle the mirroring of the fan on or off based on your needs.
Show or hide specific angle divisions to tailor the display to your preferences.
Display or conceal the information label that indicates the price per longitude and the number of degrees traveled.
This indicator is inspired by the methodologies of W.D. Gann and Patrick Mikula, expanding on concepts from Gann Scientific Method Unveiled, Volume 2. It was built using Astrolib by @BarefootJoey
I crafted this tool through dedication to support my own study of these ideas. I’m sharing it open-source not only to deepen my understanding and honor the work of Gann and Mikula, but also to invite collaboration. There’s always room for improvement—whether in functionality, accuracy, or design—and I hope others will join me in refining it. This is for those like me: eager to explore these concepts but lacking tools to experiment with. Let’s build on it together.
Indicator BMS V5 [Traderhood]Introducing BMS (Base Market Strategy)
Overview
Base Market Strategy (BMS) is a trend-following and oscillator indicator designed to detect market trends with high accuracy while providing clear entry signals. BMS utilizes four Exponential Moving Averages (EMA) to filter trends across multiple timeframes and Bollinger Bands (BB) to identify overbought and oversold zones. This approach makes BMS highly suitable for scalping strategies in lower timeframes with a high win rate potential.
Key Features
📈 Multi-EMA Trend Filtering
Uses 4 EMAs to confirm the dominant trend.
Separates trend detection between lower timeframes and H1 for additional validation.
🎯 Dynamic Overbought & Oversold Detection
Sell signal occurs when the price touches the Bollinger Bands Upper.
Buy signal occurs when the price touches the Bollinger Bands Lower.
🔥 High Win Rate Scalping Strategy
Designed to capture quick price movements in trending markets.
Ideal for traders looking for fast executions with controlled risk.
🎨 Customizable Visual Enhancements
Users can adjust indicator colors to match their personal preferences.
How It Works
1️⃣ EMA-Based Trend Identification
The indicator applies 4 EMAs to determine short-term and medium-term trends.
If the price is above all EMAs → Bullish trend.
If the price is below all EMAs → Bearish trend.
2️⃣ Bollinger Bands Signal Generation
Sell Entry: When the price touches Bollinger Bands Upper, indicating an overbought area.
Buy Entry: When the price touches Bollinger Bands Lower, indicating an oversold area.
3️⃣ Scalping Execution
Entries are executed only on lower timeframes with trend confirmation from H1 EMA.
Profit targets are adjusted based on volatility, while stop loss is placed outside the Bollinger Bands.
4️⃣ Visual Customization
Indicator colors can be modified for better visibility.
Practical Applications
✅ Scalping Strategy – Uses Bollinger Bands and EMA filtering for fast trades.
✅ Trend Confirmation – Multi-timeframe EMA validation ensures precise entries.
✅ Dynamic Support & Resistance – Bollinger Bands help identify potential reversals.
✅ Noise Reduction – EMA filtering removes minor price fluctuations for clearer signals.
🛠 Settings
EMA Periods: 4 EMAs for trend filtering.
Bollinger Bands Length: 20 (default), adjustable.
Bollinger Bands Deviation: 2 (default).
Color Customization: Users can personalize indicator colors as needed.
📌 Conclusion
Base Market Strategy (BMS) is a high win-rate scalping indicator, combining trend-following EMA filtering with momentum reversal detection from Bollinger Bands. With a dynamic and adaptive approach, this indicator provides precise entry signals while reducing noise from insignificant price movements.
Key Takeaways:
✔ High Accuracy – A combination of EMA and Bollinger Bands provides clear signals.
✔ Scalping Optimization – Works best on lower timeframes with H1 validation.
✔ Visual Customization – Users can adjust the indicator colors to their preference.
✔ Simple Yet Powerful – Easy to use but highly effective in capturing market opportunities.
🔹 Disclaimer: Trading carries high risks. Always backtest and optimize settings to align with your risk tolerance before live trading.
Dynamic 50% Indicator of the selected range!This is a indicator which shows you the 50% level of the selected timeframe range. This is a good tool because price tends to bounce of of 50% levels.
Introducing the 50% Range Level Indicator, designed for traders who seek accuracy and strategic insights in their market analysis. This tool calculates and visually displays the midpoint (50% level) of any selected price range, helping you identify key equilibrium zones where price action often reacts.
Why Use This Indicator?
Key Market Equilibrium – The 50% level is a crucial reference point where price often consolidates, reverses, or gathers momentum.
Custom Range Selection – Simply select your desired price range, and the indicator will dynamically plot the midpoint.
Enhance Your Trading Strategy – Use it for support & resistance confirmation, retracement analysis, or confluence with other indicators.
Works on All Timeframes & Assets – Suitable for stocks, forex, crypto, and indices.
Gain an Edge in the Market
Whether you’re a day trader, swing trader, or long-term investor, the 50% Range Level Indicator can enhance your technical analysis and decision-making.
Supply and Demand by BrekelThis indicator uses, and 8 and 13 ema with a solid white line for the VWAP. The POI is your points of interest and the BOS is your break of structure when a stock breaks out one direction or another after hitting that line. You will see HH for higher high, HL for Higher low indicating bullish directional moves and also LL for lower low, and Lower High, indicating a bearish directional move.
Emondsta 0DTE Trading Indicatorbasically this indicator is for day traders , will tell you when to buy puts an calls but also tell you when to cut your loss.
ZenAlgo - QZenAlgo - Q
Description
ZenAlgo - Q is an oscillator based on the QQE (Quantitative Qualitative Estimation) method. This version incorporates refinements for additional visualization and interpretation options. It is designed to help traders observe momentum changes and divergence patterns in price movements.
Key Features
QQE-Based Calculation : Derived from the open-source QQE script by Glaz (Metastock Version of QQE), with modifications for alternative visualization.
Dual RSI-Based Analysis : Uses two RSI calculations to provide additional context on price movements.
Adaptive Trend Bands : Adjust dynamically based on the market conditions.
Divergence Identification : Highlights potential differences between price action and oscillator movement.
Dynamic Color Coding : Displays histogram bars to illustrate shifts in oscillator values.
Configurable Alerts : Enables notifications for specific oscillator conditions.
How It Works
The indicator calculates a smoothed RSI-based oscillator that tracks the relative strength of price movement. It applies an exponential moving average (EMA) smoothing to reduce noise while maintaining responsiveness.
Two adaptive bands are calculated using a variation of the QQE method, which helps define dynamic overbought and oversold conditions.
The histogram bars shift in color based on the position of the oscillator relative to the bands. Lighter shades indicate weaker momentum, while stronger momentum is represented by more saturated colors.
The script also includes a secondary RSI component, which provides an additional layer of analysis. This secondary RSI helps refine momentum trends by smoothing out short-term fluctuations.
Divergence identification is built-in, highlighting where price action deviates from oscillator readings. Bullish divergence occurs when price forms a lower low while the oscillator forms a higher low, and bearish divergence is identified when price forms a higher high while the oscillator forms a lower high.
The indicator does not generate buy or sell signals but instead provides contextual information that can be used alongside other trading strategies.
Use Cases
Trend Observation : Traders can use the histogram to observe whether momentum is strengthening or weakening over time. A shift in color can indicate a potential change in trend strength.
Divergence Analysis : By comparing oscillator divergence with price movement, traders can identify situations where price action may be losing momentum. Divergences do not guarantee reversals but can serve as an early warning to re-evaluate positions.
Momentum Tracking : The dual RSI structure allows users to monitor both short-term and long-term momentum. When both RSI components are aligned, it suggests a more stable trend, while divergence between them may indicate potential consolidation or trend shifts.
Supplementary Analysis : This indicator is best used as a supporting tool alongside volume-based or trend-following indicators. It helps visualize underlying price behavior but should not be used in isolation for decision-making.
Market Context Interpretation : The combination of adaptive bands and histogram visualization allows traders to assess how recent price action compares to historical movement, helping to place current conditions in a broader market context.
Attribution
This script is an adaptation of the open-source QQE script originally developed by Glaz. We acknowledge and appreciate the original author's work, which served as a foundation for our modifications.
Disclaimer
This indicator is intended for informational purposes only. It should not be interpreted as financial advice. Always conduct independent research and risk management before making trading decisions.
Filtered Buy/Sell Signals After Stochastic Extreme Crossover//@version=5
indicator("Filtered Buy/Sell Signals After Stochastic Extreme Crossover", overlay=true)
// Define parameters
lr_period = 6
tma_period = 5
stoch_k = 8
stoch_d = 4
stoch_smooth = 4
// Compute Linear Regression Forecast (6, close)
linRegForecast = ta.linreg(close, lr_period, 0)
// Compute Triangular Moving Average (5)
tma = ta.sma(ta.sma(close, math.ceil(tma_period / 2)), tma_period)
// Compute the Average Line
averageLine = (linRegForecast + tma) / 2
// Compute Stochastic (8,4,4)
k = ta.sma(ta.stoch(close, high, low, stoch_k), stoch_smooth)
d = ta.sma(k, stoch_d)
// Track last confirmed Stochastic crossovers
var float lastBuyCrossover = na
var float lastSellCrossover = na
if ta.crossover(k, d) and k < 30
lastBuyCrossover := bar_index // Store the bar index of last Buy crossover below 30
if ta.crossunder(k, d) and k > 70
lastSellCrossover := bar_index // Store the bar index of last Sell crossover above 70
// Define Buy & Sell Signal Conditions with Confirmation
buySignal = ta.crossover(linRegForecast, tma) and lastBuyCrossover > lastSellCrossover
sellSignal = ta.crossunder(linRegForecast, tma) and lastSellCrossover > lastBuyCrossover
// Plot the indicators
plot(linRegForecast, color=color.blue, title="Linear Regression Forecast")
plot(tma, color=color.green, title="Triangular Moving Average (TMA)")
plot(averageLine, color=color.white, title="Average Line", linewidth=2) // White Average Line
// Plot Buy and Sell Signals
plotshape(series=buySignal, location=location.belowbar, color=color.green, style=shape.labelup, size=size.small, title="BUY")
plotshape(series=sellSignal, location=location.abovebar, color=color.red, style=shape.labeldown, size=size.small, title="SELL")
Supply & Demand Zones (SK Wealth Guru)Supply & Demand Zones (SK Wealth Guru) 📈
🚀 Description:
This indicator helps traders identify key Supply & Demand Zones, integrating SuperTrend, SMA, ATR-based Stop Loss & Target, and Higher Timeframe Confirmation to refine entries.
✅ Key Features:
Automatic Supply & Demand Zone Marking
Trade Only on Candle Close within Zones
Intraday & Positional Mode (Default: 20 & 30 Lookback)
SuperTrend & SMA for Trend Confirmation
ATR-based Stop Loss & Fibonacci Target Extension
Risk-Reward Ratio Filtering
Table Display of Market Levels, Trend, and Trade Signals
⚠️ Note:
This script does not guarantee profits. Use proper risk management.
Educational Purpose Only—not financial advice.
Always backtest and use alongside other confirmation signals.
🔔 Alerts:
Buy & Sell opportunities based on zone break & trend confirmation.
📌 How It Works:
1️⃣ Demand Zone (Support) Trade:
A bullish trade is triggered only if a candle closes inside the demand zone.
2️⃣ Supply Zone (Resistance) Trade:
A bearish trade is triggered only if a candle closes inside the supply zone.
3️⃣ Risk-Reward Validation:
Trade is taken only if Risk-Reward > 2.
🔥 Developed by: SK Wealth Guru
FVG Reversal Sentinel🔵 FVG Reversal Sentinel – Multi-Timeframe Fair Value Gap Indicator
The FVG Reversal Sentinel is a powerful TradingView indicator designed to help traders identify and track Fair Value Gaps (FVGs) across multiple timeframes, all within a single chart.
This tool allows you to select up to five separate timeframes, ensuring you never miss key market shifts, whether you are scalping, day trading, or swing trading. You can use this indicator in any asset (Cryptos, Futures, Indices, Forex Pairs, etc.).
🔵 - Key Features -
Multi-Timeframe FVG Tracking – Select and display up to five different timeframes on one chart, providing a comprehensive view of market structure.
Customizable Colors – Adjust bullish and bearish FVG colors to match your chart theme for a seamless trading experience.
Enhanced Market Context – Quickly identify key liquidity zones and refine your entries and exits with precision.
Hide the lower timeframes FVGs to get a clear view in a custom timeframe.
Show or hide mitigated FVGs to declutter the chart.
FVGs boxes are going to be displayed only when the candle bar closes
FVGs are going to be mitigated only when the body of the candle closes above or below the FVG area.
No repainting
Whether you're looking to fine-tune your entries or gain a broader market perspective, the FVG Reversal Sentinel indicator ensures you have the tools to stay ahead of price action and capitalize on market inefficiencies.
🔵 - Customization-
You can change the indicator settings as you see fit to achieve the best results for your use case.
TIMEFRAMES
This indicator provides the ability to select up to 5 timeframes. These timeframes are based on the trader's timeframes including any custom timeframes.
Select the desired timeframe from the options list.
Add the label text you would like to show for the selected timeframe.
Check or uncheck the box to display or hide the timeframe from your chart.
FVG SETTINGS
Length of boxes: allows you to select the length of the box that is going to be displayed for the FVGs.
Delete boxes after fill?: allows you to show or hide mitigated FVGs on your chart.
Hide FVGs lower than enabled timeframes?: allows you to show or hide lower timeframe FVGs on your chart. Example - You are in a 15 minutes timeframe chart, if you choose to hide lower timeframe FVGs you will not be able to see 5 minutes FVG defined in your Timeframes Settings, only 15 minutes or higher timeframe FVGs will be displayed on your chart.
BOX VISUALS
Bullish FVG box color: the color and opacity of the box for the bullish FVGs.
Bearish FVG box color: the color and opacity of the box for the bearish FVGs.
LABELS VISUALS
Bullish FVG labels color: the color for bullish labels.
Bearish FVG labels color: the color for bearish labels.
Labels size: the size of the text displayed in the labels.
Labels position: the position of the label inside the FVGs boxes (right, left or center).
BORDER VISUALS
Border width: the width of the border (the thickness).
Bullish FVG border color: the color and the opacity of the bullish box border.
Bearish FVG border color: the color and the opacity of the bearish box border.
🔵 - How to use the indicator -
Just add the indicator in your chart and click in the settings option to customize it.
Make sure you select the desired timeframes and set the colors and opacity for the FVGs boxes.
This indicator can be used in many trading strategies, such as:
SILVER BULLET
iFVG
iFVG RETEST
These strategies are based on the use of FVGs, this tool can help you analyze the market and make the right decision.
🔵 - How was the indicator designed? -
I have spent a lot of time testing other open source indicators from the community. All of these indicators do a great job, but they have a problem, they not only mitigate FVGs when a candle closes above or below the FVG, they also mitigate FVGs when the candle closes exactly to the tick (not above or below the FVG). This is a problem for many strategies that rely on FVGs mitigation.
What makes this indicator different is that it focuses on just mitigating imbalances at the right time for these strategies.
I have taken ideas and some pieces of code from many community indicator developers, such as:
@twingall
@tflab
@marktools
@nacho-fx
@pmk07
... and many other people, to whom I thank for their valuable work and have allowed me to create this tool by making modifications to their source code.
🔵 - Disclaimer -
This tool is intended solely for informational and educational purposes and should not be regarded as financial, investment, or trading advice. It's not designed to predict market movements or offer specific recommendations. Users should be aware that past performance is not indicative of future results and should not rely on any indicator for financial decisions.
FVG Radar [Mr_Rakun]The FVG Radar indicator is designed to automatically detect Fair Value Gaps (FVG) on your TradingView chart. It visually highlights bullish and bearish gaps with colored boxes and provides alerts when specific conditions are met.
How It Works
Fair Value Gap (FVG) Detection:
The script identifies gaps based on previous price action. A bullish FVG is recognized when there is a gap below a higher low candle, and a bearish FVG when there is a gap above a lower high candle.
Radar Area:
A yellow “Radar Area” box is drawn on the chart using upper and lower bands defined as a percentage above and below the current price. This area helps you visualize where the price is relative to these bands.
Alerts:
Alerts are triggered based on user-defined conditions:
When price crosses half of the gap (if the "Clear FVG When Price Reaches Half" option is enabled).
When price fully fills the gap (if the option is disabled).
The alert will only be activated after waiting a specified number of bars post-gap formation (as set by the "Wait X Bars After FVG Formation" parameter).
Input Parameters
Radar Upper Band (%):
Sets the upper threshold percentage relative to the current price for the radar area.
Radar Lower Band (%):
Sets the lower threshold percentage relative to the current price for the radar area.
Minimum FVG Size (%):
Determines the minimum size (as a percentage) for a gap to be recognized as a valid FVG.
Clear FVG When Price Reaches Half:
If enabled, the FVG will be cleared when the price reaches the midpoint of the gap. If disabled, the entire gap must be filled before it is cleared.
Wait X Bars After FVG Formation:
Specifies the number of bars to wait after an FVG is detected before triggering an alert. This delay helps to avoid premature alerts.
Bullish and Bearish FVG Colors and Opacity:
Customize the appearance of the FVG boxes for bullish (green) and bearish (red) gaps, including the opacity of these visual elements.
How to Use
Add the Indicator:
Load the FVG Radar indicator on your TradingView chart.
Customize Settings:
Adjust the input parameters based on your trading style and the market’s volatility. The radar area settings help you set your own visual reference for price deviations.
Monitor the Chart:
Watch for the colored boxes that represent FVGs. The boxes will display the size of the gap as a percentage.
Respond to Alerts:
When an alert is triggered after the specified number of bars, it indicates that the price has interacted with the gap. Use this information to guide your trading decisions.
Türkçe --------------------------------------------
FVG Radar göstergesi, TradingView grafiğinizde Fair Value Gap (FVG) – yani adil değer boşluklarını – otomatik olarak tespit etmek için tasarlanmıştır. Bu boşluklar, yükseliş ve düşüş boşluklarını farklı renkli kutularla vurgular ve belirli koşullar sağlandığında uyarılar verir.
Nasıl Çalışır
Fair Value Gap (FVG) Tespiti:
Gösterge, önceki fiyat hareketlerine dayalı olarak boşlukları belirler. Yükseliş boşluğu, düşük seviyenin yukarıdaki mumun altındaki boşlukla oluştuğu durumlarda; düşüş boşluğu ise, yüksek seviyenin aşağıdaki mumun üstünde boşluk oluştuğunda tespit edilir.
Radar Alanı:
Grafikte, mevcut fiyata göre belirlenen üst ve alt yüzde bantlarına dayalı olarak sarı renkte “Radar Alanı” kutusu çizilir. Bu alan, fiyatın bu bantlara göre nerede olduğunu görsel olarak anlamanıza yardımcı olur.
Uyarılar:
Kullanıcının belirlediği koşullara göre uyarılar verilir:
Fiyat, boşluğun yarısına ulaştığında (eğer "FVG'nin yarısına ulaştığında temizle" seçeneği etkinse).
Fiyat boşluğu tamamen doldurduğunda (seçenek devre dışı bırakıldığında).
Uyarı, boşluk oluşumundan sonra belirlenen bar sayısı kadar bekledikten sonra tetiklenir ("FVG Oluşumundan Sonra X Bar Bekle" parametresi).
Giriş Parametreleri
Radar Upper Band (%):
Mevcut fiyata göre radar alanı için üst eşik yüzdesini ayarlar.
Radar Lower Band (%):
Mevcut fiyata göre radar alanı için alt eşik yüzdesini ayarlar.
Minimum FVG Size (%):
Bir boşluğun geçerli bir FVG olarak tanınabilmesi için gereken minimum boyutu (yüzde olarak) belirler.
FVG'nin yarısına ulaştığında temizle:
Etkinse, fiyat boşluğun orta noktasına ulaştığında boşluk temizlenir. Devre dışı bırakılırsa, boşluğun tamamen doldurulması gerekir.
FVG Oluşumundan Sonra X Bar Bekle:
Bir FVG tespit edildikten sonra uyarı tetiklenmeden önce beklenmesi gereken bar sayısını belirler. Bu gecikme, erken uyarıların önüne geçmeyi amaçlar.
Yükseliş ve Düşüş FVG Renkleri ve Opaklık:
Yükseliş boşlukları (yeşil) ve düşüş boşlukları (kırmızı) için kutuların görünümünü ve opaklığını özelleştirmenize olanak tanır.
Nasıl Kullanılır
Göstergeyi Ekleyin:
FVG Radar göstergesini TradingView grafiğinize ekleyin.
Ayarları Özelleştirin:
Ticaret tarzınıza ve piyasanın oynaklığına göre giriş parametrelerini ayarlayın. Radar alanı ayarları, fiyat sapmalarını kendi görsel referansınızla tanımlamanıza yardımcı olur.
Grafiği İzleyin:
FVG’leri temsil eden renkli kutuları takip edin. Kutular, boşluğun yüzdelik büyüklüğünü gösterecektir.
Uyarılara Tepki Verin:
Belirlenen bar sayısı sonrasında tetiklenen uyarı, fiyatın boşluk ile etkileşime girdiğini gösterir. Bu bilgiyi, ticaret kararlarınızı yönlendirmek için kullanın.
