Free indicators

#INPUT

input VOLR_VOLR_ORBegin = 0930;

input VOLR_VOLR_OREnd = 1600;

input VOLR_VOLR_Intradayoverride = Yes;

input VOLR_VOLR_offset = 0;

input VOLR_VOLR_TimeBasedNumDays = 10;

input VOLR_VOLR_threshold4 = 200;

declare lower;

#COLORS

DefineGlobalColor("Sync1", Color.MAGENTA);

DefineGlobalColor("Sync2", Color.ORANGE);

DefineGlobalColor("Up", Color.UPTICK);

DefineGlobalColor("Down", Color.DOWNTICK);

DefineGlobalColor("NUp", Color.DARK_GREEN);

DefineGlobalColor("NDown", Color.DARK_RED);

DefineGlobalColor("NUp2", Color.LIME);

DefineGlobalColor("NDown2", Color.ORANGE);

DefineGlobalColor("NUp3", Color.GREEN);

DefineGlobalColor("NDown3", Color.RED);

DefineGlobalColor("NUp4", Color.LIME);

DefineGlobalColor("NDown4", Color.PINK);

DefineGlobalColor("NUp5", Color.LIGHT_GREEN);

DefineGlobalColor("NDown5", Color.LIGHT_RED);

DefineGlobalColor("On", Color.GREEN);

DefineGlobalColor("Off", Color.DARK_GRAY);

DefineGlobalColor("Off2", Color.GRAY);

DefineGlobalColor("Bullish", Color.GREEN);

DefineGlobalColor("Bearish", Color.RED);

DefineGlobalColor("Neutral", Color.BLUE);

DefineGlobalColor("Neutral1", Color.YELLOW);

DefineGlobalColor("Neutral2", Color.CYAN);

DefineGlobalColor("Neutral3", Color.WHITE);

#INPUTS CORE

input chartPlacement = { default upper, lower, lower2, debug};

input showPlots = yes; #plot main plots

input showLabels = yes; #show main labels

input showTitle = no; #show title buttons

input showStats = yes; #show stats buttons

input showTrading = yes; #show trading buttons

input showBubbles = no; #show bubbles in dashboard

input enableAlerts = no; #enable alerts

input aggregationLimit = 9;

input displace = 0;

input entryThreshold = 4;

input thresholdSmoothingFactor = 3;

input caclLongerTimeFrame = no;

def na = Double.NaN;

def SYNC = BarNumber() % 2 == 0;

#AGGREGATIONS

input aggregationEnabled = yes;

input aggregation1 = AggregationPeriod.HOUR;

def v_M1 = If(aggregationEnabled, volume(period = aggregation1), na);

def vw_M1 = If(aggregationEnabled, vwap(period = aggregation1), na);

def hl_M1 = If(aggregationEnabled, hl2(period = aggregation1), na);

def h_M1 = If(aggregationEnabled, high(period = aggregation1), na);

def l_M1 = If(aggregationEnabled, low(period = aggregation1), na);

def o_M1 = If(aggregationEnabled, open(period = aggregation1), na);

def c_M1 = If(aggregationEnabled, close(period = aggregation1), na);

#Module

def VOLR_VOLR_M1_UPX = o_M1 < c_M1;

def VOLR_VOLR_M1_DNX = o_M1 > c_M1;

def VOLR_VOLR_M1_AP = GetAggregationPeriod();

def VOLR_VOLR_M1_DAILY = CompoundValue(1, If (VOLR_VOLR_M1_AP >= AggregationPeriod.DAY, 1, 0), 0);

def VOLR_VOLR_M1_ACTIVE = If(!VOLR_VOLR_Intradayoverride , 1, If(VOLR_VOLR_M1_DAILY, 1, If(SecondsFromTime(VOLR_VOLR_ORBegin) >= 0 and SecondsTillTime(VOLR_VOLR_OREnd ) >= 0, 1, 0)));

def VOLR_VOLR_M1_V1 = v_M1 / TrueRange(h_M1, c_M1, l_M1);

def VOLR_VOLR_M1_ISOPEN = GetTime() >= RegularTradingStart(GetYYYYMMDD()) and GetTime() < RegularTradingEnd(GetYYYYMMDD());

def VOLR_VOLR_M1_BARS = if GetYYYYMMDD() != GetYYYYMMDD()[1] then 1 else if VOLR_VOLR_M1_ISOPEN then VOLR_VOLR_M1_BARS[1] + 1 else 0;

def VOLR_VOLR_M1_BN = HighestAll(VOLR_VOLR_M1_BARS);

def VOLR_VOLR_M1_U1 = c_M1 >= o_M1;

def VOLR_VOLR_M1_D1 = !VOLR_VOLR_M1_U1;

def VOLR_VOLR_M1_UP1 = VOLR_VOLR_M1_U1[VOLR_VOLR_offset];

def VOLR_VOLR_M1_DN1 = VOLR_VOLR_M1_D1[VOLR_VOLR_offset];

def VOLR_VOLR_M1_VSUM = fold VOLR_VOLR_VOLR_VOLR_M1_INDEX = 1 to VOLR_VOLR_TimeBasedNumDays + 1 with VOLR_VOLR_VOLR_VOLR_M1_A = 0 do VOLR_VOLR_VOLR_VOLR_M1_A + GetValue(VOLR_VOLR_M1_V1, VOLR_VOLR_VOLR_VOLR_M1_INDEX * VOLR_VOLR_M1_BN);

def VOLR_VOLR_M1_RELVOL1 = (VOLR_VOLR_M1_V1[VOLR_VOLR_offset] / (VOLR_VOLR_M1_VSUM[VOLR_VOLR_offset] / VOLR_VOLR_TimeBasedNumDays)) * 100;

def VOLR_VOLR_M1_CURVOL1 = if VOLR_VOLR_M1_UP1 then Min(VOLR_VOLR_threshold4, VOLR_VOLR_M1_RELVOL1) else Round(Max(-VOLR_VOLR_threshold4, -VOLR_VOLR_M1_RELVOL1));

def VOLR_VOLR_M1_HACLOSE = (o_M1 + h_M1 + l_M1 + c_M1) / 4;

def VOLR_VOLR_M1_HAOPEN = CompoundValue(1, (VOLR_VOLR_M1_HAOPEN[1] + VOLR_VOLR_M1_HACLOSE[1]) / 2, (o_M1[1] + c_M1[1]) / 2);

def VOLR_VOLR_M1_HAHIGH = Max(h_M1, Max(VOLR_VOLR_M1_HAOPEN, VOLR_VOLR_M1_HACLOSE));

def VOLR_VOLR_M1_HALOW = Min(l_M1, Min(VOLR_VOLR_M1_HAOPEN, VOLR_VOLR_M1_HACLOSE));

def VOLR_VOLR_M1_CANDLE = h_M1 - l_M1;

def VOLR_VOLR_M1_UP2 = VOLR_VOLR_M1_HACLOSE[VOLR_VOLR_offset] >= VOLR_VOLR_M1_HAOPEN[VOLR_VOLR_offset];

def VOLR_VOLR_M1_DN2 = !VOLR_VOLR_M1_UP2[VOLR_VOLR_offset];

def VOLR_VOLR_M1_VSUM2 = fold VOLR_VOLR_VOLR_VOLR_M1_INDEX2 = 1 to VOLR_VOLR_TimeBasedNumDays + 1 with VOLR_VOLR_VOLR_VOLR_M1_B = 0 do VOLR_VOLR_VOLR_VOLR_M1_B + GetValue(v_M1, VOLR_VOLR_VOLR_VOLR_M1_INDEX2 * VOLR_VOLR_M1_BN);

def VOLR_VOLR_M1_RELVOL2 = (v_M1[VOLR_VOLR_offset] / (VOLR_VOLR_M1_VSUM2[VOLR_VOLR_offset] / VOLR_VOLR_TimeBasedNumDays)) * 100;

def VOLR_VOLR_M1_CURVOL2 = if VOLR_VOLR_M1_UP2 then Min(VOLR_VOLR_threshold4, VOLR_VOLR_M1_RELVOL2) else Round(Max(-VOLR_VOLR_threshold4, -VOLR_VOLR_M1_RELVOL2));

def VOLR_VOLR_M1_VTK = v_M1 / tick_count / TrueRange(h_M1, c_M1, l_M1);

def VOLR_VOLR_M1_VSUMTK = fold VOLR_VOLR_VOLR_VOLR_M1_INDEX3 = 1 to VOLR_VOLR_TimeBasedNumDays + 1 with VOLR_VOLR_VOLR_VOLR_M1_CX = 0 do VOLR_VOLR_VOLR_VOLR_M1_CX + GetValue(VOLR_VOLR_M1_VTK, VOLR_VOLR_VOLR_VOLR_M1_INDEX3 * VOLR_VOLR_M1_BN);

def VOLR_VOLR_M1_RELVOLTK = (VOLR_VOLR_M1_V1[VOLR_VOLR_offset] / (VOLR_VOLR_M1_VSUM[VOLR_VOLR_offset] / VOLR_VOLR_TimeBasedNumDays)) * 100;

def VOLR_VOLR_M1_CURVOLTK = if VOLR_VOLR_M1_UP1 then Min(VOLR_VOLR_threshold4, VOLR_VOLR_M1_RELVOLTK) else Round(Max(-VOLR_VOLR_threshold4, -VOLR_VOLR_M1_RELVOLTK));

def VOLR_VOLR_M1_VSH = v_M1 / tick_count;

def VOLR_VOLR_M1_VSUMSH = fold VOLR_VOLR_VOLR_VOLR_M1_INDEX4 = 1 to VOLR_VOLR_TimeBasedNumDays + 1 with VOLR_VOLR_VOLR_VOLR_M1_D = 0 do VOLR_VOLR_VOLR_VOLR_M1_D + GetValue(VOLR_VOLR_M1_VSH, VOLR_VOLR_VOLR_VOLR_M1_INDEX4 * VOLR_VOLR_M1_BN);

def VOLR_VOLR_M1_RELVOLSH = (VOLR_VOLR_M1_VSH[VOLR_VOLR_offset] / (VOLR_VOLR_M1_VSUMSH[VOLR_VOLR_offset] / VOLR_VOLR_TimeBasedNumDays)) * 100;

def VOLR_VOLR_M1_CURVOLSH = if VOLR_VOLR_M1_UP1 then Min(VOLR_VOLR_threshold4, VOLR_VOLR_M1_RELVOLSH) else Round(Max(-VOLR_VOLR_threshold4, -VOLR_VOLR_M1_RELVOLSH));

def VOLR_VOLR_M1_VOLUMEOSC1 = if (Average(v_M1, 1) - Average(v_M1, 9)) / Average(v_M1, 9) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC2 = if (Average(v_M1, 1) - Average(v_M1, 11)) / Average(v_M1, 11) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC3 = if (Average(v_M1, 1) - Average(v_M1, 13)) / Average(v_M1, 13) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC4 = if (Average(v_M1, 1) - Average(v_M1, 15)) / Average(v_M1, 15) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC5 = if (Average(v_M1, 1) - Average(v_M1, 17)) / Average(v_M1, 17) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC6 = if (Average(v_M1, 1) - Average(v_M1, 20)) / Average(v_M1, 20) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC21 = if (Average(v_M1, 2) - Average(v_M1, 10)) / Average(v_M1, 10) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC22 = if (Average(v_M1, 2) - Average(v_M1, 12)) / Average(v_M1, 12) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC23 = if (Average(v_M1, 2) - Average(v_M1, 14)) / Average(v_M1, 14) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC24 = if (Average(v_M1, 2) - Average(v_M1, 16)) / Average(v_M1, 16) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC25 = if (Average(v_M1, 2) - Average(v_M1, 18)) / Average(v_M1, 18) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSC26 = if (Average(v_M1, 2) - Average(v_M1, 21)) / Average(v_M1, 21) > 1 then 100 else 0;

def VOLR_VOLR_M1_VOLUMEOSCSUM = VOLR_VOLR_M1_VOLUMEOSC1 + VOLR_VOLR_M1_VOLUMEOSC2 + VOLR_VOLR_M1_VOLUMEOSC3 + VOLR_VOLR_M1_VOLUMEOSC4 + VOLR_VOLR_M1_VOLUMEOSC5 + VOLR_VOLR_M1_VOLUMEOSC6;

def VOLR_VOLR_M1_VOLUMEOSCSUM2 = VOLR_VOLR_M1_VOLUMEOSC21 + VOLR_VOLR_M1_VOLUMEOSC22 + VOLR_VOLR_M1_VOLUMEOSC23 + VOLR_VOLR_M1_VOLUMEOSC24 + VOLR_VOLR_M1_VOLUMEOSC25 + VOLR_VOLR_M1_VOLUMEOSC26;

def VOLR_VOLR_M1_ISSPIKE = if VOLR_VOLR_M1_VOLUMEOSCSUM > 0 or VOLR_VOLR_M1_VOLUMEOSCSUM2 > 0 then 1 else 0;

def VOLR_VOLR_M1_SPIKEVALUE = VOLR_VOLR_M1_VOLUMEOSCSUM + VOLR_VOLR_M1_VOLUMEOSCSUM2;

def VOLR_VOLR_M1_START = VOLR_VOLR_M1_ACTIVE && !VOLR_VOLR_M1_ACTIVE[1];

def VOLR_VOLR_M1_CNT = if VOLR_VOLR_M1_START then 1 else VOLR_VOLR_M1_CNT[1] + 1;

def VOLR_VOLR_M1_SUMV = CompoundValue(1, if VOLR_VOLR_M1_START then v_M1 else VOLR_VOLR_M1_SUMV [1] + v_M1, 0);

def VOLR_VOLR_M1_RTHAVVOL = VOLR_VOLR_M1_SUMV / VOLR_VOLR_M1_CNT;

def VOLR_VOLR_M1_VOLUMEOSCRTH = if (Average(v_M1, 1) - VOLR_VOLR_M1_RTHAVVOL) / VOLR_VOLR_M1_RTHAVVOL > 1 then 80 else 0;

def VOLR_VOLR_M1_TRSTATE3 = if IsAscending(l_M1, 3) && IsAscending(h_M1, 3) then 100 else if IsDescending(l_M1, 3) && IsDescending(h_M1, 3) then -100 else 0;

def VOLR_VOLR_M1_TRSTATE4 = if IsAscending(l_M1, 4) && IsAscending(h_M1, 4) then 100 else if IsDescending(l_M1, 4) && IsDescending(h_M1, 4) then -100 else 0;

def VOLR_VOLR_M1_TRSTATE5 = if IsAscending(l_M1, 5) && IsAscending(h_M1, 5) then 100 else if IsDescending(l_M1, 5) && IsDescending(h_M1, 5) then -100 else 0;

def VOLR_VOLR_M1_TRSTATE6 = if IsAscending(l_M1, 6) && IsAscending(h_M1, 6) then 100 else if IsDescending(l_M1, 6) && IsDescending(h_M1, 6) then -100 else 0;

def VOLR_VOLR_M1_TRSTATE7 = if IsAscending(l_M1, 7) && IsAscending(h_M1, 7) then 100 else if IsDescending(l_M1, 7) && IsDescending(h_M1, 7) then -100 else 0;

def VOLR_VOLR_M1_TRSTATE8 = if IsAscending(l_M1, 8) && IsAscending(h_M1, 8) then 100 else if IsDescending(l_M1, 8) && IsDescending(h_M1, 8) then -100 else 0;

def VOLR_VOLR_M1_ALLSTATE = if VOLR_VOLR_M1_TRSTATE3 == 100 && VOLR_VOLR_M1_TRSTATE4 == 100 && VOLR_VOLR_M1_TRSTATE5 == 100 && VOLR_VOLR_M1_TRSTATE6 == 100 && VOLR_VOLR_M1_TRSTATE7 == 100 then 100 else if VOLR_VOLR_M1_TRSTATE3 == -100 && VOLR_VOLR_M1_TRSTATE4 == -100 && VOLR_VOLR_M1_TRSTATE5 == -100 && VOLR_VOLR_M1_TRSTATE6 == -100 && VOLR_VOLR_M1_TRSTATE7 == -100 then -100 else 0;

def VOLR_VOLR_M1_RVOLSTATE1 = if VOLR_VOLR_M1_CURVOL1 >= 200 then 200

else if VOLR_VOLR_M1_CURVOL1 <= -200 then -200

else 0;

def VOLR_VOLR_M1_RVOLSTATE2 = if VOLR_VOLR_M1_CURVOL2 >= 200 then 200

else if VOLR_VOLR_M1_CURVOL2 <= -200 then -200

else 0;

def VOLR_VOLR_M1_RVOLSTATETK = if VOLR_VOLR_M1_CURVOLTK >= 200 then 200

else if VOLR_VOLR_M1_CURVOLTK <= -200 then -200

else 0;

def VOLR_VOLR_M1_RVOLSTATESH = if VOLR_VOLR_M1_CURVOLSH >= 200 then 200

else if VOLR_VOLR_M1_CURVOLSH <= -200 then -200

else 0;

def VOLR_VOLR_M1_SPIKESTATE =

if VOLR_VOLR_M1_SPIKEVALUE < 200 && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == 100 then 100

else if VOLR_VOLR_M1_SPIKEVALUE < 200 && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == -100 then -100

else if VOLR_VOLR_M1_SPIKEVALUE < 200 && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == 0 && VOLR_VOLR_M1_UPX then 50

else if VOLR_VOLR_M1_SPIKEVALUE < 200 && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == 0 && VOLR_VOLR_M1_DNX then -50

else if Between(VOLR_VOLR_M1_SPIKEVALUE, 199, 599) && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == 100 then 200

else if Between(VOLR_VOLR_M1_SPIKEVALUE, 199, 599) && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == -100 then -200

else if Between(VOLR_VOLR_M1_SPIKEVALUE, 199, 599) && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == 0 && VOLR_VOLR_M1_UPX then 150

else if Between(VOLR_VOLR_M1_SPIKEVALUE, 199, 599) && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == 0 && VOLR_VOLR_M1_DNX then -150

else if VOLR_VOLR_M1_SPIKEVALUE >= 600 && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == 100 then 300

else if VOLR_VOLR_M1_SPIKEVALUE >= 600 && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == -100 then -300

else if VOLR_VOLR_M1_SPIKEVALUE >= 600 && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == 0 && VOLR_VOLR_M1_UPX then 250

else if VOLR_VOLR_M1_SPIKEVALUE >= 600 && VOLR_VOLR_M1_ISSPIKE && VOLR_VOLR_M1_ALLSTATE == 0 && VOLR_VOLR_M1_DNX then -250

else 0;

def VOLR_VOLR_M1_SPIKESTATERTH =

if VOLR_VOLR_M1_VOLUMEOSCRTH != 0 && VOLR_VOLR_M1_ALLSTATE == 100 then 100

else if VOLR_VOLR_M1_VOLUMEOSCRTH != 0 && VOLR_VOLR_M1_ALLSTATE == -100 then -100

else 0;

def VOLR_VOLR_M1_ALLSTATESUM = VOLR_VOLR_M1_RVOLSTATE1 + VOLR_VOLR_M1_RVOLSTATE2 + VOLR_VOLR_M1_RVOLSTATETK + VOLR_VOLR_M1_RVOLSTATESH + VOLR_VOLR_M1_SPIKESTATE + VOLR_VOLR_M1_SPIKESTATERTH ;

def VOLR_VOLR_M1_ALLRELVOLSTATE = if VOLR_VOLR_M1_ALLSTATESUM > 0 then 100 else if VOLR_VOLR_M1_ALLSTATESUM < 0 then -100 else 0;

def VOLR_VOLR_M1_SSTATE = VOLR_VOLR_M1_ALLRELVOLSTATE;

#STATS

def M1_BULLISH = VOLR_VOLR_M1_sState == 100;

def M1_BEARISH = VOLR_VOLR_M1_sState == -100;

input Threshold = 1;

def TOTAL_COUNT = 1;

def BULLISH_COUNT = M1_BULLISH;

def BEARISH_COUNT = M1_BEARISH;

def ALL_STATE = if BULLISH_COUNT == TOTAL_COUNT then 100 else if BEARISH_COUNT == TOTAL_COUNT then -100 else 0;

def MAJ_STATE = if BULLISH_COUNT == BEARISH_COUNT then 0 else if BULLISH_COUNT > BEARISH_COUNT then 100 else -100;

def THE_STATE = if BULLISH_COUNT >= Threshold then 100 else if BEARISH_COUNT >= Threshold then -100 else 0;

input MOMO = { default MAJ, THE };

def SIGNAL;

switch (MOMO)

{

case MAJ:

SIGNAL = MAJ_STATE;

case THE:

SIGNAL = THE_STATE;

}

def MOMO_BULL = BULLISH_COUNT < BULLISH_COUNT[1];

def MOMO_BEAR = BEARISH_COUNT < BEARISH_COUNT[1];

def MOMO_EXIT = if SIGNAL != SIGNAL[1] then SIGNAL else if SIGNAL == 100 and MOMO_BULL then 0 else if SIGNAL == -100 and MOMO_BEAR then 0 else MOMO_EXIT[1];

#AddLabel (showLabels, "HULL", Color.ORANGE);

#AddLabel (showLabels, "S ", if SYNC then GlobalColor("Sync1") else GlobalColor("Sync2"));

AddLabel(showLabels, "VOL", if IsNaN(VOLR_VOLR_M1_SSTATE[displace]) then GlobalColor("Off") else

if VOLR_VOLR_M1_SSTATE[displace] == 100 then GlobalColor("Up") else

if VOLR_VOLR_M1_SSTATE[displace] == -100 then GlobalColor("Down") else

if VOLR_VOLR_M1_SSTATE[displace] == 10 then GlobalColor("NUp") else

if VOLR_VOLR_M1_SSTATE[displace] == -10 then GlobalColor("NDown") else

if VOLR_VOLR_M1_SSTATE[displace] == -1 then GlobalColor("Neutral") else

if VOLR_VOLR_M1_SSTATE[displace] == 1 then GlobalColor("Neutral") else

GlobalColor("Off2")); #M1

#AddLabel (showLabels, "S ", if SYNC then GlobalColor("Sync1") else GlobalColor("Sync2"));

#PLOTS

plot pVOLR_VOLR_M1_1 = If(!isNaN(close), 1, na);

pVOLR_VOLR_M1_1.SetDefaultColor(COLOR.GRAY);

pVOLR_VOLR_M1_1.AssignValueColor(

if VOLR_VOLR_M1_sState == 100 then GlobalColor("Up") else

if VOLR_VOLR_M1_sState == -100 then GlobalColor("Down") else

if VOLR_VOLR_M1_sState == 10 then GlobalColor("NUp") else

if VOLR_VOLR_M1_sState == -10 then GlobalColor("NDown") else

if VOLR_VOLR_M1_sState == -1 then GlobalColor("Neutral") else

if VOLR_VOLR_M1_sState == 1 then GlobalColor("Neutral") else

GlobalColor("Off"));

pVOLR_VOLR_M1_1.SetPaintingStrategy (PaintingStrategy.HORIZONTAL);

pVOLR_VOLR_M1_1.SetLineWeight(4);

pVOLR_VOLR_M1_1.HideTitle();

pVOLR_VOLR_M1_1.HideBubble();

#pVOLR_VOLR_M1_1.SetHiding(chartPlacement != chartPlacement.lower);

#COLORMAPS

input showColorBars = { default none, M1};

def CC;

switch (showColorBars) {

case none:

CC = na;

case M1:

CC = VOLR_VOLR_M1_sState;

}

AssignPriceColor(

if !IsNaN(showColorBars) then

if CC == 100 then Color.GREEN else

if CC == 10 then Color.LIME else

if CC == -100 then Color.RED else

if CC == -10 then Color.ORANGE else

if CC == 1 then Color.YELLOW else

if CC == -1 then Color.CYAN else

Color.DARK_GRAY

else

Color.CURRENT);

#plot pSpace = If(!IsNaN(close), 1.7, na);

#pSpace.SetDefaultColor(Color.DARK_GRAY);

#pSpace.HideTitle();

#pSpace.HideBubble();