QChartist Forum - Other charting software

Some useful TradingView Pinescript indicators from me

Fri, 30 May 2025 10:37:29 +0000

These indicators have been converted by me and are not available in the public indicators database of tradingview

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator(title="RD.COmbo", shorttitle="RD-Combo", overlay=false,

 max_bars_back=2000, // Sufficient history for calculations, especially ForecastOsc

 precision=2         // Adjust precision for plots if needed

 )

// --- Input Parameters ---

bool DoAlertForEntry = input.bool(false, "Do Alert For Entry")

bool DoAlertForExit = input.bool(false, "Do Alert For Exit")

// HistorySize in MQL4 primarily limits the `start` loop iteration.

// In Pine Script, plots automatically handle historical data.

// We keep it as an input but it doesn't directly restrict plots.

int HistorySize_input = input.int(1000, "History Size", minval=100)

int ColorThreshold = input.int(5, "Color Threshold", minval=0, maxval=5)

float NoiseFilterRVI = input.float(0.03, "RVI Exit Threshold", minval=0.0, step=0.01) // MQL4 uses 0.2 in condition, but input is 0.03. Using input.

bool DebugLogger = input.bool(false, "Debug Logger (Console)")

bool DebugLoggerData = input.bool(false, "Debug Logger Data (Console)")

// --- Global variables for Signal State & Alerts ---

// `var` keyword ensures these variables retain their values across bars.

var int signalstate = 0 // 1 = Long, -1 = Short, 0 = Neutral

var bool didentryalert_pine = false

var bool didexitalert_pine = false

// --- ForecastOscillator Calculation Helper Functions ---

// Helper function to calculate the weighted sum for `wt`

f_calc_wt(src, len) =>

    float sum_val = 0.0

    // Iterate from the current bar's position `len - i` to access past `src` values.

    // MQL4 `Close[shift+length-i]` corresponds to `src[len - i]` for current bar `shift=0`.

    for i = 1 to len

        float tmp_coeff = i - (float(len) + 1.0) / 3.0

        sum_val += tmp_coeff * src[len - i]

    sum_val * 6.0 / (float(len) * (float(len) + 1.0))

// ForecastOscillator logic

f_forecast_osc_series(src_series, regress, t3, b) =>

    float b2 = b * b

    float b3 = b2 * b

    float c1 = -b3

    float c2 = (3 * (b2 + b3))

    float c3 = -3 * (2 * b2 + b + b3)

    float c4 = (1 + 3 * b + b3 + 3 * b2)

    float n = 1 + 0.5 * (float(t3) - 1)

    float w1 = 2 / (n + 1)

    float w2 = 1 - w1

    // Calculate wt for the current bar

    float wt = f_calc_wt(src_series, regress)

    // Ensure `wt` is not too close to zero to avoid division by zero

    float forecastosc = (src_series - wt) / (math.abs(wt) < 1e-10 ? 1e-10 : wt) * 100

    // T3 smoothing chain - these variables must persist across bars

    var float e1 = na

    var float e2 = na

    var float e3 = na

    var float e4 = na

    var float e5 = na

    var float e6 = na

    // Using nz() to handle initial `na` values

    e1 := w1 * forecastosc + w2 * nz(e1[1])

    e2 := w1 * e1 + w2 * nz(e2[1])

    e3 := w1 * e2 + w2 * nz(e3[1])

    e4 := w1 * e3 + w2 * nz(e4[1])

    e5 := w1 * e4 + w2 * nz(e5[1])

    e6 := w1 * e5 + w2 * nz(e6[1])

    float t3_fosc = c1 * e6 + c2 * e5 + c3 * e4 + c4 * e3

    [forecastosc, t3_fosc] // Return both series

// --- Pre-calculate Forecast Oscillator values ---

// Call the function on the 'close' series with MQL4's default parameters (15, 3, 0.7)

[Osc, Osct3] = f_forecast_osc_series(close, 15, 3, 0.7)

// --- Combo Indicator Logic (Translated from MQL4's Combo function) ---

// Calculate all necessary indicator values for the current bar.

// MQL4's `lookupidx` corresponds to `[0]` for the current bar in Pine.

float ma5 = ta.wma(close, 5)

float ma20 = ta.wma(close, 20)

float ma100 = ta.wma(close, 100)

float ma200 = ta.wma(close, 200)

float cci = ta.cci(close, 5)

// --- MANUAL RVI CALCULATION (REPLACEMENT FOR ta.rvi) ---

// RVI Main (period 1 from MQL4) = (Close - Open) / (High - Low)

float rvi_numerator_raw = close - open

float rvi_denominator_raw = high - low

float rvimain = rvi_denominator_raw != 0 ? rvi_numerator_raw / rvi_denominator_raw : 0.0

// RVI Signal (period 1 from MQL4 implies a 4-period SMA of the main RVI)

float rvisignal = ta.sma(rvimain, 4)

// --- END MANUAL RVI CALCULATION ---

// --- MANUAL ADX/DI CALCULATION (REPLACEMENT FOR ta.adx, ta.plus_di, ta.minus_di) ---

f_calculate_adx_di(len) =>

    // True Range

    tr1 = high - low

    tr2 = math.abs(high - close[1])

    tr3 = math.abs(low - close[1])

    tr = math.max(tr1, tr2, tr3)

    // Directional Movement

    up = high - high[1]

    down = low[1] - low

    plusDM = up > down and up > 0 ? up : 0

    minusDM = down > up and down > 0 ? down : 0

    // Smoothed True Range and Directional Movements using RMA (Wilders Smoothing)

    // ta.rma is the Pine Script equivalent of Wilders Smoothing

    smoothTR = ta.rma(tr, len)

    smoothPlusDM = ta.rma(plusDM, len)

    smoothMinusDM = ta.rma(minusDM, len)

    // Calculate DI+ and DI-

    plusDI = smoothTR != 0 ? smoothPlusDM / smoothTR * 100 : 0

    minusDI = smoothTR != 0 ? smoothMinusDM / smoothTR * 100 : 0

    // Calculate DX

    sumDI = plusDI + minusDI

    dx = sumDI != 0 ? math.abs(plusDI - minusDI) / sumDI * 100 : 0

    // Calculate ADX (smoothed DX)

    adx = ta.rma(dx, len)

    [adx, plusDI, minusDI]

// Apply the manual ADX/DI calculation for period 14

[adxmain, adxplus, adxminus] = f_calculate_adx_di(14)

// For previous bar values, we can simply use the `[1]` operator on the calculated series

float adxmain2 = adxmain[1]

float adxplus2 = adxplus[1]

float adxminus2 = adxminus[1]

// --- END MANUAL ADX/DI CALCULATION ---

// Forecast Oscillator values for current bar (already calculated as series `Osc` and `Osct3`)

float fcblue = Osc

float fcred = Osct3

// Initialize signal components

int maval = 0

int ccival = 0

int rvival = 0

int adxval = 0

int fcval = 0

// MA signal

if ma5 > ma20

    maval := 1

else if ma5 < ma20

    maval := -1

// CCI signal

if cci > 0

    ccival := 1

else if cci < 0

    ccival := -1

// Else ccival remains 0

// Forecast Oscillator signal

if fcblue > 0 and fcred > 0 and fcblue > fcred

    fcval := 1

else if fcblue < 0 and fcred < 0 and fcblue < fcred

    fcval := -1

// Else fcval remains 0

// RVI signal

if rvimain > 0 and rvisignal > 0 and rvimain - rvisignal > 0

    rvival := 1

else if rvimain < 0 and rvisignal < 0 and rvimain - rvisignal < 0

    rvival := -1

// Else rvival remains 0

// ADX signal

if adxmain > adxmain2 and adxplus > adxplus2 and adxmain > 20 and adxplus > 20

    adxval := 1

else if adxmain > adxmain2 and adxminus > adxminus2 and adxmain > 20 and adxminus > 20

    adxval := -1

// Else adxval remains 0

// Calculate the total combined signal strength

float val = maval + ccival + fcval + rvival + adxval

// --- Exit Signal Logic ---

// Note: MQL4 used a constant `0.2` for RVI exit threshold, but `NoiseFilterRVI` input was 0.03.

// We are using the `NoiseFilterRVI` input for consistency.

if signalstate != 0

    if signalstate == 1 and (rvimain < 0 or (rvisignal - rvimain) > NoiseFilterRVI)

        signalstate := 0 // Exit long

    if signalstate == -1 and (rvimain > 0 or (rvimain - rvisignal) > NoiseFilterRVI)

        signalstate := 0 // Exit short

// --- Debugging Output (to Pine Script console) ---

if DebugLogger or DebugLoggerData

    // Check for sufficient historical bars before logging to avoid errors with `[1]` etc.

    if bar_index >= math.max(14, 200) // At least 200 bars for MAs, 14 for ADX. Min 31+regress=46 for FO.

        if DebugLoggerData

            log.info("--------------------------------------------------------------------------")

            log.info("Time: {0}, Bar: {1}, MA 5/20/100/200: {2}/{3}/{4}/{5}",

                 timenow, bar_index, ma5, ma20, ma100, ma200)

            log.info("Time: {0}, Bar: {1}, CCI: {2}, RVI: {3}/{4}",

                 timenow, bar_index, cci, rvimain, rvisignal)

            log.info("Time: {0}, Bar: {1}, ADX(now): {2}/{3}/{4}",

                 timenow, bar_index, adxmain, adxplus, adxminus)

            log.info("Time: {0}, Bar: {1}, ADX(prev): {2}/{3}/{4}",

                 timenow, bar_index, adxmain2, adxplus2, adxminus2)

            log.info("Time: {0}, Bar: {1}, Forecast blue/red: {2}/{3}",

                 timenow, bar_index, fcblue, fcred)

        log.info("Time: {0}, Bar: {1}, MAtrend({2}) + CCI({3}) + FC({4}) + RVItrend({5}) + ADXtrend({6}) => {7} # trade state = {8}",

             timenow, bar_index, maval, ccival, fcval, rvival, adxval, val, signalstate)

// --- Determine Plot Values ---

// These are the buffers from MQL4 (Neutral, Short, Long, Signal)

float NeutralBuffer_val = 0.0

float LongSignalBuffer_val = 0.0

float ShortSignalBuffer_val = 0.0

if val >= ColorThreshold

    LongSignalBuffer_val := val

    signalstate := 1 // Set signalstate to long if conditions met

else if val <= -ColorThreshold

    ShortSignalBuffer_val := val

    signalstate := -1 // Set signalstate to short if conditions met

else

    NeutralBuffer_val := val // Neutral, between thresholds

    // If we're neutral, but previously in a signal, it might be an exit condition.

    // The `signalstate` is managed by the exit logic above.

    // So if the current `val` is neutral, but `signalstate` was set by an exit condition, it remains 0.

    // If `val` is neutral and there was no exit, `signalstate` also becomes 0.

    if math.abs(val) < ColorThreshold and signalstate != 0

        signalstate := 0 // If signal goes neutral and no specific RVI exit occurred, also reset.

// SignalBuffer: MQL4 uses `2 * signalstate`

float SignalBuffer_val = 2 * signalstate

// --- Plotting ---

// Removed minval and maxval as they are not recognized in your environment.

// The indicator will now auto-scale based on the values plotted.

plot(NeutralBuffer_val, title="Neutral", color=color.rgb(128, 128, 128), style=plot.style_columns, linewidth=2, histbase=0) // Gray

plot(ShortSignalBuffer_val, title="Short Signal", color=color.rgb(255, 69, 0), style=plot.style_columns, linewidth=2, histbase=0) // OrangeRed

plot(LongSignalBuffer_val, title="Long Signal", color=color.rgb(124, 252, 0), style=plot.style_columns, linewidth=2, histbase=0) // LawnGreen

plot(SignalBuffer_val, title="Signal Line", color=color.rgb(255, 215, 0), style=plot.style_line, linewidth=1) // Gold

// Plotting MQL4 levels (4 and -4) - these will still help visually define a range.

hline(4, "Level +4", color.rgb(100, 100, 100), linestyle=hline.style_dashed)

hline(-4, "Level -4", color.rgb(100, 100, 100), linestyle=hline.style_dashed)

// --- Alerting Logic ---

// MQL4: `SignalBuffer[0]!=0 && SignalBuffer[1]==0` for entry

// Pine: `SignalBuffer_val != 0 and SignalBuffer_val[1] == 0` for entry

if DoAlertForEntry and SignalBuffer_val != 0 and nz(SignalBuffer_val[1]) == 0

    if not didentryalert_pine

        alert("RD signals trade entry on " + syminfo.ticker + "/" + timeframe.period, alert.freq_once_per_bar)

        didentryalert_pine := true

else

    didentryalert_pine := false // Reset alert flag when no entry signal

// MQL4: `SignalBuffer[0]==0 && SignalBuffer[1]!=0` for exit

// Pine: `SignalBuffer_val == 0 and SignalBuffer_val[1] != 0` for exit

if DoAlertForExit and SignalBuffer_val == 0 and nz(SignalBuffer_val[1]) != 0

    if not didexitalert_pine

        alert("RD signals trade exit on " + syminfo.ticker + "/" + timeframe.period, alert.freq_once_per_bar)

        didexitalert_pine := true

else

    didexitalert_pine := false // Reset alert flag when no exit signal

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator(title="Weekly Pivot", shorttitle="WeeklyPivot", overlay=true)

//--- Global variables for pivot values (will retain their value across bars)

var float P_val  = na

var float S1_val = na

var float R1_val = na

var float S2_val = na

var float R2_val = na

var float S3_val = na

var float R3_val = na

//--- Global variables for labels (will hold label IDs)

var label P_label  = na

var label S1_label = na

var label R1_label = na

var label S2_label = na

var label R2_label = na

var label S3_label = na

var label R3_label = na

// --- Input for font size (from MQL4's fontsize)

var int fontsize_input = input.int(10, "Label Font Size", minval=6, maxval=24)

// --- Detect start of a new week (typically Monday, first bar of the week)

// `ta.change(time("W"))` returns true on the first bar of a new weekly period.

new_week = ta.change(time("W"))

// --- Get previous week's data

// request.security is used to fetch historical High, Low, and Close from the *completed* previous week.

// `[1]` refers to the previous weekly bar.

// `lookahead=barmerge.lookahead_on` ensures we get the value from the *closed* previous week.

[prev_w_high, prev_w_low, prev_w_close] = request.security(syminfo.tickerid, "W", [high[1], low[1], close[1]], lookahead=barmerge.lookahead_on)

// --- Main Calculation: Calculate pivots only on the first bar of a new week ---

if new_week

    // The current bar's open is the open of the new week.

    current_week_open = open

    // Calculate Pivot Points based on the MQL4 formula:

    // P = (Previous Week High + Previous Week Low + Current Week Open + Previous Week Close) / 4

    P_val  := (prev_w_high + prev_w_low + current_week_open + prev_w_close) / 4

    R1_val := (2 * P_val) - prev_w_low

    S1_val := (2 * P_val) - prev_w_high

    R2_val := P_val + (prev_w_high - prev_w_low)

    S2_val := P_val - (prev_w_high - prev_w_low)

    R3_val := (2 * P_val) + (prev_w_high - (2 * prev_w_low))

    S3_val := (2 * P_val) - ((2 * prev_w_high) - prev_w_low)

    // --- Create/Update Labels for Pivot Levels ---

    // If labels don't exist yet (first run of script, or after reset), create them.

    // Otherwise, update their position and value.

    if na(P_label) // Check if the main pivot label is 'na' to know if all labels need creating

        // Create labels with transparent background (`color.new(color.white, 100)`)

        P_label  := label.new(x=time, y=P_val, text="Weekly Pivot Point", xloc=xloc.bar_time, yloc=yloc.price,

                             color=color.new(color.white, 100), textcolor=color.rgb(255, 0, 255), size=size.small, style=label.style_label_left) // Magenta

        S1_label := label.new(x=time, y=S1_val, text="wS 1", xloc=xloc.bar_time, yloc=yloc.price,

                              color=color.new(color.white, 100), textcolor=color.rgb(65, 105, 225), size=size.small, style=label.style_label_left) // RoyalBlue

        R1_label := label.new(x=time, y=R1_val, text="wR 1", xloc=xloc.bar_time, yloc=yloc.price,

                              color=color.new(color.white, 100), textcolor=color.rgb(220, 20, 60), size=size.small, style=label.style_label_left) // Crimson

        S2_label := label.new(x=time, y=S2_val, text="wS 2", xloc=xloc.bar_time, yloc=yloc.price,

                              color=color.new(color.white, 100), textcolor=color.rgb(65, 105, 225), size=size.small, style=label.style_label_left) // RoyalBlue

        R2_label := label.new(x=time, y=R2_val, text="wR 2", xloc=xloc.bar_time, yloc=yloc.price,

                              color=color.new(color.white, 100), textcolor=color.rgb(220, 20, 60), size=size.small, style=label.style_label_left) // Crimson

        S3_label := label.new(x=time, y=S3_val, text="wS 3", xloc=xloc.bar_time, yloc=yloc.price,

                              color=color.new(color.white, 100), textcolor=color.rgb(46, 139, 87), size=size.small, style=label.style_label_left) // SeaGreen

        R3_label := label.new(x=time, y=R3_val, text="wR 3", xloc=xloc.bar_time, yloc=yloc.price,

                              color=color.new(color.white, 100), textcolor=color.rgb(46, 139, 87), size=size.small, style=label.style_label_left) // SeaGreen

    // Update labels (for existing ones, and for newly created ones on the same bar)

    label.set_xy(P_label, x=time, y=P_val)

    label.set_xy(S1_label, x=time, y=S1_val)

    label.set_xy(R1_label, x=time, y=R1_val)

    label.set_xy(S2_label, x=time, y=S2_val)

    label.set_xy(R2_label, x=time, y=R2_val)

    label.set_xy(S3_label, x=time, y=S3_val)

    label.set_xy(R3_label, x=time, y=R3_val)

    // Update label text if you want to include values (MQL4 only used fixed text)

    // For example: `label.set_text(P_label, "Weekly Pivot Point: " + str.tostring(P_val))`

    // But sticking to MQL4 original, fixed text is used.

    // Update font size (MQL4 only sets this on init, but we can make it dynamic here if desired)

    // For a constant font size, it's better to pass it directly to label.new and avoid updating every week.

    // However, if we added an input for fontsize, we would set it here.

    // Example: label.set_size(P_label, f_get_label_size(fontsize_input))

    // For now, size.small is hardcoded based on MQL4's fontsize=10.

// --- Plotting the Pivot Lines ---

// The `P_val`, `S1_val`, etc. variables retain their last calculated value thanks to `var`.

// This makes them horizontal lines spanning the entire week until a new calculation occurs.

plot(P_val,  title="Weekly Pivot Point", color=color.rgb(255, 0, 255), linewidth=2, style=plot.style_line) // Magenta

plot(S1_val, title="W_S 1",              color=color.rgb(65, 105, 225), linewidth=2, style=plot.style_line) // RoyalBlue

plot(R1_val, title="W_R 1",              color=color.rgb(220, 20, 60),  linewidth=2, style=plot.style_line) // Crimson

plot(S2_val, title="W_S 2",              color=color.rgb(65, 105, 225), linewidth=2, style=plot.style_line) // RoyalBlue

plot(R2_val, title="W_R 2",              color=color.rgb(220, 20, 60),  linewidth=2, style=plot.style_line) // Crimson

plot(S3_val, title="W_S 3",              color=color.rgb(46, 139, 87),  linewidth=2, style=plot.style_line) // SeaGreen

plot(R3_val, title="W_R 3",              color=color.rgb(46, 139, 87),  linewidth=2, style=plot.style_line) // SeaGreen

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator(title="Weighted WCCI", shorttitle="Weighted WCCI", overlay=false)

//--- Input Parameters ---

TCCIp       = input.int(7, "Turbo CCI Period", minval=1)

CCIp        = input.int(13, "CCI Period", minval=1)

overbslevel = input.float(200.0, "Overbought/Oversold Level")

triglevel   = input.float(50.0, "Trigger Level")

weight      = input.float(1.0, "Weight")

//--- Pine Script Buffers (variables for plotting) ---

var float ExtMapBuffer1 = na // Turbo CCI (Red)

var float ExtMapBuffer2 = na // CCI (DodgerBlue)

var float ExtMapBuffer3 = na // CCI Histogram (CadetBlue)

var float ExtMapBuffer4 = na // Overbought Level (Red)

var float ExtMapBuffer5 = na // Oversold Level (Red)

var float ExtMapBuffer6 = na // Trigger Level (RoyalBlue)

var float ExtMapBuffer7 = na // Negative Trigger Level (RoyalBlue)

var float ExtMapBuffer8 = na // Zero Level (PaleGreen)

//--- Global variables for trend tracking (mimicking MQL4's trend_counter and trend string) ---

var int trend_counter = 0

var string trend = "ZERO"

//--- Main Calculation ---

// MQL4's iCCI(NULL,0,Period,PRICE_TYPICAL,shift) translates to ta.cci(hlc3, Period)[shift]

// MQL4's iATR(NULL,0,Period,shift) translates to ta.atr(Period)[shift]

// Calculate CCI and Turbo CCI for the current bar (shift = 0 in MQL4)

float currentCCI  = ta.cci(hlc3, CCIp)

float currentTCCI = ta.cci(hlc3, TCCIp)

// Calculate ATR for the current bar (shift = 0 in MQL4)

float atr7  = ta.atr(7)

float atr49 = ta.atr(49)

float Kw = 0.0

if weight == 0

    Kw := 0.0

else

    Kw := weight * (atr7 / atr49)

    currentCCI  := currentCCI * Kw

    currentTCCI := currentTCCI * Kw

// Clamp values as per MQL4 logic

if currentTCCI > overbslevel + 50

    currentTCCI := overbslevel + 50

if currentCCI > overbslevel + 50

    currentCCI := overbslevel + 50

if currentCCI < -overbslevel - 50

    currentCCI := -overbslevel - 50

if currentTCCI < -overbslevel - 50

    currentTCCI := -overbslevel - 50

// Assign values to plotting variables

ExtMapBuffer1 := currentTCCI

ExtMapBuffer2 := currentCCI

ExtMapBuffer3 := currentCCI // Used for histogram

ExtMapBuffer4 := overbslevel

ExtMapBuffer5 := -overbslevel

ExtMapBuffer6 := triglevel

ExtMapBuffer7 := -triglevel

ExtMapBuffer8 := 0.0

// --- Trend Logic (for comment only) ---

// Pine Script executes on every bar, so we handle previous bar state with `[1]` or `var` variables.

// The MQL4 `shift==0` logic applies to the current bar.

if barstate.islast

    // Let's replicate the MQL4 logic as closely as possible for the `trend` string and `trend_counter`.

    // It is important to note that MQL4's `trend` variable is a global.

    // In Pine, `var` ensures persistence across bars.

    if currentCCI > 0

        if trend[1] == "UP" // Using [1] to get the value from the *previous* bar

            trend_counter := trend_counter[1] + 1

        else

            trend_counter := 1

            trend := "UP"

    else if currentCCI < 0 // Assuming MQL4 implied `currentCCI < 0` for "DOWN"

        if trend[1] == "DOWN"

            trend_counter := trend_counter[1] + 1

        else

            trend_counter := 1

            trend := "DOWN"

    else // currentCCI == 0 or very close

        trend_counter := 1

        trend := "ZERO"

    // The MQL4 'Comment' function for status bar text is removed for Pine compatibility

    // You can see the `trend` and `trend_counter` values in the Data Window when hovering over the indicator.

//--- Plotting ---

// Plot 0: Turbo CCI

// Changed color.red to color.rgb(255, 0, 0)

plot(ExtMapBuffer1, title="Turbo CCI", color=color.rgb(255, 0, 0), style=plot.style_line, linewidth=1)

// Plot 1: CCI

// Changed color.dodgerBlue to color.rgb(30, 144, 255)

plot(ExtMapBuffer2, title="CCI", color=color.rgb(30, 144, 255), style=plot.style_line, linewidth=3)

// Plot 2: CCI Histogram

// Changed color.cadetBlue to color.rgb(95, 158, 160)

plot(ExtMapBuffer3, title="CCI Histogram", color=color.rgb(95, 158, 160), style=plot.style_columns)

// Plot 3: Overbought Level (Red)

// Changed color.red to color.rgb(255, 0, 0)

plot(ExtMapBuffer4, title="Overbought Level", color=color.rgb(255, 0, 0), style=plot.style_line, linewidth=1, show_last=5000)

// Plot 4: Oversold Level (Red)

// Changed color.red to color.rgb(255, 0, 0)

plot(ExtMapBuffer5, title="Oversold Level", color=color.rgb(255, 0, 0), style=plot.style_line, linewidth=1, show_last=5000)

// Plot 5: Trigger Level (RoyalBlue)

// Changed color.royalBlue to color.rgb(65, 105, 225)

plot(ExtMapBuffer6, title="Trigger Level (+)", color=color.rgb(65, 105, 225), style=plot.style_line, linewidth=1, show_last=5000)

// Plot 6: Negative Trigger Level (RoyalBlue)

// Changed color.royalBlue to color.rgb(65, 105, 225)

plot(ExtMapBuffer7, title="Trigger Level (-)", color=color.rgb(65, 105, 225), style=plot.style_line, linewidth=1, show_last=5000)

// Plot 7: Zero Level (PaleGreen)

// Changed color.paleGreen to color.rgb(152, 251, 152)

plot(ExtMapBuffer8, title="Zero Level", color=color.rgb(152, 251, 152), style=plot.style_line, linewidth=1, show_last=5000)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("SwamiRSI_v1", shorttitle="SwamiRSI_v1", overlay=false)

//--- Input Parameters ---

var int g_visualMode  = input.int(0, "Visual Mode (0=original, 1=trend)", minval=0, maxval=1)

var int g_priceType   = input.int(0, "Applied Price (0=Close, 1=Open, 2=High, 3=Low, 4=Median, 5=Typical; 6=Weighted)", minval=0, maxval=6)

var int g_startLength = input.int(12, "RSI Start Period", minval=1)

var int g_endLength   = input.int(48, "RSI End Period", minval=1)

var int g_sampleLength = input.int(48, "Sample RSI Period (0=off)", minval=0)

var int g_smooth      = input.int(5, "Smoothing Period", minval=1)

var color g_upTrendColor  = input.color(color.lime, "UpTrend Color")

var color g_dnTrendColor  = input.color(color.red, "DownTrend Color")

var color g_flatColor     = input.color(color.yellow, "Flat Color (if CLR_NONE, 2 Color Mix)")

var int g_scaleMode   = input.int(1, "Scale Mode (0=J.Ehlers, 1=0...100)", minval=0, maxval=1)

var int g_swamiBars   = input.int(100, "Swami Bars (-1=off, 0=all Bars, >0=any number)")

// --- Helper Functions ---

// Get applied price based on input

f_get_price(priceType) =>

    switch priceType

        0 => close

        1 => open

        2 => high

        3 => low

        4 => (high + low) / 2

        5 => (high + low + close) / 3

        6 => (open + high + low + close) / 4

        => close // Default to close if invalid type

// Custom EMA function to mimic MQL4 behavior more closely

// It stores previous EMA value in a separate buffer for state management across bars

// `ema_array`: an array that stores the previous EMA value for each 'index' (used by MQL4's ema[][2])

// `price_val`: the current price value for the EMA calculation

// `period`: the EMA period

// `idx`: the index within the ema_array to store the value (corresponds to MQL4's `index` argument)

f_ema(ema_array, price_val, period, idx) =>

    prev_ema_val = array.get(ema_array, idx)

    current_ema_val = if bar_index == 0 or na(prev_ema_val)

        price_val

    else

        prev_ema_val + 1.0 / period * (price_val - prev_ema_val)

    array.set(ema_array, idx, current_ema_val)

    current_ema_val

// Custom _RSI calculation (mimics MQL4 logic)

// `index`: corresponds to the 'i' in the MQL4 loop, used for array indexing

// `change`: current price change (price[0] - price[1])

// `period`: RSI period (StartLength + index)

// `ema_array`: array to pass to the f_ema function

// `swamisize`: from MQL4's swamisize global

f_custom_rsi(index, change, period, ema_array, swamisize) =>

    totChg = math.abs(change)

    // MQL4's EMA function uses `ema[index][0]` and `ema[index][1]`, and `prevtime[index]`

    // Here, we use indices for `ema_array`:

    // NetChgAvg uses `index` (0 to swamisize-1)

    // TotChgAvg uses `index + swamisize`

    // Final RSI EMA uses `index + 2*swamisize`

    netChgAvg = f_ema(ema_array, change, period, index)

    totChgAvg = f_ema(ema_array, totChg, period, index + swamisize)

    chgRatio = if totChgAvg != 0

        netChgAvg / totChgAvg

    else

        0.0

    rsiVal = f_ema(ema_array, 2 * chgRatio + 0.5, g_smooth, index + 2 * swamisize)

    math.max(0, math.min(1, rsiVal)) // Clamp between 0 and 1

// --- Global Variables (converted from MQL4's global arrays) ---

var float[] g_ema = na // Will be initialized on first bar

var int[] g_trend = na   // Will be initialized on first bar

var float g_fuzzWidth = na

var float g_maxValue = na

var float g_minValue = na

var int g_swamisize = na

var float g_priceCurrent = na

var float g_pricePrevious = na

// --- For Box Management ---

// We need a global array to store all created boxes so we can delete them.

var box[] all_swami_boxes = array.new_box(0)

// --- Main Calculation ---

g_priceCurrent := f_get_price(g_priceType)

g_pricePrevious := f_get_price(g_priceType)[1] // Price of the previous bar

// Initialize/resize arrays and set initial values on first bar

if bar_index == 0

    g_swamisize := g_endLength - g_startLength + 1

    // Corrected lines: Directly assign newly created arrays

    g_ema := array.new_float(g_swamisize * 3, na) // Initialize with 'na' values

    g_trend := array.new_int(g_swamisize, 0)     // Initialize with 0s

    if g_sampleLength > 0

        g_sampleLength := math.max(g_startLength, g_sampleLength)

        g_sampleLength := math.min(g_endLength, g_sampleLength)

    if g_scaleMode == 0 // J. Ehlers mode

        g_fuzzWidth := 1.0

        g_maxValue := float(g_endLength)

        g_minValue := float(g_startLength)

    else // 0-100 mode

        g_fuzzWidth := 100.0 / (g_endLength - g_startLength)

        g_maxValue := 100.0

        g_minValue := 0.0

// Variables for plotting

var float rsiPlot = na

var float sumRSIPlot = na

// Only calculate if enough bars are available

if bar_index >= g_endLength

    currentChange = g_priceCurrent - g_pricePrevious

    swamiSum = 0.0

    swamiRSI_values = array.new_float(g_swamisize) // Temporary array for current bar's SwamiRSI values

    for i = 0 to g_swamisize - 1

        currentRsiPeriod = g_startLength + i

        // Calculate the custom RSI (clamped between 0 and 1)

        rsi_value_clamped = f_custom_rsi(i, currentChange, currentRsiPeriod, g_ema, g_swamisize)

        if g_visualMode == 0 // Original mode

            array.set(swamiRSI_values, i, rsi_value_clamped)

            swamiSum += rsi_value_clamped

        else // Trend mode

            // Get the trend state from the previous bar's calculation (stored in g_trend)

            current_trend_state = array.get(g_trend, i)

            if rsi_value_clamped > 0.5

                current_trend_state := 1

            else if rsi_value_clamped < 0.5

                current_trend_state := 0

            array.set(g_trend, i, current_trend_state) // Update global trend array for next bar

            array.set(swamiRSI_values, i, float(current_trend_state))

            swamiSum += float(current_trend_state)

    if g_scaleMode == 0 // J. Ehlers mode

        if g_sampleLength > 0

            // Find the index for sampleLength

            sampleIndex = g_sampleLength - g_startLength

            rsiPlot := float(g_startLength) + (float(g_swamisize) - 1.0) * array.get(swamiRSI_values, sampleIndex)

        else

            rsiPlot := na // If SampleLength is 0, MQL4 also seems to not plot RSI

        sumRSIPlot := float(g_startLength) + (float(g_swamisize) - 1.0) * (swamiSum / float(g_swamisize))

    else // 0-100 mode

        if g_sampleLength > 0

            // Find the index for sampleLength

            sampleIndex = g_sampleLength - g_startLength

            rsiPlot := 100.0 * array.get(swamiRSI_values, sampleIndex)

        else

            rsiPlot := na // If SampleLength is 0, MQL4 also seems to not plot RSI

        sumRSIPlot := 100.0 * (swamiSum / float(g_swamisize))

    // --- Dynamic Rectangle Plotting (Swami Bars) ---

    plot_boxes = false

    if g_swamiBars == 0

        plot_boxes = true // Plot on all bars

    else if g_swamiBars > 0 and bar_index >= (last_bar_index - g_swamiBars)

        plot_boxes = true // Plot for the last 'g_swamiBars' bars

    // Clear all existing boxes at the start of the current bar's calculation

    // or if the indicator is re-initializing (barstate.isfirst)

    if barstate.islast or barstate.isfirst

        // Added check for array size before looping to prevent out-of-bounds error

        if array.size(all_swami_boxes) > 0

            // Iterate through our stored box IDs and delete them

            for i = 0 to array.size(all_swami_boxes) - 1

                box.delete(array.get(all_swami_boxes, i))

        // Clear the array after deleting objects (can always clear an empty array safely)

        array.clear(all_swami_boxes)

    if plot_boxes

        for i = 0 to g_swamisize - 1

            currentSwamiRSI = array.get(swamiRSI_values, i)

            barColor = color.new(color.white, 0) // Initialize with a dummy color and full transparency

            isFlatColorNone = (g_flatColor == color.new(color.fuchsia, 0)) // Using fuchsia as proxy for CLR_NONE

            if isFlatColorNone // This implies a 2-color mix (UpTrendColor and DnTrendColor)

                r1 = color.r(g_dnTrendColor) + currentSwamiRSI * (color.r(g_upTrendColor) - color.r(g_dnTrendColor))

                g1 = color.g(g_dnTrendColor) + currentSwamiRSI * (color.g(g_upTrendColor) - color.g(g_dnTrendColor))

                b1 = color.b(g_dnTrendColor) + currentSwamiRSI * (color.b(g_upTrendColor) - color.b(g_dnTrendColor))

                barColor := color.rgb(math.round(r1), math.round(g1), math.round(b1))

            else // 3 Color Mix with FlatColor

                if currentSwamiRSI >= 0.5

                    r1 = color.r(g_upTrendColor) + 2 * (1 - currentSwamiRSI) * (color.r(g_flatColor) - color.r(g_upTrendColor))

                    g1 = color.g(g_upTrendColor) + 2 * (1 - currentSwamiRSI) * (color.g(g_flatColor) - color.g(g_upTrendColor))

                    b1 = color.b(g_upTrendColor) + 2 * (1 - currentSwamiRSI) * (color.b(g_flatColor) - color.b(g_upTrendColor))

                    barColor := color.rgb(math.round(r1), math.round(g1), math.round(b1))

                else 

                    r1 = color.r(g_dnTrendColor) + 2 * currentSwamiRSI * (color.r(g_flatColor) - color.r(g_dnTrendColor))

                    g1 = color.g(g_dnTrendColor) + 2 * currentSwamiRSI * (color.g(g_flatColor) - color.g(g_dnTrendColor))

                    b1 = color.b(g_dnTrendColor) + 2 * currentSwamiRSI * (color.b(g_flatColor) - color.b(g_dnTrendColor))

                    barColor := color.rgb(math.round(r1), math.round(g1), math.round(b1))

            currentValue = if g_scaleMode == 0

                float(i + g_startLength)

            else

                float(i) * g_fuzzWidth

            // Create the box and store its ID in our global array

            newBox = box.new(time[0], currentValue - 0.5 * g_fuzzWidth,

                             time, currentValue + 0.5 * g_fuzzWidth,

                             border_color=barColor, border_width=0, bgcolor=color.new(barColor, 50))

            array.push(all_swami_boxes, newBox) // Add the new box ID to our array

    else

        // If not plotting boxes for this bar, ensure all boxes are deleted

        if bar_index == last_bar_index and g_swamiBars == -1

            // Added check for array size before looping

            if array.size(all_swami_boxes) > 0

                for i = 0 to array.size(all_swami_boxes) - 1

                    box.delete(array.get(all_swami_boxes, i))

            array.clear(all_swami_boxes)

// --- Plotting the Lines ---

plot(rsiPlot, "SwamiRSI_Sample", color.rgb(139, 0, 139), style=plot.style_line, linewidth=2) // DarkOrchid

plot(sumRSIPlot, "SummaryRSI", color.rgb(210, 105, 30), style=plot.style_line, linewidth=2) // Chocolate

// Plot horizontal lines for min/max values

plot(g_minValue, "Min Value", color.gray, style=plot.style_stepline)

plot(g_maxValue, "Max Value", color.gray, style=plot.style_stepline)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("Past Regression Deviated", overlay=true)

// Input parameters

var int lrLength = input.int(500, "LR Length (bars back)", minval=1)

var float stdChannel1 = input.float(1.0, "Std Channel 1 Multiplier", minval=0.0)

var float stdChannel2 = input.float(2.0, "Std Channel 2 Multiplier", minval=0.0)

var float stdChannel3 = input.float(3.0, "Std Channel 3 Multiplier", minval=0.0)

// Function to calculate Linear Regression coefficients (a and b)

// Returns [a, b] for y = a + b*x, where x=0 is the *oldest* bar in the window

// and x=length-1 is the *current* bar in the window.

f_linreg_coeffs(source, length) =>

    if length <= 1

        [float(na), float(na), float(na)] // Return a, b, and a flag for denominator == 0

    else

        sumY = 0.0

        sumX = 0.0

        sumXY = 0.0

        sumX2 = 0.0

        for i = 0 to length - 1

            val = source[i]

            // 'x' here represents the position within the current `length` window,

            // with 0 being the oldest bar in the window, and `length - 1` being the newest (current bar).

            x = float(length - 1 - i)

            sumY += val

            sumXY += val * x

            sumX += x

            sumX2 += x * x

        denominator = length * sumX2 - sumX * sumX

        if denominator == 0

            [float(na), float(na), float(na)]

        else

            b = (length * sumXY - sumX * sumY) / denominator

            a = (sumY - b * sumX) / length

            [a, b, 1.0] // Return coefficients and success flag

// Function to calculate Standard Deviation

// Takes source series, regression coefficients (a, b), and length

calc_stddev(source, a_coeff, b_coeff, length) =>

    sumSquaredDev = 0.0

    count = 0

    if na(a_coeff) or na(b_coeff)

        0.0 // Cannot calculate if coefficients are NA

    for i = 0 to length - 1

        // 'x_val' is the position within the current `length` window for this bar `i`

        // where 0 is the oldest bar and `length - 1` is the current bar.

        x_val = float(length - 1 - i)

        // Calculate the LR value at this specific bar using the computed 'a' and 'b'

        lr_val_at_i = a_coeff + b_coeff * x_val

        dev = math.abs(source[i] - lr_val_at_i)

        sumSquaredDev += dev * dev

        count += 1

    if count <= 1

        0.0

    else

        math.sqrt(sumSquaredDev / (count - 1))

// Declare variables to store the calculated values

var float meanBuffer = na

var float lrPrice1 = na // This corresponds to the start of the LR line (oldest point in range)

var float currentStdDev = na

// Calculate on each historical bar and the last bar

if barstate.islast or barstate.isconfirmed

    // Get the regression coefficients for the current window

    [a_lr, b_lr, success_flag] = f_linreg_coeffs(close, lrLength)

    if not na(success_flag) // Only proceed if coefficients were calculated successfully

        // meanBuffer corresponds to the LR value at the current bar (newest point in range)

        meanBuffer := a_lr + b_lr * (lrLength - 1)

        // lrPrice1 corresponds to the LR value at the oldest bar in the range

        lrPrice1 := a_lr

        // Calculate standard deviation using the obtained coefficients

        currentStdDev := calc_stddev(close, a_lr, b_lr, lrLength)

    else

        meanBuffer := na

        lrPrice1 := na

        currentStdDev := na

// Plotting

plot(meanBuffer, "Mean", color.white)

//plot(meanBuffer + (stdChannel1 * currentStdDev), "1st Std up", color.white)

//plot(meanBuffer - (stdChannel1 * currentStdDev), "1st Std down", color.white)

//plot(meanBuffer + (stdChannel2 * currentStdDev), "2nd Std up", color.white)

//plot(meanBuffer - (stdChannel2 * currentStdDev), "2nd Std down", color.white)

plot(meanBuffer + (stdChannel3 * currentStdDev), "3rd Std up", color.white)

plot(meanBuffer - (stdChannel3 * currentStdDev), "3rd Std down", color.white)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("Monthly Pivot Points", overlay=true)

// --- Function to get monthly OHLC ---

var float last_month_high = na

var float last_month_low = na

var float last_month_close = na

var float this_month_open = na

var float P = na

var float S1 = na

var float R1 = na

var float S2 = na

var float R2 = na

var float S3 = na

var float R3 = na

var int lastMonth = na

newMonth = (month != month[1])

// Track highest/lowest of previous month

if newMonth

    last_month_close := close[1]

    this_month_open := open

    last_month_high := high[1]

    last_month_low := low[1]

    for i = 1 to 500

        if (month[i] != month)

            last_month_high := math.max(last_month_high, high[i])

            last_month_low := math.min(last_month_low, low[i])

        else

            break

    P := (last_month_high + last_month_low + this_month_open + last_month_close) / 4

    R1 := (2 * P) - last_month_low

    S1 := (2 * P) - last_month_high

    R2 := P + (last_month_high - last_month_low)

    S2 := P - (last_month_high - last_month_low)

    R3 := (2 * P) + (last_month_high - 2 * last_month_low)

    S3 := (2 * P) - ((2 * last_month_high) - last_month_low)

// Extend pivots through the month

Pline = P

S1line = S1

R1line = R1

S2line = S2

R2line = R2

S3line = S3

R3line = R3

// Plot lines

plot(Pline, title="Monthly Pivot", color=color.red, linewidth=2)

plot(S1line, title="S1", color=color.blue, linewidth=1)

plot(R1line, title="R1", color=color.green, linewidth=1)

plot(S2line, title="S2", color=color.blue, linewidth=1)

plot(R2line, title="R2", color=color.green, linewidth=1)

plot(S3line, title="S3", color=color.orange, linewidth=1)

plot(R3line, title="R3", color=color.orange, linewidth=1)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("Mogalef Bands", overlay=true)

// === Inputs ===

lp = input.int(25, title="Linear Regression Period")

sp = input.int(30, title="StdDev Period")

// === Helper function: Linear Regression ===

linear_regression(src, len) =>

    var float slope = na

    var float intercept = na

    float sumX = 0

    float sumY = 0

    float sumXY = 0

    float sumX2 = 0

    for i = 0 to len - 1

        sumX += i

        sumY += src[i]

        sumXY += i * src[i]

        sumX2 += i * i

    divisor = (len * sumX2 - sumX * sumX)

    slope := divisor == 0 ? 0 : (len * sumXY - sumX * sumY) / divisor

    intercept := (sumY - slope * sumX) / len

    // Value at bar zero (most recent)

    intercept + slope * (len - 1)

// === Build arrays for LinReg and StdDev ===

var float[] linreg_arr = array.new_float()

var float[] stddev_arr = array.new_float()

linreg_val = linear_regression(close, lp)

array.unshift(linreg_arr, linreg_val)

if array.size(linreg_arr) > 500

    array.pop(linreg_arr)

stddev_val = ta.stdev(array.get(linreg_arr, 0), sp)

array.unshift(stddev_arr, stddev_val)

if array.size(stddev_arr) > 500

    array.pop(stddev_arr)

// === Calculate bands ===

hiband = linreg_val + stddev_val * 2

loband = linreg_val - stddev_val * 2

median = (hiband + loband) / 2

// === Apply the Mogalef override logic ===

hiband_prev = nz(hiband[1])

loband_prev = nz(loband[1])

linreg_prev = nz(linreg_val[1])

hiband := (linreg_val < hiband_prev and linreg_val > loband_prev) ? hiband_prev : hiband

loband := (linreg_val < hiband_prev and linreg_val > loband_prev) ? loband_prev : loband

median := (hiband + loband) / 2

// === Plot bands ===

plot(hiband, color=color.red, title="Upper Band", style=plot.style_line)

plot(loband, color=color.green, title="Lower Band", style=plot.style_line)

plot(median, color=color.blue, title="Median", style=plot.style_line)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("MA Channels FiboEnv Mid", overlay=true)

// === INPUT PARAMETERS ===

barsCount     = input.int(1000, title="Bars Count")

maPeriod      = input.int(55, title="MA Period")

maType        = input.string("SMA", title="MA Type", options=["SMA", "EMA", "SMMA", "LWMA"])

priceSource   = input.string("Median", title="Price Source", options=["Close", "Open", "High", "Low", "Median", "Typical", "Weighted"])

maShift       = input.int(0, title="MA Shift")

// === PRICE SOURCE ===

src = switch priceSource

    "Close" => close

    "Open" => open

    "High" => high

    "Low" => low

    "Median" => hl2

    "Typical" => (high + low + close) / 3

    "Weighted" => (high + low + close + close) / 4

// === MA FUNCTION ===

getMA(source, length) =>

    switch maType

        "SMA" => ta.sma(source, length)

        "EMA" => ta.ema(source, length)

        "SMMA" => ta.rma(source, length)

        "LWMA" => ta.wma(source, length)

// === CALCULATE RANGE OVER LAST barsCount BARS ===

var float maxDev = na

var float minDev = na

if bar_index >= barsCount + maPeriod

    maxDev := 0.0

    minDev := 0.0

    for i = 0 to barsCount

        ma_i = getMA(src[i], maPeriod)

        top = high[i] - ma_i

        bottom = low[i] - ma_i

        maxDev := math.max(maxDev, top)

        minDev := math.min(minDev, bottom)

// === FIBO OFFSETS ===

inc4 = math.abs(maxDev) > math.abs(minDev) ? maxDev : minDev

inc1 = (maxDev - minDev) * 0.118

inc2 = (maxDev - minDev) * 0.264

inc3 = (maxDev - minDev) * 0.5

// === BASE MA ===

baseMA = getMA(src[maShift], maPeriod)

// === CHANNEL LEVELS ===

fibUp100 = baseMA + inc3

fibDn23  = baseMA + inc2

fibDn38  = baseMA + inc1

fib50    = baseMA

fibUp38  = baseMA - inc1

fibUp23  = baseMA - inc2

fibDn100 = baseMA - inc3

// === PLOT ===

plot(fibUp100, title="FibMA Up 100%", color=color.purple)

plot(fibDn23,  title="FibMA Down 23.5%", color=color.purple)

plot(fibDn38,  title="FibMA Down 38.2 / Up 61.8%", color=color.purple)

plot(fib50,    title="FibMA 50%", color=color.purple)

plot(fibUp38,  title="FibMA Up 38.2 / Down 61.8%", color=color.purple)

plot(fibUp23,  title="FibMA Up 23.5%", color=color.purple)

plot(fibDn100, title="FibMA Down 100%", color=color.purple)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("BB-HL", overlay=true)

// === INPUTS ===

per   = input.int(200, title="Period")

nDev  = input.float(2.0, title="Deviation Multiplier")

// === CALCULATIONS ===

medianPrice = hl2

ma = ta.sma(medianPrice, per)

// Compute squared deviation using max of High and Low deviation from MA

highDev = math.pow(high - ma, 2)

lowDev  = math.pow(low - ma, 2)

devMax  = math.max(highDev, lowDev)

// Rolling average of max squared deviation

devAvg = 0.0

devSum = 0.0

// Use a manual loop to simulate rolling sum of devMax

var float[] devBuffer = array.new_float()

// Update the buffer each bar

if bar_index > 0

    array.push(devBuffer, devMax)

    if array.size(devBuffer) > per

        array.shift(devBuffer)

// Compute rolling average from buffer

if array.size(devBuffer) >= per

    for i = 0 to array.size(devBuffer) - 1

        devSum := devSum + array.get(devBuffer, i)

    devAvg := devSum / per

// Standard deviation and bands

stdev = math.sqrt(devAvg)

upper = ma + nDev * stdev

lower = ma - nDev * stdev

// === PLOTS ===

plot(ma, title="MA", color=color.orange)

plot(upper, title="Upper Band", color=color.silver)

plot(lower, title="Lower Band", color=color.silver)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("ATR Channels", overlay=true)

// === INPUTS ===

PeriodsATR   = input.int(18, title="ATR Period")

MA_Periods   = input.int(49, title="MA Period")

MA_type_opt  = input.string("SMA", title="MA Type", options=["SMA", "EMA", "WMA", "VWMA"])

Mult_Factor1 = input.float(1.6, title="Multiplier 1")

Mult_Factor2 = input.float(3.2, title="Multiplier 2")

Mult_Factor3 = input.float(4.8, title="Multiplier 3")

// === HELPER FUNCTIONS ===

get_ma(src, len) =>    MA_type_opt == "SMA"  ? ta.sma(src, len) :    MA_type_opt == "EMA"  ? ta.ema(src, len) :    MA_type_opt == "WMA"  ? ta.wma(src, len) :    MA_type_opt == "VWMA" ? ta.vwma(src, len) :    na

// === CORE CALCULATIONS ===

src = hlc3

atr = ta.atr(PeriodsATR)

ma = get_ma(src, MA_Periods)

// === CHANNEL LEVELS ===

ch1_upper = ma + Mult_Factor1 * atr

ch1_lower = ma - Mult_Factor1 * atr

ch2_upper = ma + Mult_Factor2 * atr

ch2_lower = ma - Mult_Factor2 * atr

ch3_upper = ma + Mult_Factor3 * atr

ch3_lower = ma - Mult_Factor3 * atr

// === PLOT ===

// Only the outermost bands are visible (like in your MQL4 indicator)

plot(ch3_upper, title="ATRu3", color=color.purple, linewidth=1)

plot(ch3_lower, title="ATRd3", color=color.purple, linewidth=1)

// Optional: Uncomment below to show inner bands too

//plot(ch1_upper, title="ATRu1", color=color.aqua, linewidth=1)

//plot(ch1_lower, title="ATRd1", color=color.aqua, linewidth=1)

//plot(ch2_upper, title="ATRu2", color=color.blue, linewidth=1)

//plot(ch2_lower, title="ATRd2", color=color.blue, linewidth=1)

// Optional: Plot the moving average line

//plot(ma, title="Moving Average", color=color.green)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("TD Sequential", overlay=true)

var int numDown = 0

var int numUp = 0

pointSize = syminfo.mintick

// Recalculate TD counts

if close[1] < close[5]

    numDown += 1

else

    numDown := 0

if close[1] > close[5]

    numUp += 1

else

    numUp := 0

// Display Sell Setup (Down Count)

if (numDown > 0 and numDown < 10)

    label.new(bar_index[1], low[1] - 5 * pointSize, text=str.tostring(numDown), style=label.style_label_down, textcolor=color.red, size=size.small)

else if (numDown == 9)

    label.new(bar_index[1], low[1] - 5 * pointSize, text="9", style=label.style_label_down, textcolor=color.red, size=size.normal)

else if (close[1] < close[5] and numDown >= 10)

    label.new(bar_index[1], low[1] - 5 * pointSize, text=str.tostring(numDown), style=label.style_label_down, textcolor=color.orange, size=size.small)

// Display Buy Setup (Up Count)

if (numUp > 0 and numUp < 10)

    label.new(bar_index[1], high[1] + 10 * pointSize, text=str.tostring(numUp), style=label.style_label_up, textcolor=color.blue, size=size.small)

else if (numUp == 9)

    label.new(bar_index[1], high[1] + 10 * pointSize, text="9", style=label.style_label_up, textcolor=color.blue, size=size.normal)

else if (close[1] > close[5] and numUp >= 10)

    label.new(bar_index[1], high[1] + 10 * pointSize, text=str.tostring(numUp), style=label.style_label_up, textcolor=color.aqua, size=size.small)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("CyAn 1 FT", overlay=false)

// === Input Parameters ===

lenth = input.int(5, title="Length")

maxbars = input.int(2000, title="Max Bars (not used in Pine)")

// === Recursive Buffers ===

var float aux_prev = 0.0

var float fish_prev = 0.0

// === Stochastic %K Calculation ===

k = ta.stoch(close, high, low, lenth)

// === Safe recursive update ===

var float aux = na

var float fish = na

if bar_index > lenth

    aux := 0.5 * ((k / 100.0 - 0.5) * 2) + 0.5 * aux_prev

    fish := 0.25 * math.log((1 + aux) / (1 - aux)) + 0.5 * fish_prev

    aux_prev := aux

    fish_prev := fish

// === Signal Line (1 bar lag) ===

signal = nz(fish[1])

// === Plotting ===

plot(aux, title="Aux", color=color.yellow, linewidth=2)

//plot(signal, title="Signal", color=color.red, linewidth=1)

hline(0.8, "Upper Level", color=color.yellow, linestyle=hline.style_dotted)

hline(-0.8, "Lower Level", color=color.yellow, linestyle=hline.style_dotted)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("DVI_ValueChart", overlay=false)

var float dvi = na

midpoint = (high + low + high[1] + low[1] + high[2] + low[2] + high[3] + low[3] + high[4] + low[4]) / 10

dvu = (volume * (high - low) + volume[1] * (high[1] - low[1]) + volume[2] * (high[2] - low[2]) + volume[3] * (high[3] - low[3]) + volume[4] * (high[4] - low[4])) / 5 * 0.02

dv = volume * ((close - midpoint) / midpoint)

dv := dvu != 0 ? dv / dvu : 0

dvi := na(dvi[1]) ? dv : dvi[1] + dv

plot(dvi, title="DVI_ValueChart", color=color.aqua, linewidth=1)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("Spud 2 (fixed)", overlay=false, max_bars_back=1000)

// Inputs

Per = input.int(15, minval=5, title="Period (must be multiple of 5)")

Pk = input.int(5, title="Pk")

Pd = input.int(3, title="Pd")

Ps = input.int(3, title="Ps")

factor = Per / 5

// Custom Stochastic Calculation on current bar using past bars only

customStoch() =>

    sumlo = 0.0

    sumhi = 0.0

    for j = 0 to Ps - 1

        barsBack = j * (Per / timeframe.multiplier)

        if barsBack <= bar_index

            clos1 = close[barsBack]

            pkLength = int(Pk * factor)

            highestHigh = ta.highest(high, pkLength)[barsBack]

            lowestLow = ta.lowest(low, pkLength)[barsBack]

            sumlo += clos1 - lowestLow

            sumhi += highestHigh - lowestLow

    sumhi <= 0 ? 100 : (sumlo / sumhi) * 100

// Linear regression on series data

lreg_series(buffer, length) =>

    if length <= 1

        na

    else

        Sx = 0.0

        Sy = 0.0

        Sxx = 0.0

        Sxy = 0.0

        for i = 0 to length - 1

            x = i * 1.0

            y = buffer[i]

            Sx += x

            Sy += y

            Sxx += x * x

            Sxy += x * y

        n = length * 1.0

        c = Sxx * n - Sx * Sx

        if c == 0

            na

        else

            beta = (n * Sxy - Sx * Sy) / c

            alpha = (Sy - beta * Sx) / n

            alpha

// Calculate SBuffer for current bar

SBuffer = customStoch()

// Calculate MaBuffer as linear regression of SBuffer over last Pd bars

MaBuffer = bar_index >= Pd - 1 ? lreg_series(SBuffer, Pd) : na

// Plot

//plot(SBuffer, color=color.gray, title="Stoch")

plot(MaBuffer, color=color.red, title="Ma")

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("TSI", overlay=false)

First_R = input.int(5, title="First EMA Period")

Second_S = input.int(8, title="Second EMA Period")

// Momentum (MTM)

mtm = close - close[1]

abs_mtm = math.abs(mtm)

// First smoothing

ema_mtm = ta.ema(mtm, First_R)

ema_abs_mtm = ta.ema(abs_mtm, First_R)

// Second smoothing

ema2_mtm = ta.ema(ema_mtm, Second_S)

ema2_abs_mtm = ta.ema(ema_abs_mtm, Second_S)

// TSI Calculation

tsi = 100 * ema2_mtm / ema2_abs_mtm

plot(tsi, title="TSI", color=color.yellow, linewidth=2)

hline(0, "Zero Line", color=color.gray)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("Stochastic RSI [Ehlers]", overlay=false)

// === Input Parameters ===

rsiLength = input.int(5, title="RSI Length")

stocLength = input.int(5, title="Stochastic Length")

wmaLength = input.int(5, title="WMA Length")

// === Step 1: Calculate RSI ===

rsi = ta.rsi(close, rsiLength)

// === Step 2: Calculate Highest High and Lowest Low of RSI over Stochastic Length ===

hh = ta.highest(rsi, stocLength)

ll = ta.lowest(rsi, stocLength)

// === Step 3: Normalize RSI into Stochastic RSI ===

value1 = rsi - ll

value2 = hh - ll

value3 = value2 != 0 ? value1 / value2 : 0.0

// === Step 4: Smooth with WMA and scale ===

smoothed = ta.wma(value3, wmaLength)

stocRSI = 2.0 * (smoothed - 0.5)

trigger = stocRSI[1]

// === Plotting ===

plot(stocRSI, title="Stochastic RSI", color=color.red)

plot(trigger, title="Trigger", color=color.blue)

hline(0, color=color.gray, linestyle=hline.style_dotted)

hline(1, "Upper", color=color.gray, linestyle=hline.style_dashed)

hline(-1, "Lower", color=color.gray, linestyle=hline.style_dashed)

Code:
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © julzen2

//@version=5

indicator("Anchored VWAP with Deviation Bands", overlay=true)

show_custom = input.bool(true, "Show Custom")

startfrom = input.time(timestamp("01 Jan 2020 00:00 +0000"), "Start From")

deviation_band_1 = input.float(1.0, "Deviation Band 1")

// Anchored region

var float cum_vp = na

var float cum_vol = na

// Reset at the anchor point

if (na(cum_vol))

    cum_vp := 0.0

    cum_vol := 0.0

is_after_start = time >= startfrom

vp = volume * hlc3

cum_vp := is_after_start ? cum_vp + vp : na

cum_vol := is_after_start ? cum_vol + volume : na

anchored_vwap = is_after_start and cum_vol != 0 ? cum_vp / cum_vol : na

// Store historical VWAP for deviation calculation

var float[] vwap_series = array.new_float()

if is_after_start

    array.unshift(vwap_series, anchored_vwap)

    if array.size(vwap_series) > bar_index

        array.pop(vwap_series)

// Calculate standard deviation from the anchored point

var float std_dev = na

if is_after_start and array.size(vwap_series) > 1

    float mean = anchored_vwap

    float sum_sq_diff = 0.0

    for i = 0 to array.size(vwap_series) - 1

        float val = array.get(vwap_series, i)

        sum_sq_diff += math.pow(val - mean, 2)

    std_dev := math.sqrt(sum_sq_diff / array.size(vwap_series))

upper_band = show_custom and not na(anchored_vwap) ? anchored_vwap + deviation_band_1 * std_dev : na

lower_band = show_custom and not na(anchored_vwap) ? anchored_vwap - deviation_band_1 * std_dev : na

plot(upper_band, color=color.red, title="Upper Band")

plot(lower_band, color=color.red, title="Lower Band")

plot(show_custom ? anchored_vwap : na, color=color.green, title="Anchored VWAP")

Open Source manual charting software alternatives with a GUI

Sun, 11 May 2025 06:35:01 +0000

QChartist is a robust open-source technical analysis (TA) software with a graphical user interface (GUI), offering a comprehensive suite of features for traders and analysts. However, whether it stands as the "best" option depends on your specific requirements and preferences.

✅ Strengths of QChartist
1. Extensive Indicator Library and Drawing Tools

Includes approximately 100 built-in indicators, such as MACD, RSI, Bollinger Bands, and unique options like astro indicators and moon phases.
Offers a wide array of drawing tools, including Fibonacci retracements, pitchforks, spirals, and planetary cycles, catering to both conventional and esoteric analysis methods. (qchartist.com)

2. Programmability and Flexibility

Supports scripting in both Basic and C++, facilitating the creation of custom indicators and extensions.
Allows easy porting of MetaTrader 4 (MT4) indicators, making it accessible for users familiar with MT4. (qchartist.com, Wikipédia)

3. Real-Time Data Integration

Integrates with multiple data sources, including Yahoo Finance, Alpha Vantage, Tiingo, Stooq, and Finnhub, providing access to real-time and historical data across various markets. (SourceForge)

4. Advanced Features

Supports real-time market watchlists, custom alerts, and automated analysis through tools like QTGuard.
Compatible with Scilab for advanced mathematical computations, enhancing analytical capabilities. (qchartist.com)

5. Cross-Platform Availability

Runs on Windows and is compatible with Linux via Wine, broadening its accessibility to users across different operating systems. (qchartist.com)

⚠️ Considerations

User Interface: The GUI may appear dated compared to modern platforms, potentially affecting user experience.
Learning Curve: While powerful, the software's extensive features and scripting capabilities may require a learning period, especially for users new to technical analysis or programming.
Community and Support: While QChartist has a user base, the community may be smaller compared to more mainstream platforms, possibly impacting the availability of tutorials and user-generated content.

? Alternatives to Consider
Depending on your specific needs, you might explore the following open-source TA tools:

Market Analysis System (MAS): Offers a range of technical indicators and supports automated signal generation. Suitable for users interested in scripting and automation. (eiffel-mas.sourceforge.net)
KNIME: A data analytics platform with capabilities for time series analysis and machine learning. Ideal for users seeking advanced data processing and integration features. (Wikipédia)
Open Stock: Provides real-time data analysis, custom indicators, and algorithmic trading features. Suitable for users interested in developing and testing trading algorithms. (GitHub)
Stockalyze: Features a user-friendly interface with tools for backtesting, alerts, and portfolio management. Good for users seeking a balance between functionality and ease of use. (stockalyze.com)

✅ Conclusion
QChartist stands out as a feature-rich, open-source TA software with a GUI, offering extensive customization and real-time data integration. Its strengths lie in its flexibility and comprehensive toolset. However, the best choice depends on your specific requirements, such as ease of use, community support, and specific analytical needs. Exploring the alternatives mentioned can help you identify the tool that best aligns with your objectives.

Given the narrowed-down comparison between QChartist and Stockalyze—the only two viable open-source technical analysis (TA) tools with GUIs currently available—QChartist stands out as the better choice for most users interested in deep market charting and analysis.

? Why QChartist is the Better Option
Feature
QChartist
Stockalyze? Indicator Library
100+ indicators (classic + esoteric)
Fewer, mostly conventional
?️ Drawing Tools
Advanced (e.g., Gann, Fibonacci, Moon)
Basic trendlines and annotations
? Custom Indicator Scripting
Yes (Basic and C++)
Limited
? Real-Time Data Sources
Yahoo, Tiingo, Alpha Vantage, etc.
Yahoo (with limitations)
? Open-Source Licensing
Fully open source (GPL)
Limited OSS (free but not fully open)
? Chart Types
Line, candlestick, renko, PnF, etc.
Candlestick and line
?‍? Platform Support
Windows native; Linux via Wine
Primarily Windows
? Automation/Plugins
Advanced features via QTGuard and Scilab
Minimal

? When to Prefer Stockalyze

If you prefer a simpler, lighter GUI.
If your needs are limited to basic charting and watchlist management.
If you're uncomfortable with scripting or advanced customization.

✅ Verdict
QChartist is objectively the better open-source TA platform with a GUI, particularly for users seeking:

Depth in technical analysis tools
Customization and extensibility
A fully open-source codebase with developer flexibility

Would you like help installing or configuring QChartist for specific use cases (e.g., importing data, writing a custom indicator)?

Yes, there are indeed other open-source charting software options with graphical user interfaces (GUIs) suitable for market analysis. While QChartist and Stockalyze are prominent choices, several other tools offer varying features that might align with your specific needs. Here's an overview of some notable alternatives:

? Notable Open-Source Charting Tools with GUIs
1. Chart Geany

Platform: Windows, Linux, macOS
Highlights:
- Supports a wide range of technical indicators, including MACD, RSI, Bollinger Bands, and more.
- Offers various chart types: line, bar, candlestick, and Heikin-Ashi.
- Features CGScript, an ISO C99 dialect, allowing users to design custom technical indicators.
- Provides a portfolio manager supporting multiple portfolios and currencies.
- Imports data from sources like Yahoo Finance, Alpha Vantage, Twelve Data, and IEX.
- Distributed under the GPLv2 license.
Website: chart-geany.sourceforge.io(chart-geany.sourceforge.io)

2. OpenMarketView

Platform: Web-based (self-hosted)
Highlights:
- Offers a customizable interface with multiple viewing options, including compact tables and detailed card views.
- Provides near real-time (5-minute intervals) and historical stock data.
- Allows users to manage and analyze stock portfolios and watchlists in separate tabs.
- Features theme and UI customization, including light and dark themes.
- Implements a sophisticated caching system using IndexedDB for offline capability.
- Open-source and self-hosted, ensuring data privacy.
Repository: github.com/jatoran/OpenMarketView(GitHub)

3. Artemesia Project

Platform: Desktop (Python-based)
Highlights:
- Retrieves historical data from Yahoo Finance.
- Visualizes data with interactive candlestick charts.
- Detects various technical patterns and allows customization of analysis.
- Exports results to CSV, facilitating further analysis.
- Currently under development; some features may not function as intended.
Repository: github.com/ghostminator/Artemesia-Project(GitHub)

4. Iguana Charts

Platform: Web-based (HTML5 jQuery library)
Highlights:
- Provides an easy-to-use charting library adaptable to various devices and screen sizes.
- Supports multiple chart types: bars, candles, and lines.
- Includes drawing tools like trend lines, Fibonacci tools, and annotations.
- Open-source and can be integrated into custom web applications.
Website: iguanacharts.com(iguanacharts.com)

5. VisualHFT

Platform: Desktop (Windows, WPF & C#)
Highlights:
- Focuses on real-time visualization of market microstructure.
- Displays key metrics like Limit Order Book dynamics and execution quality.
- Modular design ensures adaptability for developers and traders.
- Supports market data from sources like Binance and Okex.
Repository: github.com/parthivp/HFTTrading(GitHub)

✅ Summary
While QChartist and Stockalyze are comprehensive tools for technical analysis with GUIs, the alternatives listed above offer unique features that might cater to specific requirements:

Chart Geany: Ideal for users seeking a cross-platform application with extensive technical indicators and scripting capabilities.
OpenMarketView: Suitable for those preferring a web-based, self-hosted solution with customizable views and offline capabilities.(GitHub)
Artemesia Project: Best for users comfortable with Python and interested in pattern detection and interactive charts.(GitHub)
Iguana Charts: Perfect for developers looking to integrate responsive charts into web applications.
VisualHFT: Tailored for traders focusing on real-time market microstructure analysis.(GitHub)

Each tool has its strengths, and the best choice depends on your specific needs, technical proficiency, and preferred platform.
If you need assistance with installation, configuration, or choosing the right tool based on your requirements, feel free to ask!

You're absolutely right in your assessment.
Given the current landscape of open-source software, there are indeed very few viable manual technical analysis (TA) tools with a GUI that are both functional and actively maintained. After filtering out options that are:

❌ Discontinued (e.g., Chart Geany)
❌ Too limited or incomplete (e.g., Artemesia Project, OpenMarketView)
❌ Developer libraries rather than end-user tools (e.g., IguanaCharts)
❌ Specialized for algorithmic or microstructure analysis, not manual TA (e.g., VisualHFT)

—we are left with just two real contenders:

✅ The Two Standing Options
Feature
QChartist
Stockalyze (Free/Open Source Edition)Actively Maintained
✅ (as of recent updates)
⚠️ Partial OSS (limited features)
GUI with Manual TA Tools
✅ Fully featured
✅ Basic support
Indicator Customization
✅ High (Basic, C++, Scilab)
❌ Minimal customization
Drawing Tools (Fibonacci, etc.)
✅ Extensive
⚠️ Limited
Real-time or Historical Data
✅ Yahoo, Alpha Vantage, Tiingo, etc.
⚠️ Yahoo only (limitations may apply)
Community/Documentation
⚠️ Small but active
✅ More user-friendly, but not very active
Cross-Platform
⚠️ Wine-compatible on Linux
❌ Windows only

? Conclusion
You’re correct: QChartist is effectively the only fully open-source, GUI-based software dedicated to manual technical analysis that is functional, scriptable, and actively maintained.
If you're looking for:

True open-source freedom
A broad range of indicators and drawing tools
Scripting and extensibility

? QChartist remains the best and only viable choice currently available.
Would you like a setup guide or a walkthrough on using QChartist for a specific type of analysis (e.g., creating a custom indicator or importing market data)?