// Shows the price renko bars (or range bars) instead of the PERIOD renko
// bars that are integrated into Trading View. The normal renko bars that
// Trading View offers only consider the drawing of a new brick when the 
// price closes above or below the required brick size. This can produce
// misleading charts since depending on the time interval of a chart, new
// bricks may or may not be drawn. True price renko bars will draw a new 
// brick immediately upon the price exceeding the next target brick size.
// An option exists to enable PERIOD based renko bars, but that is not
// the default. 

// It may be desired to require a PERIOD based close to ensure an update.

// NEW BRICKS: PRICE VS PERIOD 

// The option exists to use the PERIOD based renko bars by checking the
// FORCE CLOSE box. This will force a band update when the target brick 
// threshold is exceeded only by the close price instead of the high or low.
//
// By unchecking the box labeled USE CHART INTERVAL, one can specify 
// a separate interval to enforce the close criteria. For example, you
// can use a 5 pip brick size on EURUSD in Traditional Mode, and 
// instruct that the close interval is 1HR. Your chart interval could
// be 5 minutes, but the hour closes above or below the brick threshold
// are required to update the band. 5 minute closes above or below the
// new brick threshold will only draw a PROJECTION band while the hour
// interval has not yet expired.

// Play around with the settings for this if you would like the close
// criteria to be in force (which is the PERIOD based renkos that Trading
// view uses by default). An example would be a 5 pip brick size, and close
// interval set to H1 (1 hour). The chart should be viewed on an interval 
// LESS THAN OR EQUAL TO 1 hour, to ensure that the close is accurate, such 
// as 5 minute, 15 minute, or 60 minute.

// TRADITIONAL MODE

// This mode uses exact brick sizes, in ticks. The brick starting anchor 
// point will attempt to be a "nice number" at a round interval for the 
// chart ticker. For example, if viewing EURUSD with the box size equal 
// to 50 ticks/pips, the open and close prices will take the form of 
// 1.2100, 1.2150, 1.2200, 1.2250, and so on. This is the same behavior 
// as the normal traditional Renko bars in Trading View and other major
// trading platforms such as Meta Trader.

// Use the tick size in traditional mode to specify the block size, in 
// ticks (or pips).

// ATR MODE

// The ATR mode functions differently than the Trading View built in 
// version. The block size is updated each time the range is exceeded.
// In Trading View, when using the ATR mode, the ATR is the last ATR 
// value calculated on the ENTIRE data interval, and is applied to all 
// past data. You can see this when you press the '+' sign of the ticker 
// in the top left of the chart window and you will see the brick size 
// as a constant, the brick size is not a function of the ever changing 
// ATR value of the price action. 

// The block size of this script is not updated for each price candle 
// (i.e. each 1HR on a 1HR chart), instead it is updated only when the 
// price thresholds are exceeded requiring a the band to be updated. At 
// that point the current ATR is sampled and the brick size is updated.
// This continues each time the band thresholds are exceeded, therefore 
// the band width is always changing depending on the current volatility.

// ATR mode will also consider the FORCE CLOSE type when selected. If a
// different chart interval is required for the ATR calcualtion, that is
// considered also. For example, say you want to view a 5 minute chart, but
// use the ATR calcuation for the Day interval. Select "Day" from the drop
// down menu to do this, and then set the ATR settings you desire. The
// chart will be a 5 minute chart, but ATR information will be sampled as
// if it were a 1 hour chart. Be aware that if indeed the Day interval is
// selected, the band will ONLY UPDATE when the day closes. While the day
// has not closed a projection bar will be draw to show the current status.

// If the USE CHART INTERVAL box is left selected, the ATR interval is 
// the chart interval.

// PROJECTION

// When the barstate is live, a single projection band will be plotted under
// the following conditions:

// 1. Whenever FORCE CLOSE is enabled. This happens regardless if the chart
//    interval is the same as the desired interval selected from the drop
//    down menu, or if the USE CHART INTERVAL box is selected. The reason for
//    this is that the close of the interval is not truly valid until the
//    interval expires.

// 2. Whenever the desired interval is greater than the chart interval. If 
//    the interval chosen from the drop down is greater than the chart 
//    interval the band cannot update until the desired interval expires.

// OPTIONS

// Brick size rounding is available for ATR Mode. This will enforce that
// the bricks are multiples of the input value (in ticks). The default is
// 1 tick so that no rounding occurs. This is useful when it is desired
// that the bricks "snap" to round number intervals, such as 5 or 25 ticks. 
// The minimum block size will always be at least 1 tick in ATR mode. 
// Rounding the block size is essentially the best of both both worlds,
// Traditional and ATR, since the bricks will adjust to the ATR of the 
// desired time interval but at the same time only be multiples of the 
// rounding tick size specified.

// An option exists to show the required levels that the price must exceed 
// to draw a new brick and update the band. This is useful for setting 
// limit and stop prices.

// @version=3
study(title = "Renko Price Bars Overlay", shorttitle = "Renko Overlay", overlay = true)

type = input(title = "Type", defval = "Traditional", options=["Traditional", "ATR"])
theme = input(title = "Theme", defval = "Green/Red", options=["Green/Red", "Blue/White", "Blue/Red", "Green/White"])

forceClose = input(false, title = "Force Interval Close to Update (PEROD based bricks)")
intval = input("H1", "Interval Close Length", options=["M1", "M3", "M5", "M15", "M30", "M45", "H1", "H2", "H3", "H4", "H8", "H12", "Day", "Week", "Month", "Year"])
useChartIntval = input(true, "Use Chart Interval")

size = input(1, title = "Box Tick Size (Traditional Mode)", type = integer, minval = 1) 
atrLen = input(14, title = "ATR Length (ATR Mode)", minval = 1)
atrMult = input(1, title = "ATR Multiplier (ATR Mode)", type = float, minval = 1, step = 0.1)

round = input(1, title = "Box Tick Size Rounding (ATR Mode)", minval = 1)

showBand = input(true, title = "Show Renko Band?")
colorBars = input(false, "Color Price Bars?")
showBreak = input(true, title = "Show New Brick Price Level Thresholds?")

int = iff(intval == "M1", "1", iff(intval == "M3", "3", iff(intval == "M5", "5", iff(intval == "M15", "15", iff(intval == "M30", "30", iff(intval == "M45", "45", iff(intval == "H1", "60", iff(intval == "H2", "120", iff(intval == "H3", "180", iff(intval == "H4", "240", iff(intval == "H8", "480", iff(intval == "H12", "720", iff(intval == "Day", "D", iff(intval == "Week", "W", iff(intval == "Month", "M", iff(intval == "Year", "12M", "60"))))))))))))))))

// We must discover how many bars back the desired interval
// opened as a new bar. The previous bar on the chart interval
// is the closing value of that bar. For instance, if viewing
// a 5 min chart, and the desired interval is 15 min, only
// once every 3 bars does the chart interval close at the same
// location as the desired interval.

start = security(tickerid, int, time, lookahead = true)
newSession = iff(change(start), 1, 0)

barsInInterval() =>
    sinceNewSession = 0
    offset = useChartIntval ? 0 : barssince(newSession)
    sinceNewSession := na(sinceNewSession[1]) or offset > nz(sinceNewSession[1]) ? offset : nz(sinceNewSession[1])
    
barsInInt = barsInInterval()

tk = syminfo.mintick
blockMult = tk < 0.1 and (tk != 0.01 or close > 100) and (tk != 0.001 or close > 50) and tk != 0.0001 and tk != 0.0005 and tk != 0.03125 ? tk == 0.00005 or tk * 100 == 0.00005 ? 2 : 10 : 1

// Get the variables. These may be different depending on:
// 
// 1. The time interval desired is the chart interval, or PERIOD close is not enforced
// 2. The time interval desired is greater than the chart interval, and PERIOD close is enforced
// 3. The calculation is for projection purposes only, and PERIOD close is enforced. Projection
//    is only used when PERIOD close is enforced regardless of the desired interval.

getVars() =>
    block1 = tk * blockMult * size
    block2 = max(round(atrMult * atr(atrLen) / (round * blockMult * tk)), 1) * round * blockMult * tk
    block = type == "Traditional" ? block1 : block2
    
    h = not forceClose ? high : close
    l = not forceClose ? low : close
    
    targetO = (floor(open / block) - 1) * block
    targetC = floor(open / block) * block
    targetUp = targetC + block
    targetDn = targetO - block
    
    pClose = nz(targetC[1])
    pOpen = nz(targetO[1])
    pTargetUp = nz(targetUp[1])
    pTargetDn = nz(targetDn[1])
    
    trend = 1
    trend := h > pTargetUp ? 1 : l < pTargetDn ? -1 : nz(trend[1], 1)
    
    // Sometimes multiple blocks are exceeded all in the
    // same candle we must account for this. In normal
    // renko charting this would be observed as multiple
    // projection candles
    
    newHighBlock = ceil(abs(pTargetUp - h) / block) * block
    newLowBlock = ceil(abs(pTargetDn - l) / block) * block
    
    newHighBlock2 = floor(abs(pTargetUp - h) / block) * block
    newLowBlock2 = floor(abs(pTargetDn - l) / block) * block
    
    crossUp = h > pTargetUp
    crossDn = l < pTargetDn
    
    targetUp := crossUp ? pTargetUp + newHighBlock : crossDn ? trend[1] < 0 ? pClose + block - newLowBlock2 : pOpen + block - newLowBlock2 : pTargetUp
    targetDn := crossDn ? pTargetDn - newLowBlock : crossUp ? trend[1] > 0 ? pClose - block + newHighBlock2 : pOpen - block + newHighBlock2 : pTargetDn
    
    targetC := crossUp ? pTargetUp + newHighBlock2 : crossDn ? pTargetDn - newLowBlock2 : pClose
    targetO := crossUp ? max(targetC - block, pClose) : crossDn ? min(targetC + block, pClose) : pOpen
    
    targetL = low
    targetL := crossUp or crossDn ? low : min(nz(targetL[1]), low)
    
    targetH = high
    targetH := crossUp or crossDn ? high : max(nz(targetH[1]), high) 
    
    [targetUp, targetDn, pTargetUp, pTargetDn, targetC, targetO, targetH, targetL, newHighBlock2, newLowBlock2, block, pClose, trend]
    
[_targetUp, _targetDn, _pTargetUp, _pTargetDn, _targetC, _targetO, _targetH, _targetL, _newHighBlock2, _newLowBlock2, _block, _pClose, _trend] = getVars()

transform(var, hist) =>
    t = useChartIntval or barsInInt == 0 ? var : security(tickerid, int, var[hist], lookahead = true)
    
targetUp = transform(_targetUp, 1)
targetDn = transform(_targetDn, 1)
targetUp0 = transform(_targetUp, 0)
targetDn0 = transform(_targetDn, 0)
pTargetUp = transform(_pTargetUp, 1)
pTargetDn = transform(_pTargetDn, 1)
targetC = transform(_targetC, 1)
targetO = transform(_targetO, 1)
targetH = transform(_targetH, 1)
targetL = transform(_targetL, 1)
newHighBlock2 = transform(_newHighBlock2, 0)
newLowBlock2 = transform(_newLowBlock2, 0)
block = transform(_block, 1)
block0 = transform(_block, 0)
pClose = transform(_pClose, 1)
trend = transform(_trend, 1)

// Projection

// Solve the same target close and open forumla but with the current values

// Find the highest high and lowest low between now and when the desired
// interval started with a new bar. Use the current close if force close
// mode is enabled

hh = high
hh := useChartIntval or barsInInt == 0 ? high : newSession ? high : max(nz(hh[1]), high)

ll = low
ll := useChartIntval or barsInInt == 0 ? low : newSession ? low : min(nz(ll[1]), low)

hP = forceClose ? close : hh
lP = forceClose ? close : ll

// Find the offset that we must look back. If FORCE CLOSE is enabled but
// the desired interval is less than or equal to the chart interval, just
// look at the previous bar. If the bars in the chart interval are greater
// than zero (desired interval > chart interval) then the data is already
// pointing to the previous value on the desired interval (it's already
// locked in and complete)

x = barsInInt == 0 ? forceClose ? 1 : 0 : 0

// We must offset the band by the number of bars that chart interval has
// inside one bar of the desired interval, i.e. there are 12 5 minute 
// candles for each 1 hour candle

x2 = barsInInt > 0 or forceClose ? barsInInt + 1 : 0

// Solve the same formula for the new projected close and open based on
// the current price. The price may be the current high of the desired
// interval or current low, or may simply be the close price of this candle
// of the FORCE CLOSE parameter is true

targetCP = hP > targetUp[x] ? targetUp[x] + newHighBlock2 : lP < targetDn[x] ? targetDn[x] - newLowBlock2 : targetC
targetOP = hP > targetUp[x] ? max(targetCP - block, targetC[x]) : lP < targetDn[x] ? min(targetCP + block, targetC[x]) : targetO 
trendP = hP > targetUp[x] ? 1 : lP < targetDn[x] ? -1 : trend[1]

// Colors

trendS = ((barsInInt > 0 or forceClose) and trend[x] > 0) or ((barsInInt == 0 and not forceClose) and trend > 0) ? 1 : -1

posCol1 = iff(theme == "Green/Red" or theme == "Green/White", #32CD32FF, #3C78D8FF)
posCol2 = iff(theme == "Green/Red" or theme == "Green/White", #32CD3255, #3C78D855)
posCol3 = iff(theme == "Green/Red" or theme == "Green/White", #00FF001A, #006AFF38)

negCol1 = iff(theme == "Green/Red" or theme == "Blue/Red", #FF00FFFF, #CBCBCBFF)
negCol2 = iff(theme == "Green/Red" or theme == "Blue/Red", #FF00FF55, #CBCBCB55)
negCol3 = iff(theme == "Green/Red" or theme == "Blue/Red", #FF00001A, #FFFFFF20)

posCol4 = iff(theme == "Green/Red" or theme == "Green/White", #00FFFFFF, #00FFFFFF)
posCol5 = iff(theme == "Green/Red" or theme == "Green/White", #00FFFF55, #00FFFF55)
posCol6 = iff(theme == "Green/Red" or theme == "Green/White", #00FFFF3A, #00FFFF3A)

negCol4 = iff(theme == "Green/Red" or theme == "Blue/Red", #FF0000FF, #FFFFFFFF)
negCol5 = iff(theme == "Green/Red" or theme == "Blue/Red", #FF000055, #FFFFFF55)
negCol6 = iff(theme == "Green/Red" or theme == "Blue/Red", #FF00807A, #FFFFFF7A)

tradeColPos = iff(theme == "Green/Red" or theme == "Green/White", #00FF00FF, #00FFFFFF)
tradeColNeg = iff(theme == "Green/Red" or theme == "Blue/Red", #FF0000FF, #FFFFFFFF)

barColPos = iff(theme == "Green/Red" or theme == "Green/White", #11DD11FF, #0268FFFF)
barColNeg = iff(theme == "Green/Red" or theme == "Blue/Red", #DD1111FF, #FFFFFFFF)

labelColPos = iff(theme == "Green/Red" or theme == "Green/White", #11CA11FF, #0268FFFF)
labelColNeg = iff(theme == "Green/Red" or theme == "Blue/Red", #CA1111FF, #AAAAAAFF)

colC = trendS > 0 ? posCol1 : negCol1
colO = trendS > 0 ? posCol2 : negCol2
fill = trendS > 0 ? posCol3 : negCol3

colCP = targetCP >= targetC[x] ? posCol4 : negCol4
colOP = targetCP >= targetC[x] ? posCol5 : negCol5
fillP = targetCP >= targetC[x] ? posCol6 : negCol6

// Target high and low for new brick

plotshape(showBreak ? targetCP != targetC[x] ? targetUp0[x] : targetUp[x] : na, title = "Target High Break Label", style = shape.labeldown, location = location.absolute, offset = 3, size = size.small, text = "H", color = labelColPos, textcolor = #FFFFFFEE, show_last = 1, editable = false)
plotshape(showBreak ? targetCP != targetC[x] ? targetDn0[x] : targetDn[x] : na, title = "Target Low Break Label", style = shape.labelup, location = location.absolute, offset = 3, size = size.small, text = "L", color = labelColNeg, textcolor = #FFFFFFEE, show_last = 1, editable = false)

// Plots
 
c = plot(showBand ? targetC[x] : na, title = "Close (Anchored to Interval Open)", offset = -x2, color = colC, editable = false)
o = plot(showBand ? targetO[x] : na, title = "Open (Anchored to Interval Open)", offset = -x2, color = colO, editable = false)

// The projections show how the current data is behaving and potentially how the
// actually band can change in real time

cPx = forceClose or barsInInt > 0 ? targetCP != targetC[x] ? targetCP : targetC[x] : na
cOx = forceClose or barsInInt > 0 ? targetCP != targetC[x] ? targetOP : targetO[x] : na

colorCP = targetCP != targetC[x] ? colCP : colC
colorOP = targetCP != targetC[x] ? colOP : colO
colorFillP = targetCP != targetC[x] ? fillP : fill

cP = plot(showBand ? cPx : na, title = "Projected Close (Offset = 0)", color = colorCP, show_last = 2, editable = false)
oP = plot(showBand ? cOx : na, title = "Projected Open (Offset = 0)", color = colorOP, show_last = 2, editable = false)

// Because pine script does not offer 'ID objects' like lines or colums... we are forced
// to do this hack solution in order to plot a box like figure. We do this because the
// chart interval may be less than the desired interval, so there are many bars to fill
// for the complete projected brick. Imagine a 5 minute chart but using the 1 HR interval
// as the desired interval for closes or for ATR setting. While the current price may
// exceed the next brick threshold, there are a total of 12 candles for each 1 HR interval.
// Up to 12 bars are plotted and no more, since we could do this forever... i.e. imagine
// the desired interval is 1 Year, and the chart interval is 1 minute. 

// This problem is the result of the 'show_last' parameter not able to process dynamic
// variables. Even wrapped in a function the show_last parameter gives up and plots all
// data history for the plot() instance. The only way to combat this is to have many 
// width = 1 plots (show_last = 2) and offset them to stack them horizontally. This gives
// the appearance of a rectangle test candle that occupies the entire space of the current
// desired interval candle. HOWEVER, we are limited by 64 plots for a script, so we can 
// only plot so many. There will be a gap between the current data mark and the projected
// box if the total number of chart interval contained in one desired interval exceeds this
// value.

cP1 = plot(barsInInt > 0 and showBand ? cPx : na, title = "Projected Close (Offset = 1)", color = colorCP, offset = -1, show_last = 2, editable = false)
oP1 = plot(barsInInt > 0 and showBand ? cOx : na, title = "Projected Open (Offset = 1)", color = colorOP, offset = -1, show_last = 2, editable = false)

cP2 = plot(barsInInt > 1 and showBand ? cPx : na, title = "Projected Close (Offset = 2)", color = colorCP, offset = -2, show_last = 2, editable = false)
oP2 = plot(barsInInt > 1 and showBand ? cOx : na, title = "Projected Open (Offset = 2)", color = colorOP, offset = -2, show_last = 2, editable = false)

cP3 = plot(barsInInt > 2 and showBand ? cPx : na, title = "Projected Close (Offset = 3)", color = colorCP, offset = -3, show_last = 2, editable = false)
oP3 = plot(barsInInt > 2 and showBand ? cOx : na, title = "Projected Open (Offset = 3)", color = colorOP, offset = -3, show_last = 2, editable = false)

cP4 = plot(barsInInt > 3 and showBand ? cPx : na, title = "Projected Close (Offset = 4)", color = colorCP, offset = -4, show_last = 2, editable = false)
oP4 = plot(barsInInt > 3 and showBand ? cOx : na, title = "Projected Open (Offset = 4)", color = colorOP, offset = -4, show_last = 2, editable = false)

cP5 = plot(barsInInt > 4 and showBand ? cPx : na, title = "Projected Close (Offset = 5)", color = colorCP, offset = -5, show_last = 2, editable = false)
oP5 = plot(barsInInt > 4 and showBand ? cOx : na, title = "Projected Open (Offset = 5)", color = colorOP, offset = -5, show_last = 2, editable = false)

cP6 = plot(barsInInt > 5 and showBand ? cPx : na, title = "Projected Close (Offset = 6)", color = colorCP, offset = -6, show_last = 2, editable = false)
oP6 = plot(barsInInt > 5 and showBand ? cOx : na, title = "Projected Open (Offset = 6)", color = colorOP, offset = -6, show_last = 2, editable = false)

cP7 = plot(barsInInt > 6 and showBand ? cPx : na, title = "Projected Close (Offset = 7)", color = colorCP, offset = -7, show_last = 2, editable = false)
oP7 = plot(barsInInt > 6 and showBand ? cOx : na, title = "Projected Open (Offset = 7)", color = colorOP, offset = -7, show_last = 2, editable = false)

cP8 = plot(barsInInt > 7 and showBand ? cPx : na, title = "Projected Close (Offset = 8)", color = colorCP, offset = -8, show_last = 2, editable = false)
oP8 = plot(barsInInt > 7 and showBand ? cOx : na, title = "Projected Open (Offset = 8)", color = colorOP, offset = -8, show_last = 2, editable = false)

cP9 = plot(barsInInt > 8 and showBand ? cPx : na, title = "Projected Close (Offset = 9)", color = colorCP, offset = -9, show_last = 2, editable = false)
oP9 = plot(barsInInt > 8 and showBand ? cOx : na, title = "Projected Open (Offset = 9)", color = colorOP, offset = -9, show_last = 2, editable = false)

// Fills

fill(c, o, title = "Fill", color = fill, editable = false)

fill(cP, oP, title = "Projection Fill (Offset = 0)", color = colorFillP, show_last = 2, editable = false)
fill(cP1, oP1, title = "Projection Fill (Offset = 1)", color = colorFillP, show_last = 3, editable = false)
fill(cP2, oP2, title = "Projection Fill (Offset = 2)", color = colorFillP, show_last = 4, editable = false)
fill(cP3, oP3, title = "Projection Fill (Offset = 3)", color = colorFillP, show_last = 5, editable = false)
fill(cP4, oP4, title = "Projection Fill (Offset = 4)", color = colorFillP, show_last = 6, editable = false)
fill(cP5, oP5, title = "Projection Fill (Offset = 5)", color = colorFillP, show_last = 7, editable = false)
fill(cP6, oP6, title = "Projection Fill (Offset = 6)", color = colorFillP, show_last = 8, editable = false)
fill(cP7, oP7, title = "Projection Fill (Offset = 7)", color = colorFillP, show_last = 9, editable = false)
fill(cP8, oP8, title = "Projection Fill (Offset = 8)", color = colorFillP, show_last = 10, editable = false)
fill(cP9, oP9, title = "Projection Fill (Offset = 9)", color = colorFillP, show_last = 11, editable = false)

// Bar Color

test = targetCP != targetC[x] and (barssince(newSession) == barsInInt or not forceClose)
barColor = trendS > 0 ? barColPos : barColNeg

barcolor(title = "Bar Color", color = colorBars ? test ? targetCP > targetC[x] ? barColPos : targetCP < targetC[x] ? barColNeg : barColor : barColor : na, editable = false)