diff --git "a/Pinescript Folder/0SCT2025/SCT Sunstoic's Charting Tool.ipynb" "b/Pinescript Folder/0SCT2025/SCT Sunstoic's Charting Tool.ipynb" new file mode 100644--- /dev/null +++ "b/Pinescript Folder/0SCT2025/SCT Sunstoic's Charting Tool.ipynb" @@ -0,0 +1,2263 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e36b3f34", + "metadata": {}, + "source": [ + "This is my first ever completed Charting Tool project. I started learning using LLMs to program from early Febuary 2025 and finished it at late April." + ] + }, + { + "cell_type": "markdown", + "id": "a70dd8cf", + "metadata": {}, + "source": [ + "## This is what normal chart looks like" + ] + }, + { + "cell_type": "markdown", + "id": "cd7d6b29", + "metadata": {}, + "source": [ + "![img](https://github.com/algorembrant/Pinescript.TradingView-Indicators.and.Strategies/blob/main/Images/Screenshot%202025-11-15%20182205.png?raw=true)" + ] + }, + { + "cell_type": "markdown", + "id": "25398540", + "metadata": {}, + "source": [ + "## Modifyig it using piescript code, Indicator (1/2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d20e1d89", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "//@version=6\n", + "//indicator(\"v5\", overlay = true, max_labels_count = 300, max_lines_count = 300, max_boxes_count = 300, max_bars_back = 300)\n", + "indicator(\"Sunstoic\", \"v6 Sunstoic\", true, max_bars_back = 5000, max_boxes_count = 500, max_lines_count = 500, max_labels_count = 500)\n", + "\n", + "\n", + "//candle logic\n", + "// === Inputs ===\n", + "bCol = input.color(#008080, title=\"Bull Border\")\n", + "rCol = input.color(#e20000, title=\"Bear Border\")\n", + "bgB = input.color(color.new(#008080, 20), title=\"Bull Body\")\n", + "bgR = input.color(color.new(#FF0000, 20), title=\"Bear Body\")\n", + "\n", + "\n", + " // === Input your time zone (Manila = GMT+8) \n", + "timeSessionStart = timestamp(\"GMT+8\", year, month, dayofmonth, 6, 0) // Start of day\n", + "isNewDay = ta.change(time(\"D\")) // Detect new day\n", + "\n", + "// Track the current day's developing close on each bar\n", + "var float devClose = na\n", + "if bool(isNewDay)\n", + " devClose := close // reset on new day\n", + "else\n", + " devClose := close // update each bar\n", + "\n", + "\n", + "// === Default Daily Candle (6:00 AM) ===\n", + "dO = request.security(syminfo.tickerid, \"D\", open)\n", + "dH = request.security(syminfo.tickerid, \"D\", high)\n", + "dL = request.security(syminfo.tickerid, \"D\", low)\n", + "dC = request.security(syminfo.tickerid, \"D\", close)\n", + "\n", + "\n", + "// Calculate daily high and low using 'day' timeframe\n", + "var float dailyHigh = na\n", + "var float dailyLow = na\n", + "newDay = ta.change(time(\"D\"))\n", + "\n", + "\n", + "// On new day, reset high/low\n", + "if bool(newDay)\n", + " dailyHigh := close\n", + " dailyLow := open\n", + "else\n", + " dailyHigh := math.max(dailyHigh, close)\n", + " dailyLow := math.min(dailyLow, open)\n", + "\n", + "\n", + "// Midpoint of the daily candle \n", + "midPrice = (dailyHigh + dailyLow) / 2\n", + "\n", + "\n", + "dBull = dC >= dO\n", + "dCol = dBull ? bCol : rCol\n", + "dBg = dBull ? bgB : bgR\n", + "\n", + "\n", + "// Offset for visuals\n", + "ofs = 10\n", + "bw = 2\n", + "rIdx = bar_index + ofs + bw / 2\n", + "lIdx = bar_index + ofs - bw / 2\n", + "xMid = int(bar_index + ofs)\n", + "\n", + "\n", + "// Body of daily candle box\n", + "var box dBx = na\n", + "box.delete(dBx)\n", + "tB = math.max(dO, devClose) //y=dC\n", + "bB = math.min(dO, devClose)\n", + "dBx := box.new(left=int(lIdx), right=int(rIdx), top=tB, bottom=bB, border_color=dCol, bgcolor=dBg)\n", + "\n", + "\n", + "// Wicks for daily candle\n", + "var line dW1 = na\n", + "var line dW2 = na\n", + "line.delete(dW1)\n", + "line.delete(dW2)\n", + "dW1 := line.new(x1=xMid, y1=dH, x2=xMid, y2=tB, color=dCol)\n", + "dW2 := line.new(x1=xMid, y1=bB, x2=xMid, y2=dL, color=dCol)\n", + "\n", + "\n", + "\n", + "// Labels for daily candle\n", + "var label lblO = na\n", + "var label lblH = na\n", + "var label lblL = na\n", + "var label lblC = na\n", + "label.delete(lblO)\n", + "label.delete(lblH)\n", + "label.delete(lblL)\n", + "label.delete(lblC)\n", + "\n", + "\n", + "lblStyle = label.style_label_right\n", + "lblSize = size.tiny\n", + "lblOfs = -2\n", + "\n", + "lblO := label.new(x=xMid + lblOfs, y=dO, text=\"6O \" + str.tostring(dO, \"#\"), style=lblStyle, color=color.new(#2195f3, 100), textcolor=color.black, size=lblSize)\n", + "lblH := label.new(x=xMid + lblOfs, y=dH, text=\"6H \" + str.tostring(dH, \"#\"), style=lblStyle, color=color.new(#2195f3, 100), textcolor=color.black, size=lblSize)\n", + "lblL := label.new(x=xMid + lblOfs, y=dL, text=\"6L \" + str.tostring(dL, \"#\"), style=lblStyle, color=color.new(#2195f3, 100), textcolor=color.black, size=lblSize)\n", + "lblC := label.new(x=xMid + lblOfs, y=devClose, text=\"6C \" + str.tostring(dC, \"#\"), style=lblStyle, color=color.new(#2195f3, 100), textcolor=color.black, size=lblSize)\n", + "\n", + "// === Custom Daily Candle (8:00 AM Manila) ===\n", + "sh = 24\n", + "sm = 0\n", + "stt = timestamp(\"UTC\", year, month, dayofmonth, sh, sm)\n", + "\n", + "\n", + "var float cO = na\n", + "var float cH = na\n", + "var float cL = na\n", + "var float cC = na\n", + "\n", + "\n", + "if (time == stt)\n", + " cO := open\n", + " cH := high\n", + " cL := low\n", + " cC := close\n", + "\n", + "\n", + "if (not na(cO))\n", + " cH := math.max(cH, high)\n", + " cL := math.min(cL, low)\n", + " cC := close\n", + "\n", + "\n", + "cBull = cC >= cO\n", + "cCol = cBull ? bCol : rCol\n", + "cBg = cBull ? bgB : bgR\n", + "\n", + "\n", + "cOfs = 12\n", + "cbw = 2\n", + "crIdx = bar_index + cOfs + cbw / 2\n", + "clIdx = bar_index + cOfs - cbw / 2\n", + "cX = int(bar_index + cOfs)\n", + "\n", + "\n", + "// Custom body box\n", + "var box cBx = na\n", + "box.delete(cBx)\n", + "ctB = math.max(cO, devClose) //y=dC\n", + "cbB = math.min(cO, devClose)\n", + "cBx := box.new(left=int(clIdx), right=int(crIdx), top=ctB, bottom=cbB, border_color=cCol, bgcolor=cBg)\n", + "\n", + "\n", + "// Custom wicks\n", + "var line cW1 = na\n", + "var line cW2 = na\n", + "line.delete(cW1)\n", + "line.delete(cW2)\n", + "cW1 := line.new(x1=cX, y1=cH, x2=cX, y2=ctB, color=cCol)\n", + "cW2 := line.new(x1=cX, y1=cbB, x2=cX, y2=cL, color=cCol)\n", + "\n", + "\n", + "// Custom labels\n", + "var label clO = na\n", + "var label clH = na\n", + "var label clL = na\n", + "var label clC = na\n", + "label.delete(clO)\n", + "label.delete(clH)\n", + "label.delete(clL)\n", + "label.delete(clC)\n", + "\n", + "\n", + "clStyle = label.style_label_left\n", + "clSize = size.tiny\n", + "clOfs = 2\n", + "\n", + "\n", + "clO := label.new(x=cX + clOfs, y=cO, text=\"8O \" + str.tostring(cO, \"#\"), style=clStyle, color=color.new(#2195f3, 100), textcolor=color.black, size=clSize)\n", + "clH := label.new(x=cX + clOfs, y=cH, text=\"8H \" + str.tostring(cH, \"#\"), style=clStyle, color=color.new(#2195f3, 100), textcolor=color.black, size=clSize)\n", + "clL := label.new(x=cX + clOfs, y=cL, text=\"8L \" + str.tostring(cL, \"#\"), style=clStyle, color=color.new(#2195f3, 100), textcolor=color.black, size=clSize)\n", + "clC := label.new(x=cX + clOfs, y=devClose, text=\"8C \" + str.tostring(dC, \"#\"), style=clStyle, color=color.new(#2195f3, 100), textcolor=color.black, size=clSize)\n", + "\n", + "// === High and Low Lines (using bar_index for x coords) ===\n", + "// Track bar_index of high and low bars within current day\n", + "var int highBarIndex = na\n", + "var int lowBarIndex = na\n", + "var float dayHigh = na\n", + "var float dayLow = na\n", + "\n", + "\n", + "startOfDay = timestamp(year, month, dayofmonth, 0, 0)\n", + "t6amManila = timestamp(\"Asia/Manila\", year, month, dayofmonth, 6, 0)\n", + "\n", + "\n", + "issNewDay = ta.change(time(\"D\"))\n", + "\n", + "\n", + "if (time >= startOfDay)\n", + " if na(dayHigh) or high > dayHigh\n", + " dayHigh := high\n", + " highBarIndex := bar_index\n", + " if na(dayLow) or low < dayLow\n", + " dayLow := low\n", + " lowBarIndex := bar_index\n", + "\n", + "\n", + "if bool(issNewDay)\n", + " dayHigh := na\n", + " dayLow := na\n", + " highBarIndex := na\n", + " lowBarIndex := na\n", + "\n", + "\n", + "// Draw high line from high bar index to current xMid\n", + "var line highLine = na\n", + "if not na(dayHigh) and not na(highBarIndex)\n", + " if na(highLine)\n", + " highLine := line.new(x1=highBarIndex, y1=dayHigh, x2=xMid, y2=dayHigh, color=dCol, width=2, style = line.style_solid)\n", + " else\n", + " line.set_xy1(highLine, highBarIndex, dayHigh)\n", + " line.set_xy2(highLine, xMid, dayHigh)\n", + "\n", + "\n", + "// Draw low line from low bar index to current xMid\n", + "var line lowLine = na\n", + "if not na(dayLow) and not na(lowBarIndex)\n", + " if na(lowLine)\n", + " lowLine := line.new(x1=lowBarIndex, y1=dayLow, x2=xMid, y2=dayLow, color=dCol, width=2, style = line.style_solid)\n", + " else\n", + " line.set_xy1(lowLine, lowBarIndex, dayLow)\n", + " line.set_xy2(lowLine, xMid, dayLow)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "// --- 6:00 AM Asia/Manila horizontal line ---\n", + "// Manila 6:00 AM timestamp today\n", + "manila_6am = timestamp(\"GMT+8\", year, month, dayofmonth, 30, 0)\n", + "\n", + "\n", + "// Detect bar where time crosses 6:00 AM Manila\n", + "isStartBar6am = (time >= manila_6am) and (time[1] < manila_6am)\n", + "\n", + "\n", + "// Store 6:00 AM bar open price and index\n", + "var float price6am = na\n", + "var int bar6am_index = na\n", + "\n", + "\n", + "if isStartBar6am\n", + " price6am := open\n", + " bar6am_index := bar_index\n", + "\n", + "\n", + "// Draw horizontal line from 6AM bar index to xMid at price6am\n", + "var line hLine6am = na\n", + "\n", + "\n", + "if not na(price6am) and not na(bar6am_index)\n", + " line.delete(hLine6am)\n", + " hLine6am := line.new(x1=bar6am_index, y1=price6am, x2=xMid, y2=price6am, color=color.new(#000000, 0), width=1, style=line.style_solid)\n", + "\n", + "\n", + "// --- 8:00 AM Asia/Manila horizontal line ---\n", + "// Detect bar where time crosses 8:00 AM Manila\n", + "isStartBar8am = (time >= stt) and (time[1] < stt)\n", + "\n", + "\n", + "// Store 8:00 AM bar open price and index\n", + "var float price8am = na\n", + "var int bar8am_index = na\n", + "\n", + "\n", + "if isStartBar8am\n", + " price8am := open\n", + " bar8am_index := bar_index\n", + "\n", + "\n", + "// Draw horizontal line from 8AM bar index to cX at price8am\n", + "var line hLine8am = na\n", + "var line hhLine8am = na\n", + "\n", + "\n", + "if not na(price8am) and not na(bar8am_index)\n", + " line.delete(hLine8am)\n", + " hLine8am := line.new(x1=bar8am_index, y1=price8am, x2=cX, y2=price8am, color=color.new(#000000, 0), width=1, style=line.style_solid)\n", + "\n", + "\n", + "\n", + "// Draw horizontal line that updates000000000000000000000000\n", + "var line devCloseLine = na\n", + "var line ddevCloseLine = na\n", + "if bar_index > 0\n", + " if na(devCloseLine)\n", + " devCloseLine := line.new(x1=bar_index, y1=devClose , x2=xMid , y2=devClose, style = line.style_solid, color=color.new(#ecc900, 0), width=1)\n", + " else\n", + " line.set_xy1(devCloseLine, bar_index, devClose)\n", + " line.set_xy2(devCloseLine, bar_index + 13, devClose)\n", + " if na(ddevCloseLine) \n", + " //ddevCloseLine := line.new(x1=xMid, y1=devClose, x2=xMid, y2=devClose, extend=extend.right, color=dCol, width=2)\n", + " ddevCloseLine := line.new(x1=xMid, y1=devClose, x2=xMid , y2=devClose, style = line.style_dotted, extend=extend.right, color=color.black, width=1)\n", + " else\n", + " line.set_xy1(ddevCloseLine, bar_index + 19, devClose)\n", + " line.set_xy2(ddevCloseLine, bar_index + 20, devClose)\n", + "\n", + "\n", + "\n", + "//zone logic\n", + "// Disable visuals if timeframe is higher than 1 hour\n", + "isValidTF = timeframe.isminutes and timeframe.multiplier <= 60\n", + "\n", + "\n", + "// Current time components\n", + "currentTime = timestamp(year, month, dayofmonth, hour, minute)\n", + "\n", + "// Define 12PM to 12AM session\n", + "start12pm = timestamp(year, month, dayofmonth, 12, 0)\n", + "end12am = timestamp(year, month, dayofmonth, 23, 59)\n", + "in12pmTo12am = currentTime >= start12pm and currentTime <= end12am\n", + "\n", + "// Define 8AM to 8PM session\n", + "start8am = timestamp(year, month, dayofmonth, 8, 0)\n", + "end8pm = timestamp(year, month, dayofmonth, 20, 0)\n", + "in8amTo8pm = currentTime >= start8am and currentTime <= end8pm\n", + "\n", + "// Define 6PM to 8PM session\n", + "start6pm = timestamp(year, month, dayofmonth, 6, 0)\n", + "eend8pm = timestamp(year, month, dayofmonth, 8, 0)\n", + "in6pmTo8pm = currentTime >= start6pm and currentTime <= eend8pm\n", + "\n", + "start6am = timestamp(year, month, dayofmonth, 18, 0)\n", + "eend8am = timestamp(year, month, dayofmonth, 20, 0)\n", + "in6amTo8am = currentTime >= start6am and currentTime <= eend8am\n", + "\n", + "// Apply background highlights\n", + "bgcolor(isValidTF and in12pmTo12am ? color.new(color.black, 99) : na)\n", + "bgcolor(isValidTF and in8amTo8pm ? color.new(color.black, 99) : na)\n", + "bgcolor(isValidTF and in6pmTo8pm ? color.new(color.black, 97) : na)\n", + "bgcolor(isValidTF and in6amTo8am ? color.new(color.black, 95) : na)\n", + "\n", + "// Get the current day of the week and the current time\n", + "isMonday = dayofweek == dayofweek.sunday\n", + "ccurrentTime = timestamp(year, month, dayofmonth, hour, minute)\n", + "\n", + "// Define the time range for 6:00 AM to 8:00 AM\n", + "startTime = timestamp(year, month, dayofmonth, 18, 6) // 6:00 AM\n", + "endTime = timestamp(year, month, dayofmonth, 20, 0) // 8:00 AM\n", + "\n", + "// Check if it's Monday and the current time is within the range of 6:00 AM to 8:00 AM\n", + "isInTimeRange = isMonday and ccurrentTime >= startTime and ccurrentTime <= endTime\n", + "\n", + "// Highlight the area with a background color\n", + "bgcolor(isValidTF and isInTimeRange ? color.new(color.blue, 90) : na)\n", + "\n", + "// Vertical lines logic\n", + "// Only show vertical lines if timeframe is intraday and valid\n", + "showLines = timeframe.isintraday and isValidTF\n", + "\n", + "// Convert current bar time to Asia/Manila timezone\n", + "t = time(timeframe.period, 'Asia/Manila')\n", + "\n", + "// Target hours excluding 0, 12, 20\n", + "var array targetHours = array.from(3, 6, 8, 15, 24) // 24 means midnight (0h)\n", + "\n", + "// Special hours separated\n", + "specialHour20 = 20\n", + "specialHour0 = 0 // midnight\n", + "specialHour12 = 12 // noon\n", + "\n", + "// Function to check if current bar time matches any target hour exactly at minute zero\n", + "isTargetTime() =>\n", + " h = hour(t)\n", + " m = minute(t)\n", + " match = false\n", + " for i = 0 to array.size(targetHours) - 1 by 1\n", + " if (h == array.get(targetHours, i) or h == 0 and array.get(targetHours, i) == 24) and m == 0\n", + " match := true\n", + " match\n", + " match\n", + "\n", + "// Check if current time matches special hour 20 at minute zero\n", + "isSpecialTime20() =>\n", + " h = hour(t)\n", + " m = minute(t)\n", + " h == specialHour20 and m == 0\n", + "\n", + "// Check if current time matches special hour 0 at minute zero\n", + "isSpecialTime0() =>\n", + " h = hour(t)\n", + " m = minute(t)\n", + " h == specialHour0 and m == 0\n", + "\n", + "// Check if current time matches special hour 12 at minute zero\n", + "isSpecialTime12() =>\n", + " h = hour(t)\n", + " m = minute(t)\n", + " h == specialHour12 and m == 0\n", + "\n", + "// Detect new day (day break)\n", + "nnewDay = ta.change(time('D'))\n", + "\n", + "// Only draw lines if timeframe is intraday and valid\n", + "if showLines\n", + " // Draw vertical line at day break (green, width 1)\n", + " if bool(nnewDay)\n", + " line.new(bar_index, low - 10 * syminfo.mintick, bar_index, high + 10 * syminfo.mintick, color = color.rgb(76, 175, 79, 90), width = 1, extend = extend.both)\n", + "\n", + " // Draw vertical line at target times (blue, width 1)\n", + " if isTargetTime()\n", + " line.new(bar_index, low - 10 * syminfo.mintick, bar_index, high + 10 * syminfo.mintick, color = color.rgb(33, 149, 243, 95), width = 1, extend = extend.both)\n", + "\n", + " // Draw vertical line at special hour 20 (teal, width 1)\n", + " if isSpecialTime20()\n", + " line.new(bar_index, low - 10 * syminfo.mintick, bar_index, high + 10 * syminfo.mintick, color = color.new(color.teal, 50), width = 1, extend = extend.both)\n", + "\n", + " // Draw vertical line at special hour 0 (midnight) - orange, dotted\n", + " if isSpecialTime0()\n", + " var line midnightLine = na\n", + " midnightLine := line.new(bar_index, low - 10 * syminfo.mintick, bar_index, high + 10 * syminfo.mintick, color = color.rgb(255, 153, 0, 50), width = 1, extend = extend.both)\n", + " line.set_style(midnightLine, line.style_dotted)\n", + "\n", + " // Draw vertical line at special hour 12 (noon) - red, dotted\n", + " if isSpecialTime12()\n", + " var line noonLine = na\n", + " noonLine := line.new(bar_index, low - 10 * syminfo.mintick, bar_index, high + 10 * syminfo.mintick, color = color.rgb(255, 82, 82, 50), width = 1, extend = extend.both)\n", + " line.set_style(noonLine, line.style_dotted)\n", + "\n", + "//hourly logic\n", + "// === UTILITY FUNCTION ===\n", + "f_show(tf) =>\n", + " timeframe.period != tf\n", + "\n", + "// === HOURLY ===\n", + "hH = request.security(syminfo.tickerid, '60', high, lookahead = barmerge.lookahead_on)\n", + "hL = request.security(syminfo.tickerid, '60', low, lookahead = barmerge.lookahead_on)\n", + "hIdx = request.security(syminfo.tickerid, '60', bar_index, lookahead = barmerge.lookahead_on)\n", + "\n", + "var int hPrev = na\n", + "var float hHi = na\n", + "var int hHiBar = na\n", + "var line hHiLine = na\n", + "var bool hHiOn = false\n", + "var float hLo = na\n", + "var int hLoBar = na\n", + "var line hLoLine = na\n", + "var bool hLoOn = false\n", + "\n", + "if hIdx != hPrev\n", + " hPrev := hIdx\n", + " hHi := na\n", + " hHiBar := na\n", + " line.delete(hHiLine)\n", + " hHiLine := na\n", + " hHiOn := false\n", + " hLo := na\n", + " hLoBar := na\n", + " line.delete(hLoLine)\n", + " hLoLine := na\n", + " hLoOn := false\n", + " hLoOn\n", + "\n", + "if hHiOn and not na(hHiLine)\n", + " bMin = math.min(open, close)\n", + " bMax = math.max(open, close)\n", + " if hHi <= bMax and hHi >= bMin\n", + " line.set_x2(hHiLine, bar_index)\n", + " line.set_y2(hHiLine, hHi)\n", + " hHiOn := false\n", + " hHiOn\n", + " else\n", + " line.set_x2(hHiLine, bar_index)\n", + " line.set_y2(hHiLine, hHi)\n", + "\n", + "if hLoOn and not na(hLoLine)\n", + " bMin = math.min(open, close)\n", + " bMax = math.max(open, close)\n", + " if hLo <= bMax and hLo >= bMin\n", + " line.set_x2(hLoLine, bar_index)\n", + " line.set_y2(hLoLine, hLo)\n", + " hLoOn := false\n", + " hLoOn\n", + " else\n", + " line.set_x2(hLoLine, bar_index)\n", + " line.set_y2(hLoLine, hLo)\n", + "\n", + "\n", + "// === D/W/M High-Low Steplines ===\n", + "ddH = request.security(syminfo.tickerid, 'D', high, lookahead = barmerge.lookahead_on)\n", + "ddL = request.security(syminfo.tickerid, 'D', low, lookahead = barmerge.lookahead_on)\n", + "wH = request.security(syminfo.tickerid, 'W', high, lookahead = barmerge.lookahead_on)\n", + "wL = request.security(syminfo.tickerid, 'W', low, lookahead = barmerge.lookahead_on)\n", + "mH = request.security(syminfo.tickerid, 'M', high, lookahead = barmerge.lookahead_on)\n", + "mL = request.security(syminfo.tickerid, 'M', low, lookahead = barmerge.lookahead_on)\n", + "\n", + "plot(f_show('60') ? hH : na, title = 'H High', color = color.new(color.black, 90), style = plot.style_stepline, linewidth = 2)\n", + "plot(f_show('60') ? hL : na, title = 'H Low', color = color.new(color.black, 90), style = plot.style_stepline, linewidth = 2)\n", + "plot(f_show('D') ? ddH : na, title = 'D High', color = color.new(color.green, 50), style = plot.style_stepline)\n", + "plot(f_show('D') ? ddL : na, title = 'D Low', color = color.new(color.green, 70), style = plot.style_stepline)\n", + "plot(f_show('W') ? wH : na, title = 'W High', color = color.new(color.blue, 90), style = plot.style_stepline, linewidth = 2)\n", + "plot(f_show('W') ? wL : na, title = 'W Low', color = color.new(color.blue, 90), style = plot.style_stepline, linewidth = 2)\n", + "plot(f_show('M') ? mH : na, title = 'M High', color = color.new(color.purple, 90), style = plot.style_stepline, linewidth = 3)\n", + "plot(f_show('M') ? mL : na, title = 'M Low', color = color.new(color.purple, 90), style = plot.style_stepline, linewidth = 3)\n", + "\n", + "\n", + "//vwap logic\n", + "// VWAP calculation from 1-minute data\n", + "f_vwap_calc() =>\n", + " var float cumPV = 0.0\n", + " var float cumVol = 0.0\n", + " var float cumPV_buy = 0.0\n", + " var float cumVol_buy = 0.0\n", + " var float cumPV_sell = 0.0\n", + " var float cumVol_sell = 0.0\n", + "\n", + " // Reset on new day\n", + " if bool(ta.change(time('D')))\n", + " cumPV := 0.0\n", + " cumVol := 0.0\n", + " cumPV_buy := 0.0\n", + " cumVol_buy := 0.0\n", + " cumPV_sell := 0.0\n", + " cumVol_sell := 0.0\n", + " cumVol_sell\n", + "\n", + " buyVol = close > open ? volume : 0.0\n", + " sellVol = close < open ? volume : 0.0\n", + "\n", + " cumPV := cumPV + close * volume\n", + " cumVol := cumVol + volume\n", + "\n", + " cumPV_buy := cumPV_buy + close * buyVol\n", + " cumVol_buy := cumVol_buy + buyVol\n", + "\n", + " cumPV_sell := cumPV_sell + close * sellVol\n", + " cumVol_sell := cumVol_sell + sellVol\n", + "\n", + " vwap = cumVol != 0 ? cumPV / cumVol : na\n", + " buyVWAP = cumVol_buy != 0 ? cumPV_buy / cumVol_buy : na\n", + " sellVWAP = cumVol_sell != 0 ? cumPV_sell / cumVol_sell : na\n", + "\n", + " [vwap, buyVWAP, sellVWAP]\n", + "\n", + "// Pull 1-minute VWAP values\n", + "[vwap_1m, buyVWAP_1m, sellVWAP_1m] = request.security(syminfo.tickerid, '1', f_vwap_calc())\n", + "\n", + "// Only show on intraday charts\n", + "showVWAP = not timeframe.isdaily and not timeframe.isweekly and not timeframe.ismonthly\n", + " \n", + "// Plot VWAPs with conditional display\n", + "plot_vwap = plot(showVWAP ? vwap_1m : na, color = color.rgb(238, 218, 90), linewidth = 1, title = 'VWAP (1m)')\n", + "//plot_buy_vwap = plot(showVWAP ? buyVWAP_1m : na, color = color.rgb(0, 137, 123, 80), linewidth = 1, title = 'Buy Delta VWAP (1m)')\n", + "//plot_sell_vwap = plot(showVWAP ? sellVWAP_1m : na, color = color.rgb(255, 82, 82, 80), linewidth = 1, title = 'Sell Delta VWAP (1m)')\n", + "\n", + "// Fill areas\n", + "//fill(plot_vwap, plot_buy_vwap, color = showVWAP ? color.new(color.teal, 95) : na, title = 'Buy VWAP Fill')\n", + "//fill(plot_vwap, plot_sell_vwap, color = showVWAP ? color.new(color.red, 95) : na, title = 'Sell VWAP Fill')\n", + "\n", + "//table logic\n", + "// === Function to get OHLC of specified candle ===\n", + "get_prev_ohlc(tf, shift) =>\n", + " o = request.security(syminfo.tickerid, tf, open[shift])\n", + " h = request.security(syminfo.tickerid, tf, high[shift])\n", + " l = request.security(syminfo.tickerid, tf, low[shift])\n", + " c = request.security(syminfo.tickerid, tf, close[shift])\n", + " [o, h, l, c]\n", + "\n", + "// === Function to calculate ranges and colors ===\n", + "get_data(tf, shift) =>\n", + " [o, h, l, c] = get_prev_ohlc(tf, shift)\n", + " full_range = h - l\n", + " oc_range = math.abs(c - o)\n", + " hl_range = h - l\n", + " is_bull = c > o\n", + " bg_color = is_bull ? color.new(color.teal, 90) : color.new(color.red, 90)\n", + " [full_range, oc_range, hl_range, bg_color]\n", + "\n", + "// === Daily Candle Data ===\n", + "[d1_fr, d1_oc, d1_hl, d1_bg] = get_data(\"D\", 1)\n", + "[d2_fr, d2_oc, d2_hl, d2_bg] = get_data(\"D\", 2)\n", + "\n", + "// === Weekly Candle Data ===\n", + "[w0_fr, w0_oc, w0_hl, w0_bg] = get_data(\"W\", 0) // Developing Week\n", + "[w1_fr, w1_oc, w1_hl, w1_bg] = get_data(\"W\", 1)\n", + "[w2_fr, w2_oc, w2_hl, w2_bg] = get_data(\"W\", 2)\n", + "\n", + "\n", + "// Daily candle (6:00 AM)\n", + "sixambgcolor = dO < dC ? color.rgb(0, 137, 123, 90) : color.rgb(255, 82, 82, 90)\n", + "\n", + "// Custom candle (8:00 AM Manila)\n", + "eightambgcolor = cO < cC ? color.rgb(0, 137, 123, 90) : color.rgb(255, 82, 82, 90) \n", + "\n", + "// Adjust UTC time to Manila (UTC+8) qewrqwerwerwerwerwerew\n", + "manilaTime = time + 8 * 60 * 60 * 1000 // Shift by 8 hours in milliseconds\n", + "\n", + "// Extract date components from Manila time\n", + "manilaYear = year(manilaTime)\n", + "manilaMonth = month(manilaTime)\n", + "manilaDay = dayofmonth(manilaTime)\n", + "\n", + "// Format date as \"DD/MM/YYYY\"\n", + "formattedDate = str.tostring(manilaDay, \"00\") + \"/\" + str.tostring(manilaMonth, \"00\") + \"/\" + str.tostring(manilaYear)\n", + "\n", + "// Track day changes in Manila time\n", + "var int prevManilaDay = na\n", + "newManilaDay = manilaDay != prevManilaDay\n", + "\n", + "// Update stored day\n", + "if newManilaDay\n", + " prevManilaDay := manilaDay\n", + "//qweqweqweqweqeqweqweqwewqeqwewqeqe\n", + "\n", + "// UTC/UTC+8 Time\n", + "var label utcLbl = na\n", + "var label utc8Lbl = na\n", + "label.delete(utcLbl)\n", + "label.delete(utc8Lbl)\n", + "\n", + "//utcStr = \"UTC: \" + str.tostring(hour, \"00\") + \":\" + str.tostring(minute, \"00\")\n", + "uutcStr = str.tostring(hour, \"00\") + \":\" + str.tostring(minute, \"00\") + \" 𝘜𝘛𝘊+8\"\n", + "utc8H = (hour + 12) % 24\n", + "//utc8Str = \"UTC: \" + str.tostring(utc8H, \"00\") + \":\" + str.tostring(minute, \"00\")\n", + "uutc8Str =str.tostring(utc8H, \"00\") + \":\" + str.tostring(minute, \"00\") + \" 𝘜𝘛𝘊+8\"\n", + "\n", + "// TF Label\n", + "var label tfLbl = na\n", + "label.delete(tfLbl)\n", + "var label tfLbl2 = na\n", + "label.delete(tfLbl2)\n", + "\n", + "tfS = \"\"\n", + "if (str.length(timeframe.period) > 1 and str.substring(timeframe.period, str.length(timeframe.period)-1, str.length(timeframe.period)) == \"m\")\n", + " tfS := \"m\"\n", + "else if (str.length(timeframe.period) > 1 and str.substring(timeframe.period, str.length(timeframe.period)-1, str.length(timeframe.period)) == \"h\")\n", + " tfS := \"h\"\n", + "tfP = str.replace(timeframe.period, tfS, \"\")\n", + "tfText = tfP + tfS + \"m 𝘪𝘯𝘵𝘰 1D\"\n", + "\n", + "// Range Labels\n", + "dHL = math.abs(dH - dL)\n", + "dOC = math.abs(dO - dC)\n", + "cHL = math.abs(cH - cL)\n", + "cOC = math.abs(cO - cC)\n", + "\n", + "// === Create and update table ===\n", + "var table tt = table.new(position.top_right, 80, 80, border_width=1)\n", + "\n", + "if bar_index == 1\n", + " table.cell(tt, 0, 0, \"\", text_color=color.rgb(255, 255, 255, 100), text_size = size.tiny, bgcolor=color.rgb(120, 123, 134, 100))\n", + " table.cell(tt, 1, 0, \"\", text_color=color.rgb(255, 255, 255, 100), text_size = size.tiny,bgcolor=color.rgb(120, 123, 134, 100))\n", + "\n", + " table.cell(tt, 0, 1, \"\", text_color=color.rgb(255, 255, 255, 100), text_size = size.tiny, bgcolor=color.rgb(120, 123, 134, 100))\n", + " table.cell(tt, 1, 1, \"\", text_color=color.rgb(255, 255, 255, 100), text_size = size.tiny,bgcolor=color.rgb(120, 123, 134, 100))\n", + " \n", + "// === Daily Rows ===\n", + "table.cell(tt, 1, 2, \"𝑺𝒑𝒆𝒄𝒊𝒇𝒊𝒄𝒂𝒕𝒊𝒐𝒏\", text_color = color.white, text_size = size.tiny, bgcolor = color.navy)\n", + "\n", + "table.cell(tt, 0, 3, \"Date\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 3, formattedDate, text_size = size.tiny, bgcolor = color.rgb(120, 123, 134, 90), text_color = color.rgb(255, 255, 255, 30))\n", + " \n", + "table.cell(tt, 0, 4, \"Time\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 4, text = uutc8Str, text_size = size.tiny, bgcolor = color.rgb(120, 123, 134, 90), text_color = color.rgb(255, 255, 255, 30))\n", + " \n", + "table.cell(tt, 0, 5, \"Time\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 5, text=uutcStr, text_size = size.tiny, bgcolor = color.rgb(120, 123, 134, 90), text_color = color.rgb(255, 255, 255, 30))\n", + "\n", + "table.cell(tt, 0, 6, \"Type\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 6, text=tfText, text_size = size.tiny, bgcolor = color.rgb(120, 123, 134, 90), text_color = color.rgb(255, 255, 255, 30))\n", + "\n", + "table.cell(tt, 1, 7, \"𝑯𝒊𝒈𝒉𝒆𝒓 𝑻𝑭\", text_color = color.white, text_size = size.tiny, bgcolor = color.navy)\n", + "\n", + "table.cell(tt, 0, 8, \"6:00\\nяαηgє\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 8, \"HL | $\" + str.tostring(dHL, \"#\") + \"\\nOC | $\" + str.tostring(dOC, \"#\"), text_size = size.tiny, bgcolor = sixambgcolor, text_color = color.rgb(255, 255, 255, 30))\n", + "\n", + "table.cell(tt, 0, 9, \"8:00\\nяαηgє\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 9, \"HL | $\" + str.tostring(cHL, \"#\") + \"\\nOC | $\" + str.tostring(cOC, \"#\"), text_size = size.tiny, bgcolor = eightambgcolor, text_color = color.rgb(255, 255, 255, 30))\n", + "\n", + "table.cell(tt, 1, 11, \"1D 𝑪𝒂𝒏𝒅𝒍𝒆\", text_color = color.white, text_size = size.tiny, bgcolor = color.navy)\n", + "\n", + "table.cell(tt, 0, 12, \"-1D \\nяαηgє\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 12, \"HL | $\" + str.tostring(d1_hl, \"#\") + \"\\nOC | $\" + str.tostring(d1_oc, \"#\"), text_size = size.tiny, bgcolor=d1_bg, text_color = color.rgb(255, 255, 255, 30))\n", + "\n", + "table.cell(tt, 0, 13, \"-2D \\nяαηgє\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 13, \"HL | $\" + str.tostring(d2_hl, \"#\") + \"\\nOC | $\" + str.tostring(d2_oc, \"#\"), text_size = size.tiny, bgcolor=d2_bg, text_color = color.rgb(255, 255, 255, 30))\n", + "\n", + "table.cell(tt, 1, 14, \"1W 𝑪𝒂𝒏𝒅𝒍𝒆\", text_color = color.white, text_size = size.tiny, bgcolor = color.navy)\n", + "\n", + "table.cell(tt, 0, 15, \"0W \\nяαηgє\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 15, \"HL | $\" + str.tostring(w0_hl, \"#\") + \"\\nOC | $\" + str.tostring(w0_oc, \"#\"), text_size = size.tiny, bgcolor=w0_bg, text_color = color.rgb(255, 255, 255, 30))\n", + "\n", + "table.cell(tt, 0, 16, \"-1W \\nяαηgє\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 16, \"HL | $\" + str.tostring(w1_hl, \"#\") + \"\\nOC | $\" + str.tostring(w1_oc, \"#\"), text_size = size.tiny, bgcolor=w1_bg, text_color = color.rgb(255, 255, 255, 30))\n", + "\n", + "table.cell(tt, 0, 17, \"-2W \\nяαηgє\", text_size = size.tiny, text_color = color.white)\n", + "table.cell(tt, 1, 17, \"HL | $\" + str.tostring(w2_hl, \"#\") + \"\\nOC | $\" + str.tostring(w2_oc, \"#\"), text_size = size.tiny, bgcolor=w2_bg, text_color = color.rgb(255, 255, 255, 30))\n", + "\n", + "table.cell(tt, 1, 18, \"© 2025 𝚆𝚀𝚜\", text_color = color.white, text_size = size.tiny, bgcolor = color.black)\n", + "\n", + "//developinf day \n", + "// === INPUTS ===\n", + "startSession = input.session(\"0000-2359\", title=\"Session Time\")\n", + "sshowLines = input.bool(true, title=\"Show Lines\")\n", + "showLabels = input.bool(true, title=\"Show Labels\")\n", + "\n", + "// === TIME LOGIC ===\n", + "isNNewDay = ta.change(time(\"D\"))\n", + "\n", + "// === DEVELOPING HIGH/LOW TRACKING ===\n", + "var float devHigh = na\n", + "var float devLow = na\n", + "\n", + "// Reset at new day\n", + "if bool(isNNewDay)\n", + " devHigh := high\n", + " devLow := low\n", + "else\n", + " devHigh := math.max(devHigh, high)\n", + " devLow := math.min(devLow, low)\n", + "\n", + "// === PLOTTING ===\n", + "plot(sshowLines ? devHigh : na, title=\"Developing High\", color=color.rgb(76, 175, 79, 50), linewidth=2, style=plot.style_stepline)\n", + "plot(sshowLines ? devLow : na, title=\"Developing Low\", color=color.rgb(255, 82, 82, 50), linewidth=2, style=plot.style_stepline)\n", + "\n", + "\n", + "// Input only controls how many 1-minute candles are used\n", + "llen = input.int(24, \"VWMA Length (1m)\")\n", + "\n", + "// VWMA calculation inside 1-minute context\n", + "vwma_1m = request.security(syminfo.tickerid, \"1\", math.sum(close * volume, llen) / math.sum(volume, llen))\n", + "\n", + "// Only plot if current timeframe is 5 minutes\n", + "is_5min = timeframe.period == \"5\"\n", + "\n", + "plot(is_5min ? vwma_1m : na, title=\"1-Minute VWMA\", color=color.rgb(117, 117, 117), linewidth=2)\n", + "\n", + "//Profile Settings\n", + "tf = input.timeframe(\"D\", title = \"Timeframe\", inline = \"0\", group = \"PROFILE SETTINGS\")\n", + "lb_calc = input.bool(false, title = \"Use Lookback Calc?\", inline = \"0\", group = \"PROFILE SETTINGS\", tooltip = \"Lookback Calculation Historically compiles a profile to display the data from the requested timeframe amount of time.\\nProgressive Calculation (Default) restarts the profile calculation on each change of the requested timeframe(New Bar).\\n\\nExamples:\\nLookback = '1D' will display a profile based on 1 Day of historical data.\\nProgressive = '1D' will display a profile base on data since the start of the Day.\\n\\nTip: There is a manual control for lookback bars at the bottom if you prefer to see a specific number.\")\n", + "vap = input.float(0, title = \"Value Area %\", inline = \"1_1\", group = \"PROFILE SETTINGS\")\n", + "mp = input.bool(false, title = \"Calculate As Market Profile\", inline = \"2\", group = \"PROFILE SETTINGS\", tooltip = \"Calculations will distribue a 1 instead of the candle's volume.\")\n", + "//Display Settings\n", + "disp_size = input.int(-30, minval = -500,maxval = 500,title = \"Display Size   \", inline = \"3\", group = \"DISPLAY SETTINGS\", tooltip = \"The entire range of your profile will scale to fit inside this range.\\nNotes:\\n-This value is # bars away from your profile's axis.\\n-The larger this value is, the more granular your (horizontal) view will be. This does not change the Profiles' value; because of this, sometimes the POC looks tied with other values widely different. The POC CAN be tied to values close to it, but if the value is far away it is likely to just be a visual constraint.\\n-This Value CAN be negative\")\n", + "prof_offset = input.int(0, minval = -500,maxval = 500, title = \"Display Offset\", inline = \"4\", group = \"DISPLAY SETTINGS\", tooltip = \"Offset your profile's axis (Left/Right) to customize your display to fit your style.\\nNotes:\\n-Zero = Current Bar\\n-This Value CAN be negative\")\n", + "//Additional Data Displays\n", + "extend_day = input.bool(false, title = \"Extend POC/VAH/VAL\", inline = \"1\", group = \"Additional Data Displays\")\n", + "lab_tog = input.bool(true, title = \"Label POC/VAH/VAL\", inline = \"2\", group = \"Additional Data Displays\") \n", + "dev_poc = input.bool(false, title = \"Rolling POC/TPO\", inline = \"3\", group = \"Additional Data Displays\", tooltip = \"Displays Value as it Develops!\\nNote: Will Cause Longer Load Time. If not needed, it is reccomended to turn these off.\\n\\n> Consider manually overriding the Row Size Below!\")\n", + "dev_va = input.bool(false, title = \"Rolling VAH/VAL\", inline = \"4\", group = \"Additional Data Displays\")\n", + "//High/Low Volume Nodes\n", + "node_tog = input.bool(true, title = \"Highlight Nodes\", group = \"High/Low Volume Nodes\")\n", + "hi_width = input.int(10, maxval = 100, minval = 1,title = \"[HVN] Analysis Width %      ↕\", group = \"High/Low Volume Nodes\", tooltip = \"[HVN] = High Volume Node\\nAnalysis Width % = % of profile to take into account when determining what is a High Volume Node and what is Not.\")*0.01\n", + "lo_width = input.int(10, maxval = 100, minval = 1, title = \"[LVN]  Analysis Width %      ↕\", group = \"High/Low Volume Nodes\", tooltip = \"[LVN] = Low Volume Node\\nAnalysis Width % = % of profile to take into account when determining what is a Low Volume Node and what is Not.\")*0.01\n", + "//Colors\n", + "poc_color = input.color(#d3be00, title = \"POC/TPO Color\", group = \"Colors\")\n", + "var_color = input.color(#886000, title = \"Value High/Low Color\", group = \"Colors\")\n", + "vaz_color = input.color(color.new(#886000, 0), title = \"Value Zone Color\", group = \"Colors\")\n", + "ov_color = input.color(#886000, title = \"Profile Color\", group = \"Colors\")\n", + "lv_color = input.color(#886000, title = \"Low Volume Color\", group = \"Colors\")\n", + "hv_color = input.color(#886000, title = \"High Volume Color\", group = \"Colors\")\n", + "//⭕Manual Overrides⭕\n", + "lb_override = input.bool(false, title = \">\", group = \"⭕Manual Overrides⭕[CHECK TO ENABLE]\", inline = \"1\")\n", + "lb_over_bars = input.int(500, title = \"Lookback\", group = \"⭕Manual Overrides⭕[CHECK TO ENABLE]\", inline = \"1\", tooltip = \"Lookback Calc must be enabled for this feature.\")\n", + "row_size_override = input.bool(false, title = \">\", group = \"⭕Manual Overrides⭕[CHECK TO ENABLE]\", inline = \"2\")\n", + "row_size_input = input.int(100, minval= 2, maxval = 999, title = \"Profile Rows\", group = \"⭕Manual Overrides⭕[CHECK TO ENABLE]\", inline = \"2\", tooltip = \"Manually set the Number of Rows to Use.\\nReccomended when faster calculations are neccesary, like replay mode or Developing POC/VAH/VAL.\")\n", + "///_________________________________________\n", + "///Misc Stuff\n", + "///‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n", + " \n", + "round_to(_round,_to) =>\n", + " math.round(_round/_to)*_to\n", + "\n", + "///_________________________________________\n", + "///Setup for Length\n", + "///‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n", + "tf_change = timeframe.change(tf)\n", + "var int bi_nd = na // BI_ND = Bar Index _ New Day\n", + "var int bi_lnd = na //BI_LND = Bar Index Last New Day\n", + "\n", + "bi_lnd := tf_change?bi_nd:bi_lnd\n", + "bi_nd := tf_change?bar_index:bi_nd\n", + "\n", + "tf_len = (bi_nd - bi_lnd)+1\n", + "bs_newtf = (bar_index - bi_nd)+1\n", + "id_lb_bars = timeframe.in_seconds(tf)/timeframe.in_seconds(timeframe.period)\n", + "dwm_lb_bars = (math.max(tf_len,bs_newtf)>1?math.max(tf_len,bs_newtf)-1:1)\n", + "auto_lb_bars = timeframe.in_seconds(tf) >= timeframe.in_seconds(\"D\")?dwm_lb_bars:id_lb_bars\n", + "lb_bars = (lb_calc?(na(tf_len)?bar_index:(lb_override?lb_over_bars:auto_lb_bars)):na(bs_newtf)?bar_index:bs_newtf)\n", + "///_________________________________________\n", + "///Warning for Large Timeframe\n", + "///‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n", + "var d = dayofmonth\n", + "var m = switch\n", + " month == 1 => \"Jan\"\n", + " month == 2 => \"Feb\"\n", + " month == 3 => \"Mar\"\n", + " month == 4 => \"Apr\"\n", + " month == 5 => \"May\"\n", + " month == 6 => \"Jun\"\n", + " month == 7 => \"Jul\"\n", + " month == 8 => \"Aug\"\n", + " month == 9 => \"Sep\"\n", + " month == 10 => \"Oct\"\n", + " month == 11 => \"Nov\"\n", + " month == 12 => \"Dec\"\n", + "var y = year - (int(year/100)*100)\n", + "send_warning = (lb_calc and (na(tf_len) or bar_index= lb_bars\n", + " for i = 0 to bar_index\n", + " if highs.size() == lb_bars\n", + " break\n", + " else\n", + " highs.shift()\n", + " lows.shift()\n", + " if not mp\n", + " vol.shift()\n", + " \n", + "//Granularity Gets more corse farther from current bar for speed. Replay mode can get a full gran profile if needed.\n", + "v_gran = row_size_override?row_size_input:bar_index>=(last_bar_index-1000)?999: bar_index>=(last_bar_index-2000)?249: bar_index>=(last_bar_index-4000)?124:64\n", + "\n", + "\n", + "\n", + "full_hist_calc = (dev_poc or dev_va)\n", + "tick_size = full_hist_calc or barstate.islast?math.ceil(((highs.max()-lows.min())/v_gran)/syminfo.mintick)*syminfo.mintick:na\n", + "\n", + "\n", + "///_________________________________________\n", + "///Profile Calcs\n", + "///‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n", + "data_map = map.new()\n", + "\n", + "if full_hist_calc and highs.size() > 0\n", + " highs_size = array.size(highs)-1\n", + " for i = 0 to highs_size\n", + " hi = round_to(highs.get(i),tick_size)\n", + " lo = round_to(lows.get(i),tick_size)\n", + " candle_index = ((hi-lo)/tick_size)\n", + " tick_vol = mp?1:math.round((vol.get(i)/(candle_index+1)),3)\n", + " for e = 0 to candle_index\n", + " val = round_to(lo+(e*tick_size),tick_size)\n", + " data_map.put(val, math.round(nz(data_map.get(val)),3)+tick_vol)\n", + "\n", + "if (full_hist_calc == false) and barstate.islast\n", + " highs_size = array.size(highs)-1\n", + " for i = 0 to highs_size\n", + " hi = round_to(highs.get(i),tick_size)\n", + " lo = round_to(lows.get(i),tick_size)\n", + " candle_index = ((hi-lo)/tick_size)\n", + " tick_vol = mp?1:math.round((vol.get(i)/(candle_index+1)),3)\n", + " for e = 0 to candle_index\n", + " val = round_to(lo+(e*tick_size),tick_size)\n", + " data_map.put(val,nz(data_map.get(val))+tick_vol)\n", + "\n", + "///_________________________________________\n", + "////Other Profile Values\n", + "///‾‾‾‾‾‾‾‾‾‾‾��‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n", + "keys = map.keys(data_map)\n", + "values = map.values(data_map)\n", + "array.sort(keys, order.ascending)\n", + "///_________________________________________\n", + "///AQUIRE POC\n", + "///‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n", + "//POC = Largest Volume Closest to Price Average of Profile\n", + "//\n", + "float poc = 0\n", + "float poc_vol = values.max()\n", + "prof_avg = keys.avg()\n", + "if barstate.islast or dev_poc\n", + " for [key, value] in data_map\n", + " if (value == poc_vol and math.abs(key-prof_avg)= max_vol\n", + " break\n", + " upper_vol = nz(data_map.get(round_to(up_count+tick_size,tick_size))) + nz(data_map.get(round_to(up_count+(tick_size*2),tick_size)))\n", + " lower_vol = nz(data_map.get(round_to(down_count-tick_size,tick_size))) + nz(data_map.get(round_to(down_count-(tick_size*2),tick_size)))\n", + " if (((upper_vol >= lower_vol) and upper_vol > 0) or (lower_vol>0 == false)) and up_count < array.max(keys)-tick_size\n", + " vol_count += upper_vol \n", + " up_count := round_to(up_count+(tick_size*2),tick_size) \n", + " else if down_count > array.min(keys)+tick_size\n", + " vol_count += lower_vol\n", + " down_count := round_to(down_count-(tick_size*2),tick_size) \n", + "val = down_count\n", + "vah = up_count\n", + "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n", + "//END PROFILE CALCs//\n", + "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n", + "\n", + "\n", + "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n", + "//Cluster ID for Volume Nodes//\n", + "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n", + "// Cluster ID analyzes a local group (cluster) of volume profile indices (rows) to determine if the current index is higher(or lower) than those around it.\n", + "// The Analysis width is a % of the entire # of rows in the profile to pull into a cluster, by increasing or decreasing this value, we can tune the profile to our individual preference.\n", + "\n", + "vgroup_pull(_var,_array,_num1,_num2) =>\n", + " _var == 1 and _num1>=_num2 ? data_map.get(array.get(_array,_num1-_num2)): //Pulls Index Value from Below\n", + " _var == 2 and array.size(_array)-1 >= (_num1 + _num2) ? data_map.get(array.get(_array,_num1+_num2)) //Pulls Index Value from Above \n", + " :0\n", + "hvn_points = array.new_int(na) \n", + "if array.size(keys) > 0 and barstate.islast and node_tog\n", + " array.clear(hvn_points)\n", + " for [i,v] in keys \n", + " _val = data_map.get(v)\n", + " ary = array.new_float(na) \n", + " for e = 0 to int(keys.size()*hi_width) \n", + " array.push(ary,vgroup_pull(1,keys,i,e))\n", + " array.push(ary,vgroup_pull(2,keys,i,e)) \n", + " max = array.max(ary) \n", + " avg = array.avg(ary)\n", + " if _val >= math.avg(max,avg)\n", + " array.push(hvn_points,i)\n", + "\n", + "lvn_points = array.new_int(na)\n", + "if array.size(keys) > 0 and barstate.islast and node_tog\n", + " array.clear(lvn_points)\n", + " for [i,v] in keys\n", + " _val = data_map.get(v) \n", + " ary = array.new_float(na) \n", + " for e = 0 to int(array.size(keys)*lo_width) \n", + " array.push(ary,vgroup_pull(1,keys,i,e))\n", + " array.push(ary,vgroup_pull(2,keys,i,e))\n", + " min = array.min(ary)\n", + " avg = array.avg(ary)\n", + " if _val <= math.avg(min,avg) \n", + " array.push(lvn_points,i)\n", + "\n", + "///_________________________________________\n", + "///Cluster Merging\n", + "///‾‾‾‾‾‾‾‾‾‾‾‾‾‾��‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n", + "\n", + "merge_clusters(_array) =>\n", + " if array.size(_array)>0\n", + " ary_size = array.size(_array)-1\n", + " for i = 0 to ary_size\n", + " merge_found = false\n", + " _val = array.get(_array,i)\n", + " prof_merge_percent = int(array.size(keys)*0.02)\n", + " for e = prof_merge_percent to 0\n", + " if merge_found\n", + " array.push(_array,_val+e)\n", + " else if array.includes(_array,_val+e)\n", + " merge_found := true \n", + " dummy = \"This is here to make the loop return 'void'. \" //Delete This line to Break the Indicator.\n", + "\n", + "// run it\n", + "if barstate.islast and node_tog\n", + " merge_clusters(hvn_points)\n", + " merge_clusters(lvn_points)\n", + "\n", + "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n", + "//END Cluster ID Calcs//\n", + "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n", + "\n", + "\n", + "/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n", + "//Display//\n", + "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n", + "\n", + "var profile = array.new_line(na)\t\n", + "var box_profile = array.new_box(na)\t \n", + "if barstate.islast\n", + " if array.size(profile) > 0\n", + " for [index,line] in profile \n", + " line.delete(line) \n", + " array.clear(profile)\n", + " if array.size(box_profile) > 0 \n", + " for [index,box] in box_profile \n", + " box.delete(box) \n", + " array.clear(box_profile)\n", + " if polyline.all.size() > 0 \n", + " for pl in polyline.all \n", + " pl.delete() \n", + " \n", + "prof_color(_num,_key) => //Function for determining what color each profile index gets\n", + " switch\n", + " array.includes(hvn_points,_num) and array.includes(lvn_points,_num) => ((_key>up_count or _key lv_color //If it is < lv% of the max volume, give it the low volume color \n", + " array.includes(hvn_points,_num) => hv_color //If its > hv% of the max volume, give it the high volume color \n", + " (_key>up_count or _key ov_color //If its above or below our value zone, give it the out of value color\n", + " => vaz_color // Everything else is inside the value zone so it gets the value zone color\n", + "\n", + "dash(_i) => (_i/2 - math.floor(_i/2)) > 0 //only true when the number is odd, Making it oscillate on/off, I can make use of this to evenly distribute boxes and lines throughout the display to make it cleaner.\n", + "\n", + "///_________________________________________\n", + "///Drawing the Profile\n", + "///‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n", + "scale = disp_size/array.max(values)\n", + "var lab = label.new(na,na, style = (disp_size<0?label.style_label_lower_right:label.style_label_lower_left), color = color.rgb(0,0,0,100), textalign = text.align_left, text_font_family = font.family_monospace)\n", + "if barstate.islast\n", + " if extend_day\n", + " polyline.new(array.from(chart.point.from_time(time[lb_bars],poc),chart.point.from_time(time,poc)), line_color = poc_color, xloc = xloc.bar_time, line_width = 2)\n", + " polyline.new(array.from(chart.point.from_time(time[lb_bars],vah),chart.point.from_time(time,vah)), line_color = var_color, xloc = xloc.bar_time, line_width = 2)\n", + " polyline.new(array.from(chart.point.from_time(time[lb_bars],val),chart.point.from_time(time,val)), line_color = var_color, xloc = xloc.bar_time, line_width = 2)\n", + " for [i,get_key] in keys\n", + " get_vol = data_map.get(get_key)\n", + " scaled = math.round(get_vol*scale)\n", + " p1 = extend_day and disp_size > 0 ? bar_index : (bar_index+prof_offset)\n", + " p2 = extend_day and disp_size < 0 ? bar_index : ((bar_index+scaled)+prof_offset)\n", + " if get_key == poc\n", + " array.push(box_profile,box.new(p1,poc,p2,poc, border_color = poc_color, border_style = line.style_solid, border_width = 1))\n", + " else if get_key == vah\n", + " array.push(box_profile,box.new(p1,vah,p2,vah, border_color = var_color, border_style = line.style_solid, border_width = 1))\n", + " else if get_key == val\n", + " array.push(box_profile,box.new(p1,val,p2,val, border_color = var_color, border_style = line.style_solid, border_width = 1))\n", + " else if dash(i) and (array.size(profile) <= 499) and (math.abs(scaled)>=1)\n", + " array.push(profile,line.new(bar_index+prof_offset,get_key,(bar_index+scaled)+prof_offset,get_key, color = prof_color(i,get_key), style = (get_keyup_count?line.style_dotted:line.style_solid),width = 1))\n", + " else if (array.size(box_profile) <= 499) and (math.abs(scaled)>=1)\n", + " array.push(box_profile,box.new(bar_index+prof_offset,get_key,(bar_index+scaled)+prof_offset,get_key, border_color = prof_color(i,get_key), border_style = (get_keyup_count?line.style_dotted:line.style_solid), border_width = 1))\n", + "\n", + "//Drawing labels for the profile\n", + " lab.set_xy(bar_index+prof_offset, keys.max())\n", + " lab.set_textcolor(send_warning?color.rgb(255, 136, 0):chart.fg_color)\n", + " if lab_tog \n", + " var poc_lab = label.new(bar_index+prof_offset,poc, text = mp?\"TPO\":\"POC\", tooltip = (mp?\"TPO: $\":\"POC: $\") + str.tostring(poc,format.mintick),size = size.small, style = (disp_size<0?label.style_label_left:extend_day?label.style_label_lower_right:label.style_label_right), color = color.rgb(0,0,0,100), textcolor = poc_color, textalign = (disp_size<0?text.align_right:text.align_left), text_font_family = font.family_monospace)\n", + " var vah_lab = label.new(bar_index+prof_offset,vah, text = \"VAH\",size = size.small,tooltip = \"VAH: \" + str.tostring(vah,format.mintick), style = (disp_size<0?label.style_label_left:extend_day?label.style_label_lower_right:label.style_label_right), color = color.rgb(0,0,0,100), textcolor = var_color, textalign = (disp_size<0?text.align_right:text.align_left), text_font_family = font.family_monospace)\n", + " var val_lab = label.new(bar_index+prof_offset,val, text = \"VAL\",size = size.small,tooltip = \"VAL: \" + str.tostring(val,format.mintick), style = (disp_size<0?label.style_label_left:extend_day?label.style_label_lower_right:label.style_label_right), color = color.rgb(0,0,0,100), textcolor = var_color, textalign = (disp_size<0?text.align_right:text.align_left), text_font_family = font.family_monospace)\n", + " poc_lab.set_xy(bar_index+prof_offset,poc)\n", + " vah_lab.set_xy(bar_index+prof_offset,vah)\n", + " val_lab.set_xy(bar_index+prof_offset,val)\n", + "// Alerts\n", + "alertcondition(ta.crossover(close,poc), \"Cross-Over Point of Control\")\n", + "alertcondition(ta.crossunder(close,poc), \"Cross-Under Point of Control\")\n", + "alertcondition(ta.crossover(close,vah), \"Cross-Over Value High\")\n", + "alertcondition(ta.crossunder(close,vah), \"Cross-Under Value High\")\n", + "alertcondition(ta.crossover(close,val), \"Cross-Over Value Low\")\n", + "alertcondition(ta.crossunder(close,val),\"Cross-Under Value Low\")\n", + "//Plotting Developing Lines\n", + "plot(dev_poc?(poc==0?na:poc):na, color = poc_color, title = \"Developing POC/TOP\")\n", + "plot(dev_va?vah:na, color = var_color, title = \"Developing VAH\")\n", + "plot(dev_va?val:na, color = var_color, title = \"Developing VAL\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "bcd3ff3b", + "metadata": {}, + "source": [ + "## Modifyig it using piescript code, Indicator (2/2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3652c855", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "//@version=5\n", + "indicator(\"v6 Sunstoic VP&TPO\", shorttitle = \"v6 Sunstoic VP&TPO\", overlay = true, max_lines_count = 500, max_boxes_count = 500, max_labels_count = 500, max_bars_back = 2000)\n", + "\n", + "\n", + "ti = input.string(defval = \"Regular\", title = \"Calculation Type\", options = [\"Regular\", \"Fixed Range\", \"Fixed Interval\"], group = \"Calculation Type\")\n", + "\n", + "\n", + "auto = input.string(defval = \"Custom\", options = [\"Auto\", \"Custom\"], title = \"Auto Calculate Tick Levels? Custom?\", inline = \"1\", group = \"Current Session Configurations\")\n", + "tickzz = input.float(defval = 2000 ,title = \"Ticks\", inline = \"1\", group = \"Current Session Configurations\")\n", + "tickLevels = input.bool(false, title = \"Show Tick Levels?\", group = \"Current Session Configurations\")\n", + "textSize = input.string(defval = \"Tiny\", options = [\"Auto\",\"Tiny\", \"Small\", \"Normal\", \"Large\", \"Huge\"], group = \"Current Session Configurations\")\n", + "showIb = input.bool(defval = false, title = \"Show Initial Balance Range?\", group = \"Current Session Configurations\")\n", + "sess = input.string(defval = \"D\", title = \"Recalculate After How Much Time?\", tooltip = \"from 1 to 1440 for minutes \\nfrom 1D to 365D for days \\nfrom 1W to 52W for weeks \\nfrom 1M to 12M for months\", group = 'If \"Regular\" is Selected')\n", + "st = input.time(defval = timestamp(\"19 Sep 2022 00:00 +0300\"), title = \"Fixed Range Start\", group = 'If \"Fixed Range\" Is Selected')\n", + "timE = input.session(defval = \"1300-1700\", title = \"Time Range\", group = 'If \"Fixed Interval\" is Selected', tooltip = 'Select \"Fixed Interval\" For The \"Calculation Type\" Setting To Activate This Feature')\n", + "showPre = input.bool(defval = true, title = \"Show Previous Sessions TPO?\", group = \"Previous Session Settings\")\n", + "blackBox = input.bool(defval = false, title = \"Segment Previous Sessions With Black Box?\", group = \"Previous Session Settings\")\n", + "rang = input.bool(defval = true, title = \"Show Previous Sessions Ranges?\", group = \"Previous Session Settings\")\n", + "\n", + "\n", + "distCalc = input.float(defval = 5.0, title = \"% Distance to Hide Old SP Lines\", tooltip = \"If Price Exceeds The % Threshold Defined For This\n", + " Setting (Price Distance From An Existing Sp Line - The Sp Line Will Dissapear Until Price Is Within Proximity Once More\",\n", + " group = \"Previous Session Settings\")\n", + "distCalc2 = input.float(defval = 5.0, title = \"% Distance to Hide Old VA Lines\", tooltip = \"If Price Exceeds The % Threshold Defined For This\n", + " Setting (Price Distance From An Existing Va Line - The Va Line Will Dissapear Until Price Is Within Proximity Once More\",\n", + " group = \"Previous Session Settings\")\n", + "distCalc3 = input.float(defval = 5.0, title = \"% Distance to Hide Old POC Lines\", tooltip = \"If Price Exceeds The % Threshold Defined For This\n", + " Setting (Price Distance From An Existing Poc Line - The Poc Line Will Dissapear Until Price Is Within Proximity Once More\",\n", + " group = \"Previous Session Settings\")\n", + "\n", + "\n", + "spShw = input.bool(defval = true, title = \"Show SP Lines and Labels\", group = \"Display Options\", tooltip = \"If Deselected, TPO Letters Will Only Turn Red When a SP Forms. No Other Identifying Features are Displayed\")\n", + "fr = input.bool(defval = true, title = \"Show Fixed Range Label and Line?\" , group =\"Display Options\")\n", + "warn = input.bool(defval = true, title = \"Show Warning\", group = \"Display Options\")\n", + "col = input.color(defval = color.gray, title = \"Main Character Color (Gray Default)\", group = \"Colors\")\n", + "col1 = input.color(defval = color.red , title = \"SP Character Color (Red Default)\", group = \"Colors\")\n", + "col2 = input.color(defval = color.yellow, title = \"POC Character Color (Yellow Default)\", group = \"Colors\")\n", + "col3 = input.color(defval = color.blue, title = \"IB Character Color (Blue Default)\", group = \"Colors\")\n", + "col4 = input.color(defval = color.rgb(0, 114, 59), title = \"Value Area Color (Lime Default)\", group = \"Colors\")\n", + "col5 = input.color(defval = color.rgb(163, 147, 0), title = \"Value Area Letter Color (White Default)\", group = \"Colors\")\n", + "fnt = input.string(defval = \"Default\", title = \"Font Type\", options = [\"Default\", \"Monospace\"], group = \"Colors\")\n", + "\n", + "if timeframe.isdwm\n", + " ti := \"Fixed Range\"\n", + "\n", + "\n", + "if fr == true and barstate.islast\n", + " line.new(math.round(st), close, math.round(st), close + 0.001, extend = extend.both, color = color.white, width = 4, xloc = xloc.bar_time)\n", + " if ti != \"Fixed Range\"\n", + " var box frStart = box.new(math.round(st), high + ta.tr, math.round(st), low - ta.tr,\n", + " bgcolor = color.new(color.white, 100), border_color = na, text_size = size.normal, text_color = color.white, text_wrap = text.wrap_none, text = \"If Selected in Settings, \\nFixed Range Begins Here\", xloc = xloc.bar_time)\n", + "\n", + "\n", + "fixTime = time(timeframe.period, timE)\n", + "\n", + "\n", + "fonT = switch fnt\n", + " \n", + " \"Default\" => font.family_default\n", + " \"Monospace\" => font.family_monospace\n", + "\n", + "finTim = switch ti\n", + " \n", + " \"Regular\" => timeframe.change(sess)\n", + " \"Fixed Range\" => time[1] < st and time >= st\n", + " \"Fixed Interval\" => na(fixTime[1]) and not na(fixTime)\n", + "\n", + "sz = switch textSize\n", + " \n", + " \"Auto\" => size.auto\n", + " \"Tiny\" => size.tiny\n", + " \"Small\" => size.small\n", + " \"Normal\" => size.normal\n", + " \"Large\" => size.large\n", + " \"Huge\" => size.huge\n", + "\n", + "var string [] str = array.from(\n", + " \n", + " \" A\",\n", + " \" B\",\n", + " \" C\",\n", + " \" D\",\n", + " \" E\",\n", + " \" F\",\n", + " \" G\",\n", + " \" H\",\n", + " \" I\",\n", + " \" J\",\n", + " \" K\",\n", + " \" L\",\n", + " \" M\",\n", + " \" N\",\n", + " \" O\",\n", + " \" P\",\n", + " \" Q\",\n", + " \" R\",\n", + " \" S\",\n", + " \" T\",\n", + " \" U\",\n", + " \" V\",\n", + " \" W\",\n", + " \" X\",\n", + " \" Y\",\n", + " \" Z\",\n", + " \" a\",\n", + " \" b\",\n", + " \" c\",\n", + " \" d\",\n", + " \" e\",\n", + " \" f\",\n", + " \" g\",\n", + " \" h\",\n", + " \" i\",\n", + " \" j\",\n", + " \" k\",\n", + " \" l\", \n", + " \" m\",\n", + " \" n\",\n", + " \" o\",\n", + " \" p\",\n", + " \" q\",\n", + " \" r\",\n", + " \" s\",\n", + " \" t\",\n", + " \" u\",\n", + " \" v\",\n", + " \" w\",\n", + " \" x\",\n", + " \" y\",\n", + " \" z\"\n", + "\n", + "\n", + " )\n", + "\n", + "\n", + "if barstate.isfirst\n", + "\n", + " sX = \"\"\n", + "\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"1 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"2 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"3 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"4 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"5 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"6 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"7 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"8 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"9 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"10 \" // => Loops are run sequentially, not simultaneously, so string characters populate in order\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"11 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"12 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"13 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"14 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"15 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"16 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"17 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"18 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"19 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"20 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"21 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"22 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"23 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"24 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"25 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"26 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"27 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"28 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"29 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"30 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"31 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"32 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"33 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"34 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"35 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"36 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"37 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"38 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"39 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"39 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"40 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"41 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"42 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"43 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"44 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"45 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"46 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"47 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"48 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"49 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"50 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"51 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"52 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"53 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"54 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"55 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"56 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"57 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"58 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"59 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"60 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"61 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"62 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"63 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"64 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"65 \"\n", + " array.push(str, sX)\n", + " for i = 0 to 51\n", + " sX := array.get(str, i) + \"66 \"\n", + " array.push(str, sX)\n", + "\n", + "cond(y, x) => \n", + " not na(str.match(label.get_text(array.get(y, x)), \"[1-9]\"))\n", + "\n", + "cond2(y, x) =>\n", + " not na(str.match(label.get_text(array.get(y, x)), \"[10-66]\"))\n", + "\n", + "atr = ta.atr(14)\n", + "var float tickz = 0.0\n", + "ticks2 = array.new_float()\n", + "\n", + "\n", + "if ti == \"Regular\" or ti == \"Fixed Interval\"\n", + " if last_bar_index - bar_index == 1601\n", + " if syminfo.mintick >= 0.01\n", + " tickz := auto == \"Custom\" ? tickzz :\n", + " auto == \"Auto\" and timeframe.period == \"1\" ? atr * 50 :\n", + " auto == \"Auto\" and timeframe.period == \"5\" ? atr * 40 :\n", + " atr * 30\n", + " \n", + " else\n", + " tickz := auto == \"Custom\" ? tickzz : atr * 100000\n", + "else\n", + " if time < st\n", + " if syminfo.mintick >= 0.01\n", + " tickz := auto == \"Custom\" ? tickzz :\n", + " auto == \"Auto\" and timeframe.period == \"1\" ? atr * 50 :\n", + " auto == \"Auto\" and timeframe.period == \"5\" ? atr * 40 :\n", + " atr * 30 \n", + " else\n", + " tickz := auto == \"Custom\" ? tickzz : atr * 100000 \n", + "\n", + "\n", + "var line [] tpoLines = array.new_line()\n", + "ticks = array.new_float()\n", + "var float max = 0.0\n", + "var float min = 10000000\n", + "var float [] track = array.new_float()\n", + "var label [] pocL = array.new_label()\n", + "var float [] finChe = array.new_float()\n", + "var line j = line.new(time, high, time, low, color = color.aqua, width = 4, xloc = xloc.bar_time)\n", + "var int first = 0\n", + "var int firstBar = 0\n", + "max := math.max(high, max)\n", + "min := math.min(low, min)\n", + "var float ibF = 0.0\n", + "var line [] ib = array.new_line()\n", + "var label [] tpoLabels = array.new_label()\n", + "var label [] SP = array.new_label()\n", + "var line [] val = array.new_line()\n", + "var label [] VA = array.new_label()\n", + "var line ibBar = na\n", + "var linefill fil = na\n", + "var label op = label.new(time, open, xloc = xloc.bar_time, size = size.large, text_font_family = fonT, color = color.new(color.white, 100), text = \"●\", style = label.style_label_right, textcolor = color.blue)\n", + "var int timRound = 0\n", + "if session.isfirstbar_regular[4] and timRound == 0\n", + " timRound := math.round(time - time[4])\n", + "\n", + "\n", + "timeCond = switch ti\n", + " \n", + " \"Regular\" => last_bar_index - bar_index <= 1600\n", + " \"Fixed Range\" => time >= st\n", + " \"Fixed Interval\" => last_bar_index - bar_index <= 1600\n", + "\n", + "\n", + "if timeCond\n", + " \n", + " if showIb == true and ti == \"Regular\"\n", + " if time == ibF\n", + " \n", + " array.push(ib, line.new(first, max, time, max, color = color.new(col3, 50), xloc = xloc.bar_time))\n", + " array.push(ib, line.new(first, min, time, min, color = color.new(col3, 50), xloc = xloc.bar_time))\n", + " \n", + " if array.size(ib) > 1\n", + " \n", + " linefill.new(array.get(ib, 0), array.get(ib, 1), color.new(col3, 95))\n", + " \n", + " if time == ibF and ti == \"Regular\"\n", + " line.delete(ibBar)\n", + " ibBar := line.new(first, max, first, min, color = color.blue, xloc =xloc.bar_time, width = 4)\n", + "\n", + " if finTim\n", + " \n", + " if array.size(val) > 0\n", + " for i = 0 to array.size(val) - 1\n", + " line.delete(array.shift(val))\n", + " \n", + " if array.size(VA) > 0\n", + " for i = 0 to array.size(VA) - 1\n", + " label.delete(array.shift(VA))\n", + " \n", + " if array.size(track) > 0\n", + " array.clear(track)\n", + " \n", + " if array.size(finChe) > 0\n", + " array.clear(finChe)\n", + " \n", + " if array.size(ib) > 0\n", + " for i = 0 to array.size(ib) - 1\n", + " line.delete(array.shift(ib))\n", + " \n", + " if array.size(tpoLines) > 0\n", + " for i = 0 to array.size(tpoLines) - 1\n", + " line.delete(array.shift(tpoLines))\n", + " \n", + " if array.size(tpoLabels) > 0\n", + " for i = 0 to array.size(tpoLabels) - 1\n", + " label.delete(array.shift(tpoLabels))\n", + " \n", + " if array.size(SP) > 0\n", + " for i = 0 to array.size(SP) - 1\n", + " label.delete(array.shift(SP))\n", + " \n", + " if array.size(pocL) > 0\n", + " for i = 0 to array.size(pocL) - 1\n", + " label.delete(array.shift(pocL))\n", + " \n", + " max := high\n", + " min := low\n", + " \n", + " first := math.round(time)\n", + " ibF := math.round(timestamp(year, month, dayofmonth, hour + 1, minute, second))\n", + " \n", + " label.set_x(op, first), label.set_y(op, open)\n", + "\n", + "\n", + " firstBar := bar_index\n", + " array.push(ticks, low)\n", + " array.push(track, low)\n", + " for i = 1 to 500\n", + " if array.get(ticks, i - 1) + (tickz * syminfo.mintick) <= high\n", + " array.push(ticks, array.get(ticks, i - 1) + (tickz * syminfo.mintick))\n", + " else\n", + " break\n", + "\n", + " for i = 0 to array.size(ticks) - 1\n", + " array.push(tpoLines, line.new(bar_index, array.get(ticks, i) ,\n", + " bar_index + 1, array.get(ticks, i),\n", + " color = tickLevels == true ? color.new(color.lime, 75) : na, xloc = xloc.bar_index))\n", + " array.push(tpoLabels, label.new(first, array.get(ticks, i) , text = \" A\", xloc = xloc.bar_time,\n", + " color = color.new(col, 100), textcolor = col, text_font_family = fonT, style = label.style_label_left))\n", + " \n", + "if timeCond and not finTim and ti == \"Regular\"\n", + " or barstate.islast and ti == \"Fixed Range\"\n", + " or timeCond and not finTim and ti == \"Fixed Interval\" and fixTime\n", + "\n", + "\n", + " calc = max - min\n", + " var label ibav = label.new(bar_index, close, color = na, style = label.style_label_left, text_font_family = fonT)\n", + " if array.size(ib) > 1\n", + " for i = 0 to array.size(ib) - 1\n", + " line.set_x2(array.get(ib, i), time)\n", + " label.set_y(ibav, math.avg(line.get_y1(array.get(ib, 0)), line.get_y1(array.get(ib, 1))))\n", + " label.set_x(ibav, bar_index + 2)\n", + " label.set_text(ibav, \"Initial Balance Range\")\n", + " label.set_textcolor(ibav, col3)\n", + " label.set_color(ibav,color.new(color.white, 100))\n", + " else\n", + " label.set_textcolor(ibav, na)\n", + " \n", + " if array.size(VA) > 0\n", + " for i = 0 to array.size(VA) - 1\n", + " label.delete(array.shift(VA))\n", + "\n", + " if array.size(val) > 0\n", + " for i = 0 to array.size(val) - 1\n", + " line.delete(array.shift(val))\n", + " \n", + " if array.size(tpoLines) > 0\n", + " for i = 0 to array.size(tpoLines) - 1\n", + " line.delete(array.shift(tpoLines))\n", + " \n", + " if array.size(tpoLabels) > 0\n", + " for i = 0 to array.size(tpoLabels) - 1\n", + " label.delete(array.shift(tpoLabels))\n", + " if array.size(SP) > 0\n", + " for i = 0 to array.size(SP) - 1\n", + " label.delete(array.shift(SP))\n", + " \n", + " if array.size(pocL) > 0\n", + " for i = 0 to array.size(pocL) - 1\n", + " label.delete(array.shift(pocL))\n", + " \n", + " if array.size(finChe) > 0\n", + " array.clear(finChe)\n", + "\n", + "\n", + " if array.size(track) > 0\n", + " array.push(ticks, array.get(track, array.size(track) - 1))\n", + " for i = 1 to 500\n", + " if array.get(ticks, i - 1) + (tickz * syminfo.mintick) <= max\n", + " array.push(ticks, array.get(ticks, i - 1) + (tickz * syminfo.mintick))\n", + " else\n", + " break\n", + " array.push(ticks2, array.get(track, array.size(track) - 1))\n", + " for i = 1 to 500\n", + " if array.get(ticks2, i - 1) - (tickz * syminfo.mintick) >= min\n", + " array.push(ticks2, array.get(ticks2, i - 1) - (tickz * syminfo.mintick))\n", + " else\n", + " break\n", + " for i = array.size(ticks2) - 1 to 0\n", + "\n", + "\n", + " array.push(tpoLines, line.new( first, array.get(ticks2, i),\n", + "\n", + "\n", + " last_bar_time, \n", + " array.get(ticks2, i),\n", + " color = tickLevels == true ? color.new(color.lime, 75) : na,\n", + " xloc = xloc.bar_time\n", + "\n", + "\n", + " ))\n", + "\n", + "\n", + " array.push(tpoLabels, label.new( first, array.get(ticks2, i),\n", + "\n", + "\n", + " color = color.new(color.white, 100),\n", + " textcolor = col,\n", + " size = sz,\n", + " style = label.style_label_left,\n", + " xloc = xloc.bar_time ,\n", + " text_font_family = fonT\n", + " )) \n", + " for i = 0 to array.size(ticks) - 1\n", + " array.push(tpoLines, line.new( first, array.get(ticks, i),\n", + "\n", + "\n", + " last_bar_time, \n", + " array.get(ticks, i),\n", + " color = tickLevels == true ? color.new(color.lime, 75) : na,\n", + " xloc = xloc.bar_time\n", + "\n", + "\n", + " ))\n", + "\n", + "\n", + " array.push(tpoLabels, label.new( first, array.get(ticks, i),\n", + "\n", + "\n", + " color = color.new(color.white, 100),\n", + " textcolor = col,\n", + " size = sz,\n", + " style = label.style_label_left,\n", + " xloc = xloc.bar_time,\n", + " text_font_family = fonT\n", + " ))\n", + "\n", + "\n", + " if array.size(tpoLines) > 1 and bar_index - firstBar < array.size(str)\n", + " \n", + " levels = array.new_float()\n", + " che = array.new_float(array.size(tpoLines), 0)\n", + " for i = bar_index - firstBar to 0\n", + " for x = 0 to array.size(tpoLines) - 1\n", + " if line.get_y1(array.get(tpoLines, x)) <= high[i] and line.get_y1(array.get(tpoLines, x)) >= low[i]\n", + " label.set_text(array.get(tpoLabels, x),\n", + " text = label.get_text(array.get(tpoLabels, x)) + array.get(str, math.abs(bar_index - firstBar - i)))\n", + " array.set(che, x, array.get(che, x) + 1)\n", + " \n", + " \n", + " len = 0.0\n", + " for x = 0 to array.size(tpoLabels) - 1\n", + " len := math.max(len, array.get(che, x))\n", + " \n", + " lenTrack = 0\n", + " \n", + " for x = 0 to array.size(tpoLabels) - 1\n", + " \n", + " if array.get(che, x) == len\n", + " label.set_textcolor(array.get(tpoLabels, x), col2)\n", + " lenTrack := x\n", + " if bar_index - firstBar >= 4\n", + " \n", + " line.set_color(array.get(tpoLines, x), color.new(col2, 75))\n", + " line.set_width(array.get(tpoLines, x), 2)\n", + " array.push(finChe, line.get_y1(array.get(tpoLines, x)))\n", + " if array.size(finChe) == 1\n", + " array.push(pocL, label.new(first, line.get_y1(array.get(tpoLines, x)), xloc = xloc.bar_time,\n", + " color = color.new(col, 100), textcolor = col2, style = label.style_label_right, text_font_family = fonT, text = \"POC\", size = sz))\n", + " \n", + " \n", + " break\n", + " \n", + " sum = array.new_float()\n", + " sum1 = array.new_float()\n", + " lin = array.new_float()\n", + " lin1 = array.new_float()\n", + " cheX = array.new_float()\n", + " cheX1 = array.new_float()\n", + " \n", + " if lenTrack > 0\n", + " for x = lenTrack - 1 to 0\n", + " array.push(sum , array.size(sum) == 0 ? array.get(che, x) : array.get(sum, array.size(sum) - 1) + array.get(che, x))\n", + " array.push(lin, label.get_y(array.get(tpoLabels, x)))\n", + " array.push(cheX, array.get(che, x))\n", + " for x = lenTrack to array.size(che) - 1\n", + " array.push(sum1, array.size(sum1) == 0 ? array.get(che, x) : array.get(sum1, array.size(sum1) - 1) + array.get(che, x))\n", + " array.push(lin1, label.get_y(array.get(tpoLabels, x)))\n", + " array.push(cheX1, array.get(che, x))\n", + " \n", + " \n", + " miN = math.min(array.size(sum), array.size(sum1))\n", + " \n", + " \n", + " for n = 0 to miN - 1\n", + " if array.get(sum, n) + array.get(sum1, n) >= array.sum(che) * .7\n", + " array.push(val,line.new(first , array.get(lin, n), time,\n", + " array.get(lin, n), xloc = xloc.bar_time, color = color.new(col4, 75)))\n", + " \n", + " array.push(val,line.new(first, array.get(lin1, n), time,\n", + " array.get(lin1, n), xloc = xloc.bar_time, color = color.new(col4, 75)))\n", + " \n", + " array.push(VA, label.new(first, line.get_y1(array.get(val, 0)), text = line.get_y1(array.get(val, 0)) > line.get_y1(array.get(val, 1)) ? \"VAH\" : \"VAL\",\n", + " textcolor = col4, size = sz, color = color.new(color.white, 100), style = label.style_label_right, text_font_family = fonT, xloc = xloc.bar_time))\n", + " \n", + " array.push(VA, label.new(first, line.get_y1(array.get(val, 1)), text = line.get_y1(array.get(val, 0)) > line.get_y1(array.get(val, 1)) ? \"VAL\" : \"VAH\",\n", + " textcolor = col4, size = sz, color = color.new(color.white, 100), style = label.style_label_right, text_font_family = fonT, xloc = xloc.bar_time))\n", + " \n", + " \n", + " break\n", + " \n", + " if array.size(val) < 2\n", + " \n", + " stop = 0\n", + " \n", + " if miN == array.size(sum1)\n", + " \n", + " \n", + " for n = 0 to array.size(cheX1) - 1\n", + " if array.get(cheX1, n) >= math.round(len * .7)\n", + " stop := n\n", + " for n = 0 to array.size(sum) - 1 \n", + " \n", + " if array.get(sum, n) + array.get(sum1, stop) >= array.sum(che) * .7\n", + " \n", + " array.push(val,line.new(first, array.get(lin, n), time,\n", + " array.get(lin, n), xloc = xloc.bar_time, color = color.new(col4, 75)))\n", + " \n", + " array.push(val,line.new(first, array.get(lin1, stop), time,\n", + " array.get(lin1, stop), xloc = xloc.bar_time, color = color.new(col4, 75)))\n", + " \n", + " array.push(VA, label.new(first, line.get_y1(array.get(val, 0)), text = line.get_y1(array.get(val, 0)) > line.get_y1(array.get(val, 1)) ? \"VAH\" : \"VAL\",\n", + " textcolor = col4, size = sz, color = color.new(color.white, 100), text_font_family = fonT, style = label.style_label_right, xloc = xloc.bar_time))\n", + " \n", + " array.push(VA, label.new(first, line.get_y1(array.get(val, 1)), text = line.get_y1(array.get(val, 0)) > line.get_y1(array.get(val, 1)) ? \"VAL\" : \"VAH\",\n", + " textcolor = col4, size = sz, color = color.new(color.white, 100), text_font_family = fonT, style = label.style_label_right, xloc = xloc.bar_time))\n", + " \n", + " break\n", + " \n", + " else\n", + " \n", + " for n = 0 to array.size(cheX) - 1\n", + " if array.get(cheX, n) >= math.round(len * .7)\n", + " stop := n\n", + " for n = 0 to array.size(sum1) - 1 \n", + " \n", + " if array.get(sum, stop) + array.get(sum1, n) >= array.sum(che) * .7\n", + " \n", + " array.push(val,line.new(first, array.get(lin1, n), time,\n", + " array.get(lin1, n), xloc = xloc.bar_time, color = color.new(col4, 75)))\n", + " \n", + " array.push(val,line.new(first, array.get(lin, stop), time,\n", + " array.get(lin, stop), xloc = xloc.bar_time, color = color.new(col4, 75)))\n", + " \n", + " array.push(VA, label.new(first, line.get_y1(array.get(val, 0)), text = line.get_y1(array.get(val, 0)) > line.get_y1(array.get(val, 1)) ? \"VAH\" : \"VAL\",\n", + " textcolor = col4, size = sz, color = color.new(color.white, 100), text_font_family = fonT, style = label.style_label_right, xloc = xloc.bar_time))\n", + " \n", + " array.push(VA, label.new(first, line.get_y1(array.get(val, 1)), text = line.get_y1(array.get(val, 0)) > line.get_y1(array.get(val, 1)) ? \"VAL\" : \"VAH\",\n", + " textcolor = col4, size = sz, color = color.new(color.white, 100), text_font_family = fonT, style = label.style_label_right, xloc = xloc.bar_time))\n", + " \n", + " break \n", + " \n", + " if array.size(val) == 2 and array.size(pocL) > 0 and array.size(tpoLabels) > 0\n", + " fil := linefill.new(array.get(val, 0), array.get(val, 1), color = color.new(col4, 90))\n", + " \n", + " for i = 0 to array.size(tpoLabels) - 1\n", + " if line.get_y1(array.get(val, 0)) > line.get_y2(array.get(val, 1))\n", + " if label.get_y(array.get(tpoLabels, i)) <= line.get_y1(array.get(val, 0))\n", + " and label.get_y(array.get(tpoLabels, i)) >= line.get_y1(array.get(val, 1))\n", + " and label.get_y(array.get(tpoLabels, i)) != label.get_y(array.get(pocL, 0))\n", + " label.set_textcolor(array.get(tpoLabels, i), col5)\n", + " \n", + " else if label.get_y(array.get(tpoLabels, i)) == label.get_y(array.get(pocL, 0))\n", + " label.set_textcolor(array.get(tpoLabels, i), col2)\n", + " \n", + " \n", + " else\n", + " \n", + " if label.get_y(array.get(tpoLabels, i)) >= line.get_y1(array.get(val, 0) )\n", + " and label.get_y(array.get(tpoLabels, i)) <= line.get_y1(array.get(val, 1))\n", + " and label.get_y(array.get(tpoLabels, i)) != label.get_y(array.get(pocL, 0))\n", + " label.set_textcolor(array.get(tpoLabels, i), col5) \n", + " \n", + " else if label.get_y(array.get(tpoLabels, i)) == label.get_y(array.get(pocL, 0))\n", + " label.set_textcolor(array.get(tpoLabels, i), col2)\n", + " \n", + " \n", + " for x = 0 to array.size(tpoLabels) - 1\n", + " if str.length(label.get_text(array.get(tpoLabels, x))) == 2\n", + " or str.length(label.get_text(array.get(tpoLabels, x))) == 5 and cond2(tpoLabels, x) == true\n", + " or str.length(label.get_text(array.get(tpoLabels, x))) == 4 and cond(tpoLabels, x) == true\n", + " label.set_textcolor(array.get(tpoLabels, x), col1)\n", + " if bar_index - firstBar >= 4 and spShw == true\n", + " line.set_color(array.get(tpoLines, x), color.new(col1, 75))\n", + " array.push(SP, label.new(time, line.get_y1(array.get(tpoLines, x)), xloc = xloc.bar_time, color = color.new(col, 100),\n", + " style = label.style_label_left, text = \"SP\", textcolor = col1, text_font_family = fonT, size = size.tiny))\n", + " \n", + " if array.size(VA) == 2 and array.size(pocL) > 0\n", + " if label.get_y(array.get(VA, 0)) == label.get_y(array.get(pocL, 0))\n", + " label.set_x(array.get(VA, 0), first - timRound)\n", + " if label.get_y(array.get(VA, 1)) == label.get_y(array.get(pocL, 0))\n", + " label.set_x(array.get(VA, 1), first - timRound)\n", + "if ti == \"Regular\" or ti == \"Fixed Range\" \n", + " line.set_x1(j, first)\n", + " line.set_x2(j, first)\n", + " line.set_y1(j, max)\n", + " line.set_y2(j, min) \n", + "else\n", + " if fixTime \n", + " line.set_x1(j, first)\n", + " line.set_x2(j, first)\n", + " line.set_y1(j, max)\n", + " line.set_y2(j, min) \n", + "\n", + "var line [] SPCopy = array.new_line()\n", + "var line [] valCopy = array.new_line()\n", + "var label [] tpoLabelsCopy = array.new_label()\n", + "var line [] pocCopy = array.new_line()\n", + "var line [] jCopy = array.new_line()\n", + "var line [] ibBarCopy = array.new_line()\n", + "var box [] bBox = array.new_box()\n", + "\n", + "\n", + "tCnd = hour == str.tonumber(str.substring(timE, str.pos(timE, \"-\") + 1, str.length(timE) - 2))\n", + " and minute == str.tonumber(str.substring(timE, str.pos(timE, \"-\") + 3))\n", + "\n", + "\n", + "if session.islastbar and barstate.isconfirmed\n", + " and timeCond and ti == \"Regular\" and array.size(tpoLabels) > 0\n", + " and showPre == true\n", + " or tCnd and barstate.isconfirmed and timeCond and ti == \"Fixed Interval\"\n", + " and array.size(tpoLabels) > 0 and showPre == true\n", + " \n", + " if blackBox == true \n", + " array.push(bBox, box.new(first, max, time, min, xloc = xloc.bar_time, bgcolor = #000000, border_color = na))\n", + " if rang == true\n", + "\n", + "\n", + " array.push(jCopy, line.copy(j))\n", + " array.push(ibBarCopy, line.copy(ibBar))\n", + " if array.size(val) > 0 and distCalc2 != 0\n", + " for i = 0 to array.size(val) - 1\n", + " array.push(valCopy, line.copy(array.get(val, i)))\n", + "\n", + "\n", + " if array.size(tpoLabels) > 0\n", + " for i = 0 to array.size(tpoLabels) - 1\n", + " array.push(tpoLabelsCopy, label.copy(array.get(tpoLabels, i)))\n", + " if label.get_y(array.get(tpoLabels, i)) == label.get_y(array.get(pocL, 0))\n", + " array.push(pocCopy, line.copy(array.get(tpoLines, i)))\n", + " \n", + " if array.size(SP) > 0 and distCalc != 0\n", + " for i = 0 to array.size(SP) - 1\n", + " array.push(SPCopy, line.new(first, label.get_y(array.get(SP, i)), time, label.get_y(array.get(SP, i)), xloc = xloc.bar_time, color = color.new(col1, 80)))\n", + " \n", + "\n", + "\n", + "if array.size(SPCopy) > 0\n", + " for i = 0 to array.size(SPCopy) - 1\n", + " if line.get_y1(array.get(SPCopy, i)) <= high and line.get_y1(array.get(SPCopy, i)) >= low \n", + " line.delete(array.get(SPCopy, i))\n", + " else\n", + " if math.abs((close / line.get_y1(array.get(SPCopy, i))- 1)* 100) <= distCalc\n", + " line.set_x2(array.get(SPCopy, i), time)\n", + " else if math.abs((close / line.get_y1(array.get(SPCopy, i)) - 1)* 100) >= distCalc\n", + " line.set_x2(array.get(SPCopy, i), line.get_x1(array.get(SPCopy, i)))\n", + " \n", + "if array.size(valCopy) > 0\n", + " for i = 0 to array.size(valCopy) - 1\n", + " if line.get_y1(array.get(valCopy, i)) <= high and line.get_y1(array.get(valCopy, i)) >= low \n", + " line.delete(array.get(valCopy, i))\n", + " else if math.abs((close / line.get_y1(array.get(valCopy, i))- 1)* 100) <= distCalc2\n", + " line.set_x2(array.get(valCopy, i), time)\n", + " else if math.abs((close / line.get_y1(array.get(valCopy, i)) - 1)* 100) >= distCalc2\n", + " line.set_x2(array.get(valCopy, i), line.get_x1(array.get(valCopy, i)))\n", + "\n", + "\n", + "if array.size(pocCopy) > 0\n", + " for i = 0 to array.size(pocCopy) - 1\n", + " if line.get_y1(array.get(pocCopy, i)) <= high and line.get_y1(array.get(pocCopy, i)) >= low \n", + " line.delete(array.get(pocCopy, i))\n", + " else if math.abs((close / line.get_y1(array.get(pocCopy, i))- 1)* 100) <= distCalc3\n", + " line.set_x2(array.get(pocCopy, i), time)\n", + " else if math.abs((close / line.get_y1(array.get(pocCopy, i)) - 1)* 100) >= distCalc3\n", + " line.set_x2(array.get(pocCopy, i), line.get_x1(array.get(pocCopy, i)))\n", + "\n", + "\n", + "if array.size(tpoLabelsCopy) > 500\n", + " for i = 0 to array.size(tpoLabelsCopy) - 500\n", + " label.delete(array.shift(tpoLabelsCopy))\n", + " if array.size(ibBarCopy) > 1\n", + " line.delete(array.shift(ibBarCopy))\n", + " line.delete(array.shift(jCopy))\n", + " if array.size(bBox) > 1\n", + " box.delete(array.shift(bBox))\n", + "\n", + "\n", + "tf = input.timeframe(\"D\", title = \"Timeframe\", inline = \"0\", group = \"PROFILE SETTINGS\")\n", + "\n", + "\n", + "vap = input.float(70, title = \"Value Area %\", group = \"PROFILE SETTINGS\")/100\n", + "lb_days = input.int(5, title = \"# of Profiles\", maxval = 20, minval = 1, tooltip = \"Max: 20 \\nLarge Display = Less Granular Profiles\\nSmall Display = More Granular Profiles\")\n", + "mp = input.bool(false, title = \"Calculate As Market Profile\", group = \"PROFILE SETTINGS\", tooltip = \"Calculations will distribue a 1 instead of the candle's volume.\")\n", + "\n", + "\n", + "disp_size = input.int(-10, minval = -500,maxval = 500,title = \"Display Size \", inline = \"3\", group = \"DISPLAY SETTINGS\", tooltip = \"The entire range of your profile will scale to fit inside this range.\\n When Positive, the profile will display from the start of the day. \\n When Negative, the profile will display from the end of the day.\\nNotes:\\n-This value is # bars away from your profile's Axis.\\n-The farther from 0 this value is, the more granular your (horizontal) view will be. This does not change the Profiles' value; because of this, sometimes the POC looks tied with other values widely different. The POC CAN be tied to values close to it, but if the value is far away it is likely to just be a visual constraint. \\n AUTO SCALE - Fits the profile within the lookback period.\")\n", + "auto_size = input.bool(true, title = \"Auto-Scale\", inline = \"3\", group = \"DISPLAY SETTINGS\")\n", + "\n", + "\n", + "hi_width = input.int(10, maxval = 100, minval = 1,title = \"[HVN] Analysis Width %   ↕\", group = \"High/Low Volume Nodes\", tooltip = \"[HVN] = High Volume Node\\nAnalysis Width % = % of profile to take into account when determining what is a High Volume Node and what is Not.\")*0.01\n", + "lo_width = input.int(10, maxval = 100, minval = 1, title = \"[LVN] Analysis Width %   ↕\", group = \"High/Low Volume Nodes\", tooltip = \"[LVN] = Low Volume Node\\nAnalysis Width % = % of profile to take into account when determining what is a Low Volume Node and what is Not.\")*0.01\n", + "\n", + "\n", + "poc_color = input.color(#d3be00, title = \"POC Color\", group = \"Colors\")\n", + "var_color = input.color(#886000, title = \"Value High/Low Color\", group = \"Colors\")\n", + "vaz_color = input.color(color.new(#886000,0), title = \"Value Zone Color\", group = \"Colors\")\n", + "ov_color = input.color(#886000, title = \"Profile Color\", group = \"Colors\")\n", + "lv_color = input.color(#886000, title = \"Low Volume Color\", group = \"Colors\")\n", + "hv_color = input.color(#886000, title = \"High Volume Color\", group = \"Colors\")\n", + "\n", + "\n", + "fix_z(_val) => _val>0?_val:1\n", + "\n", + "\n", + "round_to(_round,_to) =>\n", + " math.round(_round/_to)*_to\n", + "\n", + "\n", + "vgroup_pull(_var,_array,_num1,_num2) =>\n", + " _var == 1 and _num1>=_num2?array.get(_array,_num1-_num2):\n", + " _var == 2 and array.size(_array)-1 >= (_num1 + _num2)?array.get(_array,_num1+_num2)\n", + " :0\n", + "\n", + "\n", + "prof_color(_num,_mv,_a1,_a2,_a3,_a4) =>\n", + " _num==0?na:\n", + " _num==_mv?poc_color:\n", + " (_num==_a3 or _num==_a4)?var_color:\n", + " array.includes(_a1,_num) and array.includes(_a2,_num)?((_num>_a3 or _num<_a4)?ov_color:vaz_color):\n", + " array.includes(_a2,_num)?lv_color:\n", + " array.includes(_a1,_num)?hv_color:\n", + " (_num>_a3 or _num<_a4)?ov_color:\n", + " vaz_color \n", + "\n", + "\n", + "var line_array = array.new_line(na)\n", + "var box_array = array.new_box(na)\n", + "\n", + "\n", + "kill_bar = ta.valuewhen(timeframe.change(tf),bar_index,lb_days+1)+1\n", + "if array.size(line_array) > 0\n", + " for i = array.size(line_array)-1 to 0\n", + " ln = array.get(line_array,i)\n", + " lx = line.get_x1(ln)\n", + " if lx <= kill_bar\n", + " line.delete(ln)\n", + " array.remove(line_array,i)\n", + "if array.size(box_array) > 0\n", + " for i = array.size(box_array)-1 to 0\n", + " bx = array.get(box_array,i)\n", + " bl = box.get_left(bx)\n", + " if bl <= kill_bar or na(bl)\n", + " box.delete(bx)\n", + " array.remove(box_array,i)\n", + "if array.size(label.all) > 0\n", + " for i = array.size(label.all)-1 to 0\n", + " lb = array.get(label.all,i)\n", + " lx = label.get_x(lb)\n", + " if lx <= kill_bar\n", + " label.delete(lb)\n", + " array.remove(label.all,i)\n", + "\n", + "\n", + "get_prof(_mp,_tf) =>\n", + " new_calc = timeframe.change(_tf)\n", + " last_new_calc = ta.valuewhen(new_calc,bar_index,1)\n", + " index_num = math.floor(1000/lb_days)-1\n", + " start_time = request.security(\"\",_tf,ta.valuewhen(bar_index == last_bar_index-lb_days,time,0))\n", + " calc_bars = (bar_index - ta.valuewhen(new_calc,bar_index,0))[1]+1\n", + " base = ta.lowest(low,fix_z(calc_bars)+1)[1]\n", + " roof = ta.highest(high,fix_z(calc_bars)+1)[1]\n", + " tick_size = round_to(math.max(((roof - base)/index_num),syminfo.mintick),(syminfo.mintick/100))\n", + " c_hi = round_to(high,tick_size)\n", + " c_lo = round_to(low,tick_size)\n", + " candle_range = c_hi - c_lo\n", + " candle_index = (candle_range/tick_size)+1\n", + " tick_vol = _mp?1:volume/candle_index\n", + " main = array.new_float(na)\n", + " hvn_points = array.new_int(na)\n", + " lvn_points = array.new_int(na)\n", + " if new_calc and time >= start_time\n", + " for i = 0 to index_num\n", + " index_price = base + (i*tick_size)\n", + " if index_price >= roof\n", + " break\n", + " float index_sum = 0\n", + " for e = 1 to calc_bars\n", + " if index_price <= c_hi[e] and index_price >= c_lo[e]\n", + " index_sum := index_sum + tick_vol[e]\n", + " array.push(main,index_sum)\n", + " max_index = math.round(math.avg(array.indexof(main,array.max(main)),array.lastindexof(main,array.max(main))))\n", + " poc = base + (tick_size*max_index)\n", + " max_vol = array.sum(main)*vap\n", + " vol_count = max_index >=0?array.get(main, max_index):0.0\n", + " up_count = max_index\n", + " down_count = max_index\n", + " if array.size(main) > 0\n", + " for x = 0 to array.size(main)-1\n", + " if vol_count >= max_vol\n", + " break \n", + " uppervol = up_count0?array.get(main, down_count - 1):na\n", + " if ((uppervol >= lowervol) and not na(uppervol)) or na(lowervol)\n", + " vol_count += uppervol\n", + " up_count += 1\n", + " else \n", + " vol_count += lowervol\n", + " down_count -= 1\n", + " val = base + (tick_size*down_count)\n", + " vah = base + (tick_size*up_count)\n", + " uc = up_count\n", + " dc = down_count\n", + " \n", + "\n", + " ///////////////////////////////\n", + " //Cluster ID for Volume Nodes//\n", + " ///////////////////////////////\n", + " \n", + " if array.size(main) > 0\n", + " for i = 0 to array.size(main)-1 \n", + " _val = array.get(main,i) \n", + " ary = array.new_float(na) \n", + " for e = 0 to int(array.size(main)*hi_width) \n", + " array.push(ary,vgroup_pull(1,main,i,e)) \n", + " array.push(ary,vgroup_pull(2,main,i,e)) \n", + " max = array.max(ary) \n", + " if _val >= math.avg(max,array.avg(ary)) \n", + " array.push(hvn_points,i) \n", + "\n", + "\n", + " if array.size(main) > 0 \n", + " for i = 0 to array.size(main)-1\n", + " _val = array.get(main,i)\n", + " ary = array.new_float(na)\n", + " for e = 0 to int(array.size(main)*lo_width) \n", + " array.push(ary,vgroup_pull(1,main,i,e))\n", + " array.push(ary,vgroup_pull(2,main,i,e))\n", + " min = array.min(ary)\n", + " if _val <= math.avg(min,array.avg(ary)) \n", + " array.push(lvn_points,i)\n", + " ///_________________________________________\n", + " ///Cluster Merging\n", + " ///‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n", + " merge_per = 0.02\n", + " if array.size(hvn_points)>0\n", + " for i = 0 to array.size(hvn_points)-1\n", + " hi_found = false\n", + " lo_found = false\n", + " _val = array.get(hvn_points,i)\n", + " for e = int(array.size(main)*merge_per) to 0\n", + " if array.includes(hvn_points,_val+e)\n", + " hi_found := true\n", + " if hi_found\n", + " array.push(hvn_points,_val+e)\n", + " if array.includes(hvn_points,_val-e)\n", + " lo_found := true\n", + " if lo_found\n", + " array.push(hvn_points,_val-e)\n", + "\n", + "\n", + " if array.size(lvn_points)>0\n", + " for i = 0 to array.size(lvn_points)-1\n", + " hi_found = false\n", + " lo_found = false\n", + " _val = array.get(lvn_points,i)\n", + " for e = int(array.size(main)*merge_per) to 0\n", + " if array.includes(lvn_points,_val+e)\n", + " hi_found := true\n", + " if hi_found\n", + " array.push(lvn_points,_val+e)\n", + " if array.includes(lvn_points,_val-e)\n", + " lo_found := true\n", + " if lo_found\n", + " array.push(lvn_points,_val-e)\n", + " prof_axis = disp_size>0?last_new_calc:bar_index[1]\n", + " display_size = auto_size and disp_size!=0?(disp_size/math.abs(disp_size))*(calc_bars-1):disp_size\n", + " \n", + "\n", + " if array.size(main) > 0\n", + " for i = 0 to array.size(main) - 1\n", + " scale = display_size/array.max(main)\n", + " scaled = math.round(array.get(main,i)*scale)\n", + " if ((i>uc) or (iuc?line.style_dotted:line.style_solid)))\n", + " else if ((i<=uc) or (i>=dc)) and (array.size(box_array) <= 499)\n", + " array.push(box_array,box.new(prof_axis,base+(i*tick_size[1]),(prof_axis+scaled),base+(i*tick_size[1]), border_color = prof_color(i,max_index,hvn_points,lvn_points,uc,dc), border_style = (iuc?line.style_dotted:line.style_solid), border_width = 1))\n", + " else if (array.size(line_array) <= 499)\n", + " array.push(line_array,line.new(prof_axis,base+(i*tick_size[1]),(prof_axis+scaled),base+(i*tick_size[1]), color = prof_color(i,max_index,hvn_points,lvn_points,uc,dc), style = (iuc?line.style_dotted:line.style_solid)))\n", + " else if (array.size(box_array) <= 499)\n", + " array.push(box_array,box.new(prof_axis,base+(i*tick_size[1]),(prof_axis+scaled),base+(i*tick_size[1]), border_color = prof_color(i,max_index,hvn_points,lvn_points,uc,dc), border_style = (iuc?line.style_dotted:line.style_solid), border_width = 1))\n", + " \n", + "get_prof(mp,tf)\n" + ] + }, + { + "cell_type": "markdown", + "id": "831b7fc1", + "metadata": {}, + "source": [ + "## And slight adjustments on the chart settings \n", + "\n", + "**Go to TradingView setting and set:**\n", + "\n", + "Chart backgrounf into black.\n", + "\n", + "Set high-low candle chart, color it white.\n", + "\n", + "Disable all status lines. *(if you wanna make the sides simple-looking)*\n", + "\n", + "Make scales and lines hidde. *(for simple GUIs)*\n", + "\n", + "Disable gridlines.\n", + "\n", + "Disable all events.\n", + "\n", + "Disable all trading alerts. *(if you trade on unsupported broker, like exness)*\n" + ] + }, + { + "cell_type": "markdown", + "id": "7a89030a", + "metadata": {}, + "source": [ + "## The chart will look like this, (30minute chart for example)\n", + "\n", + "![img](https://github.com/algorembrant/Pinescript.TradingView-Indicators.and.Strategies/blob/main/Images/Screenshot%202025-11-15%20184043.png?raw=true)" + ] + }, + { + "cell_type": "markdown", + "id": "6f4785ff", + "metadata": {}, + "source": [ + "## Features\n", + "\n", + "1. Candle logic, 6am and 8am daliy candle formation overview.\n", + "2. Horizontal Zones logic, session times.\n", + "3. Hourly logic, sees higher timeframes formation while being at lower timeframes.\n", + "4. VWAP logic.\n", + "5. Table logic, presents the data statistics.\n", + "6. Intraday TPO & volume profile logic\n", + "7. Weekly TPO & volume profiles logic" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "89b77b18", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "id": "6be033c4", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}