PHP Code:
// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// @ ChartPrime
//@version=6
indicator('Prime Bands [ChartPrime]', '.', overlay = true, max_labels_count=500)
// --------------------------------------------------------------------------------------------------------------------}
// 𝙐𝙎𝙀𝙍 𝙄𝙉𝙋𝙐𝙏𝙎
// --------------------------------------------------------------------------------------------------------------------{
int length = input.int(50)
int sd = input.int(3, 'Standart Deviation', [1, 2, 3])
// Colors
color color_plus = input.color(#48d81c, '+', inline = 'Color')
color color_minus = input.color(#d8611c, '-', inline = 'Color')
// --------------------------------------------------------------------------------------------------------------------}
// 𝙄𝙉𝘿𝙄𝘾𝘼𝙏𝙊𝙍 𝘾𝘼𝙇𝘾𝙐𝙇𝘼𝙏𝙄𝙊𝙉𝙎
// --------------------------------------------------------------------------------------------------------------------{
method check_size(array<float> array, val, size) =>
array.push(array, val)
if array.size(array) >= size
array.shift(array)
label_plot(src, sd, col = chart.fg_color) =>
txt = sd == 0 ? str.tostring(sd, '#') + ' ' : sd == 3 ? str.tostring(sd, '+#') + ' SD ' : str.tostring(sd, '#') + ' SD '
label.delete(label.new(bar_index + 15, src, txt + str.tostring(src, '(#,###.##)'), style = label.style_label_left, color = color(na), textcolor = col)[1])
method line_new(float src, slope, color = chart.fg_color, width = 1) =>
line.delete(line.new(bar_index, src, bar_index + 15, src + slope, width = width, color = color)[1])
slope(src) =>
src - src[2]
mean_reversion(src, mid, lower, upper) =>
float source = src - mid
float mean_rev = (src - lower) / (upper - lower)
mean_rev := ta.hma(mean_rev / ta.stdev(mean_rev, 200), 15) - 1
mean_rev := math.min(4, math.max(-4, mean_rev))
mean_rev
prime_bands(length) =>
var upper = array.new<float>()
var lower = array.new<float>()
var color = color(na)
float Hg = ta.highest(length)
float Lw = ta.lowest(length)
float base = math.avg(Hg, Lw)
float atr = ta.atr(200)
float up_b = base + atr * sd
float low_b = base - atr * sd
upper.check_size(up_b, length)
lower.check_size(low_b, length)
float up_band = ta.sma(upper.max(), 15)
float low_band = ta.sma(lower.min(), 15)
float mid_band = math.avg(up_band, low_band)
float slope1 = slope(mid_band)
float slope2 = slope(up_band)
float slope3 = slope(low_band)
float mean_rev = mean_reversion(hl2, mid_band, low_band, up_band)
bool sig_down = ta.crossunder(mean_rev, mean_rev[1]) and high > up_band and mean_rev > ta.highest(mean_rev, length)[10]
bool sig_up = ta.crossover(mean_rev, mean_rev[1]) and low < low_band and mean_rev < ta.lowest(mean_rev, length)[10]
if ta.crossover(mid_band, mid_band[2])
color := color_plus
color
if ta.crossunder(mid_band, mid_band[2])
color := color_minus
color
if barstate.islast
line_new(mid_band, slope1, color, 2)
line_new(up_band, slope2)
line_new(low_band, slope3)
label_plot(up_band + slope2, +sd)
label_plot(low_band + slope3, -sd)
label_plot(mid_band + slope1, 0, color)
[up_band, mid_band, low_band, color, sig_down, sig_up, mean_rev]
[up_band, mid_band, low_band, color, sig_down, sig_up, mean_rev] = prime_bands(length)
// --------------------------------------------------------------------------------------------------------------------}
// 𝙑𝙄𝙎𝙐𝘼𝙇𝙄𝙕𝘼𝙏𝙄𝙊𝙉
// --------------------------------------------------------------------------------------------------------------------{
ph = plot(up_band, color = chart.fg_color)
pm = plot(mid_band, color = color, linewidth = 2)
pl = plot(low_band, color = chart.fg_color)
//fill(pm, ph, up_band, mid_band, na, color.new(color, 90))
//fill(pm, pl, mid_band, low_band, color.new(color, 90), na)
plotchar(sig_up, 'Signal Up', '🞛', location.belowbar, color = color_plus, size = size.small)
plotchar(sig_down, 'Signal Dn', '🞜', location.abovebar, color = color_minus, size = size.small)
if barstate.islast
var tbl = table.new(position.middle_right, 100, 100)
for i = 0 to 9 by 1
tbl.cell(1, i + 1, bgcolor = color.from_gradient(i, 0, 8, color_minus, color_plus))
tbl.cell(0, i + 1, '>>', text_color = color(na))
tbl.cell(0, 9 - math.round((hl2 > up_band ? 4 : hl2 < low_band ? -4 : mean_rev) + 4), '>>', text_color = color.from_gradient(i, 0, 8, color_minus, color_plus))
if i == 9
tbl.cell(1, 9 + 1, str.tostring(-sd) + '\nSD', text_color = chart.fg_color)
else if i == 0
tbl.cell(1, 0, 'SD\n' + str.tostring(sd), text_color = chart.fg_color)
// --------------------------------------------------------------------------------------------------------------------}
groupKalman = "Kalman Filter"
kalmanAlpha = input.float(0.01, title="Kalman Alpha", tooltip="The Alpha parameter controls the smoothing factor of the Kalman filter. A smaller value results in more smoothing, while a larger value makes the filter more responsive to price changes.", group=groupKalman)
kalmanBeta = input.float(0.1, title="Kalman Beta", tooltip="The Beta parameter influences the rate of change in the Kalman filter. It adjusts the filter's sensitivity to trend changes.", group=groupKalman)
kalmanPeriod = input.int(21, title="Kalman Period", tooltip="The Period defines the number of bars used in the Kalman filter calculation, affecting the filter's responsiveness to market movements.", group=groupKalman)
groupSupertrend = "Supertrend"
supertrendFactor = input.float(1, title="Supertrend Factor", tooltip="This Factor determines the multiplier for the ATR in the Supertrend calculation, affecting the distance of the trend line from the price.", group=groupSupertrend)
supertrendAtrPeriod = input.int(7, title="ATR Period", tooltip="The ATR Period specifies the number of bars used to calculate the Average True Range, which is a component of the Supertrend indicator.", group=groupSupertrend)
groupColors = "Colors"
green = input.color(#5b9cf6, title="Bullish Color", tooltip="This color is used to indicate a bullish trend in the chart.", group=groupColors)
red = input.color(#ffb74d, title="Bearish Color", tooltip="This color is used to indicate a bearish trend in the chart.", group=groupColors)
kalman(a, b, alpha, beta) =>
var float v1 = na
var float v2 = 1.0
var float v3 = alpha * b
var float v4 = 0.0
var float v5 = na
if na(v1)
v1 := a[1]
v5 := v1
v4 := v2 / (v2 + v3)
v1 := v5 + v4 * (a - v5)
v2 := (1 - v4) * v2 + beta / b
v1
pine_supertrend(k, factor, atrPeriod) =>
src = k
atr = ta.atr(atrPeriod)
upperBand = src + factor * atr
lowerBand = src - factor * atr
prevLowerBand = nz(lowerBand[1])
prevUpperBand = nz(upperBand[1])
lowerBand := lowerBand > prevLowerBand or k[1] < prevLowerBand ? lowerBand : prevLowerBand
upperBand := upperBand < prevUpperBand or k[1] > prevUpperBand ? upperBand : prevUpperBand
int _direction = na
float superTrend = na
prevSuperTrend = superTrend[1]
if na(atr[1])
_direction := 1
else if prevSuperTrend == prevUpperBand
_direction := k > upperBand ? -1 : 1
else
_direction := k < lowerBand ? 1 : -1
superTrend := _direction == -1 ? lowerBand : upperBand
[superTrend, _direction]
k = kalman(close, kalmanPeriod, kalmanAlpha, kalmanBeta)
[Pine_Supertrend, pineDirection] = pine_supertrend(k, supertrendFactor, supertrendAtrPeriod)
upTrend = plot(pineDirection < 0 ? Pine_Supertrend : na, "Up direction", color = color.new(green, 70), style=plot.style_linebr)
downTrend = plot(pineDirection > 0 ? Pine_Supertrend : na, "Down direction", color = color.new(red, 70), style=plot.style_linebr)
//bodyMiddle = plot(barstate.isfirst ? na : (open + close) / 2, "Body Middle", display = display.none)
uu = plot(pineDirection < 0 ? Pine_Supertrend + ta.ema(high - low, 70) * 5 : na, "Upper Exit Bands Upper Bound", red, style = plot.style_linebr)
ul = plot(pineDirection < 0 ? Pine_Supertrend + ta.ema(high - low, 70) * 4.5 : na, "Upper Exit Bands Lower Bound", red, style = plot.style_linebr, display = display.none)
//fill(uu, ul, Pine_Supertrend + ta.ema(high - low, 70) * 4.5, Pine_Supertrend + ta.ema(high - low, 70) * 5, color.new(red, 95), color.new(red, 70))
lu = plot(pineDirection > 0 ? Pine_Supertrend - ta.ema(high - low, 70) * 4.5 : na, "Lower Exit Bands Upper Bound", green, style = plot.style_linebr, display = display.none)
ll = plot(pineDirection > 0 ? Pine_Supertrend - ta.ema(high - low, 70) * 5 : na, "Lower Exit Bands Lower Bound", green, style = plot.style_linebr)
//////////////////
// ＩＮＰＵＴＳ ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――{
int length2 = input.int(50, 'Length')
int transp = input.int(5, 'Levels Transparency', minval = 2, maxval = 10)
string trend_col = input.string('Neutral', 'Price Color', ['Trend', 'Neutral', 'None'])
color up_color = input.color(#17e05a, '', inline = 'col')
color dn_color = input.color(#db621c, '', inline = 'col')
float src = close
// }
// ＣＡＬＣＵＬＡＴＩＯＮＳ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――{
var level = array.new<float>(11)
series int strength = 0
series float Lower_band = ta.lowest(length2)
series float Upper_band = ta.highest(length2)
series float step = (Upper_band - Lower_band) / 10
for i = 0 to 10 by 1
level.set(i, Lower_band + step * i)
float lvl = level.get(i)
bool cross_up = ta.crossover(src, lvl)
bool cross_dn = ta.crossunder(src, lvl)
if cross_up
strength := strength + 1
strength
if cross_dn
strength := strength - 1
strength
series float price = barstate.islast ? level.get(strength) : close
draw_label(level1, level2, src) =>
if barstate.islast
lvl = (level1 + level2) / 2
label.delete(label.new(bar_index + 1, lvl, src > level1 ? '▲' : '▼', textcolor = src > level1 ? up_color : dn_color, color = color(na), style = label.style_label_center)[1])
col1 = src < level.get(1) ? color.new(dn_color, 100 - transp * 11) : color.new(up_color, 100 - transp * 1)
col2 = src > level.get(1) ? color.new(up_color, 100 - transp * 2) : color.new(dn_color, 100 - transp * 10)
col3 = src > level.get(2) ? color.new(up_color, 100 - transp * 3) : color.new(dn_color, 100 - transp * 9)
col4 = src > level.get(3) ? color.new(up_color, 100 - transp * 4) : color.new(dn_color, 100 - transp * 8)
col5 = src > level.get(4) ? color.new(up_color, 100 - transp * 5) : color.new(dn_color, 100 - transp * 7)
col6 = src > level.get(5) ? color.new(up_color, 100 - transp * 6) : color.new(dn_color, 100 - transp * 6)
col7 = src > level.get(6) ? color.new(up_color, 100 - transp * 7) : color.new(dn_color, 100 - transp * 5)
col8 = src > level.get(7) ? color.new(up_color, 100 - transp * 8) : color.new(dn_color, 100 - transp * 4)
col9 = src > level.get(8) ? color.new(up_color, 100 - transp * 9) : color.new(dn_color, 100 - transp * 3)
col10 = src > level.get(9) ? color.new(up_color, 100 - transp * 10) : color.new(dn_color, 100 - transp * 2)
col11 = src > level.get(10) ? color.new(up_color, 100 - transp * 11) : color.new(dn_color, 100 - transp * 1)
// }
// ＰＬＯＴ ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――{
color color2 = switch trend_col
'Trend' => color.from_gradient(strength, 4, 6, dn_color, up_color)
'Neutral' => chart.fg_color
'None' => color(na)
disp = display.all
if barstate.islast
color col_grad = strength > 5 ? up_color : dn_color
float level_ = level.get(strength)
float stren = strength * 10
draw_label(level.get(0), level.get(1), src)
draw_label(level.get(1), level.get(2), src)
draw_label(level.get(2), level.get(3), src)
draw_label(level.get(3), level.get(4), src)
draw_label(level.get(4), level.get(5), src)
draw_label(level.get(5), level.get(6), src)
draw_label(level.get(6), level.get(7), src)
draw_label(level.get(7), level.get(8), src)
draw_label(level.get(8), level.get(9), src)
draw_label(level.get(9), level.get(10), src)
label.delete(label.new(bar_index + 1, level_, str.tostring(100 - stren, format.percent) + '▼ | ' + str.tostring(stren, format.percent) + '▲', color = color.new(col_grad, 50), style = label.style_label_left, textcolor = col_grad)[1])
line.delete(line.new(bar_index, level_, bar_index + 1, level_, color = color.new(col_grad, 50))[1])
//plot(price, color = color, linewidth = 3)
// }
// Input Groups
var string trend_settings = "════════ Trend Settings ════════"
var string visual_settings = "════════ Visualization Settings ════════"
// Tooltips
tooltip_length = "Length of the trend calculation period. Higher values create smoother signals."
tooltip_smooth = "Smoothing period for volatility. Higher values reduce noise."
tooltip_sens = "Multiplier for volatility bands. Higher values create wider bands."
tooltip_bars = "Enable/disable bar coloring based on trend direction"
tooltip_bg = "Enable/disable background gradient coloring"
tooltip_signals = "Enable/disable signal markers on trend changes"
// Trend Settings
length3 = input.int(5, "Main Length", minval=2,
group=trend_settings, tooltip=tooltip_length)
smooth_len = input.int(14, "Smoothing Length", minval=2,
group=trend_settings, tooltip=tooltip_smooth)
sensitivity = input.float(2.0, "Sensitivity", step=0.1,
group=trend_settings, tooltip=tooltip_sens)
// Visualization Settings
bullcolor = input.color(#00ffaa, "Bullish Color", group=visual_settings)
bearcolor = input.color(#ff0000, "Bearish Color", group=visual_settings)
showbars = input.bool(true, "Color Bars?", group=visual_settings, tooltip=tooltip_bars)
showbg = input.bool(true, "Background Color?", group=visual_settings, tooltip=tooltip_bg)
showsignals = input.bool(true, "Show Signals?", group=visual_settings, tooltip=tooltip_signals)
calculate_trend_levels() =>
typical = hlc3
fast_ema = ta.ema(typical, length3)
slow_ema = ta.ema(typical, length3 * 2)
basis = (fast_ema + slow_ema) / 2
vol = ta.stdev(typical, length3)
smooth_vol = ta.ema(vol, smooth_len)
upper = basis + (smooth_vol * sensitivity)
lower = basis - (smooth_vol * sensitivity)
[basis, upper, lower]
get_trend_state(upper, lower, basis) =>
var float prev_level = na
var int trend = 0
if na(prev_level)
trend := close > basis ? 1 : -1
prev_level := trend == 1 ? lower : upper
if trend == 1
if close < lower
trend := -1
prev_level := upper
else
prev_level := lower
else
if close > upper
trend := 1
prev_level := lower
else
prev_level := upper
[trend, prev_level]
[basis, upper, lower] = calculate_trend_levels()
[trend, level3] = get_trend_state(upper, lower, basis)
// Signal detection
long_signal = trend == 1 and trend[1] == -1
short_signal = trend == -1 and trend[1] == 1
// Plot average/basis line
//p2 = plot(basis, color=trend == 1 ? bullcolor : bearcolor, linewidth=2)
// Plot trend line with breaks
//p1 = plot(level3,
//color=close > level3 ? bullcolor : bearcolor,
//linewidth=2,
//style=plot.style_linebr)
// Plot additional trend line
//plot(level3,
//color=close > level3 ? bullcolor : bearcolor,
//linewidth=2,
//style=plot.style_linebr)
// Add labels for crossovers
if showsignals and ta.crossunder(close, level3)
label.new(bar_index, level3, "𝑺",
color=bearcolor,
textcolor=chart.fg_color,
style=label.style_label_lower_right)
if showsignals and ta.crossover(close, level3)
label.new(bar_index, level3, "𝑳",
color=bullcolor,
textcolor=chart.bg_color,
style=label.style_label_upper_right)
// Background gradient coloring
var float intensity = 0.0
var int prev_trend = 0
// Reset intensity on trend change
if trend != prev_trend
intensity := 0.0
prev_trend := trend
// Increment intensity based on trend
intensity := trend == 1 ? math.min(intensity + 1, 20) : trend == -1 ? math.min(intensity + 1, 20) : intensity
// Calculate gradient colors
color grad_color = trend == 1 ?
color.from_gradient(intensity, 0, 20, color.new(bullcolor, 95), color.new(bullcolor, 80)) :
color.from_gradient(intensity, 0, 20, color.new(bearcolor, 95), color.new(bearcolor, 80))
//bgcolor(showbg ? grad_color : na)
//
Alıntı yaparak yanıtla
Yer İmleri