Auf geht's

Display

SNIFOFF_51_Lang3Library "SNIFOFF_51_Lang3" Multilingual translation layer (Group 3) for Smart Trader, SNIF-OFF 5.1, Trade Finder. Provides 9 exported functions covering the Trade Finder and Signal Health dashboard rows, the S17/S18/S19 volume scenarios, the PROVISIONAL badge, the Native footprint texts, 12 tooltips, and 4 helper affixes. All 7 languages live in this single library; SNIFOFF_51_Lang and SNIFOFF_51_Lang2 stay frozen. f_trVol3(en, lang)   Translates the S17/S18/S19 volume scenario labels.   Parameters:      en (string) : The English scenario label from f_volScenarioMsg (S17/S18/S19 keys only).      lang (string) : The dashboard language selected by the user.   Returns: The translated scenario label. Unmapped inputs return unchanged. f_volNarr3(sid, deltaDir, liveAlert, lang)   Builds the S17/S18/S19 volume narrative with optional live-spike overlay.   Parameters:      sid (string) : Scenario ID: "S17", "S18", or "S19". Any other ID returns "".      deltaDir (int) : Anchored delta direction (+1 buyers, -1 sellers, 0 balanced) — S17 wording.      liveAlert (bool) : Explosive bar volume spike flag (Live Exception protocol).      lang (string) : The dashboard language selected by the user.   Returns: The multi-line narrative string, or "" for unknown scenario IDs. f_trBadge3(en, lang)   Translates the Signal Health PROVISIONAL badge.   Parameters:      en (string) : The English badge label ("◌ PROVISIONAL").      lang (string) : The dashboard language selected by the user.   Returns: The translated badge label. Unmapped inputs return unchanged. f_trTitle3(en, lang)   Translates the Trade Finder and Signal Health section titles.   Parameters:      en (string) : The English section title.      lang (string) : The dashboard language selected by the user.   Returns: The translated section title. Unmapped inputs return unchanged. f_trTf(en, lang)   Translates Trade Finder and Signal Health state and watch labels.   Parameters:      en (string) : The English state or watch label.      lang (string) : The dashboard language selected by the user.   Returns: The translated label. Unmapped inputs return unchanged. f_tfNarrative(state, dir, consensus, lang)   Builds the Trade Finder narrative row text.   Parameters:      state (int) : State code 1..10 (see section header for the mapping).      dir (int) : Composite pressure direction (+1 bullish, -1 bearish, 0 flat).      consensus (int) : Number of dimensions agreeing with the composite direction (0-5).      lang (string) : The dashboard language selected by the user.   Returns: The narrative string for the Trade Finder dashboard row. f_trTipTf(key, lang)   Returns translated tooltip text for Trade Finder and Signal Health cells.   Parameters:      key (string) : Tooltip key identifier (see section header for valid keys).      lang (string) : The dashboard language selected by the user.   Returns: The translated tooltip string. Empty string for unknown keys. f_trInline3(key, lang)   Returns translated helper affixes used inside composed dashboard strings.   Parameters:      key (string) : Affix key identifier: agree_sfx, live_sfx, bull_pfx, bear_pfx.      lang (string) : The dashboard language selected by the user.   Returns: The translated affix string. Empty string for unknown keys. f_trTipFp3(key, lang)   Returns Native-footprint display texts for the dashboard.   Parameters:      key (string) : Text key: fp_title_nat, fp_lock_nat, fp_lock_tip_nat, fp_badge_nat.      lang (string) : The dashboard language selected by the user.   Returns: The translated text. Empty string for unknown keys.
Bibliothek
von ata_sabanci
Isotropic Coordinate System (ICS)Library "ICS" Isotropic Coordinate System (ICS): a dimensionless price-time space for scale-invariant chart geometry. Vertical axis: y = ln(price) / sigma, where sigma is the Yang-Zhang (2000) minimum-variance, drift-independent, gap-consistent OHLC volatility estimator. Horizontal axis: two scalings via the XScale enum. legacy : x = bars / lookback. Linear window fraction. Backward compatible. isotropic : x = sqrt(bars / lookback), with y additionally divided by sqrt(lookback). Diffusion-consistent (sqrt-time scaling), so that tan(theta) equals the z-score of the move and 45 degrees corresponds to a move of exactly one standard deviation of the n-bar log-return distribution. Assumes approximately iid returns within the sigma window (the standard assumption behind sqrt-time scaling; see Danielsson & Zigrand, 2006, for its known limits under vol clustering and jumps). Every output (angle, length, area, centroid) is a pure dimensionless number, comparable across symbols, currencies, and timeframes. Reference: Yang, D. & Zhang, Q. (2000), "Drift-Independent Volatility Estimation Based on High, Low, Open, and Close Prices", The Journal of Business, 73(3), 477-492. yangZhangSigma(length)   Yang-Zhang volatility estimator. Minimum-variance, unbiased, drift-independent, and consistent with opening gaps (Yang & Zhang, 2000). Uses the unbiased sample variance (biased = false) for both the overnight and open-to-close components, matching the estimator's unbiasedness claim.   Parameters:      length (simple int) : (simple int) Rolling window length. Must be >= 2.   Returns: (series float) Per-bar sigma, floored at 1e-10. toX(bars, lookback, mode)   Dimensionless horizontal coordinate.   Parameters:      bars (int) : (series int) Signed bar distance from the anchor.      lookback (int) : (series int) Window length acting as the horizontal unit.      mode (series XScale) : (series XScale) Scaling mode.   Returns: (series float) Signed dimensionless x. toY(price, sigma, lookback, mode)   Dimensionless vertical coordinate.   Parameters:      price (float) : (series float) Price. Must be > 0.      sigma (float) : (series float) Yang-Zhang sigma. Must be > 1e-10.      lookback (int) : (series int) Window length (used by isotropic mode only).      mode (series XScale) : (series XScale) Scaling mode.   Returns: (series float) Dimensionless y, or na when inputs are invalid. moveZScore(dLogPrice, sigma, bars)   Z-score of a log-price move over n bars: dLog / (sigma * sqrt(n)). In isotropic mode this equals tan(theta) of the same move.   Parameters:      dLogPrice (float) : (series float) ln(target) - ln(anchor).      sigma (float) : (series float) Per-bar Yang-Zhang sigma. Must be > 1e-10.      bars (int) : (series int) Number of bars in the move. Must be > 0.   Returns: (series float) The z-score, or na when inputs are invalid. triangle(td, anchorPrice, anchorBar, targetPrice, targetBar, sig, lookback, mode)   Right triangle between an anchor and a target, computed entirely in ICS space. Writes results in place into `td` and returns it. On invalid inputs every field is set to na, so world X never receives contaminated numbers.   Parameters:      td (TriangleData) : (TriangleData) Output object, updated in place.      anchorPrice (float) : (series float) Anchor price (world A). Must be > 0.      anchorBar (int) : (series int) Anchor bar_index.      targetPrice (float) : (series float) Target price (world A). Must be > 0.      targetBar (int) : (series int) Target bar_index. Must differ from anchorBar.      sig (float) : (series float) Yang-Zhang sigma. Must be > 1e-10.      lookback (int) : (series int) Horizontal unit window.      mode (series XScale) : (series XScale) Scaling mode.   Returns: (TriangleData) The same `td`, for chaining. pinTriangle(td, anchorPrice, anchorBar, extremePrice, bodyPrice, curBar, sig, lookback, mode)   Pin (wick) triangle with three vertices in ICS space: A = anchor, B = candle extreme, C = candle body edge. Side BC is the wick. theta = signed angle at A between AB and AC. Since xB = xC, the shoelace area reduces exactly to 0.5 * |yB - yC| * |dx|.   Parameters:      td (TriangleData) : (TriangleData) Output object, updated in place.      anchorPrice (float) : (series float) Anchor price (hh or ll). Must be > 0.      anchorBar (int) : (series int) Anchor bar_index.      extremePrice (float) : (series float) Candle extreme (high or low). Must be > 0.      bodyPrice (float) : (series float) Candle body edge. Must be > 0.      curBar (int) : (series int) Current bar_index. Must differ from anchorBar.      sig (float) : (series float) Yang-Zhang sigma. Must be > 1e-10.      lookback (int) : (series int) Horizontal unit window.      mode (series XScale) : (series XScale) Scaling mode.   Returns: (TriangleData) The same `td`, for chaining. zeroTri(td)   Resets a TriangleData to na. Use when the structure is inactive, so inactive periods never enter moving averages or normalization as fake zero values.   Parameters:      td (TriangleData) : (TriangleData) Object to reset, updated in place.   Returns: (TriangleData) The same `td`, for chaining. TriangleData   One triangle's measurements in ICS space. All fields dimensionless.   Fields:      theta (series float) : Signed hypotenuse angle in degrees; in isotropic mode tan(theta) is the z-score of the move.      dy (series float) : Signed Euclidean magnitude of the hypotenuse.      area (series float) : Triangle area (>= 0).      centroidY (series float) : Vertical centroid of the triangle. FrozenAnchors   Anchors frozen at a reference bar, plus activity state.   Fields:      hh (series float) : Highest high at the freeze bar (world-A price units).      ll (series float) : Lowest low at the freeze bar (world-A price units).      mid (series float) : Geometric mean sqrt(hh * ll) at the freeze bar.      bar_x (series int) : bar_index of the freeze bar.      time_x (series int) : time of the freeze bar.      is_active (series bool) : Whether the frozen structure is currently active.
Bibliothek
von ata_sabanci
SNIFOFF_51_Lang2Library "SNIFOFF_51_Lang2" Multilingual translation layer (Group 2) for Smart Trader, SNIF-OFF 5.1, Trade Finder. Provides 21 exported functions with identical signatures to SNIFOFF_51_Lang. Covers: 10 label functions, 3 narrative engines, 6 tooltip functions, 1 trend description, and 1 inline label function. f_trSig(en, lang)   Translates trend engine signal labels.   Parameters:      en (string) : The English signal label.      lang (string) : The dashboard language selected by the user.   Returns: The translated signal label string. f_trConv(en, lang)   Translates conviction level labels.   Parameters:      en (string) : The English conviction label (HIGH, MODERATE, LOW).      lang (string) : The dashboard language.   Returns: The translated conviction label. f_trCoup(en, lang)   Translates efficiency coupling labels.   Parameters:      en (string) : The English coupling label.      lang (string) : The dashboard language.   Returns: The translated coupling label. f_trMom(en, lang)   Translates efficiency momentum labels.   Parameters:      en (string) : The English momentum label.      lang (string) : The dashboard language.   Returns: The translated momentum label. f_trVol(en, lang)   Translates volume scenario display labels.   Parameters:      en (string) : The English scenario label.      lang (string) : The dashboard language.   Returns: The translated scenario label. f_trVolZone(zone, delta, lang)   Builds the directional arrow + intensity label for the volume zone cell.   Parameters:      zone (string) : The volume zone classification.      delta (int) : The delta direction integer.      lang (string) : The dashboard language.   Returns: The composed volume zone display string. f_trPocCons(count, lang)   Builds the volume center agreement label.   Parameters:      count (int) : The number of agreeing scales (1-6).      lang (string) : The dashboard language.   Returns: The composed POC consensus display string. f_trTitle(en, lang)   Translates dashboard module header titles.   Parameters:      en (string) : The English section title.      lang (string) : The dashboard language.   Returns: The translated section title. f_trBadge(en, lang)   Translates status badge labels.   Parameters:      en (string) : The English badge label.      lang (string) : The dashboard language.   Returns: The translated badge label. f_trVolLabel(en, lang)   Translates volume data row cell labels.   Parameters:      en (string) : The English label.      lang (string) : The dashboard language.   Returns: The translated data row label. f_trendNarrative(cas, casDir, div, smD, algn, mBias, mBiasDir, conv, lang)   Builds a human-readable trend situation summary.   Parameters:      cas (bool) : Cascade active flag.      casDir (int) : Cascade direction.      div (bool) : Divergence active flag.      smD (int) : Micro direction.      algn (int) : Alignment score (-6 to +6).      mBias (bool) : Macro bias active flag.      mBiasDir (int) : Macro bias direction.      conv (string) : Conviction label string.      lang (string) : The dashboard language.   Returns: A 3-line narrative string. f_effNarrative(rz, al, op, td, mom, lang)   Builds a human-readable efficiency situation summary.   Parameters:      rz (string) : Rank zone string.      al (bool) : Aligned flag.      op (bool) : Opposed flag.      td (int) : Trend direction.      mom (string) : Momentum label string.      lang (string) : The dashboard language.   Returns: A 2-line narrative string. f_volNarrative(sid, td, pocCon, pocMidPrice, conv, mom, liveAlert, lang)   Builds a human-readable 3-line volume situation summary.   Parameters:      sid (string) : Scenario ID (S1–S16).      td (int) : Trend direction.      pocCon (int) : Volume center consensus count.      pocMidPrice (float) : Consensus center price.      conv (string) : Conviction label.      mom (string) : Efficiency momentum label.      liveAlert (bool) : Explosive bar volume spike flag.      lang (string) : The dashboard language.   Returns: A multi-line narrative string. f_trTipDash(key, lang)   Returns translated tooltip text for dashboard-level cells.   Parameters:      key (string) : Tooltip key identifier.      lang (string) : The dashboard language.   Returns: The translated tooltip string. f_trTipTrend(key, lang)   Returns translated tooltip text for Trend Engine cells.   Parameters:      key (string) : Tooltip key identifier.      lang (string) : The dashboard language.   Returns: The translated tooltip string. f_trTipEff(key, lang)   Returns translated tooltip text for Efficiency module cells.   Parameters:      key (string) : Tooltip key identifier.      lang (string) : The dashboard language.   Returns: The translated tooltip string. f_trTipVol(key, lang)   Returns translated tooltip text for Volume decomposition cells.   Parameters:      key (string) : Tooltip key identifier.      lang (string) : The dashboard language.   Returns: The translated tooltip string. f_trTipFp(key, gs, lang)   Returns translated tooltip text for Volume Footprint cells.   Parameters:      key (string) : Tooltip key identifier.      gs (string) : Group size string. Pass "" for static keys.      lang (string) : The dashboard language.   Returns: The translated tooltip string. f_trTipVi(key, lang)   Returns translated tooltip text for Volume Insight cells.   Parameters:      key (string) : Tooltip key identifier.      lang (string) : The dashboard language.   Returns: The translated tooltip string. f_trTrendDesc(cas, casDir, div, smD, algn, mBias, mBiasDir, lang)   Builds the trend state description with conviction suffix for the tooltip.   Parameters:      cas (bool) : Cascade active flag.      casDir (int) : Cascade direction.      div (bool) : Divergence active flag.      smD (int) : Micro direction.      algn (int) : Alignment score (-6 to +6).      mBias (bool) : Macro bias active flag.      mBiasDir (int) : Macro bias direction.      lang (string) : The dashboard language.   Returns: Complete tooltip string. f_trInlineLabel(key, lang)   Returns translated inline labels for dashboard cell content.   Parameters:      key (string) : Label key identifier.      lang (string) : The dashboard language.   Returns: The translated label string.
Bibliothek
von ata_sabanci
DeeptestLibrary "Deeptest" Comprehensive quantitative backtesting library with 50+ metrics: Sharpe/Sortino ratios, R-Expectancy, SQN, drawdown analysis, Monte Carlo simulation, Walk-Forward Analysis, VaR/CVaR, benchmark comparison, and interactive table rendering for TradingView strategies. @version 15 (20.06.2026) @license MIT — opensource.org IMPORTS: fikira/Text/1 as FN — Font styling for table cells (Sans Bold / Sans-Serif Bold) PUBLIC API: runDeeptest(...) — Complete backtest analysis orchestrator (only export) type Stats — 50+ metric container returned by runDeeptest type ThresholdConfig — Metric threshold + color configuration type RollingStats — Rolling window analysis results ══════════════════════════════════════════════════════════════════════════════════════ runDeeptest(tableBg, headerBg, borderColor, bullColor, bearColor, textSize, showComplementaryRow, showStressTestTable, showDrawdownRecoveryCards, showTradeCards, showRExpectancy, enableLogging)   runDeeptest — Complete backtest analysis orchestrator (PUBLIC API) Calls calculateFromStrategy() for 50+ metrics, then renders: ├ Main backtest table (23 columns × 3 rows + complementary row + footer) ├ Stress test matrix (IS | Monte Carlo | OOS — if showStressTestTable) ├ Drawdown/recovery cards (if showDrawdownRecoveryCards) └ Top/worst trade cards (if showTradeCards) Execution model: heavy computation runs once on last confirmed bar, table rendering on last bar. Benchmark returns accumulate per-bar from SPY daily.   Parameters:      tableBg (color) : Table background color      headerBg (color) : Header background color      borderColor (color) : Border color      bullColor (color) : Color for positive metric values      bearColor (color) : Color for negative metric values      textSize (string) : Cell font size      showComplementaryRow (bool) : Toggle 2nd data row      showStressTestTable (bool) : Toggle MC/WFA stress test table      showDrawdownRecoveryCards (bool) : Toggle drawdown/recovery card tables      showTradeCards (bool) : Toggle top/worst trade card tables      showRExpectancy (bool) : R-multiple display mode for expectancy      enableLogging (bool) : Output all metrics to Data Window via log.info()   Returns: Stats object with all computed metrics ═══════════════════════════════════════════════════════════════════════════ Stats   Stats — Comprehensive backtest statistics container (50+ fields)   Fields:      totalTrades (series int)      winTrades (series int)      lossTrades (series int)      evenTrades (series int)      winRate (series float)      lossRate (series float)      avgWinPct (series float)      avgLossPct (series float)      avgTradePct (series float)      profitFactor (series float)      payoffRatio (series float)      expectancy (series float)      rExpectancy (series float)      grossProfit (series float)      grossLoss (series float)      netProfit (series float)      netProfitPct (series float)      compEffect (series float)      sharpe (series float)      sortino (series float)      calmar (series float)      martin (series float)      maxDrawdownPct (series float)      currentDrawdownPct (series float)      maxEquity (series float)      minEquity (series float)      cagr (series float)      monthlyReturn (series float)      maxConsecWins (series int)      maxConsecLosses (series int)      avgTradeDuration (series float)      avgWinDuration (series float)      avgLossDuration (series float)      timeInMarketPct (series float)      tradesPerMonth (series float)      tradesPerYear (series float)      skewness (series float)      kurtosis (series float)      var95 (series float)      cvar95 (series float)      ulcerIndex (series float)      riskOfRuin (series float)      pValue (series float)      alpha (series float)      beta (series float)      buyHoldReturn (series float)      equityRSquared (series float)      firstTradeTime (series int)      lastTradeTime (series int)      tradingPeriodDays (series float)      sqn (series float)
Bibliothek
von marketlifter
SNIFOFF_51_LangLibrary "SNIFOFF_51_Lang" Multilingual translation layer for Smart Trader, SNIF-OFF 5.1, Trade Finder. Provides 13 exported functions covering all dashboard labels, status badges, and 3 narrative engines (trend, efficiency, volume) in 4 languages. Consumed by the main indicator via import and i18n.f_*() calls. f_trSig(en, lang)   Translates trend engine signal labels from English to the selected language.   Parameters:      en (string) : The English signal label from the _sigTxt priority chain.      lang (string) : The dashboard language selected by the user.   Returns: The translated signal label string. f_trConv(en, lang)   Translates conviction level labels.   Parameters:      en (string) : The English conviction label (HIGH, MODERATE, LOW).      lang (string) : The dashboard language.   Returns: The translated conviction label. f_trCoup(en, lang)   Translates efficiency coupling labels.   Parameters:      en (string) : The English coupling label from the _effCoupledMsg matrix.      lang (string) : The dashboard language.   Returns: The translated coupling label. f_trMom(en, lang)   Translates efficiency momentum labels.   Parameters:      en (string) : The English momentum label (Accelerating, Sharpening, Steady, Fading).      lang (string) : The dashboard language.   Returns: The translated momentum label. f_trVol(en, lang)   Translates volume scenario display labels.   Parameters:      en (string) : The English scenario label from f_volScenarioMsg output.      lang (string) : The dashboard language.   Returns: The translated scenario label. f_trVolZone(zone, delta, lang)   Builds the directional arrow + intensity label for the volume zone cell.   Parameters:      zone (string) : The volume zone classification (extreme/strong/normal/weak).      delta (int) : The delta direction integer (+1 buyers, -1 sellers, 0 balanced).      lang (string) : The dashboard language.   Returns: The composed volume zone display string. f_trPocCons(count, lang)   Builds the volume center agreement label.   Parameters:      count (int) : The number of agreeing scales (1-6).      lang (string) : The dashboard language.   Returns: The composed POC consensus display string. f_trTitle(en, lang)   Translates dashboard module header titles.   Parameters:      en (string) : The English section title.      lang (string) : The dashboard language.   Returns: The translated section title. f_trBadge(en, lang)   Translates status badge labels (ACTIVE, LOCKED, LIVE, HIST).   Parameters:      en (string) : The English badge label.      lang (string) : The dashboard language.   Returns: The translated badge label. f_trVolLabel(en, lang)   Translates volume data row cell labels.   Parameters:      en (string) : The English label (Total, Buy, Sell, Group, Maximum, Minimum, Control).      lang (string) : The dashboard language.   Returns: The translated data row label. f_trendNarrative(cas, casDir, div, smD, algn, mBias, mBiasDir, conv, lang)   Builds a human-readable trend situation summary for the dashboard narrative row.   Parameters:      cas (bool) : Cascade active flag.      casDir (int) : Cascade direction (+1 bullish, -1 bearish).      div (bool) : Divergence active flag.      smD (int) : Micro direction from slope engine.      algn (int) : Alignment score (-6 to +6).      mBias (bool) : Macro bias active flag.      mBiasDir (int) : Macro bias direction.      conv (string) : Conviction label string (HIGH, MODERATE, LOW).      lang (string) : The dashboard language.   Returns: A 3-line narrative string (state + structure + conviction). f_effNarrative(rz, al, op, td, mom, lang)   Builds a human-readable efficiency situation summary.   Parameters:      rz (string) : Rank zone string (extreme/strong/normal/weak).      al (bool) : Aligned flag (bar direction matches trend).      op (bool) : Opposed flag (bar direction opposes trend).      td (int) : Trend direction (+1, -1, 0).      mom (string) : Momentum label string (Accelerating, Sharpening, Steady, Fading).      lang (string) : The dashboard language.   Returns: A 2-line narrative string (situation + trajectory). f_volNarrative(sid, td, pocCon, pocMidPrice, conv, mom, liveAlert, lang)   Builds a human-readable 3-line volume situation summary.   Parameters:      sid (string) : Scenario ID (S1–S16).      td (int) : Trend direction (+1, -1, 0).      pocCon (int) : Volume center consensus count (0-6).      pocMidPrice (float) : Consensus center price (weighted average of cluster).      conv (string) : Conviction label (HIGH, MODERATE, LOW).      mom (string) : Efficiency momentum label.      liveAlert (bool) : Explosive bar volume spike flag.      lang (string) : The dashboard language.   Returns: A multi-line narrative string (live alert prefix + what + why + outlook).
Bibliothek
von ata_sabanci
AIUnifiedCoreLibrary "AIUnifiedCore" Core signal engine for the AI Learning Trader Bot unified system. This library contains reusable logic only. Inputs, plots, labels, strategy orders, and alerts belong in the wrapper scripts that import this library. clampFloat(value, minValue, maxValue)   Clamps a number between a minimum and maximum.   Parameters:      value (float) : Number to clamp.      minValue (float) : Minimum allowed value.      maxValue (float) : Maximum allowed value.   Returns: Clamped value. trendEngine(source, fastLen, midLen, slowLen)   Calculates the EMA/VWAP trend engine.   Parameters:      source (float) : Source price.      fastLen (simple int) : Fast EMA length.      midLen (simple int) : Middle EMA length.      slowLen (simple int) : Slow EMA length.   Returns: Fast EMA, middle EMA, slow EMA, VWAP, bullish trend, bearish trend. momentumEngine(source, rsiLen)   Calculates RSI/MACD momentum engine.   Parameters:      source (float) : Source price.      rsiLen (simple int) : RSI length.   Returns: RSI, MACD line, MACD signal, MACD histogram, bullish momentum, bearish momentum. volumeEngine(volumeLen)   Calculates volume confirmation.   Parameters:      volumeLen (simple int) : Volume average length.   Returns: Volume average, high volume, bullish volume, bearish volume. priceActionEngine(swingLen)   Calculates price action breakout and candle direction.   Parameters:      swingLen (simple int) : Swing lookback length.   Returns: Swing high, swing low, bullish break, bearish break, bullish candle, bearish candle. chopEngine(diLen, adxSmooth, minAdx, atrLen, minAtrPercent, minEmaSpreadPercent, votesNeeded, emaFast, emaSlow)   Calculates the chop/no-trade filter.   Parameters:      diLen (simple int) : DMI DI length.      adxSmooth (simple int) : ADX smoothing.      minAdx (float) : Minimum ADX trend strength.      atrLen (simple int) : ATR length.      minAtrPercent (float) : Minimum ATR percent.      minEmaSpreadPercent (float) : Minimum EMA spread percent.      votesNeeded (simple int) : Number of chop votes needed.      emaFast (float) : Fast EMA.      emaSlow (float) : Slow EMA.   Returns: DI+, DI-, ADX, ATR, ATR percent, EMA spread percent, chop votes, chop market. probabilityEngine(bullTrend, bearTrend, bullMomentum, bearMomentum, bullVolume, bearVolume, bullBreak, bearBreak, bullCandle, bearCandle, mtfLongOk, mtfShortOk)   Calculates long/short probability scores.   Parameters:      bullTrend (bool) : Bullish trend.      bearTrend (bool) : Bearish trend.      bullMomentum (bool) : Bullish momentum.      bearMomentum (bool) : Bearish momentum.      bullVolume (bool) : Bullish volume.      bearVolume (bool) : Bearish volume.      bullBreak (bool) : Bullish breakout.      bearBreak (bool) : Bearish breakout.      bullCandle (bool) : Bullish candle.      bearCandle (bool) : Bearish candle.      mtfLongOk (bool) : Higher-timeframe long confirmation.      mtfShortOk (bool) : Higher-timeframe short confirmation.   Returns: Long probability and short probability. superEngine(emaFast, emaMid, rsiValue, macdHist)   Calculates premium super-aggressive pressure scores.   Parameters:      emaFast (float) : Fast EMA.      emaMid (float) : Middle EMA.      rsiValue (float) : RSI value.      macdHist (float) : MACD histogram.   Returns: Super long probability, super short probability. likelyRevEngine(showSignals, aggression, minVotes, realtimeOnly, chopOk, cooldownUpOk, cooldownDownOk, longProbability, shortProbability, superLongProbability, superShortProbability, bullTrend, bearTrend, emaFast, rsiValue, macdHist, superSensitivity, minEntryProbability)   Calculates early likely reversal votes/signals.   Parameters:      showSignals (bool) : Master toggle.      aggression (simple string) : Aggression text: Balanced, Aggressive, or Hyper.      minVotes (simple int) : Minimum votes.      realtimeOnly (bool) : Only allow before candle closes.      chopOk (bool) : Whether chop filter allows signal.      cooldownUpOk (bool)      cooldownDownOk (bool)      longProbability (float) : Long probability.      shortProbability (float) : Short probability.      superLongProbability (float) : Super long probability.      superShortProbability (float) : Super short probability.      bullTrend (bool) : Bull trend.      bearTrend (bool) : Bear trend.      emaFast (float) : Fast EMA.      rsiValue (float) : RSI value.      macdHist (float) : MACD histogram.      superSensitivity (simple int) : Super aggressive threshold.      minEntryProbability (simple int) : Minimum entry probability.   Returns: Up votes, down votes, votes needed, likely rev up, likely rev down. easyQuality(trendOk, momentumOk, mtfOk, volumeOk, breakOk, chopMarket, oppositeLikelyRev, probability)   Calculates Easy Mode trade quality score.   Parameters:      trendOk (bool) : Trend agreement.      momentumOk (bool) : Momentum agreement.      mtfOk (bool) : Higher-timeframe agreement.      volumeOk (bool) : Volume agreement.      breakOk (bool) : Breakout agreement.      chopMarket (bool) : No-trade/chop state.      oppositeLikelyRev (bool) : Opposite likely reversal warning.      probability (float) : Direction probability.   Returns: Easy Mode quality score. actionCode(chopMarket, masterLong, masterShort, exitLong, exitShort, flipLong, flipShort, likelyRevUp, likelyRevDown)   Final unified action code.   Parameters:      chopMarket (bool) : No-trade market.      masterLong (bool) : Master long.      masterShort (bool) : Master short.      exitLong (bool) : Exit long.      exitShort (bool) : Exit short.      flipLong (bool) : Flip to long.      flipShort (bool) : Flip to short.      likelyRevUp (bool) : Likely reversal up.      likelyRevDown (bool) : Likely reversal down.   Returns: Integer action code. actionText(action)   Converts an action code into text.   Parameters:      action (int) : Action code.   Returns: Action text. trendText(bullTrend, bearTrend)   Converts trend states into text.   Parameters:      bullTrend (bool) : Bull trend.      bearTrend (bool) : Bear trend.   Returns: Trend text. topStackPrice(highValue, atrValue, gapAtr, slot)   Returns stacked label price above the candle.   Parameters:      highValue (float) : Candle high.      atrValue (float) : ATR.      gapAtr (float) : Gap in ATR multiples.      slot (int) : Stack slot, starting at 1.   Returns: Label price. bottomStackPrice(lowValue, atrValue, gapAtr, slot)   Returns stacked label price below the candle.   Parameters:      lowValue (float) : Candle low.      atrValue (float) : ATR.      gapAtr (float) : Gap in ATR multiples.      slot (int) : Stack slot, starting at 1.   Returns: Label price.
Bibliothek
von Anthonyvilchez
ICE_CRT_AuditLibrary "ICE_CRT_Audit" renderRRAudit(t, tradeEntries, tradeStops, tradeRisks, tradeTp1s, tradeTp1Need, tradeTp1Delta, tradeRRs, tradeDistEs, tradeDistEt1, tradeMissRew, tradeDirs, tradeReasons, minRR, failTotal, avgRR, avgNeedReward, avgMissingRew, avgEntry, avgStop, avgRisk, avgTp1, avgDistStop, avgDistTp1)   Parameters:      t (table)      tradeEntries (array)      tradeStops (array)      tradeRisks (array)      tradeTp1s (array)      tradeTp1Need (array)      tradeTp1Delta (array)      tradeRRs (array)      tradeDistEs (array)      tradeDistEt1 (array)      tradeMissRew (array)      tradeDirs (array)      tradeReasons (array)      minRR (float)      failTotal (int)      avgRR (float)      avgNeedReward (float)      avgMissingRew (float)      avgEntry (float)      avgStop (float)      avgRisk (float)      avgTp1 (float)      avgDistStop (float)      avgDistTp1 (float) renderTp1FormulaAudit(t, tradeDirs, tradeCrtRanges, tradeRatios, tradeDistEt1, tradeDistEs, tradeRRs, tradeNeedRatios, tradeGapRatios, tradeFixAt1, tradeTp1AtRR, minRR, curTp1CrtRatio, auditFixAt1, auditTotal, fixAt1Pct, auditUnfixable, needRatioMax, avgNeedRatio, avgGapRatio)   Parameters:      t (table)      tradeDirs (array)      tradeCrtRanges (array)      tradeRatios (array)      tradeDistEt1 (array)      tradeDistEs (array)      tradeRRs (array)      tradeNeedRatios (array)      tradeGapRatios (array)      tradeFixAt1 (array)      tradeTp1AtRR (array)      minRR (float)      curTp1CrtRatio (float)      auditFixAt1 (int)      auditTotal (int)      fixAt1Pct (float)      auditUnfixable (int)      needRatioMax (float)      avgNeedRatio (float)      avgGapRatio (float)
Bibliothek
von OSMANYBTC
ICE_CRT_CoreLibrary "ICE_CRT_Core" calcBodySize(o, c)   Parameters:      o (float)      c (float) calcRangeSize(h, l)   Parameters:      h (float)      l (float) calcUpperWick(h, o, c)   Parameters:      h (float)      o (float)      c (float) calcLowerWick(l, o, c)   Parameters:      l (float)      o (float)      c (float) calcBodyRatio(bodySize, rangeSize)   Parameters:      bodySize (float)      rangeSize (float) validateCRT(o, h, l, c, bodyRatioMinIn, atrValIn, atrMultIn)   Parameters:      o (float)      h (float)      l (float)      c (float)      bodyRatioMinIn (float)      atrValIn (float)      atrMultIn (float) crtLabelText(isBullish, isBearish)   Parameters:      isBullish (bool)      isBearish (bool) crtLabelStyle(isBullish, isBearish)   Parameters:      isBullish (bool)      isBearish (bool) crtLabelColor(isBullish, isBearish, bullishColor, bearishColor, validColor)   Parameters:      isBullish (bool)      isBearish (bool)      bullishColor (color)      bearishColor (color)      validColor (color) crtLabelPrice(isBullish, isBearish, crtHighIn, crtLowIn, crtMidIn)   Parameters:      isBullish (bool)      isBearish (bool)      crtHighIn (float)      crtLowIn (float)      crtMidIn (float) isGrabHigh(level, minGrab, h)   Parameters:      level (float)      minGrab (float)      h (float) isGrabLow(level, minGrab, l)   Parameters:      level (float)      minGrab (float)      l (float) isAcceptanceHigh(level, buffer, c)   Parameters:      level (float)      buffer (float)      c (float) isAcceptanceLow(level, buffer, c)   Parameters:      level (float)      buffer (float)      c (float) isWickRejectionHigh(level, wickMin, o, h, l, c)   Parameters:      level (float)      wickMin (float)      o (float)      h (float)      l (float)      c (float) isWickRejectionLow(level, wickMin, o, h, l, c)   Parameters:      level (float)      wickMin (float)      o (float)      h (float)      l (float)      c (float) isNoAcceptanceHigh(level, h, c)   Parameters:      level (float)      h (float)      c (float) isNoAcceptanceLow(level, l, c)   Parameters:      level (float)      l (float)      c (float) isFollowThroughRejectionHigh(level, grabBarIn, c, barIdx)   Parameters:      level (float)      grabBarIn (int)      c (float)      barIdx (int) isFollowThroughRejectionLow(level, grabBarIn, c, barIdx)   Parameters:      level (float)      grabBarIn (int)      c (float)      barIdx (int) isRejectedHigh(level, grabBarIn, wickMin, acceptBuf, o, h, l, c, barIdx)   Parameters:      level (float)      grabBarIn (int)      wickMin (float)      acceptBuf (float)      o (float)      h (float)      l (float)      c (float)      barIdx (int) isRejectedLow(level, grabBarIn, wickMin, acceptBuf, o, h, l, c, barIdx)   Parameters:      level (float)      grabBarIn (int)      wickMin (float)      acceptBuf (float)      o (float)      h (float)      l (float)      c (float)      barIdx (int) eventStateName(state)   Parameters:      state (int) processHighLevel(level, trackedLevel, eventState, grabBar, grabLevel, minGrab, rejWindow, wickMin, acceptBuf, o, h, l, c, barIdx)   Parameters:      level (float)      trackedLevel (float)      eventState (int)      grabBar (int)      grabLevel (float)      minGrab (float)      rejWindow (int)      wickMin (float)      acceptBuf (float)      o (float)      h (float)      l (float)      c (float)      barIdx (int) processLowLevel(level, trackedLevel, eventState, grabBar, grabLevel, minGrab, rejWindow, wickMin, acceptBuf, o, h, l, c, barIdx)   Parameters:      level (float)      trackedLevel (float)      eventState (int)      grabBar (int)      grabLevel (float)      minGrab (float)      rejWindow (int)      wickMin (float)      acceptBuf (float)      o (float)      h (float)      l (float)      c (float)      barIdx (int) returnStateName(state)   Parameters:      state (int) isInsideCrtRange(crtHighIn, crtLowIn, buffer, c)   Parameters:      crtHighIn (float)      crtLowIn (float)      buffer (float)      c (float) processReturnLevel(level, trackedLevel, rejectPulseIn, returnStateIn, rejectBarIn, returnBarIn, crtHighIn, crtLowIn, crtReadyIn, retWindowIn, crtBufIn, c, barIdx)   Parameters:      level (float)      trackedLevel (float)      rejectPulseIn (bool)      returnStateIn (int)      rejectBarIn (int)      returnBarIn (int)      crtHighIn (float)      crtLowIn (float)      crtReadyIn (bool)      retWindowIn (int)      crtBufIn (float)      c (float)      barIdx (int) isLegitGrabOpen(stateBefore, levelChanged)   Parameters:      stateBefore (int)      levelChanged (bool) isLegitReturnFromReject(rejectPulse, returnStateBefore, rejectBarBefore)   Parameters:      rejectPulse (bool)      returnStateBefore (int)      rejectBarBefore (int) amdInsideCrtCloseAt(barsBack, crtHighIn, crtLowIn, buffer, cSeries)   Parameters:      barsBack (int)      crtHighIn (float)      crtLowIn (float)      buffer (float)      cSeries (float) amdCountPreGrabInsideCrt(grabOffsetIn, lookbackIn, crtHighIn, crtLowIn, buffer, cSeries)   Parameters:      grabOffsetIn (int)      lookbackIn (int)      crtHighIn (float)      crtLowIn (float)      buffer (float)      cSeries (float) amdCountInsideCrtBetweenGrabSweep(grabOffsetIn, crtHighIn, crtLowIn, buffer, cSeries)   Parameters:      grabOffsetIn (int)      crtHighIn (float)      crtLowIn (float)      buffer (float)      cSeries (float) entryConfirmCandleLong(sweptLevelIn, c, o, insideCrtIn)   Parameters:      sweptLevelIn (float)      c (float)      o (float)      insideCrtIn (bool) entryConfirmCandleShort(sweptLevelIn, c, o, insideCrtIn)   Parameters:      sweptLevelIn (float)      c (float)      o (float)      insideCrtIn (bool) tradeStateName(stateIn)   Parameters:      stateIn (int) tradeStructStopLongPure(entryIn, bufIn, sweepLow, grabLow, tsLow, barLow)   Parameters:      entryIn (float)      bufIn (float)      sweepLow (float)      grabLow (float)      tsLow (float)      barLow (float) tradeStructStopShortPure(entryIn, bufIn, sweepHigh, grabHigh, tsHigh, barHigh)   Parameters:      entryIn (float)      bufIn (float)      sweepHigh (float)      grabHigh (float)      tsHigh (float)      barHigh (float) tradeStructTp1Long(entryIn, crtHighIn, crtLowIn, ratioIn)   Parameters:      entryIn (float)      crtHighIn (float)      crtLowIn (float)      ratioIn (float) tradeStructTp1Short(entryIn, crtHighIn, crtLowIn, ratioIn)   Parameters:      entryIn (float)      crtHighIn (float)      crtLowIn (float)      ratioIn (float) tradeStructTp2Long(crtHighIn)   Parameters:      crtHighIn (float) tradeStructTp2Short(crtLowIn)   Parameters:      crtLowIn (float) tradeStructTp3Long(entryIn, crtHighIn, pdhIn, pwhIn)   Parameters:      entryIn (float)      crtHighIn (float)      pdhIn (float)      pwhIn (float) tradeStructTp3Short(entryIn, crtLowIn, pdlIn, pwlIn)   Parameters:      entryIn (float)      crtLowIn (float)      pdlIn (float)      pwlIn (float) tradeCalcRRatio(entryIn, stopIn, targetIn)   Parameters:      entryIn (float)      stopIn (float)      targetIn (float) tradeValidateLong(entryIn, stopIn, tp1In, tp2In, tp3In, minRRIn)   Parameters:      entryIn (float)      stopIn (float)      tp1In (float)      tp2In (float)      tp3In (float)      minRRIn (float) tradeValidateShort(entryIn, stopIn, tp1In, tp2In, tp3In, minRRIn)   Parameters:      entryIn (float)      stopIn (float)      tp1In (float)      tp2In (float)      tp3In (float)      minRRIn (float) tradeAuditInvalidReason(isLongIn, entryIn, stopIn, tp1In, tp2In, tp3In, minRRIn)   Parameters:      isLongIn (bool)      entryIn (float)      stopIn (float)      tp1In (float)      tp2In (float)      tp3In (float)      minRRIn (float) tradeAuditOrderLongOk(entryIn, tp1In, tp2In, tp3In)   Parameters:      entryIn (float)      tp1In (float)      tp2In (float)      tp3In (float) tradeAuditOrderShortOk(entryIn, tp1In, tp2In, tp3In)   Parameters:      entryIn (float)      tp1In (float)      tp2In (float)      tp3In (float) tradeSimTp2OptA(isLongIn, tp1In, crtHighIn, crtLowIn, betaIn)   Parameters:      isLongIn (bool)      tp1In (float)      crtHighIn (float)      crtLowIn (float)      betaIn (float) tradeSimTp2OptB(isLongIn, entryIn, stopIn, r2In)   Parameters:      isLongIn (bool)      entryIn (float)      stopIn (float)      r2In (float) tradeSimTp2OptC(isLongIn, tp1In, tp3In, gammaIn)   Parameters:      isLongIn (bool)      tp1In (float)      tp3In (float)      gammaIn (float) tradeSimFailsTp2(isLongIn, tp1In, tp2In, tp3In)   Parameters:      isLongIn (bool)      tp1In (float)      tp2In (float)      tp3In (float) tradeSimFailsRR(entryIn, stopIn, tp1In, minRRIn)   Parameters:      entryIn (float)      stopIn (float)      tp1In (float)      minRRIn (float) tradeAuditRRReason(entryIn, stopIn, tp1In, minRRIn)   Parameters:      entryIn (float)      stopIn (float)      tp1In (float)      minRRIn (float) tradeAuditRequiredReward(riskIn, minRRIn)   Parameters:      riskIn (float)      minRRIn (float) tradeAuditMissingReward(riskIn, actualRewardIn, minRRIn)   Parameters:      riskIn (float)      actualRewardIn (float)      minRRIn (float) tradeAuditTp1ForMinRR(isLongIn, entryIn, stopIn, minRRIn)   Parameters:      isLongIn (bool)      entryIn (float)      stopIn (float)      minRRIn (float) tradeAuditTp1Delta(tp1ActualIn, tp1NeedIn)   Parameters:      tp1ActualIn (float)      tp1NeedIn (float) tradeAuditTp1NeedCrtRatio(riskIn, crtRangeIn, minRRIn)   Parameters:      riskIn (float)      crtRangeIn (float)      minRRIn (float) tradeAuditTp1ActualCrtRatio(distEt1In, crtRangeIn)   Parameters:      distEt1In (float)      crtRangeIn (float)
Bibliothek
von OSMANYBTC
chartpatternsLibrary "chartpatterns" Library having complete chart pattern implementation method draw(this)   draws pattern on the chart   Namespace types: Pattern   Parameters:      this (Pattern) : Pattern object that needs to be drawn   Returns: Current Pattern object method draw(this)   draws pattern on the chart   Namespace types: FNPPattern   Parameters:      this (FNPPattern) : FNPPattern object that needs to be drawn   Returns: Current FNPPattern object method erase(this)   erase the given pattern on the chart   Namespace types: Pattern   Parameters:      this (Pattern) : Pattern object that needs to be erased   Returns: Current Pattern object method erase(this)   erase the given pattern on the chart   Namespace types: FNPPattern   Parameters:      this (FNPPattern) : Pattern object that needs to be erased   Returns: Current Pattern object method createFNP(p, base)   creates FNP Pattern from base Pattern   Namespace types: Pattern   Parameters:      p (Pattern) : Pattern object from which the FNP Pattern needs to be created      base (chart.point) : base point of the flag or pennant   Returns: Current Pattern object method push(this, p, maxItems)   push Pattern object to the array by keeping maxItems limit   Namespace types: array   Parameters:      this (array) : array of Pattern objects      p (Pattern) : Pattern object to be added to array @oaram maxItems Max number of items the array can hold      maxItems (int)   Returns: Current Pattern array method push(this, p, maxItems)   push FNPPattern object to the array by keeping maxItems limit   Namespace types: array   Parameters:      this (array) : array of FNPPattern objects      p (FNPPattern) : FNPPattern object to be added to array @oaram maxItems Max number of items the array can hold      maxItems (int)   Returns: Current FNPPattern array method findPattern(this, properties, dProperties, patterns, ohlcArray, maxLivePatterns, draw)   Find patterns based on the currect zigzag object and store them in the patterns array   Namespace types: zg.Zigzag   Parameters:      this (Zigzag type from Trendoscope/ZigzagLite/3) : Zigzag object containing pivots      properties (ScanProperties) : ScanProperties object @oaram dProperties DrawingProperties object      dProperties (DrawingProperties)      patterns (array) : Array of Pattern objects      ohlcArray (array type from Trendoscope/ohlc/3)      maxLivePatterns (int) : max number of patterns to be retained in the patterns array      draw (bool) : pattern is drawn on the chart automatically if set to true   Returns: Current Pattern object method findPatternPlain(this, properties, dProperties, patterns, ohlcArray)   Find patterns based on the currect zigzag object but will not store them in the pattern array.   Namespace types: zg.Zigzag   Parameters:      this (Zigzag type from Trendoscope/ZigzagLite/3) : Zigzag object containing pivots      properties (ScanProperties) : ScanProperties object @oaram dProperties DrawingProperties object      dProperties (DrawingProperties)      patterns (array) : Array of Pattern objects      ohlcArray (array type from Trendoscope/ohlc/3)   Returns: Flag indicating if the pattern is valid, Current Pattern object method findFNP(this, currentPattern, sProperties)   Find flag and pennant patterns based on the current zigzag object and returns the pattern object along with flag   Namespace types: zg.Zigzag   Parameters:      this (Zigzag type from Trendoscope/ZigzagLite/3) : Zigzag object containing pivots      currentPattern (Pattern) : Pattern object to be used as base      sProperties (ScanProperties) : ScanProperties object   Returns: Flag indicating if the fng pattern is valid, new FNPPattern object ScanProperties   Object containing properties for pattern scanning   Fields:      offset (series int) : Zigzag pivot offset. Set it to 1 for non repainting scan.      numberOfPivots (series int) : Number of pivots to be used in pattern search. Can be either 5 or 6      errorRatio (series float) : Error Threshold to be considered for comparing the slope of lines      flatRatio (series float) : Retracement ratio threshold used to determine if the lines are flat      flagRatio (series float) : max ratio threshold for flag and pennnant      checkBarRatio (series bool) : Also check bar ratio are within the limits while scanning the patterns      barRatioLimit (series float) : Bar ratio limit used for checking the bars. Used only when checkBarRatio is set to true      avoidOverlap (series bool) : avoid overlapping patterns.      repaint (series bool) : allow repainting pattern if the new coordinates are more appropriate      allowedPatterns (array) : array of bool encoding the allowed pattern types.      allowedLastPivotDirections (array) : array of int representing allowed last pivot direction for each pattern types      themeColors (array) : color array of themes to be used. DrawingProperties   Object containing properties for pattern drawing   Fields:      patternLineWidth (series int) : Line width of the pattern trend lines      showZigzag (series bool) : show zigzag associated with pattern      zigzagLineWidth (series int) : line width of the zigzag lines. Used only when showZigzag is set to true      zigzagLineColor (series color) : color of the zigzag lines. Used only when showZigzag is set to true      showPatternLabel (series bool) : display pattern label containing the name      patternLabelSize (series string) : size of the pattern label. Used only when showPatternLabel is set to true      showPivotLabels (series bool) : Display pivot labels of the patterns marking 1-6      pivotLabelSize (series string) : size of the pivot label. Used only when showPivotLabels is set to true      pivotLabelColor (series color) : color of the pivot label outline. chart.bg_color or chart.fg_color are the appropriate values.      deleteOnPop (series bool) : delete the pattern when popping out from the array of Patterns. Pattern   Object containing Individual Pattern data   Fields:      pivots (array type from Trendoscope/ZigzagLite/3) : array of Zigzag Pivot points      trendLine1 (Line type from Trendoscope/LineWrapper/2) : First trend line joining pivots 1, 3, 5      trendLine2 (Line type from Trendoscope/LineWrapper/2) : Second trend line joining pivots 2, 4 (, 6)      properties (DrawingProperties) : DrawingProperties Object carrying common properties      patternColor (series color) : Individual pattern color. Lines and labels will be using this color.      ratioDiff (series float) : Difference between trendLine1 and trendLine2 ratios      zigzagLine (series polyline) : Internal zigzag line drawing Object      pivotLabels (array) : array containning Pivot labels      patternLabel (series label) : pattern label Object      patternType (series int) : integer representing the pattern type      patternName (series string) : Type of pattern in string FNPPattern   Object containing Individual Pattern data   Fields:      pivots (array type from Trendoscope/ZigzagLite/3) : array of Zigzag Pivot points      trendLine1 (Line type from Trendoscope/LineWrapper/2) : First trend line joining pivots 1, 3, 5      trendLine2 (Line type from Trendoscope/LineWrapper/2) : Second trend line joining pivots 2, 4 (, 6)      baseLine (Line type from Trendoscope/LineWrapper/2) : Base line of the flag or pennant      properties (DrawingProperties) : DrawingProperties Object carrying common properties      patternColor (series color) : Individual pattern color. Lines and labels will be using this color.      ratioDiff (series float) : Difference between trendLine1 and trendLine2 ratios      zigzagLine (series polyline) : Internal zigzag line drawing Object      pivotLabels (array) : array containning Pivot labels      patternLabel (series label) : pattern label Object      patternType (series int) : integer representing the pattern type      patternName (series string) : Type of pattern in string
Bibliothek
von bootcampuk2505
DivergenceLineLabelOutput_UtilitiesDivergenceLineLabelOutput_Utilities is a shared Pine v6 output library for scripts that already have their own oscillator, pivot, structure, or divergence logic but want a reusable divergence-rendering layer. It centralizes the parts of the workflow that tend to get rewritten across oscillator scripts: • HH / LH / HL / LL / EQ structure resolution • regular / hidden divergence state checks • same-structure context state checks • divergence and context color routing • standardized divergence/context label text • price-pane and oscillator-pane line helpers • price-pane and oscillator-pane label helpers • confirmed-object slot visibility helpers • live-preview line and label helpers • native-pane and price-pane pivot context box helpers On the example chart, the confirmed divergence lines, live preview lines, divergence labels, context labels, and pivot context boxes are all materially driven by this library. This library is intentionally focused on output and object management. It does not calculate RSI, MACD, VFI, volume flow, pressure, or any other oscillator. It does not confirm pivots or decide which pivots are valid. Calling scripts remain responsible for their own oscillator engine, pivot engine, comparison logic, colors, visibility modes, and signal interpretation. How to use Import the library near the top of your script in global scope, alongside any other imports, before you start calling its helpers. Typical placement: //@version=6 indicator(...) or strategy(...) import MYNAMEISBRANDON/DivergenceLineOutput_Utilities/1 as DivUtils Replace /1 with the latest published version if a newer version is available. This library expects the calling script to already know the price pivot, oscillator pivot, prior pivot reference, structure state, and output settings it wants to use. The library then handles the reusable line, label, live-preview, slot-budget, and box output layer. ➖Structure + Divergence State Helpers➖ These helpers convert pivot comparisons into structure tags and divergence/context states. divStructure(curr, prev, isHigh) Resolves HH, LH, HL, LL, or EQ from a current pivot and previous pivot. Parameters: curr (float): Current pivot value prev (float): Previous pivot value isHigh (bool): True for high-side comparison, false for low-side comparison Returns: Structure string divState(priceStruct, oscStruct) Resolves regular and hidden divergence states from price and oscillator structure tags. Returns: regularBear, regularBull, hiddenBear, hiddenBull, anyDivergence divContextState(priceStruct, oscStruct) Resolves same-structure context states from price and oscillator structure tags. Returns: highContinuation, highFade, lowContinuation, lowLift, anyContext divColor(priceStruct, oscStruct, regularBearColor, regularBullColor, hiddenBearColor, hiddenBullColor, highContinuationColor, lowContinuationColor, highFadeColor, lowLiftColor, fallbackColor) Routes a divergence or context pair to the matching caller-supplied color. Returns: Resolved color ➖Style + Label Helpers➖ These helpers keep divergence output styling consistent across scripts. divLineStyle(styleIn) Converts user-facing line-style text into Pine line-style enums. Parameters: styleIn (simple string): Solid, Dashed, or Dotted Returns: Pine line style divLabelSize(sizeIn) Converts user-facing label-size text into Pine label-size enums. Parameters: sizeIn (simple string): Tiny, Small, Normal, Large, or Huge Returns: Pine label size divContrastText(bg) Chooses black or white text based on background brightness. Parameters: bg (color): Background color Returns: Readable contrast text color divLabelText(divType, divSide, priceStruct, oscStruct, formatMode) Builds standardized divergence label text. Parameters: divType (simple string): Usually Reg or Hid divSide (simple string): Usually Bull or Bear priceStruct (string): Price structure tag oscStruct (string): Oscillator structure tag formatMode (simple string): Full, No Prefix, or Type Only Returns: Formatted label text ➖Confirmed Line Helpers➖ These helpers create and manage confirmed divergence or context lines. clearLines(lines, colors) Deletes all lines in an array and clears the matching color array. pushOscLine(lines, colors, show, active, x1, y1, x2, y2, lineColor, lineTransp, lineWidth, lineStyle, maxLines) Pushes a confirmed oscillator-pane line into line/color arrays. pushPriceLine(lines, colors, show, active, x1, y1, x2, y2, lineColor, lineTransp, lineWidth, lineStyle, maxLines) Pushes a confirmed price-pane line into line/color arrays using force_overlay=true. Note: Price helpers draw on the main chart from overlay=false oscillator scripts. Oscillator helpers draw in the script’s native pane. ➖Confirmed Label Helpers➖ These helpers create and manage confirmed divergence or context labels. clearLabels(labels, colors) Deletes all labels in an array and clears the matching color array. pushOscLabel(labels, colors, show, active, xIndex, y, labelText, styleText, lineColor, labelTextOnly, labelBgTransp, labelSize, maxLabels) Pushes a confirmed oscillator-pane label into label/color arrays. pushPriceLabel(labels, colors, show, active, xTime, labelText, ylocText, styleText, lineColor, labelTextOnly, labelBgTransp, labelSize, maxLabels) Pushes a confirmed price-pane label into label/color arrays using force_overlay=true. Note: For price-pane labels, xTime uses bar time and ylocText controls whether the label appears above or below the price bar. ➖Confirmed Slot Visibility Helpers➖ These helpers allow scripts to keep confirmed lines and labels stored while only showing the most recent visible slots. applyLineSlots(lines, colors, visibleSlots) Applies a visible slot budget to confirmed line arrays without deleting older objects. applyLabelSlots(labels, colors, visibleSlots, labelTextOnly, labelBgTransp) Applies a visible slot budget to confirmed label arrays without deleting older objects. Example: • Max Regular Lines = 1 - Live regular active = live regular only - No live regular = latest confirmed regular only • Max Regular Lines = 2 - Live regular active = live regular + latest confirmed regular - No live regular = latest two confirmed regular lines ➖Live Preview Line Helpers➖ These helpers create, update, or delete live divergence preview lines. syncLiveOscLine(ln, show, x1, y1, x2, y2, lineColor, lineWidth, lineStyle) Creates, updates, or deletes a live oscillator-pane line. syncLivePriceLine(ln, show, x1, y1, x2, y2, lineColor, lineWidth, lineStyle) Creates, updates, or deletes a live price-pane line using force_overlay=true. ➖Live Preview Label Helpers➖ These helpers create, update, or delete live divergence preview labels. syncLiveOscLabel(lbl, show, xIndex, y, labelText, styleText, lineColor, labelTextOnly, labelBgTransp, labelSize) Creates, updates, or deletes a live oscillator-pane label. syncLivePriceLabel(lbl, show, xTime, labelText, ylocText, styleText, lineColor, labelTextOnly, labelBgTransp, labelSize) Creates, updates, or deletes a live price-pane label using force_overlay=true. ➖Pivot Context Box Helpers➖ These helpers provide lightweight box utilities for scripts that want to frame confirmed pivot zones. divPivotBoxBounds(pivotValue, innerPct) Resolves a thin box around a pivot value using an inner percentage. Returns: top, bottom, ok syncNativeBox(bx, show, left, right, top, bottom, fillColor, borderColor, borderStyle, borderWidth) Creates, updates, or deletes a native-pane pivot context box. syncPriceBox(bx, show, left, right, top, bottom, fillColor, borderColor, borderStyle, borderWidth) Creates, updates, or deletes a price-pane pivot context box using force_overlay=true. ➖Divergence Model➖ Regular Bearish Divergence: Price makes HH while oscillator makes LH. Regular Bullish Divergence: Price makes LL while oscillator makes HL. Hidden Bearish Divergence: Price makes LH while oscillator makes HH. Hidden Bullish Divergence: Price makes HL while oscillator makes LL. ➖Structure Context Model➖ High-side continuation: Price makes HH while oscillator also makes HH. High-side fading: Price makes LH while oscillator also makes LH. Low-side continuation: Price makes LL while oscillator also makes LL. Low-side lifting: Price makes HL while oscillator also makes HL. Structure context is not divergence. It shows same-structure agreement between price and oscillator. ➖Important Notes➖ This library is an output utility layer only. It does not: • calculate an oscillator • confirm pivots • choose pivot anchors • decide whether a divergence is valid • decide trade direction • decide final signal logic Calling scripts remain responsible for: • oscillator calculation • pivot confirmation • price/oscillator comparison logic • visibility settings • color choices • max-line and max-label budgets • final visual interpretation For overlay=false oscillator scripts, Price + Oscillator / Price Only / Oscillator Only / Hide output modes work well. For overlay=true price-pane scripts, Price Only / Hide output modes usually make the most sense.
Bibliothek
von MYNAMEISBRANDON
Obj_XABCD_HarmonicLibrary "Obj_XABCD_Harmonic" Harmonic XABCD Pattern object and associated methods. Easily validate, draw, and get information about harmonic patterns. See example code at the end of the script for details. init_params(pct_error, pct_asym, types, w_e, w_p, w_d)   Create a harmonic parameters object (used by xabcd_harmonic object for pattern validation and scoring).   Parameters:      pct_error (float) : Allowed % error of leg retracement ratio versus the defined harmonic ratio      pct_asym (float) : Allowed leg length/period asymmetry % (a leg is considered invalid if it is this % longer or shorter than the average length of the other legs)      types (array) : Array of pattern types to validate (1=Gartley, 2=Bat, 3=Butterfly, 4=Crab, 5=Shark, 6=Cypher, 7=Alt-Bat, 8=Deep Butterfly, 9=Deep Crab)      w_e (float) : Weight of ratio % error (used in score calculation, dft = 1)      w_p (float) : Weight of PRZ confluence (used in score calculation, dft = 1)      w_d (float) : Weight of Point D / PRZ confluence (used in score calculation, dft = 1)   Returns: harmonic_params object instance. It is recommended to store and reuse this object for multiple xabcd_harmonic objects rather than creating new params objects unnecessarily. method erase_pattern(p)   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) init(x, a, b, c, d, params, tp, p)   Initialize an xabcd_harmonic object instance from a given set of points If the pattern is valid, an xabcd_harmonic object instance is returned. If you want to specify your own validation and scoring parameters, you can do so by passing a harmonic_params object (params). Or, if you prefer to do your own validation, you can explicitly pass the harmonic pattern type (tp) and validation will be skipped. You can also pass in an existing xabcd_harmonic instance if you wish to re-initialize it (e.g. for re-validation and/or re-scoring).   Parameters:      x (point type from reees/Pattern/1) : Point X      a (point type from reees/Pattern/1) : Point A      b (point type from reees/Pattern/1) : Point B      c (point type from reees/Pattern/1) : Point C      d (point type from reees/Pattern/1) : Point D      params (harmonic_params) : harmonic_params used to validate and score the pattern. Validation will be skipped if a type (tp) is explicitly passed in.      tp (int) : Pattern type      p (xabcd_harmonic) : xabcd_harmonic object instance to initialize (optional, for re-validation/re-scoring)   Returns: xabcd_harmonic object instance if a valid harmonic, else na init(xX, xY, aX, aY, bX, bY, cX, cY, dX, dY, params, tp, p)   Initialize an xabcd_harmonic object instance from a given set of x and y coordinate values. If the pattern is valid, an xabcd_harmonic object instance is returned. If you want to specify your own validation and scoring parameters, you can do so by passing a harmonic_params object (params). Or, if you prefer to do your own validation, you can explicitly pass the harmonic pattern type (tp) and validation will be skipped. You can also pass in an existing xabcd_harmonic instance if you wish to re-initialize it (e.g. for re-validation and/or re-scoring).   Parameters:      xX (int) : Point X bar index (required)      xY (float) : Point X price/level (required)      aX (int) : Point A bar index (required)      aY (float) : Point A price/level (required)      bX (int) : Point B bar index (required)      bY (float) : Point B price/level (required)      cX (int) : Point C bar index (required)      cY (float) : Point C price/level (required)      dX (int) : Point D bar index      dY (float) : Point D price/level      params (harmonic_params) : harmonic_params used to validate and score the pattern. Validation will be skipped if a type (tp) is explicitly passed in.      tp (int) : Pattern type      p (xabcd_harmonic) : xabcd_harmonic object instance to initialize (optional, for re-validation/re-scoring)   Returns: xabcd_harmonic object instance if a valid harmonic, else na init(pattern, params, tp, p)   Initialize an xabcd_harmonic object instance from a given pattern If the pattern is valid, an xabcd_harmonic object instance is returned. If you want to specify your own validation and scoring parameters, you can do so by passing a harmonic_params object (params). Or, if you prefer to do your own validation, you can explicitly pass the harmonic pattern type (tp) and validation will be skipped. You can also pass in an existing xabcd_harmonic instance if you wish to re-initialize it (e.g. for re-validation and/or re-scoring).   Parameters:      pattern (pattern type from reees/Pattern/1) : Pattern      params (harmonic_params) : harmonic_params used to validate and score the pattern. Validation will be skipped if a type (tp) is explicitly passed in.      tp (int) : Pattern type      p (xabcd_harmonic) : xabcd_harmonic object instance to initialize (optional, for re-validation/re-scoring)   Returns: xabcd_harmonic object instance if a valid harmonic, else na method get_name(p)   Get the pattern name   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object   Returns: Pattern name (string) method get_symbol(p)   Get the pattern symbol from a pattern instance   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object   Returns: Pattern symbol string get_symbol(tp)   Get the pattern symbol for a given pattern type integer. Static overload — does not require a pattern instance.   Parameters:      tp (int) : Pattern type (1=Gartley, 2=Bat, 3=Butterfly, 4=Crab, 5=Shark, 6=Cypher, 7=Alt-Bat, 8=Deep Butterfly, 9=Deep Crab)   Returns: Pattern symbol string method get_pid(p)   Get the Pattern ID. Patterns of the same type with the same coordinates will have the same Pattern ID.   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object   Returns: Pattern ID (string) method prz_range(p)   Returns cached PRZ upper and lower bounds.   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object   Returns: method incomplete_pid(p)   Returns the pattern ID as if point D were unconfirmed (na). Used to match incomplete patterns against their completed counterparts during deduplication. Ensures pid format is consistent with the library's internal pid generation.   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object   Returns: Pattern ID string with D forced to na method set_target(p, target, target_lvl, calc_target)   Set value for a target. Use the calc_target parameter to automatically calculate the target for a specific harmonic ratio.   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object      target (int) : Target (1 or 2)      target_lvl (float) : Target price/level (required if calc_target is not specified)      calc_target (string) : Target to auto calculate (required if target is not specified) Options:   Returns: Target price/level (float) method draw_pattern(p, clr)   Draw the pattern   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object      clr (color)   Returns: Pattern lines method erase_label(p)   Erase the pattern label   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object   Returns: p method draw_prz_levels(p, clr, extendBars)   Draw PRZ target levels as horizontal dashed lines for incomplete patterns. Shows where point D needs to land without implying a specific price path.   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object      clr (color) : Line color      extendBars (int) : Number of bars to extend the lines to the right (default 50)   Returns: — the two PRZ level lines method draw_label(p, clr, txt_clr, txt, tooltip)   Draw the pattern label. Default text is the pattern name.   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object      clr (color) : Label color      txt_clr (color) : Text color      txt (string) : Label text      tooltip (string) : Tooltip text   Returns: Label method is_complete(p)   Returns true if the pattern has a confirmed point D. A pattern is complete when D exists AND is not an unconfirmed pivot. Use this instead of checking na(p.d.x) directly — invalid_d being false is a required condition that bare na checks miss.   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object   Returns: bool method age_pct(p, tLimitMult)   Returns how far through the pattern's time limit it is, as a 0.0–1.0 float. 0.0 = just confirmed, 1.0 = time limit reached. Returns na if pattern has no confirmed D point.   Namespace types: xabcd_harmonic   Parameters:      p (xabcd_harmonic) : Instance of xabcd_harmonic object      tLimitMult (float) : Pattern time limit multiplier (same value used in main script)   Returns: float 0.0–1.0 harmonic_params   Validation and scoring parameters for a Harmonic Pattern object (xabcd_harmonic)   Fields:      pct_error (series float) : Allowed % error of leg retracement ratio versus the defined harmonic ratio      pct_asym (series float)      types (array)      w_e (series float)      w_p (series float)      w_d (series float) xabcd_harmonic   Harmonic Pattern object   Fields:      bull (series bool) : Bullish pattern flag      tp (series int)      x (point type from reees/Pattern/1)      a (point type from reees/Pattern/1)      b (point type from reees/Pattern/1)      c (point type from reees/Pattern/1)      d (point type from reees/Pattern/1)      r_xb (series float)      re_xb (series float)      r_ac (series float)      re_ac (series float)      r_bd (series float)      re_bd (series float)      r_xd (series float)      re_xd (series float)      score (series float)      score_eAvg (series float)      score_prz (series float)      score_eD (series float)      prz_bN (series float)      prz_bF (series float)      prz_xN (series float)      prz_xF (series float)      przUpper (series float)      przLower (series float)      t1Hit (series bool) : Target 1 flag      t1 (series float)      t2Hit (series bool)      t2 (series float)      sHit (series bool) : Stop flag      stop (series float) : Stop level      entry (series float) : Entry level      eHit (series bool)      e (point type from reees/Pattern/1)      invalid_d (series bool)      pLines (array)      pLabel (series label)      cdLine (series line)      pid (series string)      params (harmonic_params)
Bibliothek
von BagHoldingCat_ftw
1
TVNoGo_AR2_LibLibrary "TVNoGo_AR2_Lib" check(s1, scriptCode, slotSeconds)   Parameters:      s1 (float)      scriptCode (simple string)      slotSeconds (simple int) checkDev(s1, scriptCode, slotSeconds, devMode, devStartTime, devOkMinutes, devGraceMinutes)   Parameters:      s1 (float)      scriptCode (simple string)      slotSeconds (simple int)      devMode (simple bool)      devStartTime (simple int)      devOkMinutes (simple int)      devGraceMinutes (simple int)
Bibliothek
von Fredlamarsa
CyberVisLib# CyberVisLib v5 CyberVisLib provides rendering and visualization utilities for multi-oscillator indicators: color blending, sub-pane management, diagnostic tables, and tooltip formatting. Pure visualization layer—no market logic. ## What it does Delivers four capabilities: color utilities (RGB blending, diverging/sequential gradients, confidence-to-transparency), sub-pane management (vertical space allocation for multiple oscillators), diagnostic tables (key-value pairs, dynamic coloring), and tooltip formatting. Stack RSI, MACD, Stochastic in non-overlapping vertical bands. Outputs color values, MiniSubPane structs (band coordinates), table objects, formatted strings. All stateless, rendering-focused. ## How it works Color blending: `RGB_out = (1-t)×RGB_a + t×RGB_b`. Diverging gradients split at zero (negative→red-yellow, positive→yellow-green). Transparency: `90 - 60×confidence`. Sub-pane management: 1. Register oscillators (MiniOscMeta) 2. Finalize layout (STACK_TOP/BOTTOM/EQUAL_SPLIT policies) 3. Map values: `pane.band_y(unit_val)` converts to vertical coordinate Diagnostic tables: key-value pairs, multi-column grids, conditional formatting. ## Why this is original Only TradingView library with complete rendering toolkit. Existing libraries mix rendering with market logic. Unique features: - Sub-pane vertical allocation (automatic band calculation) - Lightweight UDT variants (co-import with OscLib) - Diverging gradients with zero-centering - Confidence-to-transparency mapping - Regime color enum (consistent color mapping) Separation of concerns: VisLib (rendering), NumLib (math), SignalLib (signals). ## How to use it ```pine //@version=6 indicator("CyberVisLib Demo", overlay=false) import cybermediaboy/CyberVisLib/5 as VL // Diverging gradient rsi = ta.rsi(close, 14) z_rsi = (rsi - 50.0) / 25.0 color rsi_color = VL.f_diverging_rgyg(z_rsi) plot(rsi, "RSI", color=rsi_color) // Sub-pane management var spm = VL.f_subpane_manager_new(VL.SubPanePolicy.EQUAL_SPLIT, 5.0) if barstate.isfirst spm.register(VL.f_meta_unipolar0100("rsi", "RSI", color.blue)) spm.register(VL.f_meta_bipolar("macd", "MACD", color.orange)) spm.finalize() var pane_rsi = array.get(spm.panes, 0) rsi_y = pane_rsi.band_y(pane_rsi.meta.to_unit(rsi)) plot(rsi_y, "RSI Pane", color.blue) // Confidence transparency conf = math.abs(rsi - 50.0) / 50.0 bgcolor(color.new(color.green, VL.f_transp(conf))) ``` ## Key functions - `f_blend()` - RGB color blending - `f_diverging_rgyg()` - Diverging gradient (zero-centered) - `f_transp()` - Confidence-to-transparency mapping - `f_subpane_manager_new()` - Sub-pane allocation - `f_regime_color()` - Regime color enum - `f_kv_tooltip()` - Tooltip formatting ## Limitations - Sub-pane allocation static after finalize - RGB-only blending (no HSL/HSV) - No automatic label/line cleanup - Tables require manual cell updates - Assumes `overlay=false` (separate pane indicators only)
Bibliothek
von cybermediaboy
aether_regime_v1Library "aether_regime_v1" getRegime(adxLen, chopLen, adxThreshold, chopLowFib, chopHighFib)   Parameters:      adxLen (simple int)      chopLen (simple int)      adxThreshold (simple float)      chopLowFib (simple float)      chopHighFib (simple float) regimeColor(regimeStr)   Parameters:      regimeStr (simple string) regimeConfidence(adxVal, adxThreshold)   Parameters:      adxVal (simple float)      adxThreshold (simple float)
Bibliothek
von lilbenxo
K21CommonLibrary "K21Common" minDollarMove()   Calculates the minimum dollar move per tick for the current symbol   Returns: (float) Dollar value per tick movement @description Uses syminfo.pointvalue (contract value per point) and syminfo.minmove (minimum tick movement) to calculate the dollar value of a single tick. This works across all futures contracts without manual configuration. replaceTradeTemplateTags(template, entry_num, description, entry_price, stop_price, tp_price, contracts, risk_dollars, reward_dollars, rr_ratio, max_risk)   Replaces trade related template tags with actual values   Parameters:      template (string) : (string) Template string with tags      entry_num (int) : (int) Entry number (1-5)      description (string) : (string) Entry description      entry_price (float) : (float) Entry price      stop_price (float) : (float) Stop price      tp_price (float) : (float) TP price      contracts (int) : (int) Number of contracts      risk_dollars (float) : (float) Risk in dollars      reward_dollars (float) : (float) Reward in dollars      rr_ratio (float) : (float) Risk:Reward ratio      max_risk (float) : (float) Maximum allowed risk   Returns: (string) Processed template string isLightColor(clr)   Checks if a color is light based on luminance calculation   Parameters:      clr (color) : (color) The color to check   Returns: (bool) True if the color is light isDarkColor(clr)   Checks if a color is dark based on luminance calculation   Parameters:      clr (color) : (color) The color to check   Returns: (bool) True if the color is dark isLightScheme()   Checks if the current chart color scheme is light   Returns: (bool) True if the chart uses a light color scheme isDarkScheme()   Checks if the current chart color scheme is dark   Returns: (bool) True if the chart uses a dark color scheme getBarIndexFromTime(target_time)   Finds the bar_index for a given timestamp by searching historical bars   Parameters:      target_time (int) : (int) The timestamp to find   Returns: (int) The bar_index where time matches or is closest to target_time
Bibliothek
von Knighted21
Pivot_Labels_Output_UtilitiesThis library contains reusable pivot label output helpers for Pine scripts that already have their own pivot, structure, or signal logic but want a shared label-rendering layer. It centralizes the parts of the workflow that tend to get rewritten across label-heavy scripts: label-size resolution, compact percent and price formatting, one-shot pivot label plotting, live directional label management, confirmed/local/current-RSI text builders, early-label emoji output, and live-stack text / object helpers. On the example chart, the visible label workflows are materially driven by the library, whether through the confirmed pivot label text, the local pivot label text, the current RSI + SMA above-bar label, the early directional labels, or the live stack text and label-object lifecycle helpers used to keep those outputs updated cleanly on the chart. How to use Import the library near the top of your script in global scope, alongside any other imports, before you start calling its helpers. Typical placement: // @version=6 indicator(...) or strategy(...) import MYNAMEISBRANDON/PivotLabelsOutput_Utilities/1 as PLutils This library does not confirm pivots, resolve structure tags, or choose label colors for you. Instead, it expects your script to already know the values it wants to display, then uses those resolved inputs to build the output layer. For more information on libraries and incorporating them into your scripts, see the Libraries section of the Pine Script User Manual. ➖Label Size Helpers➖ These helpers convert simple UI-facing size strings into Pine label-size enums so scripts can keep one consistent size resolver across confirmed pivot labels, local pivot labels, current RSI labels, early labels, and live stack labels. labelSizeFromString(sizeIn) Resolves a Pine label size from a string input. Parameters: sizeIn (simple string): Size string. Expected values: "Tiny", "Small", "Normal", "Large", or "Huge" Returns: Pine label size enum ➖Numeric Formatting Helpers➖ These helpers handle compact numeric formatting for label-driven scripts. They let a script calculate percent change safely, format that change in a label-friendly way, and convert larger price values into compact significant-figure style text. labelPercentChange(curr, prev) Returns percent change from prev to curr. Parameters: curr (float): Current value prev (float): Previous reference value Returns: Percent change or na when invalid labelFormatPercent(p) Formats a percent value for compact label output. Parameters: p (float): Percent value Returns: Formatted percent string labelFormatCompactNumber(x, sig) Formats a number using significant-figure style suffix output. Parameters: x (float): Value to format sig (simple int): Significant figures to preserve Returns: Compact number string ➖Static Label Plot Helpers➖ These helpers create one-shot label outputs for scripts that want to place confirmed or local pivot labels on historical pivot bars, or simple above-bar informational labels, without managing a live label object afterward. plotPivotLabel(x, y, txt, textColor, isHigh, sizeIn) Creates a pivot label on a specific bar. Parameters: x (int): Label x position y (float): Label y position txt (string): Label text textColor (color): Label text color isHigh (bool): True for a high-side label, false for a low-side label sizeIn (simple string): Label size string Returns: Created label reference plotAboveBarLabel(x, y, txt, textColor, sizeIn) Creates an above-bar informational label. Parameters: x (int): Label x position y (float): Label y position txt (string): Label text textColor (color): Label text color sizeIn (simple string): Label size string Returns: Created label reference ➖Directional Label Object Helpers➖ These helpers manage the lifecycle of live high-side and low-side label objects so scripts can create, update, or delete directional labels without repeating the same object-management logic each time. manageDirectionalLabel(lbl, show, x, y, txt, textColor, isHigh, sizeIn) Creates, updates, or deletes a directional label object. Parameters: lbl (label): Existing label reference show (bool): Whether the label should exist x (int): Label x position y (float): Label y position txt (string): Label text textColor (color): Label text color isHigh (bool): True for a high-side label, false for a low-side label sizeIn (simple string): Label size string Returns: Updated label reference ➖Pivot Text Helpers➖ These helpers build the final text used by confirmed pivot labels, local pivot labels, confirmed pivot alerts, and the current RSI / SMA above-bar label. In other words, this region keeps the script’s visible wording consistent while leaving structure resolution and color decisions to the calling script. buildMajorPivotLabelText(mode, priceText, priceStruct, rsiText, oscStruct, percentText, pivotLen, showLen) Builds confirmed pivot label text. Parameters: mode (simple string): Label mode. Expected values: "Full" or "RSI Only" priceText (string): Formatted pivot price priceStruct (string): Price-side structure tag rsiText (string): Formatted pivot RSI oscStruct (string): RSI-side structure tag percentText (string): Formatted percent-change text pivotLen (int): Pivot length value showLen (bool): Whether pivot length should be shown Returns: Confirmed pivot label text buildLocalPivotLabelText(priceText, priceStruct, rsiText, rsiStruct, pivotLen, showPrice, showLen) Builds local pivot label text. Parameters: priceText (string): Formatted local pivot price priceStruct (string): Price-side structure tag rsiText (string): Formatted local pivot RSI rsiStruct (string): RSI-side structure tag pivotLen (int): Pivot length value showPrice (bool): Whether the price line should be shown showLen (bool): Whether pivot length should be shown Returns: Local pivot label text buildPivotAlertText(isHigh, priceText, pctText, rsiText, structTag, rsiValue, rsiOB, rsiOS) Builds confirmed pivot alert text. Parameters: isHigh (bool): True for a high pivot, false for a low pivot priceText (string): Formatted pivot price pctText (string): Formatted percent-change text rsiText (string): Formatted pivot RSI structTag (string): RSI-side structure tag rsiValue (float): Raw RSI value at the pivot rsiOB (int): Overbought level rsiOS (int): Oversold level Returns: Alert message text buildCurrentRsiAboveBarText(currRsiText, structTag, smaText) Builds current RSI / SMA above-bar label text. Parameters: currRsiText (string): Formatted current RSI text structTag (string): Current live structure tag smaText (string): Formatted SMA text Returns: Current RSI above-bar label text ➖Early Pivot Label Helpers➖ These helpers provide the reusable output primitive used by early pivot labels. This region intentionally stops at emoji selection so scripts with different structure-tag models and color logic can still reuse the same active-vs-carried-forward label cue. earlyPivotEmoji(isHigh, isCurrentCandidateBar) Returns the early-pivot emoji for the active side and candidate state. Parameters: isHigh (bool): True for a high-side early label, false for a low-side early label isCurrentCandidateBar (bool): True when the candidate bar is the current bar Returns: Early-pivot emoji ➖Live Stack Text Helpers➖ These helpers build the reusable text layer behind live stack labels. They handle padded line construction, signed delta wording, movement glyphs, and the multi-line center block used to display price, anchor tag, RSI, RSI delta, SMA, and SMA delta. stackSignedRoundText(x) Returns a rounded signed text value for live-stack display. Parameters: x (float): Value to round Returns: Signed rounded text stackMoveGlyph(delta) Returns the move glyph used by live-stack delta text. Parameters: delta (float): Delta value Returns: Move glyph stackDeltaText(change, structTag, isPercent, pad) Builds padded delta text for the live stack. Parameters: change (float): Delta value structTag (string): Structure tag to append isPercent (bool): Whether the delta should be formatted as a percent pad (int): EM-space padding count Returns: Padded delta text stackRsiDiffText(delta, structTag, pad) Builds padded RSI-delta text for the live stack. Parameters: delta (float): RSI delta value structTag (string): Structure tag to append pad (int): EM-space padding count Returns: Padded RSI-delta text stackCenterText(price, rsiVal, rsiDelta, rsiSma, rsiSmaDelta, anchorTag, pad, sigFigs) Builds the live-stack center block text. Parameters: price (float): Current price rsiVal (float): Current RSI value rsiDelta (float): Current bar-to-bar RSI delta rsiSma (float): Current RSI SMA value rsiSmaDelta (float): Current bar-to-bar RSI SMA delta anchorTag (string): Active anchor tag such as "➜H" or "➜L" pad (int): EM-space padding count sigFigs (simple int): Significant figures used for price formatting Returns: Center live-stack text block ➖Live Stack Label Object Helpers➖ These helpers manage the lifecycle of live center-style stack labels so scripts can create, update, or delete the visible stack objects without repeatedly rewriting that object-management logic. manageCenterLabel(lblPrev, show, yVal, txt, textColor, xPos, linesBefore, linesAfter, sizeIn) Creates, updates, or deletes a center-style live-stack label. Parameters: lblPrev (label): Existing label reference show (bool): Whether the label should exist yVal (float): Label y position txt (string): Label text textColor (color): Label text color xPos (int): Label x position linesBefore (int): Blank lines inserted before the text block linesAfter (int): Blank lines inserted after the text block sizeIn (simple string): Label size string Returns: Updated label reference Local Pivot label demo (with pin emoji)— shows the library’s smaller same-side pivot label format on its own for a cleaner view of the local-label workflow.
Bibliothek
von MYNAMEISBRANDON
PivotStructureOutline_UtilitiesThis library contains reusable pivot structure outline helpers for Pine scripts that already work with confirmed pivot highs and lows. It is designed to provide the reusable outline and anchor-box layer for scripts that already have their own pivot-confirmation logic, so those scripts can keep their structure visuals consistent without repeatedly rebuilding the same framework. It brings together the parts of the workflow that are often rewritten in structure-based scripts: resolving pivot-close anchors, selecting wick vs close anchor behavior, building live outline geometry, building pivot structure anchor-box geometry, and managing the line and box objects that render those visuals. Everything on the example chart is materially driven by the library, whether through the selected outline anchor source, the outline geometry itself, the midpoint-start logic, the pivot structure anchor boxes, or the shared line/box lifecycle helpers used to keep those visuals updated cleanly on the chart. How to use Import the library near the top of your script in global scope, alongside any other imports, before you start calling its helpers. This mirrors the import-first usage pattern shown on your recent library page. Typical placement: //@version=6 indicator(...) or strategy(...) import MYNAMEISBRANDON/PivotStructureOutline_Utilities/1 as PSOutils This library is engine-agnostic. It does not confirm pivots for you. Instead, it expects your script to already know its confirmed high/low pivot indexes and anchor values, then uses those resolved inputs to build the outline and anchor-box layer. ➖Outline Line Style Helpers➖ These helpers convert simple UI-facing style strings into Pine line style enums so scripts can keep one consistent style resolver across outline lines, midpoint lines, and connector lines. outlineLineStyle(styleIn) Resolves a Pine line style from a string input. Parameters: styleIn (simple string): Style string. Expected values: "Solid", "Dashed", or "Dotted" Returns: Pine line style enum ➖Pivot Structure Outline Helpers➖ These helpers build the actual pivot structure outline framework from already-confirmed high/low pivot anchors. They let a script resolve a pivot-close anchor, choose whether the outline should use wick or close anchors, and generate the live geometry needed for the top line, bottom line, midpoint, and left-side connectors. outlinePivotCloseFromIdx(pivotIdx, closeValue) Returns the close value belonging to a confirmed pivot index. Parameters: pivotIdx (int): Confirmed pivot bar_index closeValue (float): Close series Returns: Confirmed pivot close value outlineSelectedAnchors(anchorMode, highWickAnchor, lowWickAnchor, highCloseAnchor, lowCloseAnchor) Selects the active outline anchors from Wick or Close mode. Parameters: anchorMode (simple string): Anchor mode. Expected values: "Wick" or "Close" highWickAnchor (float): Confirmed high-side wick anchor lowWickAnchor (float): Confirmed low-side wick anchor highCloseAnchor (float): Confirmed high-side close anchor lowCloseAnchor (float): Confirmed low-side close anchor Returns: Selected high anchor, selected low anchor, is outline-valid outlineGeometry(highPivotIdx, lowPivotIdx, highAnchor, lowAnchor, connectorSourceMode, midlineStartMode, highValue, lowValue, closeValue) Returns the live geometry for the pivot structure outline system. Parameters: highPivotIdx (int): Confirmed high pivot bar_index lowPivotIdx (int): Confirmed low pivot bar_index highAnchor (float): Selected top outline anchor lowAnchor (float): Selected bottom outline anchor connectorSourceMode (simple string): Connector source mode. Expected values: "Wick" or "Close" midlineStartMode (simple string): Midline start mode. Expected values: "Most Recent Pivot" or "Left Outline" highValue (float): High series lowValue (float): Low series closeValue (float): Close series Returns: ok, leftX, rightX, midX1, topY, bottomY, midY, leftTopConnectorY, leftBottomConnectorY ➖Pivot Structure Anchor Box Helpers➖ These helpers build directional top and bottom pivot structure anchor boxes from confirmed pivot bars. They let a script choose whether those boxes use wick-only extension from the candle body or the full candle body, then return the live coordinates needed to render those boxes forward to the current bar. outlineAnchorBoxGeometry(highPivotIdx, lowPivotIdx, boxAreaMode, openValue, highValue, lowValue, closeValue) Returns the live geometry for top and bottom pivot structure anchor boxes. Parameters: highPivotIdx (int): Confirmed high pivot bar_index lowPivotIdx (int): Confirmed low pivot bar_index boxAreaMode (simple string): Box area mode. Expected values: "Wick" or "Body" openValue (float): Open series highValue (float): High series lowValue (float): Low series closeValue (float): Close series Returns: showHighBox, showLowBox, highLeftX, lowLeftX, boxRightX, highTopY, highBottomY, lowTopY, lowBottomY ➖Line Object Helpers➖ These helpers manage the lifecycle of live line objects so scripts can create, update, or delete outline-related lines without rewriting that object-management logic each time. outlineManageLine(enabled, ln, x1, y1, x2, y2, col, width, style) Creates, updates, or deletes a line object. Parameters: enabled (bool): Whether the line should exist ln (line): Existing line reference x1 (int): Start x position y1 (float): Start y position x2 (int): End x position y2 (float): End y position col (color): Line color width (int): Line width style (string): Line style Returns: Updated line reference ➖Box Object Helpers➖ These helpers manage the lifecycle of live box objects so scripts can create, update, or delete pivot structure anchor boxes without repeating the same box-management code in every script. outlineManageBox(enabled, bx, left, top, right, bottom, bgColor, borderColor, borderStyle, borderWidth) Creates, updates, or deletes a box object. Parameters: enabled (bool): Whether the box should exist bx (box): Existing box reference left (int): Left x position top (float): Top y position right (int): Right x position bottom (float): Bottom y position bgColor (color): Box background color borderColor (color): Box border color borderStyle (string): Box border style borderWidth (int): Box border width Returns: Updated box reference
Bibliothek
von MYNAMEISBRANDON
Pine3D: A Native 3D Graphical Rendering EnginePine3D is a full 3D rendering engine for TradingView, powered by Pine Script™ v6. Pine3D pushes forward the frontier of TradingView 3D rendering capabilities, providing a fully fledged graphical engine under an intuitive, chainable, object oriented API. Build meshes, transform them in world space, light them, cast shadows, project them through a perspective camera, and render the result directly on your chart, all without ever bothering about trigonometry synchronization or optimization. The library brings forth a streamlined process for anyone that wishes to visualize data in 3D, without needing to know anything about the complex math that has previously gatekept such indicators. Pine3D does all the heavy lifting, including extreme optimization techniques designed for production ready indicators. The entire API is chainable and tag addressable, so spawning a mesh, registering it, pointing the camera at it, and rendering the frame is a four line affair: Mesh mybox = cube(40.0, color.orange).setTag("hero").rotateBy(0.0, 45.0, 0.0) scene.add(mybox) scene.lookAt("hero") render(scene) 🔷 SURFACES: CONTOUR BAND RENDERING Pine Script imposes a hard ceiling of 100 polylines and 500 lines per indicator . On the surface this looks fatal for dense 3D meshes: every triangle drawn naively burns one of those 100 slots, or two of the 500, and the budget evaporates within a few hundred faces. The conventional escape hatch is strip stitching , tracing a polyline forward along one row of a grid and back along the next, packing a ribbon of quads into a single drawing slot. It buys a meaningful multiplier, but it pays for that multiplier with two structural constraints baked into the geometry itself: One color per strip. A polyline carries a single stroke and fill color, so every cell along the ribbon must share the same shade. The moment you want per cell lighting, contour banding, or value driven gradients, every color change forces a new polyline and the budget collapses. One contiguous ribbon per slot. Strips can only describe topologically connected runs of cells. Disjoint regions, holes, islands, and value clustered fragments scattered across the surface each demand their own polyline. Pine3D breaks both constraints at once. At the core of the engine sits an innovation that redefines the limits for visual fidelity: contour band rendering using degenerate bridge stitching . The technique quantizes a surface's elevation into colored bands, then collapses every cell that falls inside the same band, no matter where it sits on the screen , into one continuous, hole aware polyline path per band, threading invisible zero width bridges between disjoint islands so that a single polyline can carry thousands of polygon equivalent fragments scattered across the geometry. The result: A single polyline can render up to 2,000 disconnected triangle equivalents , spread across arbitrarily separated regions of the surface. Theoretical ceiling of around 200,000 disconnected faces inside the 100 polyline budget, a regime that strip based stitching cannot enter at any color count above one. A 40 x 40 heightmap (around 3,000 triangles) renders inside the budget with full per band contour coloring and room to spare. Stress harnesses have run 40 x 80 grids . Each band's path is depth sorted and near plane culled, and cached between bars , so once geometry is built only the screen space projection runs per frame. This algorithm enables scenes with extreme detail relative to the 100 polyline limit, and shifts the optimization focus from "drawing limits" to "CPU limits", which Pine3D natively handles with aggressive caching at every layer of the pipeline. The contour technique is currently integrated into the surface() function, with the same compression strategy generalizable to any mesh class and ultimately full scene rendering in future versions. Non-uniform grids out of the box. surface() accepts optional axisX and axisZ arrays that override the default uniform spacing with custom column and row positions. This means logarithmic strike spacing on an option volatility surface, irregular timestamp spacing on a market depth heatmap, or any other non-evenly-sampled grid renders correctly without resampling the data first. The contour band engine, axis ticks, and gridBox cage all snap to the custom positions automatically. A full contour surface is just a handful of lines; the damped ripple below builds once and never needs updating: //@version=6 indicator("Pine3D - Contour Surface", overlay = false, max_polylines_count = 100, max_lines_count = 500, max_labels_count = 500) import Alien_Algorithms/Pine3D/1 as p3d var p3d.Scene scene = p3d.newScene() var p3d.Mesh heatmap = na if barstate.isfirst // Damped cosine ripple int N = 20 matrix data = matrix.new(N, N, 0.0) for r = 0 to N - 1 for c = 0 to N - 1 float dx = c - (N - 1) / 2.0 float dz = r - (N - 1) / 2.0 float d = math.sqrt(dx * dx + dz * dz) * 0.7 data.set(r, c, math.cos(d) * math.exp(-d * 0.12) * 50.0) heatmap := p3d.surface(data, 200.0, color.blue, color.red, 24) .gridBox() .gridLabels(color.white, "X", "Amplitude", "Z") scene.add(heatmap) scene.camera.orbit(35.0, 25.0, 380.0) if barstate.islast p3d.render(scene, lighting = true) 🔷 TRAIL3D: STREAMED OSCILLATOR PATHS Trail3D is a first class streaming primitive built for visualizing two correlated time series as a 3D ribbon evolving through time. You give it a rolling buffer capacity and push (u, v) samples bar by bar; the primitive maintains the buffer, builds the ribbon geometry, and renders it inside a normalized bounding cube so the path always fits cleanly in view regardless of the underlying data range. Under the hood, Trail3D is a coordinated bundle of polylines: one for the main ribbon, two for optional shadow projections onto the back wall and floor, and one for the wireframe cage. All four are depth sorted and occlusion clipped against the rest of the scene, and the primitive auto normalizes incoming samples against the rolling window's min/max so streaming data always fills the cube without manual scaling. This enables a class of visualizations that would otherwise require dozens of polylines and manual buffer management: phase space portraits, Lissajous figures, oscillator pair correlations, attractor trajectories, and any "two indicators evolving together over time" study. The demo above shows a sine and cosine pair pushing samples each bar to trace a clean spiral inside the cage, the same pattern you would use to plot RSI vs MFI, momentum vs volatility, or any custom (u, v) signal pair. A full streamed scene is a handful of lines: //@version=6 indicator("Pine3D - Trail3D", overlay = false, max_polylines_count = 100, max_lines_count = 500, max_labels_count = 500) import Alien_Algorithms/Pine3D/1 as p3d var p3d.Scene scene = p3d.newScene() var p3d.Trail3D trail = na if barstate.isfirst trail := p3d.trail3D(220.0, 200, color.yellow) .cage(true) .axisLabels("sin", "cos", color.white) trail._uProj.col := #00ffff69 trail._vProj.col := #ff00ff71 scene.add(trail) scene.camera.orbit(215.0, 20.0, 360.0) float phase = bar_index * 0.15 float sinX = math.sin(phase) * 100.0 float cosY = math.cos(phase) * 100.0 if barstate.isconfirmed trail.pushSample(sinX, cosY) p3d.render(scene) 🔷 BARS3D: CATEGORICAL 3D BAR CHARTS bars3D() turns any series of values into a fully lit, depth sorted 3D bar chart in a single call. Each bar is height mapped to its value, color graded between a low and high color, and packed into one combined mesh with per bar depth grouping so individual bars sort correctly even inside the merged geometry. The companion updateBars() mutator refreshes heights, colors, and labels in place every bar without rebuilding geometry, making it suitable for live rankings, rolling windows, and animated comparisons. The chainable barLabels(catNames, valNames) helper attaches category labels at the base of each bar and value labels at the top, both depth sorted with the rest of the scene. Category labels are set once at build time, while value labels can be passed to updateBars(values, valLabels = ...) each frame to reflect live data. Combined with wireGrid() for the floor and a contour surface() in the background, bars3D() becomes the centerpiece of dashboards comparing assets, sectors, timeframes, or any categorical metric. Negative values are handled automatically: bars below zero extrude downward from the base plane with reversed face winding, so signed series like PnL, delta, or momentum histograms render correctly without any extra setup. A complete labeled bar chart is just a few lines: //@version=6 indicator("Pine3D - Bars3D", overlay = false, max_polylines_count = 100, max_lines_count = 500, max_labels_count = 500) import Alien_Algorithms/Pine3D/1 as p3d var p3d.Scene scene = p3d.newScene() var p3d.Mesh bars = na array values = array.from(volume - volume , volume - volume , volume - volume , volume - volume , volume - volume , volume - volume ) array names = array.from("ΔV0", "ΔV-1", "ΔV-2", "ΔV-3", "ΔV-4", "ΔV-5") if barstate.isfirst bars := p3d.bars3D(values, 30.0, 30.0, 10.0, color.blue, color.red, 200.0) .barLabels(names) scene.add(bars) p3d.wireGrid(scene, 300.0, 300.0, 6, 6, color.new(color.gray, 80)) scene.camera.orbit(215.0, 25.0, 360.0) if barstate.islast bars.updateBars(values) p3d.render(scene, lighting = true) Omitting valLabels in updateBars() tells the engine to auto format each numeric value via str.tostring() . Pass valLabels only when you need custom strings. 🔷 SCATTER CLOUDS: POINTS IN 3D SPACE Pine3D treats scatter clouds as a first class use case without needing a dedicated scatter API. Because Label3D is the primitive and scene.add(array) is a single batch operation, you can scatter up to 500 points anywhere in 3D space, each with independent color, symbol, size, and tooltip , and have them depth sorted and occlusion clipped against the rest of the scene automatically. Each point is a fully addressable Label3D with mutable fields. You can change position , textColor , bgColor , labelStyle (any label.style_* glyph including circles, squares, diamonds, triangles, crosses, arrows, flags), labelSize (any size.* preset), and text per point per bar. The renderer reads these mutations every frame, so animation is just direct field assignment. This unlocks a wide class of visualizations: clustered data scatter, K means visualizations, particle systems, parametric surfaces sampled as point clouds, gradient colored attractors, multi class classification overlays, and structured curves like the demo above. The double helix demo plots two intertwined parametric strands as ~500 points with alternating colors and per point sizing, all inside the standard scene.add(array) pipeline. The pattern is straightforward: build the array once in barstate.isfirst , add it to the scene, then mutate point fields per bar to animate. //@version=6 indicator("Pine3D - Scatter Cloud", overlay = false, max_polylines_count = 100, max_lines_count = 500, max_labels_count = 500) import Alien_Algorithms/Pine3D/1 as p3d var p3d.Scene scene = p3d.newScene() var array points = array.new() if barstate.isfirst for i = 0 to 499 p3d.Vec3 pos = p3d.vec3(0.0, 0.0, 0.0) points.push(p3d.Label3D.new(position = pos, txt = "•")) scene.add(points) scene.camera.orbit(35.0, 20.0, 400.0) if barstate.islast for i = 0 to points.size() - 1 float t = i * 0.05 + bar_index * 0.01 p3d.Label3D pt = points.get(i) pt.position := p3d.vec3(80.0 * math.cos(t), i * 0.4 - 100.0, 80.0 * math.sin(t)) pt.textColor := i % 2 == 0 ? color.aqua : color.fuchsia p3d.render(scene) ---------------------------------------------------------------------------------------------------------------- 🔷 TWO LAYER ARCHITECTURE Pine3D ships as a clean, two layer library: 🔸 Layer 1 - DIY API. First principle building blocks ( Vec3 , Mesh , Camera , Light , Scene , plus world space overlay primitives) for total creative control. Author your own geometry, camera behavior, lighting setup, and scene graph from scratch. 🔸 Layer 2 - High Level Helpers. Production ready wrappers like surface() , bars3D() , trail3D() , updateBars() , updateSurface() , sphere() , torus() , cylinder() , and wireGrid() , plus chainable contour helpers gridBox() and gridLabels() that wrap the primitives into a few lines of code. Scatter clouds use the standard Label3D primitive directly. The object model is chainable and scene oriented, so complex setups still read cleanly. 🔷 FEATURE LIST Contour Surface Rendering - The most powerful 3D surface engine ever released for Pine Script. Render tens of thousands of polygon equivalent faces using a single polyline per contour band, delivering smooth, continuous terrain with natural ridges and valleys. Adaptive Rail Sharing - Solid meshes drawn with the default linefill backend reuse one edge line between adjacent coplanar faces, averaging roughly 1.6 lines per face instead of the naive two, pushing practical mesh capacity up to ~360 faces depending on topology. Interior Face Culling on Merge - mergeMeshes(meshes, removeInterior = true) detects coincident faces with opposing normals and strips them, so voxel style scenes (stacked cubes, block walls, lattice geometry) ship only their exterior shell and spend no budget on hidden interior faces. True Perspective Camera System - Full 3D camera with position, target, fov, and orbit() controls. Supports cinematic camera movement, lookAt by mesh tag, and realistic depth. Real Time Lighting and Shadows - Directional and point lights with configurable ambient, shadow strength, self shadowing, and a spatial grid acceleration structure for fast shadow queries. High Performance Update System - updateSurface() and updateBars() let you animate massive datasets bar by bar without rebuilding geometry, keeping CPU usage minimal. Rich Primitive Library - Cubes, cuboids, spheres, cylinders, tori, pyramids, planes, discs, circles, custom meshes, and the groundbreaking bars3D() with automatic labels. Streamed Trail Primitive - trail3D() maintains a rolling buffer of (u, v) samples and renders them as a 3D ribbon inside a bounding cube, with optional projections onto the back wall and floor and a wireframe cage. Depth Sorted Overlays - 3D labels, lines, polylines, wire grids, and trails, all correctly occluded and painter sorted against the rest of the scene. Professional Contour Helpers - gridBox() and gridLabels() automatically add clean bounding boxes and axis titles, ticks, and series names that refresh on every updateSurface() call. Tag Based Scene Graph - Every Mesh , Label3D , Line3D , and Polyline3D can carry a string tag. Scene exposes getMesh() , getLabel() , getLine() , getPolyline() , lookAt() , and remove() by tag, turning your scene into a lookup by name graph instead of an index juggling exercise. Chainable, Intuitive API - Everything is designed for maximum readability and speed of development. Build complex scenes in just a few lines. Production Ready Optimizations - World vertex caching, view projection caching, face preprocessing cache, shadow grid cache, and contour geometry cache, all managed automatically. ---------------------------------------------------------------------------------------------------------------- 🔷 THE RENDERER Every frame is produced by a single call to render(scene, ...) . The renderer runs the full pipeline: world transform, camera transform, back face culling, occlusion culling, depth sort, directional or point lighting with shadows, and perspective projection. ⚠ render() clears the entire chart drawing pool at the start of every call - every polyline , line , label , and linefill on the chart is deleted before Pine3D redraws, not just the ones it created. If you mix Pine3D with manual label.new() , line.new() , or similar calls, those drawings must be emitted after render() or they will be wiped every frame. 🔸 Setup Requirements. Pine3D consumes polylines, lines, and labels simultaneously, so your indicator() declaration must raise all three budgets, and the library must be imported under an alias: indicator("My 3D Scene", overlay = false, max_polylines_count = 100, max_lines_count = 500, max_labels_count = 500) import Alien_Algorithms/Pine3D/1 as p3d 🔸 render() parameters. maxFaces (int, default 100). Hard cap on solid faces drawn per frame. Contour bands, wireframe edges, labels, lines, and overlay polylines are not counted against this cap, and are bounded only by TradingView's global 100 polyline / 500 line / 500 label budgets. culling (bool, default true). Enable back face culling. lighting (bool, default false). Enable diffuse shading. Reads scene.light if set; otherwise falls back to the render() args. lightDir (Vec3). Overrides scene.light.direction when provided. Points toward the light. ambient (float, default 0.3). Minimum brightness for shadowed faces (0.0-1.0). wireframe (bool, default false). Force outline only output for the entire scene. occlusion (bool, default true). Sparse raster pass that drops hidden faces before drawing. Major perf win on dense scenes. occlusionRaster (int, default 768). Raster resolution of the occlusion buffer. Lower = faster but coarser; higher = stricter hidden face rejection. Explicit render() args always win over scene.light , which makes render() the right place for ad hoc, per frame lighting tweaks. ---------------------------------------------------------------------------------------------------------------- 🔷 MESH DRAWING MODES Two independent axes control how a mesh appears on the chart: 🔸 Style (via mesh.setStyle(...) ) - what gets drawn: "solid" . Filled faces. Default. "wireframe" . All edges, no fill. Shows interior geometry. "wireframe_front" . Only front facing edges. Cleaner silhouette for convex meshes. 🔸 Draw Mode (via mesh.drawMode ) - which TradingView primitive carries the solid faces: "linefill" (default). Uses the line and linefill budgets. An adaptive rail sharing optimization reuses one edge line between adjacent coplanar faces, pushing practical capacity up to ~360 faces per mesh depending on topology. Supports in place updates via updateSurface() and updateBars() . Rails are drawn transparent, so solid faces in this mode have no visible outline - use a wireframe style or "poly" drawMode if you need stroked edges. Recommended for all new code. "poly" . Legacy polyline backend. Capacity ~100 faces, no in place updates, but renders the face outline using mesh.lineStyle and mesh.lineWidth . Use only when you need styled solid face outlines. Wireframe styles always render with line primitives regardless of drawMode. Stroke width and style on edges (and on poly mode face outlines) come from mesh.lineWidth and mesh.lineStyle , which you mutate by direct field assignment. ---------------------------------------------------------------------------------------------------------------- 🔷 QUICK START The best practice lifecycle is simple: Create one persistent Scene with newScene() . Build meshes and helper overlays once in barstate.isfirst . On later bars, mutate objects in place with transforms or helper mutators like updateBars() and updateSurface() . Call render(scene, ...) once per frame. It automatically clears the previous chart drawings. A complete, lit, animated 3D scene is still a handful of lines: //@version=6 indicator("My First 3D Scene", overlay = false, max_polylines_count = 100, max_lines_count = 500, max_labels_count = 500) import Alien_Algorithms/Pine3D/1 as p3d var p3d.Scene scene = p3d.newScene() var p3d.Mesh sun = na if barstate.isfirst scene.setLightDir(1.0, -1.0, 0.5).setAmbient(0.3) sun := p3d.sphere(50.0, 16, 12, color.orange).setTag("sun") scene.add(sun) p3d.wireGrid(scene, 300.0, 300.0, 6, 6, color.new(color.gray, 80)) scene.camera.orbit(35.0, 25.0, 220.0) if barstate.islast sun.rotateBy(0.0, 1.5, 0.0) p3d.render(scene, lighting = true) ---------------------------------------------------------------------------------------------------------------- 🔷 RECOMMENDED USAGE PATTERN Use your Scene and major meshes in var . Build geometry once in barstate.isfirst . Use updateSurface() and updateBars() on later bars instead of rebuilding meshes. Use scene level helpers like wireGrid() when you want overlays added immediately. Use trail3D() when you want a streamed oscillator style path with built in wall projections and cage geometry. For scatter clouds, build an array once, hand it to scene.add(pts) , then mutate pt.position , pt.textColor , etc. each bar to animate. Use mesh level gridBox() and gridLabels() (contour) and barLabels() (bars) to attach overlays to the mesh setup chain. They are drained into the scene by scene.add(mesh) . 🔷 CONSIDERATIONS scene.clear() vs render(). scene.clear() removes objects from the scene graph (meshes, labels, lines, polylines). render() only clears the previous frame's TradingView drawings and redraws from the current scene graph. You almost never need scene.clear() in the build once and update pattern. Global scope series for updateSurface() / updateBars(). If your data uses Pine's history operator ( ) or calls functions like ta.rsi() , ta.atr() , request.security() , those must be declared at global scope so Pine tracks their bar by bar history. Calling them inside barstate.islast produces inconsistent results or compiler errors. gridLabels() tick values auto refresh. When you call updateSurface() , any tick value labels created by gridLabels() are automatically updated to reflect the new data range. Axis titles and positions stay constant. You don't need to rebuild them. barLabels() value labels via updateBars(). Create category labels once with mesh.barLabels(catNames) at build time, then pass valLabels to updateBars() on each frame. Value labels are refreshed automatically. Don't call barLabels() again. Lighting convenience methods are chainable. scene.setLightDir() , setLightPos() , setLightMode() , setAmbient() , setShadowStrength() , and showLightSource() all return Scene and can be chained: scene.setLightMode("point").setLightPos(0, 200, 150).setAmbient(0.25) . Mesh transforms return Mesh. moveTo() , moveBy() , rotateTo() , rotateBy() , scaleTo() , scaleUniform() , setTag() , setStyle() , setColor() , show() , hide() all return Mesh for chaining: mesh.moveTo(0, -20, 0).rotateTo(0, 45, 0).setStyle("solid") . Degrees vs radians. rotateTo() and rotateBy() on Mesh expect degrees. The low level Vec3.rotateX/Y/Z() methods expect radians. scene.lookAt() is tag only. scene.lookAt(t) accepts a string tag and points the camera at that mesh. To aim the camera at an arbitrary Vec3 , call scene.camera.lookAt(vec) directly. remove(tag) removes one object. The search order is meshes, then labels, then lines, then polylines, and the first hit wins. Avoid reusing tags across primitive types if you intend to delete by tag. Shadow grid acceleration is directional light only. The spatial shadow grid is only built when lightMode == "directional" . Point lights fall back to a linear O(M) scan, so heavy shadow scenes are fastest in directional mode. guiShift and yOffset. scene.guiShift and scene.yOffset position the 3D viewport on the chart without consuming historical bar slots. Increase guiShift to push the scene rightward into future bar space; adjust yOffset to slide it vertically in price units. bar_time projection. All chart drawings are emitted with xloc.bar_time , so the scene can sit arbitrarily far left or right of bar_index without forcing Pine to extend its history buffer. This is what keeps the engine stable on long charts and future projected scenes. barLabels() without values. When you call mesh.barLabels(catNames) and omit value labels, every later updateBars(values) auto formats the numeric values via str.tostring() . Pass valLabels only when you need custom strings. Direct mesh.vertices mutation requires invalidateCache(). Transform mutators ( moveTo , rotateBy , scaleTo , etc.) invalidate the world vertex cache on their own. Only raw index writes like mesh.vertices.set(i, newVec) need a manual mesh.invalidateCache() call to force re-projection. Skipping it will make the renderer draw stale geometry. Drawing budgets fail silently. If a scene emits more than 100 polylines, 500 lines, or 500 labels in a single frame, TradingView silently drops the overflow without raising a runtime error. Missing geometry almost always means a budget overrun - lower maxFaces , drop a contour level, or simplify overlay primitives to bring the frame back inside the caps. render() deletes non Pine3D drawings too. Every render() call clears polyline.all , line.all , label.all , and linefill.all before redrawing. Any manual label.new() , line.new() , etc. issued before render() in the same frame will be wiped. Issue custom drawings after the render call if you need them to persist. mergeMeshes() preserves depth grouping. When every source mesh passed into mergeMeshes() has the same vertex and face count (e.g. identical primitives in a voxel grid), the merged mesh auto derives depth group boundaries so the combined geometry still sorts correctly per original instance. Mixing primitives with different topologies disables the grouping. CPU timeouts: knobs to turn. Pine Script enforces a per bar execution budget, and dense scenes can trip it before the drawing budget ever does. If a scene compiles but times out at runtime, reach for these levers in order: lower occlusionRaster (e.g. 768 -> 384) for the biggest single perf win, reduce maxFaces to cap the solid face pool, drop levels on contour surfaces, simplify sphere/torus segment counts, and gate heavy work behind barstate.islast so history bars only build geometry rather than render it. ---------------------------------------------------------------------------------------------------------------- 🔷 MORE EXAMPLES The following scenes were all built entirely in Pine Script™ v6 using Pine3D as the rendering layer. They exist to demonstrate that the library is a real engine capable of complex, production grade visualizations. 🔸 4D Hypercube (Tesseract). A rotating tesseract, projected from 4D to 3D to 2D in real time using a custom 4D rotation matrix layered on top of Pine3D's standard projection pipeline. 🔸 Solar System. Following the publication of my 3D Solar System back in 2024, which introduced new graphical rendering concepts into Pine Script, we have seen a wave of various interpretations of the underlying vector classes, ranging from tutorials to niche specific integrations using hardcoded math. It became clear that a unified architecture was needed, one that would lower the barrier to entry while simultaneously handling the optimization process, which is both complex and error prone to do manually. That architecture is what Pine3D delivers. Below is a re-creation of the classic 3D Solar System rebuilt entirely on top of the library. It uses a fraction of the original code , renders roughly 5x faster , and adds real lighting cast directly from the Sun , all while consuming only a third of the available drawing budget thanks to the occlusion and culling mechanisms Pine3D handles out of the box. ---------------------------------------------------------------------------------------------------------------- 🔷 API REFERENCE 🔸 Top Level Entry Points. newScene() creates a ready to use Scene with a default camera and light. render(scene, ...) draws the current frame and auto clears the previous frame's chart drawings; see the Renderer section above for the full parameter list. vec3(x, y, z) creates a Vec3. colorBrightness() is an exported color utility helper. 🔸 Mesh Factories. Primitives - cube() , cuboid() , pyramid() , plane() , sphere() , cylinder() , torus() , grid() , disc() , circle() for ready made geometry. customMesh(verts, faces) - Low level escape hatch for authoring your own topology. mergeMeshes(meshes, tag, removeInterior) - Bakes transforms and combines many meshes into one. With removeInterior = true , coincident faces with opposing normals (e.g. shared walls between adjacent cubes in a grid) are culled so only the exterior shell survives, a major optimization for dense voxel style scenes. surface(heights, size, lowCol, highCol, levels, axisX, axisZ) - Creates a contour surface mesh. bars3D(values, barWidth, barDepth, spacing, lowCol, highCol, maxHeight) - Creates a combined 3D bar chart mesh; add labels with the chainable barLabels(names, values) method. 🔸 UDT Constructors. Overlay primitives and face descriptors are plain UDTs. Because these types have many fields, always instantiate them with named arguments rather than positional, e.g. Label3D.new(position = pos, txt = "•") : Face - fields: vi (array of vertex indices into the parent mesh), col . Used when authoring customMesh() topology; every face must have at least 3 indices and should be planar. Label3D - fields: position , txt , textColor , bgColor , labelStyle , labelSize , fontFamily , tooltip , visible , tag . Only position is required. Line3D - fields: start , end , col , width , visible , tag , lineStyle . Polyline3D - fields: points , col , fillColor , width , closed , visible , tag , lineStyle . Vec3.new(x, y, z) or the vec3(x, y, z) shorthand. 🔸 Trail Primitive. trail3D(size, capacity, trailCol, minSamples) creates a streamed Trail3D primitive with a main trail, two projection polylines, and a cage polyline. capacity is internally clamped to 300 samples to keep the rolling buffer inside Pine's execution budget; passing a larger value silently resolves to 300. minSamples (default 60) is the sample count at which the cage reaches its full cube width: below that the cage stays cube shaped and samples stretch across it; above that the cage grows rightward at a fixed step until capacity is hit. scene.add(trail) registers the sub primitives into the scene. Trail3D methods: pushSample() , axisLabels() , cage() , moveTo() , show() , hide() . 🔸 Mesh Methods. Transform - moveTo() , moveBy() , rotateTo() , rotateBy() , scaleTo() , scaleUniform() . Appearance - setColor() , setFaceColor() , setStyle() , show() , hide() , setTag() . Stroke styling (direct) - mesh.lineWidth := 3 and mesh.lineStyle := line.style_dashed control width and style of every visible mesh edge in wireframe modes and the outline of solid faces in drawMode = "poly" . Shadow opt out (direct) - mesh.castShadow := false excludes the mesh from shadow casting while still receiving light. Useful for ghost overlays, debug geometry, or semi transparent meshes you do not want occluding the scene. Lifecycle - clone() , faceCount() , invalidateCache() . Data mutation - updateSurface() and updateBars() refresh persistent meshes in place. updateBars() refreshes any bar label positions automatically; pass catLabels / valLabels to also update the text. Contour helpers - gridBox() and gridLabels() queue overlays on the mesh and hand them to the scene when you call scene.add(mesh) . Bar helpers - barLabels() is chainable on a bars3D() mesh and queues its category and value labels for the next scene.add(mesh) . Note: rotateTo() and rotateBy() expect degrees. The low level Vec3.rotateX/Y/Z() methods work in radians. 🔸 Scene Methods. Lighting - setLightDir() , setLightPos() , setLightMode() , setAmbient() , setShadowStrength() , showLightSource() . Scene graph - add(mesh) , add(label) , add(array) , add(line) , add(polyline) , add(trail) , remove(index) , remove(tag) , clear() . Lookup and navigation - getMesh() , getLabel() , getLine() , getPolyline() , lookAt() , totalFaces() . Cache control - invalidateLightCache() after mutating light direction or scene bounds externally; invalidateAllCaches() to also invalidate every mesh's world vertex cache (use after directly mutating mesh.vertices ). Note: scene.clear() clears the scene graph itself. render() only clears the previous frame's TradingView drawings. 🔸 Camera Methods. setPosition(x, y, z) moves the camera. lookAt(x, y, z) / lookAt(vec3) points at a world space target. orbit(angleX, angleY, distance) does a spherical orbit around the current target. setFov(val) sets the perspective scale factor. Camera fields ( position , target , fov ) are also directly mutable via assignment when you need to tune them outside the provided setters, e.g. scene.camera.fov := 1200.0 . 🔸 Light Field Mutation. In addition to the scene level convenience setters, every field on scene.light is directly mutable for fine grained tuning: scene.light.selfShadow := true enables self shadowing, scene.light.shadowBias := 0.2 adjusts the shadow acne offset, scene.light.shadowStrength and scene.light.ambient are also exposed. Mutate them after newScene() or between frames; the renderer reads them every call. 🔸 Vec3 Methods. Core math: add() , sub() , scale() , negate() , dot() , cross() , length() , normalize() , distanceTo() , lerp() . Rotation and helpers: rotateX() , rotateY() , rotateZ() , copy() , toString() . 🔸 Overlay Primitive Methods. Label3D - moveTo() , moveBy() , setText() , setTextColor() , setTooltip() , show() , hide() , setTag() . Line3D - setStart() , setEnd() , setPoints() , setColor() , show() , hide() , setTag() . Polyline3D - setColor() , show() , hide() , setTag() . Every UDT field is mutable via direct assignment for properties without a chainable setter: Label3D - bgColor , labelStyle (label.style_*), labelSize (size.*), fontFamily (font.family_*), visible . Line3D - width , lineStyle (line.style_solid / _dashed / _dotted / _arrow_left / _arrow_right / _arrow_both), visible . Polyline3D - width , lineStyle (line.style_solid / _dashed / _dotted only; arrow styles are not supported by TradingView's polyline primitive), fillColor , closed , visible . Mutations are read per frame by the renderer, so they animate freely. 🔸 High Level Scene Helpers. wireGrid(scene, w, d, divX, divZ, col) adds a depth sorted ground grid. scene.add(array) adds a batch of labels in one call - the idiomatic way to push a scatter cloud into the scene. 🔸 Mesh Level Chainable Overlays. mesh.barLabels(names, values, ...) adds category and value labels on a bars3D() mesh. mesh.gridBox(col, divs) adds a wireframe bounding box cage on a surface() mesh. mesh.gridLabels(col, xName, yName, zName, ticks, fmt) adds axis titles and tick value labels on a surface() mesh; tick values auto refresh on updateSurface() . All three are queued on the mesh and drained into the scene by scene.add(mesh) . ---------------------------------------------------------------------------------------------------------------- This work is licensed under (CC BY-NC-SA 4.0) , meaning usage is free for non-commercial purposes given that Alien_Algorithms is credited in the description for the underlying software. For commercial use licensing, contact Alien_Algorithms
Bibliothek
von Alien_Algorithms
9
PriceActionLibrary "PriceAction" Will draw out the market structure for the disired pivot length. SetBarIndices(pivotHigh, pivotLow)   Sets the 'BarIndex' value of the 'Pivot' object. Useful if the pivot is from an other timeframe.   Parameters:      pivotHigh (Pivot) : The 'Pivot' object for the high pivot.      pivotLow (Pivot) : The 'Pivot' object for the low pivot. Alert(turtleSoupsContext, settings)   Will fire off an alert if there is one. To be used lastly in the calling script.   Parameters:      turtleSoupsContext (TurtleSoups) : The context of all turtle soups.      settings (TurtleSoupSettings) : The settings for turtle soups. VisualizeTurtleSoups(pivots, turtleSoups, turtleSoupsContext, settings)   Will visulize found turtle soups and add alert messages for it.   Parameters:      pivots (array) : All current pivots (high or low).      turtleSoups (array) : All bullish or bearish turtle soups.      turtleSoupsContext (TurtleSoups) : The context of all turtle soups.      settings (TurtleSoupSettings) : The settings for turtle soups. GetPivots(settings)   Will get available pivots. Can be called from another timeframe.   Parameters:      settings (TurtleSoupSettings) : The settings for turtle soups.   Returns: A tuple of high and then low pivots. SetPivots(turtleSoupsContext, settings, pivotHigh, pivotLow)   Will set the new pivots in turtleSoupsContext.   Parameters:      turtleSoupsContext (TurtleSoups) : The context of all turtle soups.      settings (TurtleSoupSettings) : The settings for turtle soups.      pivotHigh (Pivot) : The 'Pivot' object for the high pivot.      pivotLow (Pivot) : The 'Pivot' object for the low pivot. Confirm(turtleSoups, turtleSoupsContext, settings, previousStructureBreakBarIndex, screener)   Will visualize turtle soups. To be called if 'TurtleSoupSettings.Confirmation' is true.   Parameters:      turtleSoups (array) : All bullish or bearish turtle soups.      turtleSoupsContext (TurtleSoups) : The context of all turtle soups.      settings (TurtleSoupSettings) : The settings for turtle soups.      previousStructureBreakBarIndex (int) : The bar index of the previous structure break (BOS/CHoCH/CHoCH+).      screener (Screener) : The 'Screener' object to be used for Pine Screening by Tradingview. The function will set 'TurtleSoupUntilBarIndex' if there's a confirmed turtle soup. Liqudity(liquidity)   Will draw liquidity.   Parameters:      liquidity (Liquidity) : The 'PriceAction.Liquidity' object. Pivot(structure)   Sets the pivots in the structure.   Parameters:      structure (Structure) PivotLabels(structure)   Draws labels for the pivots found.   Parameters:      structure (Structure) EqualHighOrLow(structure)   Draws the boxes for equal highs/lows. Also creates labels for the pivots included.   Parameters:      structure (Structure) BreakOfStructure(structure)   Will create lines when a break of strycture occures.   Parameters:      structure (Structure)   Returns: The 'Pivot' that caused the break of structure, na otherwise. ChangeOfCharacter(structure)   Will create lines when a change of character occures. This line will have a label with "CHoCH" or "CHoCH+".   Parameters:      structure (Structure)   Returns: The 'Pivot' that caused the change of character, na otherwise. VisualizeCurrent(structure)   Will create a box with a background for between the latest high and low pivots. This can be used as the current trading range (if the pivots broke strucure somehow).   Parameters:      structure (Structure) StructureBreak   Holds drawings for a structure break.   Fields:      Line (series line) : The line object.      Label (series label) : The label object. Pivot   Holds all the values for a found pivot.   Fields:      Price (series float) : The price of the pivot.      BarIndex (series int) : The bar_index where the pivot occured.      Type (series int) : The type of the pivot (-1 = low, 1 = high).      Time (series int) : The time where the pivot occured.      BreakOfStructureBroken (series bool) : Sets to true if a break of structure has happened.      LiquidityBroken (series bool) : Sets to true if a liquidity of the price level has happened.      ChangeOfCharacterBroken (series bool) : Sets to true if a change of character has happened. Structure   Holds all the values for the market structure.   Fields:      LeftLength (series int) : Define the left length of the pivots used.      RightLength (series int) : Define the right length of the pivots used.      Type (series Type) : Set the type of the market structure. Two types can be used, 'internal' and 'swing' (0 = internal, 1 = swing).      Trend (series int) : This will be set internally and can be -1 = downtrend, 1 = uptrend.      EqualPivotsFactor (series float) : Set how the limits are for an equal pivot. This is a factor of the Average True Length (ATR) of length 14. If a low pivot is considered to be equal if it doesn't break the low pivot (is at a lower value) and is inside the previous low pivot + this limit.      ExtendEqualPivotsZones (series bool) : Set to true if you want the equal pivots zones to be extended.      ExtendEqualPivotsStyle (series string) : Set the style of equal pivot zones.      ExtendEqualPivotsColor (series color) : Set the color of equal pivot zones.      EqualHighs (array) : Holds the boxes for zones that contains equal highs.      EqualLows (array) : Holds the boxes for zones that contains equal lows.      BreakOfStructures (array) : Holds all the break of structures within the trend (before a change of character).      Pivots (array) : All the pivots in the current trend, added with the latest first, this is cleared when the trend changes.      FontSize (series int) : Holds the size of the font displayed.      AlertChangeOfCharacter (series bool) : Holds true or false if a change of character should be alerted or not.      AlertBreakOfStructure (series bool) : Holds true or false if a break of structure should be alerted or not.      AlerEqualPivots (series bool) : Holds true or false if equal highs/lows should be alerted or not. Liquidity   Holds all the values for liquidity.   Fields:      LiquidityPivotsHigh (array) : All high pivots for liquidity.      LiquidityPivotsLow (array) : All low pivots for liquidity.      LiquidityConfirmationBars (series int) : The number of bars to confirm that a liquidity is valid.      LiquidityPivotsLookback (series int) : A number of pivots to look back for.      FontSize (series int) : Holds the size of the font displayed. PriceAction   Holds all the values for the general price action and the market structures.   Fields:      Liquidity (Liquidity)      Swing (Structure) : Placeholder for all objects used for the swing market structure.      Internal (Structure) : Placeholder for all objects used for the internal market structure. TurtleSoupSettings   Holds sll the values for the settings for turtle soups.   Fields:      PivotLeftLenght (series int) : Define the left length of the pivots used.      PivotRightLenght (series int) : Define the right length of the pivots used.      Lookback (series int) : Set how many pivots back that will be used.      Confirmation (series bool) : Set if you want confirmation to be needed for q turtle soup to be formed (e g. a CHoCH).      Color (series color) : The color of turtle soups.      ScreenerKeep (series int) : Set the number of bars that the plot 'Turtle soup' will have a value after a turtle soup is found.      AlertFrequency (series string) : Set the frequency of alerts, possible values are 'alert.freq_all', 'alert.freq_once_per_bar' or 'alert.freq_once_per_bar_close'. TurtleSoup   To be used when a turtle soup is found and holds all values needed for it.   Fields:      Line (series line) : The line object between the pivot and the turtle soup.      Box (series box) : The bos for the turtle soup.      Start (series int) : The first bar of the turtle soup.      End (series int) : The last bar of the turtle soup.      Pivot (Pivot) : The pivot which liquidity was taken by the turtle soup. Screener   Holds all values to be used in the Pine Screener by Tradingview.   Fields:      TurtleSoupUntilBarIndex (series int) : Pine Screener value for turtle soups. TurtleSoups   TurtleSoups The entire context for all turtle soups.   Fields:      Highs (array) : The high pivots.      Lows (array) : The low pivots.      Bullish (array) : Bullish turtle soups.      Bearish (array) : Bearish turtle soups.      AlertMessages (array) : All messages for the current iteration.
Bibliothek
von jhong2290
OriginLifecycleLibrary "OriginLifecycle" Strict Highlander v7 origin lifecycle for engulfing indicators. Exports enums, an OriginCandidate UDT, and four helper functions used by engulfing_opportunities_v20.6+ to detect, track, promote, invalidate, and consume origin levels discovered on lower timeframes inside an engulfment zone. Published-as-library rationale: the engulfing indicator is already at Pine v6's top-level-declaration limit (CE10295). Moving these types and functions into a library frees ~7 declarations in the main script without changing semantics. Reference: highlander_v7.pine:212-293 for the state-transition rules this implementation mirrors. tickStateMachine(c, bO, bH, bL, bC, bTime)   Pure state-transition function. One closed LTF bar in, updated candidate out. Mirrors highlander_v7.pine:212-293.   Parameters:      c (OriginCandidate) : The current candidate state.      bO (float) : Bar open.      bH (float) : Bar high.      bL (float) : Bar low.      bC (float) : Bar close.      bTime (int) : Bar start time in ms.   Returns: Updated OriginCandidate with `lastProcessedTime := bTime`. Caller is responsible for: - Only passing CLOSED LTF bars. - Skipping bars whose time <= c.lastProcessedTime. - On BROKEN_BSUT, looking for a retest in subsequent bars to delete. scanForBreakCandidates(isBullish, zoneLow, zoneHigh, prevO, prevH, prevL, prevC, prevT, currO, currH, currL, currC, currT, ltfValid, ltfMin, tfLabel, outCandidates)   Find new BREAK pairs in the engulfment zone and push them to `outCandidates` if not already tracked. De-dup key is (price, createdTime, tfLabel).   Parameters:      isBullish (bool) : true -> look for SUPPORT (green-green) pairs; false -> look for RESISTANCE (red-red) pairs.      zoneLow (float) : Lower bound of the engulfment zone (inclusive).      zoneHigh (float) : Upper bound of the engulfment zone (inclusive).      prevO (array)      prevH (array)      prevL (array)      prevC (array)      prevT (array)      currO (array)      currH (array)      currL (array)      currC (array)      currT (array)      ltfValid (bool) : Pre-computed validity flag for this LTF.      ltfMin (int) : LTF length in minutes (baked into each new candidate).      tfLabel (string) : Display string, e.g. "1H".      outCandidates (array) : The per-pattern candidate array to push into.   Returns: Nothing (mutates outCandidates). processNewLTFBars(candidates, ltfMin, prevO, prevH, prevL, prevC, prevT, currO, currH, currL, currC, currT, ltfValid)   Drive the state machine across unprocessed LTF bars for every candidate whose `ltfMinutes == ltfMin`. Removes candidates that reach BROKEN_BSUT AND see a retest within the buffer.   Parameters:      candidates (array) : The per-pattern candidate array to update.      ltfMin (int) : The LTF length this buffer represents; candidates with a different ltfMinutes are skipped.      prevO (array)      prevH (array)      prevL (array)      prevC (array)      prevT (array)      currO (array)      currH (array)      currL (array)      currC (array)      currT (array)      ltfValid (bool) : Validity flag.   Returns: Nothing (mutates candidates). applyConsumedOnTouch(candidates, greedyEntries, greedyConsumedFlags, isBullish, curLow, curHigh)   Per-tick sweep. Marks CONFIRMED origins and untouched greedy entries as consumed once price wicks into them. Caller passes `curLow`/`curHigh` because library functions cannot reference the `low`/`high` chart globals directly.   Parameters:      candidates (array) : Per-pattern origin-candidate array.      greedyEntries (array) : Per-pattern greedy-entry price array.      greedyConsumedFlags (array) : Parallel bool array — resized lazily to match greedyEntries size.      isBullish (bool) : Drives the touch check for greedy entries (origins use their own per-candidate dir).      curLow (float) : Current bar low (pass `low` from caller).      curHigh (float) : Current bar high (pass `high` from caller).   Returns: Nothing (mutates both arrays). OriginCandidate   A single tracked origin candidate.   Fields:      tfLabel (series string) : Display string ("1H", "5m" etc.).      ltfMinutes (series int) : Lower-timeframe length in minutes; used for the      price (series float) : The origin level price.      dir (series OriginDir) : UP (support) or DOWN (resistance).      state (series OriginState) : Current lifecycle state.      firstTouchTime (series int) : ms timestamp of first touch (0 if `touchSeen == false`).      touchSeen (series bool) : True once this candidate has been touched at least once.      createdTime (series int) : ms timestamp of the d1 bar that formed the BREAK pair.      lastProcessedTime (series int) : ms timestamp of the last LTF bar fed through the      consecutiveDirCount (series int) : Counter for 2-bar CONFIRMED confirmation, 0-2.
Bibliothek
von HybriD_ez