Adaptive Channel Reaction

ADXAE · study · 1743 行 · 点赞 50 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

//@version=6
indicator(
     "Adaptive Channel Reaction",
     shorttitle = "ACR",
     overlay = true,
     max_lines_count = 500,
     max_bars_back = 500)
 
// ============================================================================
// GROUPS
// ============================================================================
 
var string G1 = "[1] Channel Detection"
var string G2 = "[2] Channel Strength"
var string G3 = "[3] Entry"
var string G4 = "[4] Exit & Break"
var string G5 = "[5] Display"
var string G6 = "[6] Alerts"
 
// ============================================================================
// [1] CHANNEL DETECTION
// ============================================================================
 
chMode = input.string(
     "Parallel (sloped)",
     "Channel Type",
     options = ["Parallel (sloped)", "Range (flat)"],
     group = G1)
 
pivLen = input.int(
     7,
     "Swing Length",
     minval = 2,
     group = G1)
 
tolMult = input.float(
     0.25,
     "Geometry Tolerance",
     minval = 0.05,
     maxval = 1.0,
     step = 0.05,
     group = G1)
 
minQuality = input.float(
     60.0,
     "Minimum Channel Quality",
     minval = 0,
     maxval = 100,
     step = 5,
     group = G1)
 
minW = input.float(
     2.0,
     "Minimum Width (x ATR)",
     minval = 0.5,
     step = 0.25,
     group = G1)
 
atrLen = input.int(
     14,
     "ATR Length",
     minval = 1,
     group = G1)
 
maxChannelAge = input.int(
     140,
     "Maximum Channel Age (bars)",
     minval = 30,
     maxval = 500,
     group = G1)
 
maxNoInteractionBars = input.int(
     55,
     "Maximum Bars Without Interaction",
     minval = 15,
     maxval = 200,
     group = G1)
 
maxEffectiveWidthATR = input.float(
     8.0,
     "Maximum Effective Width (x ATR)",
     minval = 3.0,
     maxval = 20.0,
     step = 0.5,
     group = G1)
 
// ============================================================================
// [2] CHANNEL STRENGTH
// ============================================================================
 
strengthWeight = input.float(
     25.0,
     "Reaction Strength Weight (%)",
     minval = 0,
     maxval = 50,
     step = 5,
     group = G2)
 
touchToleranceATR = input.float(
     0.20,
     "Touch Tolerance (x ATR)",
     minval = 0.05,
     maxval = 1.0,
     step = 0.05,
     group = G2)
 
targetTouches = input.int(
     3,
     "Target Touches Per Side",
     minval = 2,
     maxval = 6,
     group = G2)
 
touchCooldown = input.int(
     3,
     "Touch Cooldown (bars)",
     minval = 1,
     maxval = 20,
     group = G2)
 
strengthLookback = input.int(
     180,
     "Strength Lookback",
     minval = 50,
     maxval = 350,
     group = G2)
 
// ============================================================================
// [3] ENTRY
// ============================================================================
 
entryMode = input.string(
     "Confirmed Rejection",
     "Entry Confirmation",
     options = [
         "Confirmed Rejection",
         "Close Back Inside",
         "Touch Only"
     ],
     group = G3)
 
entryZonePct = input.float(
     12.0,
     "Lower Reaction Zone (%)",
     minval = 0,
     maxval = 30,
     step = 1,
     group = G3)
 
maxPenetration = input.float(
     0.35,
     "Maximum Penetration (x ATR)",
     minval = 0,
     step = 0.05,
     group = G3)
 
minWickPct = input.float(
     20.0,
     "Minimum Lower Wick (%)",
     minval = 0,
     maxval = 100,
     step = 5,
     group = G3)
 
requireBullClose = input.bool(
     false,
     "Require Bullish Candle",
     group = G3)
 
useEma = input.bool(
     false,
     "Use EMA Trend Filter",
     group = G3)
 
emaLen = input.int(
     200,
     "EMA Length",
     minval = 1,
     group = G3,
     active = useEma)
 
// ============================================================================
// [4] EXIT & BREAK
// ============================================================================
 
exitMode = input.string(
     "Adaptive",
     "Exit Mode",
     options = [
         "Adaptive",
         "Upper Rejection",
         "Upper Line Touch"
     ],
     group = G4)
 
upperZonePct = input.float(
     10.0,
     "Upper Reaction Zone (%)",
     minval = 0,
     maxval = 30,
     step = 1,
     group = G4)
 
breakoutBuffer = input.float(
     0.15,
     "Breakout Hold Buffer (x ATR)",
     minval = 0,
     step = 0.05,
     group = G4)
 
breakoutBodyPct = input.float(
     55.0,
     "Minimum Breakout Body (%)",
     minval = 10,
     maxval = 100,
     step = 5,
     group = G4)
 
breakoutReturnBuffer = input.float(
     0.05,
     "Breakout Failure Buffer (x ATR)",
     minval = 0,
     maxval = 1,
     step = 0.05,
     group = G4)
 
upperRejectWickPct = input.float(
     25.0,
     "Upper Rejection Wick (%)",
     minval = 0,
     maxval = 100,
     step = 5,
     group = G4)
 
brkMult = input.float(
     0.30,
     "Break Buffer (x ATR)",
     minval = 0,
     step = 0.05,
     group = G4)
 
breakConfirmBars = input.int(
     2,
     "Break Confirmation Bars",
     minval = 1,
     maxval = 4,
     group = G4)
 
breakMinBodyPct = input.float(
     30.0,
     "Minimum Break Candle Body (%)",
     minval = 0,
     maxval = 100,
     step = 5,
     group = G4)
 
deepBreakATR = input.float(
     0.80,
     "Immediate Deep Break (x ATR)",
     minval = 0.30,
     maxval = 3.0,
     step = 0.05,
     group = G4)
 
useStop = input.bool(
     true,
     "Exit On Downside Break",
     group = G4)
 
lockWhileLong = input.bool(
     true,
     "Lock Channel While Trade Is Open",
     group = G4)
 
// ============================================================================
// [5] DISPLAY
// ============================================================================
 
showMarks = input.bool(
     true,
     "Show BUY / SELL / BREAK",
     group = G5)
 
showHist = input.bool(
     true,
     "Keep Old Channels",
     group = G5)
 
maxHist = input.int(
     15,
     "Old Channels Kept",
     minval = 1,
     maxval = 100,
     group = G5,
     active = showHist)
 
visualForwardBars = input.int(
     18,
     "Visual Forward Extension",
     minval = 0,
     maxval = 100,
     group = G5,
     tooltip =
     "Extends both active and finished channel lines forward by this many bars. " +
     "This is visual only and does not change BUY / SELL / BREAK logic.")
 
maxVisualLength = input.int(
     160,
     "Maximum Visual Channel Length",
     minval = 50,
     maxval = 500,
     group = G5,
     tooltip =
     "Maximum total visual length of a channel, including forward extension.")
 
preventNegativeProjection = input.bool(
     true,
     "Prevent Negative Price Projection",
     group = G5)
 
colTop = input.color(
     color.new(#E05A5A, 0),
     "Upper Line",
     group = G5)
 
colBot = input.color(
     color.new(#3FA37A, 0),
     "Lower Line",
     group = G5)
 
colFill = input.color(
     color.new(#7A8899, 92),
     "Channel Fill",
     group = G5)
 
lineW = input.int(
     2,
     "Channel Line Width",
     minval = 1,
     maxval = 5,
     group = G5)
 
// ============================================================================
// [6] ALERTS
// ============================================================================
 
useHook = input.bool(
     true,
     "Send Webhook Messages",
     group = G6)
 
buyMsg = input.text_area(
     "buy",
     "Buy Message",
     group = G6,
     active = useHook)
 
sellMsg = input.text_area(
     "sell",
     "Sell Message",
     group = G6,
     active = useHook)
 
brkMsg = input.text_area(
     "sell",
     "Break Exit Message",
     group = G6,
     active = useHook)
 
// ============================================================================
// BASE
// ============================================================================
 
bool isRange = chMode == "Range (flat)"
 
float atr = ta.atr(atrLen)
float ema = ta.ema(close, emaLen)
 
float ph = ta.pivothigh(high, pivLen, pivLen)
float pl = ta.pivotlow(low, pivLen, pivLen)
 
// ============================================================================
// HELPERS
// ============================================================================
 
lineAt(int i1, float v1, int i2, float v2, int x) =>
    i1 == i2 ? v2 : v2 + (v2 - v1) / (i2 - i1) * (x - i2)
 
clamp(float value, float lo, float hi) =>
    math.max(lo, math.min(hi, value))
 
// ============================================================================
// SWINGS
// ============================================================================
 
var int h1i = na
var float h1v = na
var int h2i = na
var float h2v = na
 
var int l1i = na
var float l1v = na
var int l2i = na
var float l2v = na
 
// ============================================================================
// CHANNEL STATE
// ============================================================================
 
var bool chOn = false
 
var int ah1i = na
var float ah1v = na
var int ah2i = na
var float ah2v = na
 
var int al1i = na
var float al1v = na
var int al2i = na
var float al2v = na
 
var float channelATR = na
var float channelGeometryQuality = na
var float channelTouchQuality = na
var float channelQuality = na
 
var int channelTopTouches = 0
var int channelBotTouches = 0
 
var int channelID = 0
var int channelStartBar = na
 
var int resetBar = -1
var int breakBar = -1
 
var int lastInteractionBar = na
var int lastTopTouchBar = na
var int lastBotTouchBar = na
 
var int downsideBreakCount = 0
var int upsideBreakCount = 0
 
// ============================================================================
// TRADE STATE
// ============================================================================
 
var int pos = 0
var int entryBar = -1
var int tradeChannelID = -1
 
var bool upperZoneTouched = false
var bool breakoutHoldActive = false
 
// ============================================================================
// DRAWING STATE
// ============================================================================
 
var line curTop = na
var line curBot = na
var linefill curFill = na
 
var int drawH1 = na
var int drawH2 = na
var int drawL1 = na
var int drawL2 = na
 
var array<line> oldTops = array.new<line>()
var array<line> oldBots = array.new<line>()
 
// ============================================================================
// CURRENT CHANNEL
// ============================================================================
 
float topNow = na
float botNow = na
 
if chOn
    if isRange
        topNow := math.max(ah1v, ah2v)
        botNow := math.min(al1v, al2v)
    else
        topNow := lineAt(ah1i, ah1v, ah2i, ah2v, bar_index)
        botNow := lineAt(al1i, al1v, al2i, al2v, bar_index)
 
bool validNow =
     chOn and
     not na(topNow) and
     not na(botNow) and
     topNow > botNow
 
float channelWidth =
     validNow ?
     topNow - botNow :
     na
 
int channelAge =
     validNow and not na(channelStartBar) ?
     bar_index - channelStartBar :
     0
 
// ============================================================================
// CANDLE METRICS
// ============================================================================
 
float candleRange =
     math.max(
         high - low,
         syminfo.mintick)
 
float bodySize =
     math.abs(close - open)
 
float bodyPct =
     bodySize /
     candleRange *
     100.0
 
float lowerWick =
     math.min(open, close) - low
 
float lowerWickPct =
     lowerWick /
     candleRange *
     100.0
 
float upperWick =
     high - math.max(open, close)
 
float upperWickPct =
     upperWick /
     candleRange *
     100.0
 
// ============================================================================
// LIVE TOUCH STRENGTH
// ============================================================================
 
float liveTouchTolerance =
     validNow and not na(channelATR) ?
     touchToleranceATR * channelATR :
     na
 
bool liveTopInteraction =
     validNow and
     high >= topNow - liveTouchTolerance and
     low <= topNow + liveTouchTolerance and
     close <= topNow + liveTouchTolerance
 
bool liveBotInteraction =
     validNow and
     low <= botNow + liveTouchTolerance and
     high >= botNow - liveTouchTolerance and
     close >= botNow - liveTouchTolerance
 
if validNow and bar_index >= channelStartBar
 
    bool newTopTouch =
         liveTopInteraction and
         (na(lastTopTouchBar) or bar_index - lastTopTouchBar >= touchCooldown)
 
    bool newBotTouch =
         liveBotInteraction and
         (na(lastBotTouchBar) or bar_index - lastBotTouchBar >= touchCooldown)
 
    if newTopTouch
        channelTopTouches += 1
        lastTopTouchBar := bar_index
        lastInteractionBar := bar_index
 
    if newBotTouch
        channelBotTouches += 1
        lastBotTouchBar := bar_index
        lastInteractionBar := bar_index
 
    float liveTopScore =
         math.min(
             100.0,
             channelTopTouches /
             float(targetTouches) *
             100.0)
 
    float liveBotScore =
         math.min(
             100.0,
             channelBotTouches /
             float(targetTouches) *
             100.0)
 
    channelTouchQuality :=
         math.min(
             liveTopScore,
             liveBotScore)
 
    float reactionWeightLive =
         strengthWeight /
         100.0
 
    channelQuality :=
         channelGeometryQuality *
         (1.0 - reactionWeightLive) +
         channelTouchQuality *
         reactionWeightLive
 
// ============================================================================
// ENTRY
// ============================================================================
 
float lowerZoneTop =
     validNow ?
     botNow +
     channelWidth *
     entryZonePct /
     100.0 :
     na
 
float penetrationBuffer =
     not na(channelATR) ?
     maxPenetration *
     channelATR :
     0.0
 
bool touchedLowerZone =
     validNow and
     low <= lowerZoneTop
 
bool penetrationOK =
     validNow and
     low >= botNow - penetrationBuffer
 
bool closedBackInside =
     validNow and
     close >= botNow
 
bool lowerWickOK =
     lowerWickPct >= minWickPct
 
bool bullishCandleOK =
     not requireBullClose or
     close > open
 
bool emaFilterOK =
     not useEma or
     close > ema
 
bool confirmedRejection =
     touchedLowerZone and
     penetrationOK and
     closedBackInside and
     lowerWickOK
 
bool closeBackEntry =
     touchedLowerZone and
     penetrationOK and
     closedBackInside
 
bool touchEntry =
     touchedLowerZone and
     penetrationOK
 
bool baseEntry =
     entryMode == "Confirmed Rejection" ? confirmedRejection :
     entryMode == "Close Back Inside" ? closeBackEntry :
     touchEntry
 
bool finalEntry =
     baseEntry and
     bullishCandleOK and
     emaFilterOK
 
// ============================================================================
// SIGNALS
// ============================================================================
 
bool buySig = false
bool sellSig = false
bool brkSig = false
 
// ============================================================================
// BUY
// ============================================================================
 
if pos == 0 and validNow and finalEntry and bar_index >= channelStartBar
    buySig := true
    pos := 1
    entryBar := bar_index
    tradeChannelID := channelID
    upperZoneTouched := false
    breakoutHoldActive := false
 
// ============================================================================
// UPPER REACTION
// ============================================================================
 
float upperZoneBottom =
     validNow ?
     topNow -
     channelWidth *
     upperZonePct /
     100.0 :
     na
 
bool reachedUpperArea =
     validNow and
     high >= upperZoneBottom
 
if pos == 1 and tradeChannelID == channelID and reachedUpperArea
    upperZoneTouched := true
 
bool upperRejection =
     validNow and
     high >= upperZoneBottom and
     close < topNow and
     upperWickPct >= upperRejectWickPct
 
// ============================================================================
// BREAKOUT STRENGTH
// ============================================================================
 
bool strongBullBody =
     close > open and
     bodyPct >= breakoutBodyPct
 
bool breakoutAboveTop =
     validNow and
     not na(channelATR) and
     close > topNow + breakoutBuffer * channelATR
 
bool strongBreakout =
     breakoutAboveTop and
     strongBullBody
 
// ============================================================================
// ADAPTIVE EXIT
// ============================================================================
 
bool sameTradeChannel =
     pos == 1 and
     tradeChannelID == channelID
 
bool classicUpperTouch =
     validNow and
     high >= topNow
 
bool adaptiveExit = false
 
if sameTradeChannel and bar_index > entryBar
 
    if exitMode == "Upper Line Touch"
        adaptiveExit := classicUpperTouch
 
    else if exitMode == "Upper Rejection"
        adaptiveExit := upperRejection
 
    else
 
        if strongBreakout
            breakoutHoldActive := true
 
        if breakoutHoldActive
 
            bool breakoutFailed =
                 barstate.isconfirmed and
                 close < topNow - breakoutReturnBuffer * channelATR
 
            if breakoutFailed
                adaptiveExit := true
 
        else if upperZoneTouched and upperRejection
            adaptiveExit := true
 
if adaptiveExit
    sellSig := true
    pos := 0
    tradeChannelID := -1
    upperZoneTouched := false
    breakoutHoldActive := false
 
// ============================================================================
// SMART BREAK
// ============================================================================
 
bool downBreakRaw = false
bool upBreakRaw = false
 
if validNow and barstate.isconfirmed and not na(channelATR)
    downBreakRaw := close < botNow - brkMult * channelATR
    upBreakRaw := close > topNow + brkMult * channelATR
 
if downBreakRaw
    downsideBreakCount += 1
else
    downsideBreakCount := 0
 
if upBreakRaw
    upsideBreakCount += 1
else
    upsideBreakCount := 0
 
bool deepDownBreak =
     validNow and
     not na(channelATR) and
     close < botNow - deepBreakATR * channelATR
 
bool deepUpBreak =
     validNow and
     not na(channelATR) and
     close > topNow + deepBreakATR * channelATR
 
bool bearishBreakBody =
     close < open and
     bodyPct >= breakMinBodyPct
 
bool bullishBreakBody =
     close > open and
     bodyPct >= breakMinBodyPct
 
bool downsideFollowThrough =
     breakConfirmBars <= 1 or
     close <= close[1]
 
bool upsideFollowThrough =
     breakConfirmBars <= 1 or
     close >= close[1]
 
bool normalDownBreak =
     downsideBreakCount >= breakConfirmBars and
     bearishBreakBody and
     downsideFollowThrough
 
bool normalUpBreak =
     upsideBreakCount >= breakConfirmBars and
     bullishBreakBody and
     upsideFollowThrough
 
bool downsideBreak =
     validNow and
     barstate.isconfirmed and
     (deepDownBreak or normalDownBreak)
 
bool upsideBreak =
     validNow and
     barstate.isconfirmed and
     (deepUpBreak or normalUpBreak)
 
bool acceptedUpsideExpansion =
     exitMode == "Adaptive" and
     sameTradeChannel and
     breakoutHoldActive
 
if sameTradeChannel and upsideBreak and not acceptedUpsideExpansion
    sellSig := true
    pos := 0
    tradeChannelID := -1
    upperZoneTouched := false
    breakoutHoldActive := false
 
bool confirmedChannelBreak =
     downsideBreak or
     (upsideBreak and not acceptedUpsideExpansion)
 
if confirmedChannelBreak
 
    if pos == 1 and tradeChannelID == channelID and useStop and downsideBreak
        brkSig := true
        pos := 0
        tradeChannelID := -1
        upperZoneTouched := false
        breakoutHoldActive := false
 
    breakBar := bar_index
    resetBar := bar_index
 
    downsideBreakCount := 0
    upsideBreakCount := 0
 
    chOn := false
 
// ============================================================================
// SIMPLE EXPIRATION
// ============================================================================
 
bool channelTooOld =
     validNow and
     pos == 0 and
     channelAge > maxChannelAge
 
bool channelTooStale =
     validNow and
     pos == 0 and
     not na(lastInteractionBar) and
     bar_index - lastInteractionBar > maxNoInteractionBars
 
bool channelTooWide =
     validNow and
     pos == 0 and
     not na(channelATR) and
     channelWidth > maxEffectiveWidthATR * channelATR
 
bool channelExpired =
     channelTooOld or
     channelTooStale or
     channelTooWide
 
if channelExpired
    resetBar := bar_index
    downsideBreakCount := 0
    upsideBreakCount := 0
    chOn := false
 
// ============================================================================
// REGISTER SWINGS
// ============================================================================
 
bool newSwing = false
 
if not na(ph)
    h1i := h2i
    h1v := h2v
    h2i := bar_index - pivLen
    h2v := ph
    newSwing := true
 
if not na(pl)
    l1i := l2i
    l1v := l2v
    l2i := bar_index - pivLen
    l2v := pl
    newSwing := true
 
// ============================================================================
// CHANNEL CANDIDATE
// ============================================================================
 
bool haveFourSwings =
     not na(h1i) and
     not na(h2i) and
     not na(l1i) and
     not na(l2i)
 
bool allAfterReset =
     haveFourSwings and
     math.min(
         math.min(h1i, h2i),
         math.min(l1i, l2i)
     ) > resetBar
 
bool mayReplace =
     pos == 0 or
     not lockWhileLong
 
bool evaluateCandidate =
     haveFourSwings and
     allAfterReset and
     not na(atr) and
     (not chOn or (newSwing and mayReplace))
 
if evaluateCandidate
 
    float candidateTop = na
    float candidateBot = na
    float candidateWidth = na
 
    float geometryQuality = 0.0
    float touchQuality = 0.0
    float finalQuality = 0.0
 
    int topTouchCount = 0
    int botTouchCount = 0
 
    bool widthOK = false
    bool geometryOK = false
 
    float candidateATR = atr
 
    // ------------------------------------------------------------------------
    // RANGE
    // ------------------------------------------------------------------------
 
    if isRange
 
        candidateTop := math.max(h1v, h2v)
        candidateBot := math.min(l1v, l2v)
 
        candidateWidth :=
             candidateTop -
             candidateBot
 
        widthOK :=
             candidateWidth >=
             minW *
             candidateATR
 
        float highError =
             candidateWidth > 0 ?
             math.abs(h1v - h2v) /
             candidateWidth :
             1.0
 
        float lowError =
             candidateWidth > 0 ?
             math.abs(l1v - l2v) /
             candidateWidth :
             1.0
 
        float avgError =
             (highError + lowError) /
             2.0
 
        geometryOK :=
             highError <= tolMult and
             lowError <= tolMult
 
        float normalizedError =
             tolMult > 0 ?
             avgError / tolMult :
             1.0
 
        geometryQuality :=
             100.0 *
             (1.0 -
             clamp(
                 normalizedError,
                 0.0,
                 1.0))
 
    // ------------------------------------------------------------------------
    // PARALLEL
    // ------------------------------------------------------------------------
 
    else
 
        float highSlope =
             (h2v - h1v) /
             math.max(
                 h2i - h1i,
                 1)
 
        float lowSlope =
             (l2v - l1v) /
             math.max(
                 l2i - l1i,
                 1)
 
        candidateTop :=
             lineAt(
                 h1i,
                 h1v,
                 h2i,
                 h2v,
                 bar_index)
 
        candidateBot :=
             lineAt(
                 l1i,
                 l1v,
                 l2i,
                 l2v,
                 bar_index)
 
        candidateWidth :=
             candidateTop -
             candidateBot
 
        widthOK :=
             candidateWidth >=
             minW *
             candidateATR
 
        int earliestAnchor =
             math.min(
                 math.min(h1i, h2i),
                 math.min(l1i, l2i))
 
        int latestAnchor =
             math.max(
                 math.max(h1i, h2i),
                 math.max(l1i, l2i))
 
        int structuralSpan =
             math.max(
                 latestAnchor -
                 earliestAnchor,
                 1)
 
        float slopeDrift =
             math.abs(
                 highSlope -
                 lowSlope) *
             structuralSpan
 
        float driftRatio =
             candidateWidth > 0 ?
             slopeDrift /
             candidateWidth :
             1.0
 
        geometryOK :=
             driftRatio <=
             tolMult
 
        float normalizedDrift =
             tolMult > 0 ?
             driftRatio /
             tolMult :
             1.0
 
        geometryQuality :=
             100.0 *
             (1.0 -
             clamp(
                 normalizedDrift,
                 0.0,
                 1.0))
 
    // ------------------------------------------------------------------------
    // HISTORICAL TOUCH QUALITY
    // ------------------------------------------------------------------------
 
    int earliestStructureBar =
         math.min(
             math.min(h1i, h2i),
             math.min(l1i, l2i))
 
    float historicalTouchTolerance =
         touchToleranceATR *
         candidateATR
 
    int lastTopOffset = na
    int lastBotOffset = na
 
    for off = 0 to strengthLookback - 1
 
        int absoluteBar =
             bar_index -
             off
 
        if absoluteBar >= earliestStructureBar
 
            float topAtBar =
                 isRange ?
                 candidateTop :
                 lineAt(
                     h1i,
                     h1v,
                     h2i,
                     h2v,
                     absoluteBar)
 
            float botAtBar =
                 isRange ?
                 candidateBot :
                 lineAt(
                     l1i,
                     l1v,
                     l2i,
                     l2v,
                     absoluteBar)
 
            bool upperInteraction =
                 high[off] >= topAtBar - historicalTouchTolerance and
                 low[off] <= topAtBar + historicalTouchTolerance and
                 close[off] <= topAtBar + historicalTouchTolerance
 
            bool lowerInteraction =
                 low[off] <= botAtBar + historicalTouchTolerance and
                 high[off] >= botAtBar - historicalTouchTolerance and
                 close[off] >= botAtBar - historicalTouchTolerance
 
            bool topSeparated =
                 na(lastTopOffset) or
                 math.abs(
                     off -
                     lastTopOffset) >=
                 touchCooldown
 
            bool botSeparated =
                 na(lastBotOffset) or
                 math.abs(
                     off -
                     lastBotOffset) >=
                 touchCooldown
 
            if upperInteraction and topSeparated
                topTouchCount += 1
                lastTopOffset := off
 
            if lowerInteraction and botSeparated
                botTouchCount += 1
                lastBotOffset := off
 
    float topTouchScore =
         math.min(
             100.0,
             topTouchCount /
             float(targetTouches) *
             100.0)
 
    float botTouchScore =
         math.min(
             100.0,
             botTouchCount /
             float(targetTouches) *
             100.0)
 
    touchQuality :=
         math.min(
             topTouchScore,
             botTouchScore)
 
    float reactionWeightCandidate =
         strengthWeight /
         100.0
 
    float geometryWeightCandidate =
         1.0 -
         reactionWeightCandidate
 
    finalQuality :=
         geometryQuality *
         geometryWeightCandidate +
         touchQuality *
         reactionWeightCandidate
 
    bool effectiveWidthOK =
         candidateWidth <=
         maxEffectiveWidthATR *
         candidateATR
 
    bool candidateOK =
         candidateTop > candidateBot and
         widthOK and
         effectiveWidthOK and
         geometryOK and
         finalQuality >= minQuality
 
    bool priceInsideCandidate =
         candidateOK and
         close >= candidateBot - brkMult * candidateATR and
         close <= candidateTop + brkMult * candidateATR
 
    if priceInsideCandidate
 
        bool differentChannel =
             not chOn or
             h1i != ah1i or
             h2i != ah2i or
             l1i != al1i or
             l2i != al2i
 
        if differentChannel
 
            chOn := true
 
            ah1i := h1i
            ah1v := h1v
            ah2i := h2i
            ah2v := h2v
 
            al1i := l1i
            al1v := l1v
            al2i := l2i
            al2v := l2v
 
            channelATR :=
                 candidateATR
 
            channelGeometryQuality :=
                 geometryQuality
 
            channelTouchQuality :=
                 touchQuality
 
            channelQuality :=
                 finalQuality
 
            channelTopTouches :=
                 topTouchCount
 
            channelBotTouches :=
                 botTouchCount
 
            channelID += 1
            channelStartBar := bar_index
 
            lastInteractionBar := bar_index
            lastTopTouchBar := na
            lastBotTouchBar := na
 
            downsideBreakCount := 0
            upsideBreakCount := 0
 
// ============================================================================
// RETIRE CURRENT CHANNEL
// ============================================================================
 
retireCurrent(bool broken) =>
 
    if not na(curTop)
 
        // ------------------------------------------------------------
        // IMPORTANT FIX:
        // Finished channels ALSO respect Visual Forward Extension.
        // ------------------------------------------------------------
 
        int originalX1 =
             line.get_x1(
                 curTop)
 
        int desiredEndX =
             bar_index +
             visualForwardBars
 
        // Total visual length remains capped.
        int maxAllowedEndX =
             originalX1 +
             maxVisualLength
 
        int endX =
             math.min(
                 desiredEndX,
                 maxAllowedEndX)
 
        // ------------------------------------------------------------
        // Prevent finished channels projecting into invalid prices.
        // ------------------------------------------------------------
 
        if preventNegativeProjection
 
            float projectedTop =
                 line.get_price(
                     curTop,
                     endX)
 
            float projectedBot =
                 line.get_price(
                     curBot,
                     endX)
 
            float priceFloor =
                 math.max(
                     syminfo.mintick,
                     close * 0.05)
 
            if projectedTop <= priceFloor or projectedBot <= priceFloor
                endX := bar_index
 
        float endTop =
             line.get_price(
                 curTop,
                 endX)
 
        float endBot =
             line.get_price(
                 curBot,
                 endX)
 
        line.set_xy2(
             curTop,
             endX,
             endTop)
 
        line.set_xy2(
             curBot,
             endX,
             endBot)
 
        line.set_style(
             curTop,
             broken ?
             line.style_dashed :
             line.style_dotted)
 
        line.set_style(
             curBot,
             broken ?
             line.style_dashed :
             line.style_dotted)
 
        if not na(curFill)
            linefill.delete(
                 curFill)
 
        if showHist
 
            array.push(
                 oldTops,
                 curTop)
 
            array.push(
                 oldBots,
                 curBot)
 
            if array.size(oldTops) > maxHist
 
                line.delete(
                     array.shift(
                         oldTops))
 
                line.delete(
                     array.shift(
                         oldBots))
 
        else
 
            line.delete(
                 curTop)
 
            line.delete(
                 curBot)
 
// ============================================================================
// DRAW ACTIVE CHANNEL
// ============================================================================
 
if chOn
 
    float drawTop =
         isRange ?
         math.max(
             ah1v,
             ah2v) :
         lineAt(
             ah1i,
             ah1v,
             ah2i,
             ah2v,
             bar_index)
 
    float drawBot =
         isRange ?
         math.min(
             al1v,
             al2v) :
         lineAt(
             al1i,
             al1v,
             al2i,
             al2v,
             bar_index)
 
    bool newDrawStructure =
         na(curTop) or
         ah1i != drawH1 or
         ah2i != drawH2 or
         al1i != drawL1 or
         al2i != drawL2
 
    int structuralStart =
         math.min(
             math.min(
                 ah1i,
                 ah2i),
             math.min(
                 al1i,
                 al2i))
 
    int visualStart =
         math.max(
             structuralStart,
             bar_index -
             maxVisualLength)
 
    int safeX2 =
         bar_index +
         visualForwardBars
 
    // Do not exceed maximum total visual length.
    safeX2 :=
         math.min(
             safeX2,
             visualStart +
             maxVisualLength)
 
    // ========================================================================
    // PREVENT INVALID NEGATIVE PROJECTION
    // ========================================================================
 
    if not isRange and preventNegativeProjection
 
        float highSlope =
             (ah2v - ah1v) /
             math.max(
                 ah2i - ah1i,
                 1)
 
        float lowSlope =
             (al2v - al1v) /
             math.max(
                 al2i - al1i,
                 1)
 
        float priceFloor =
             math.max(
                 syminfo.mintick,
                 close * 0.05)
 
        if highSlope < 0
 
            float barsToFloorTop =
                 (priceFloor - drawTop) /
                 highSlope
 
            if barsToFloorTop > 0
 
                int topFloorX =
                     bar_index +
                     int(
                         math.floor(
                             barsToFloorTop))
 
                safeX2 :=
                     math.min(
                         safeX2,
                         topFloorX)
 
        if lowSlope < 0
 
            float barsToFloorBot =
                 (priceFloor - drawBot) /
                 lowSlope
 
            if barsToFloorBot > 0
 
                int botFloorX =
                     bar_index +
                     int(
                         math.floor(
                             barsToFloorBot))
 
                safeX2 :=
                     math.min(
                         safeX2,
                         botFloorX)
 
        safeX2 :=
             math.max(
                 bar_index,
                 safeX2)
 
    // ========================================================================
    // CREATE
    // ========================================================================
 
    if newDrawStructure
 
        retireCurrent(false)
 
        float topStart =
             isRange ?
             drawTop :
             lineAt(
                 ah1i,
                 ah1v,
                 ah2i,
                 ah2v,
                 visualStart)
 
        float botStart =
             isRange ?
             drawBot :
             lineAt(
                 al1i,
                 al1v,
                 al2i,
                 al2v,
                 visualStart)
 
        float topEnd =
             isRange ?
             drawTop :
             lineAt(
                 ah1i,
                 ah1v,
                 ah2i,
                 ah2v,
                 safeX2)
 
        float botEnd =
             isRange ?
             drawBot :
             lineAt(
                 al1i,
                 al1v,
                 al2i,
                 al2v,
                 safeX2)
 
        curTop :=
             line.new(
                 visualStart,
                 topStart,
                 safeX2,
                 topEnd,
                 color = colTop,
                 width = lineW)
 
        curBot :=
             line.new(
                 visualStart,
                 botStart,
                 safeX2,
                 botEnd,
                 color = colBot,
                 width = lineW)
 
        curFill :=
             linefill.new(
                 curTop,
                 curBot,
                 colFill)
 
        drawH1 := ah1i
        drawH2 := ah2i
        drawL1 := al1i
        drawL2 := al2i
 
    // ========================================================================
    // UPDATE
    // ========================================================================
 
    else
 
        float topEnd =
             isRange ?
             drawTop :
             lineAt(
                 ah1i,
                 ah1v,
                 ah2i,
                 ah2v,
                 safeX2)
 
        float botEnd =
             isRange ?
             drawBot :
             lineAt(
                 al1i,
                 al1v,
                 al2i,
                 al2v,
                 safeX2)
 
        line.set_xy2(
             curTop,
             safeX2,
             topEnd)
 
        line.set_xy2(
             curBot,
             safeX2,
             botEnd)
 
// ============================================================================
// CHANNEL FINISHED
// ============================================================================
 
else if not na(curTop)
 
    bool justBroken =
         breakBar ==
         bar_index
 
    retireCurrent(
         justBroken)
 
    curTop := na
    curBot := na
    curFill := na
 
    drawH1 := na
    drawH2 := na
    drawL1 := na
    drawL2 := na
 
// ============================================================================
// SIGNAL MARKERS
// ============================================================================
 
plotshape(
     showMarks and buySig,
     title = "BUY",
     style = shape.triangleup,
     location = location.belowbar,
     color = colBot,
     text = "BUY",
     textcolor = colBot,
     size = size.small)
 
plotshape(
     showMarks and sellSig,
     title = "SELL",
     style = shape.triangledown,
     location = location.abovebar,
     color = colTop,
     text = "SELL",
     textcolor = colTop,
     size = size.small)
 
plotshape(
     showMarks and brkSig,
     title = "BREAK",
     style = shape.xcross,
     location = location.belowbar,
     color = color.new(#E0A030, 0),
     text = "BREAK",
     textcolor = color.new(#E0A030, 0),
     size = size.small)
 
// ============================================================================
// ALERTS
// ============================================================================
 
if useHook
 
    if buySig
        alert(
             buyMsg,
             alert.freq_once_per_bar)
 
    if sellSig
        alert(
             sellMsg,
             alert.freq_once_per_bar)
 
    if brkSig
        alert(
             brkMsg,
             alert.freq_once_per_bar_close)
 
alertcondition(
     buySig,
     "ACR BUY",
     "Confirmed lower channel reaction - BUY")
 
alertcondition(
     sellSig,
     "ACR SELL",
     "Upper channel reaction / breakout failure - SELL")
 
alertcondition(
     brkSig,
     "ACR BREAK",
     "Confirmed downside channel break - EXIT")

← 返回列表