Bitgak Korean Indicator Analysis

				
					// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © osprey0                                                
//              ██████╗ ███████╗██████╗ ██████╗ ███████╗██╗   ██╗
//            ██╔═══██╗██╔════╝██╔══██╗██╔══██╗██╔════╝╚██╗ ██╔╝
//            ██║   ██║███████╗██████╔╝██████╔╝█████╗   ╚████╔╝ 
//            ██║   ██║╚════██║██╔═══╝ ██╔══██╗██╔══╝    ╚██╔╝  
//            ╚██████╔╝███████║██║     ██║  ██║███████╗   ██║   
//             ╚═════╝ ╚══════╝╚═╝     ╚═╝  ╚═╝╚══════╝   ╚═╝                                                                              
//                                                                  ░░          
//       ░▒░░▒░                                                 ░▒▓▒░░░▒▓░      
//       ░█████▓▒░                                            ░▒░   ░▓░░░░      
//         ░▒▓▓▓▓▒         █████▓▒                    ░░▒            ░▓▒░       
//            ░░░           ▓███████              ░▒█▓██▓░░░                    
//                        ░░░ ░▒▓███▓░          ░▒▓███▒  ░░       ░░            
//                           ░▓████▓░▒         ▓▒██▓▒░░░░                       
//                       ░░▒▓██████▒░▒░      ░▓░▓████▒░                         
//                       ░░▓███████▓░░▒      ▓░▓████▓█▒▒░ ░░                    
//                         ░▓██████▓▒ ░░    ░▓▒███████▓▓░░░                     
//                           ███████▓▒ ░   ░█░▒▓███░                            
//                           ▒████▓█▓░  ▒  ▓█░▒█░                               
//                           ░▒█████▓█▒ ▒████▒▒                                 
//                            ░▓▒▒████▒░▒█▒                                     
//                               ░░░▒▓░ ▒▓▓▒▓▒                                  
//                                  ░  ░░▒▒░░▓░                                 
//                                 ░▒░░░░░░ ░                                   
//                              ░░▒▒░░░░▒░ ░▒░░░                                
//                           ░░░░▒▒▒░▓▓▒▒░░░▒▓▓░░                               
//                          ░▒▓▓▒▒▒▒ ▓▓▒▒ ▓░░░                                  
//                             ▒▓▓░▒▓▓░░░░                                      
// to L.L.

//@version=6
indicator("Bitgak [Osprey]", overlay=true, max_labels_count=500)                                                                          

// TYPE DEFINITIONS AND CONSTANTS


// ===== TYPES =====
type Point
    int time
    float price

type Pivot
    float   price
    int     index
    string  kind     // "HIGH" or "LOW"
    float   prominence

type ChannelCandidate
    Pivot   pivotA
    Pivot   pivotB
    string  kind                // "SUPPORT" or "RESISTANCE"
    int     score               // how many pivots this channel hits
    Pivot   pivotC              // This is the top pivot (if A,B are support) or bottom pivot (if A,B are resistance)
    float   pivotC_multiplier   // This is \in [-6.0, -5.5, ..., 0, ..., 5.5, 6.0]. It's the multiplier where that line is the line including pivotC


// ===== INPUTS =====
// Pivot Detection Settings
shortPivotMargin    = input.int(7, "Short-term Pivot Bars", minval=1, maxval=50, tooltip="Number of bars on each side to confirm a short-term pivot. Lower = more sensitive, more pivots detected.", group="Pivot Detection")
longPivotMargin     = input.int(17, "Long-term Pivot Bars", minval=1, maxval=200,tooltip="Number of bars on each side to confirm a major pivot. Higher = only significant peaks/troughs detected.",group="Pivot Detection")

// Bitgak Heuristics
// automatic_lookback  = input.bool(true, "Auto Lookback", tooltip="Automatically use all available chart history. Disable to set custom lookback period.",group="Bitgak Heuristics")
lookback            = input.int(300, "Manual Lookback Bars", minval=100, maxval=5000,tooltip="Only used when Auto Lookback is disabled. Number of historical bars to analyze.",group="Bitgak Heuristics")
L                   = input.int(1, "Top Anchors to Test (L)", minval=1, maxval=5,tooltip="Lines adjust to touch 'L' highest peaks and 'L' lowest peaks. Higher L isn't necessarily better. If L = 1, the line will try to fit the highest and the lowest pivot",group="Bitgak Heuristics")
hit_epsilon         = input.float(0.01, "Hit Tolerance (%)", minval=0.001, maxval=0.1, step=0.001,tooltip="How close a pivot must be to a line to count as a 'hit'. 0.02 = within 2% of price. Lower = stricter.",group="Bitgak Heuristics")

// Channel Line Settings
f_min               = input.float(-4.0, "Min Line Multiplier", minval=-10.0, maxval=0.0, step=0.5,tooltip="Lowest channel line to draw (e.g., -5.0 means 5 lines below base)",group="Channel Lines")
f_max               = input.float(4.0, "Max Line Multiplier", minval=0.0, maxval=10.0, step=0.5,tooltip="Highest channel line to draw (e.g., 5.0 means 5 lines above base)",group="Channel Lines")
f_step              = input.float(0.5, "Line Spacing", minval=0.1, maxval=1.0, step=0.1,tooltip="Distance between lines. 0.5 = draw at 0.5, 1.0, 1.5, etc. Smaller = more lines.",group="Channel Lines")

// Visualization Group
draw_lines          = input.bool(true, "Show Bitgak Lines", tooltip="Display the lines", group="Display Options")
draw_pivots         = input.bool(false, "Show All Pivots", tooltip="Display markers for all detected pivots (can be cluttered on busy charts)",group="Display Options")
draw_touch_pivots   = input.bool(true, "Highlight Touching Pivots",tooltip="Mark pivots that touch any Bitgak channel line with colored circles",group="Display Options")

// ===== DESIGN & PREFS =====
color   ORANGE              = input.color(color.rgb(255, 123, 34), "Main Color", group = "Color Settings")
color   PIVOT_TOUCH_COLOR   = input.color(color.rgb(255, 122, 45), "Major Pivot Touch Color", group = "Color Settings")
color   SUBCOLOR            = color.white
color   HIGH_COLOR          = input.color(color.rgb(76, 175, 80), "Small Peak Pivot", group = "Color Settings")     // Green for peaks
color   LOW_COLOR           = input.color(color.rgb(255, 82, 82), "Small Trough Pivot", group = "Color Settings")   // Red for troughs


// ===== VARIABLES =====

var line_ns = (f_max - f_min) / f_step      // # of bitgak lines

var shortPivots     = array.new<Pivot>()    // just small peak and troughs
var longPivots      = array.new<Pivot>()    // major peak and troughs
var longPeaks       = array.new<Pivot>()    // major peaks
var longThroughs    = array.new<Pivot>()    // major troughs
var highestPeaks    = array.new<Pivot>()    // L highest long peaks
var lowestTroughs   = array.new<Pivot>()    // L lowest long troughs


var channelCandidates = array.new<ChannelCandidate>()


// === FUNCTIONS ===
f_detect_pivot(margin, pivot_arr) =>
    // Only attempt detection once we have enough history
    if bar_index > 2 * margin
        // the candidate pivot is the bar at position `rightBars` (confirmed)
        candIndex = bar_index - margin
        candHigh  = high[margin]
        candLow   = low[margin]

        // check left and right neighbors
        isHigh = true
        isLow  = true

        // check left side
        for i = 1 to margin
            if high[margin + i] >= candHigh
                isHigh := false
            if low[margin + i] <= candLow
                isLow := false

        // check right side
        for i = 1 to margin
            if high[margin - i] >= candHigh
                isHigh := false
            if low[margin - i] <= candLow
                isLow := false

        // when we find a pivot, store values AND create a label exactly once
        if isHigh
            newPivot = Pivot.new(candHigh, candIndex, "HIGH", na)
            array.push(pivot_arr, newPivot)
            if draw_pivots
                if margin == shortPivotMargin
                    label.new(x = newPivot.index,y = newPivot.price,text = "H",style = label.style_circle,textcolor = color.white,color = HIGH_COLOR,size = size.tiny)
                else if margin == longPivotMargin
                    label.new(x = newPivot.index,y = newPivot.price,text = "H",style = label.style_circle,textcolor = color.white,color = ORANGE,size = size.tiny)

        if isLow
            newPivot = Pivot.new(candLow, candIndex, "LOW", na)
            array.push(pivot_arr, newPivot)
            if draw_pivots
                if margin == shortPivotMargin
                    label.new(x = newPivot.index,y = newPivot.price,text = "L",style = label.style_circle,textcolor = color.white,color = LOW_COLOR,size = size.tiny)
                else if margin == longPivotMargin
                    label.new(x = newPivot.index,y = newPivot.price,text = "L",style = label.style_circle,textcolor = color.white,color = ORANGE,size = size.tiny)



// Function to calculate perpendicular distance from point to line
f_perpendicular_distance(pivotE, pivotA, slope, intercept) =>
    // Line equation: y = slope * x + intercept
    // Point: (pivotE.index, pivotE.price)
    // Perpendicular distance: |slope*x - y + intercept| / sqrt(slope^2 + 1)
    numerator = math.abs(slope * pivotE.index - pivotE.price + intercept)
    denominator = math.sqrt(slope * slope + 1)
    numerator / denominator

// Function to calculate vertical distance from a point to line
f_vertical_distance(pivotE, slope, intercept) =>
    verticalDistance = pivotE.price - (pivotE.index * slope + intercept)
    math.abs(verticalDistance)

// Function to calculate line intercept given slope and a point
f_line_intercept(pivot, slope) =>
    // y = slope * x + intercept
    // intercept = y - slope * x
    pivot.price - slope * pivot.index

// Tests if pivotE is within any of the bitgak lines by testing all lines with different multipliers
f_pivot_in_bitgak(pivotE, slope, intercept, unitSpacing) =>
    bool found = false

    // test for all bitgak lines
    for mult = f_min to f_max by f_step
        bitgak_intercept = intercept + unitSpacing * mult
        bitgak_slope = slope

        if f_vertical_distance(pivotE, bitgak_slope, bitgak_intercept) <= pivotE.price * hit_epsilon
            found := true
            break
    found

f_find_lowest_highest_pivots(longPivots, lowestTroughs, highestPeaks) =>
    // Build sorted arrays by inserting pivots in sorted order
    for i = 0 to array.size(longPivots) - 1
        pivot = array.get(longPivots, i)
        
        if pivot.kind == "HIGH"
            // Insert into highestPeaks maintaining descending order
            inserted = false
            
            // Only loop if array is not empty
            if array.size(highestPeaks) > 0
                for j = 0 to array.size(highestPeaks) - 1
                    if pivot.price > array.get(highestPeaks, j).price
                        array.insert(highestPeaks, j, pivot)
                        inserted := true
                        break
            
            // If not inserted and we have room, add to end
            if not inserted and array.size(highestPeaks) < L
                array.push(highestPeaks, pivot)
            
            // Keep only top L
            if array.size(highestPeaks) > L
                array.pop(highestPeaks)
        
        else if pivot.kind == "LOW"
            // Insert into lowestTroughs maintaining ascending order
            inserted = false
            
            // Only loop if array is not empty
            if array.size(lowestTroughs) > 0
                for j = 0 to array.size(lowestTroughs) - 1
                    if pivot.price < array.get(lowestTroughs, j).price
                        array.insert(lowestTroughs, j, pivot)
                        inserted := true
                        break
            
            // If not inserted and we have room, add to end
            if not inserted and array.size(lowestTroughs) < L
                array.push(lowestTroughs, pivot)
            
            // Keep only top L
            if array.size(lowestTroughs) > L
                array.pop(lowestTroughs)

// given candidate, test all the different Bitgak lines with all possible pivotC and record the best result
f_best_fit(ChannelCandidate candidate) =>
    bestScore = 0
    bestPivotC = Pivot.new(na, na, na, na)
    bestMultiplier = 0.0
    
    // Determine which pivot array to use for pivotC based on channel kind
    pivotsToTest = candidate.kind == "SUPPORT" ? longPeaks : longThroughs
    
    // Try each potential pivotC
    for c = 0 to array.size(pivotsToTest) - 1
        testPivotC = array.get(pivotsToTest, c)
        
        // Skip if pivotC is same as pivotA or pivotB
        if testPivotC.index == candidate.pivotA.index or testPivotC.index == candidate.pivotB.index
            continue
        
        // Calculate base slope from pivotA to pivotB
        baseSlope = (candidate.pivotB.price - candidate.pivotA.price) / (candidate.pivotB.index - candidate.pivotA.index)
        baseIntercept = f_line_intercept(candidate.pivotA, baseSlope)
        
        // Calculate vertical distance from pivotC to base line (A-B line)
        distC = f_vertical_distance(testPivotC, baseSlope, baseIntercept)

        // Try different multipliers for pivotC line (0.5, 1.0, 1.5, ..., 5.0)
        for mult = 1.0 to f_max by f_step
            // Calculate what the unit spacing would be if pivotC is on line mult
            unitSpacing = distC / mult
            
            // Now test all hits by iterating over all pivots and checking if any of them are within
            // V_e(line.slope * x + line.intercept) of the line with the given slope and intercept
            totalHits = 0
            
            // score shortPivot hits
            for p = 0 to array.size(shortPivots) - 1
                pivotE = array.get(shortPivots, p)
                if f_pivot_in_bitgak(pivotE, baseSlope, baseIntercept, unitSpacing)
                    totalHits += 1
            
            // score longPivot hits
            for p = 0 to array.size(longPivots) - 1
                pivotE = array.get(longPivots, p)
                if f_pivot_in_bitgak(pivotE, baseSlope, baseIntercept, unitSpacing)
                    totalHits += 2
            
            // some heuristics for better Bitgak lines:
            // 1. if there are more than 2 pivots in one line, it's a strong line.
            // TODO: possibly implement in the next version update

            // 2. if it encompasses the topmost or bottommost pivot, it is good.
            for pivotE in highestPeaks
                
                if f_pivot_in_bitgak(pivotE, baseSlope, baseIntercept, unitSpacing)
                    totalHits += 20

            for pivotE in lowestTroughs
                if f_pivot_in_bitgak(pivotE, baseSlope, baseIntercept, unitSpacing)
                    totalHits += 20
            
            // If this configuration scores better, update best
            if totalHits > bestScore
                bestScore := totalHits
                bestPivotC := testPivotC
                bestMultiplier := mult
    
    
    // Update the candidate with best results
    candidate.score := bestScore
    candidate.pivotC := bestPivotC
    candidate.pivotC_multiplier := bestMultiplier
    
    [bestScore, bestPivotC, bestMultiplier]


f_mark_hitting_pivots(bestCandidate, slope, intercept, unitSpacing) =>
    
    // Check all shortPivots
    for i = 0 to array.size(shortPivots) - 1
        pivot = array.get(shortPivots, i)
        
        // Test if this pivot hits any bitgak line
        for mult = f_min to f_max by f_step
            bitgak_intercept = intercept + unitSpacing * mult
            dist = f_vertical_distance(pivot, slope, bitgak_intercept)
            threshold = pivot.price * hit_epsilon
            
            if dist <= threshold
                // Mark with the multiplier number
                label.new(x = pivot.index,y = pivot.price,text = str.tostring(mult, "#.#"),style = label.style_circle,color = PIVOT_TOUCH_COLOR,textcolor = color.white,size = size.tiny)
                break
    
    // Check all longPivots
    for i = 0 to array.size(longPivots) - 1
        pivot = array.get(longPivots, i)
        
        // Test if this pivot hits any bitgak line
        for mult = f_min to f_max by f_step
            bitgak_intercept = intercept + unitSpacing * mult
            dist = f_vertical_distance(pivot, slope, bitgak_intercept)
            threshold = pivot.price * hit_epsilon
            
            if dist <= threshold
                // Mark with the multiplier number
                label.new(x = pivot.index,y = pivot.price,text = str.tostring(mult, "#.#"),style = label.style_circle,color = PIVOT_TOUCH_COLOR,textcolor = color.white,size = size.tiny)
                break


// Function to draw the best channel - simple version
f_draw_best_channel(array<ChannelCandidate> candidates) =>
    if array.size(candidates) == 0
        na
    else
        // Find best candidate
        bestCandidate = array.get(candidates, 0)
        for i = 1 to array.size(candidates) - 1
            candidate = array.get(candidates, i)
            if candidate.score > bestCandidate.score
                bestCandidate := candidate

        log.info("Best candidate has score of " + str.tostring(bestCandidate.score) + " with A = " + str.tostring(bestCandidate.pivotA.price) + "and B = " + str.tostring(bestCandidate.pivotB.price) + " and C = " + str.tostring(bestCandidate.pivotC.price) + " with multiplier = " + str.tostring(bestCandidate.pivotC_multiplier))
        
        // Calculate geometry
        slope = (bestCandidate.pivotB.price - bestCandidate.pivotA.price) / (bestCandidate.pivotB.index - bestCandidate.pivotA.index)
        intercept = bestCandidate.pivotA.price - slope * bestCandidate.pivotA.index
        
        // Calculate unit spacing
        distC = f_vertical_distance(bestCandidate.pivotC, slope, intercept)
        unitSpacing = distC / bestCandidate.pivotC_multiplier

        // Draw lines
        endBar = bar_index + 50
        startBar = math.min(bestCandidate.pivotA.index, bestCandidate.pivotB.index, bestCandidate.pivotC.index) - 100

        for mult = f_min to f_max by f_step
            y1 = slope * startBar + (intercept + mult * unitSpacing)
            y2 = slope * endBar + (intercept + mult * unitSpacing)
            
            if draw_lines
                line.new(startBar, y1, endBar, y2, color=ORANGE, style = line.style_dashed, width= 1)
            
                // Add label at the end of each line showing the multiplier
                label.new(x = endBar+2, y = y2,text = str.tostring(mult, "#.#"),style = label.style_none,textcolor = ORANGE,size = size.small,textalign = text.align_left)

        // draw marks for pivots that touch any line
        if draw_touch_pivots
            f_mark_hitting_pivots(bestCandidate, slope, intercept, unitSpacing)



// TODO: fix this
// === FIND THE BEST LOOKBACK PERIOD
// if automatic_lookback
//     lookback := 300


// === PIVOT DETECTION ===
// For the lookback period, find the pivots
if bar_index >= last_bar_index - lookback
    f_detect_pivot(shortPivotMargin, shortPivots)
    f_detect_pivot(longPivotMargin, longPivots)

// TODO: possible next update - add the recent pivots that aren't checked because of detection margin.
// if bar_index + lookback < last_bar_index
//     recent_lowest = Pivot.new(na, na, na, na)
//     recent_highest = Pivot.new(na, na, na, na)

//     if barstate.islast
//         array.push(longPivots, recent_lowest)
//         array.push(longPivots, recent_highest)
        
    


// === CORE MECHANISM (ran once in the last bar)
if barstate.islast
    
    // Separate longPivots into Peaks and Troughs
    array.clear(longPeaks)
    array.clear(longThroughs)

    for i = 0 to array.size(longPivots) - 1
        pivot = array.get(longPivots, i)
        
        if pivot.kind == "HIGH"
            array.push(longPeaks, pivot)
        else if pivot.kind == "LOW"
            array.push(longThroughs, pivot)

    // find L highest peaks and lowest troughs
    array.clear(highestPeaks)
    array.clear(lowestTroughs)
    
    f_find_lowest_highest_pivots(longPivots, lowestTroughs, highestPeaks)


    // ===== GENERATE CANDIDATES FOR SUPPORT / RESISTANCE LINE =====
    for i = 0 to array.size(longThroughs) - 1
        pivA = array.get(longThroughs, i)
        for j = 0 to i
            pivB = array.get(longThroughs, j)
            if pivA.index == pivB.index
                continue
            // Create ChannelCandidate for support line
            channelCandidate = ChannelCandidate.new(pivA, pivB, "SUPPORT", 0, na, 0.0)
            array.push(channelCandidates, channelCandidate)
    
    for i = 0 to array.size(longPeaks) - 1
        pivA = array.get(longPeaks, i)
        for j = 0 to i
            pivB = array.get(longPeaks, j)
            if pivA.index == pivB.index
                continue
            // Create ChannelCandidate for support line
            channelCandidate = ChannelCandidate.new(pivA, pivB, "RESISTANCE", 0, na, 0.0)
            array.push(channelCandidates, channelCandidate)
    
    // ===== TEST THE BITGAK LINES =====
    for i = 0 to array.size(channelCandidates) - 1
        candidate = array.get(channelCandidates, i)
        f_best_fit(candidate)
        log.info("PivA: " + str.tostring(candidate.pivotA.price) + "PivB: " + str.tostring(candidate.pivotB.price) + "PivC " + str.tostring(candidate.pivotC.price) + "mult: " + str.tostring(candidate.pivotC_multiplier) + "Score: " + str.tostring(candidate.score))
    
        
    // ===== DRAW THE BEST BIGGAK LINE =====
    f_draw_best_channel(channelCandidates)