Mulai

Theme

Market Cap Landscape 3DHello, traders and creators! 👋 Market Cap Landscape 3D. This project is more than just a typical technical analysis tool; it's an exploration into what's possible when code meets artistry on the financial charts. It's a demonstration of how we can transcend flat, two-dimensional lines and step into a vibrant, three-dimensional world of data. This project continues a journey that began with a previous 3D experiment, the T-Virus Sentiment, which you can explore here: The Market Cap Landscape 3D builds on that foundation, visualizing market data—particularly crypto market caps—as a dynamic 3D mountain range. The entire landscape is procedurally generated and rendered in real-time using the powerful drawing capabilities of polyline.new() and line.new() , pushed to their creative limits. This work is intended as a guide and a design example for all developers, born from the spirit of learning and a deep love for understanding the Pine Script™ language. --- 🧐 Core Concept: How It Works The indicator synthesizes multiple layers of information into a single, cohesive 3D scene: The Surface: The mountain range itself is a procedurally generated 3D mesh. Its peaks and valleys create a rich, textured landscape that serves as the canvas for our data. Crypto Data Integration: The core feature is its ability to fetch market cap data for a list of cryptocurrencies you provide. It then sorts them in descending order and strategically places them onto the 3D surface. The Summit: The highest point on the mountain is reserved for the asset with the #1 market cap in your list, visually represented by a flag and a custom emblem. The Mountain Labels: The other assets are distributed across the mountainside, with their rank determining their general elevation. This creates an intuitive visual hierarchy. The Leaderboard Pole: For clarity, a dedicated pole in the back-right corner provides a clean, ranked list of the symbols and their market caps, ensuring the data is always easy to read. --- 🧐 Example of adjusting the view To evoke the feeling of flying over mountains To evoke the feeling of looking at a mountain peak on a low plain 🧐 Example of predefined colors --- 🚀 How to Use Getting started with the Market Cap Landscape 3D: Add to Chart: Apply the "Market Cap Landscape 3D" indicator to your active chart. Open Settings: Double-click anywhere on the 3D landscape or click the "Settings" icon next to the indicator's name. Customize Your Crypto List: The most important setting is in the Crypto Data tab. In the "Symbols" text area, enter a comma-separated list of the crypto tickers you want to visualize (e.g., BTC,ETH,SOL,XRP ). The indicator supports up to 40 unique symbols. > Important Note: This indicator exclusively uses TradingView's `CRYPTOCAP` data source. To find valid symbols, use the main symbol search bar on your chart. Type `CRYPTOCAP:` (including the colon) and you will see a list of available options. For example, typing `CRYPTOCAP:BTC` will confirm that `BTC` is a valid ticker for the indicator's settings. Using symbols that do not exist in the `CRYPTOCAP` index will result in a script error. or, to display other symbols, simply type CRYPTOCAP: (including the colon) and you will see a list of available options. Adjust Your View: Use the settings in the Camera & Projection tab to rotate ( Yaw ), tilt ( Pitch ), and scale the landscape until you find a view you love. Explore & Customize: Play with the color palettes, flag design, and other settings to make the landscape truly your own! --- ⚙️ Settings & Customization This indicator is highly customizable. Here’s a breakdown of what each setting does: #### 🪙 Crypto Data Symbols: Enter the crypto tickers you want to track, separated by commas. The script automatically handles duplicates and case-insensitivity. Show Market Cap on Mountain: When checked, it displays the full market cap value next to the symbol on the mountain. When unchecked, it shows a cleaner look with just the symbol and a colored circle background. #### 📷 Camera & Projection Yaw (°): Rotates the camera view horizontally (side to side). Pitch (°): Tilts the camera view vertically (up and down). Scale X, Y, Z: Stretches or compresses the landscape in width, depth, and height, respectively. Fine-tune these to get the perfect perspective. #### 🏞️ Grid / Surface Grid X/Y resolution: Controls the detail level of the 3D mesh. Higher values create a smoother surface but may use more resources. Fill surface strips: Toggles the beautiful color gradient on the surface. Show wireframe lines: Toggles the visibility of the grid lines. Show nodes (markers): Toggles the small dots at each grid intersection point. #### 🏔️ Peaks / Mountains Fill peaks volume: Draws vertical lines on high peaks, giving them a sense of volume. Fill peaks surface: Draws a cross-hatch pattern on the surface of high peaks. Peak height threshold: Defines the minimum height for a peak to receive the fill effect. Peak fill color/density: Customizes the appearance of the fill lines. #### 🚩 Flags (3D) Show Flag on Summit: A master switch to show or hide the flag and emblem entirely. Flag height, width, etc.: Provides full control over the dimensions and orientation of the flag on the highest peak. #### 🎨 Color Palette Base Gradient Palette: Choose from 13 stunning, pre-designed color themes for the landscape, from the classic SUNSET_WAVE to vibrant themes like NEON_DREAM and OCEANIC . #### 🛡️ Emblem / Badge Controls This section gives you granular control over every element of the custom emblem on the flag. Tweak rotation, offsets, and scale to design your unique logo. --- 👨‍💻 Developer's Corner: Modifying the Core Logic If you're a developer and wish to customize the indicator's core data source, this section is for you. The script is designed to be modular, making it easy to change what data is being ranked and visualized. The heart of the data retrieval and ranking logic is within the f_getSortedCryptoData() function. Here’s how you can modify it: 1. Changing the Data Source (from Market Cap to something else): The current logic uses request.security("CRYPTOCAP:" + syms.get(i), ...) to fetch market capitalization data. To change this, you need to modify this line. Example: Ranking by RSI (14) on the Daily timeframe. First, you'll need a function to calculate RSI. Add this function to the script: f_getRSI(symbol, timeframe, length) => request.security(symbol, timeframe, ta.rsi(close, length)) Then, inside f_getSortedCryptoData() , find the `for` loop that populates the `caps` array and replace the `request.security` call: // OLD LINE: // caps.set(i, request.security("CRYPTOCAP:" + syms.get(i), timeframe.period, close)) // NEW LINE for RSI: // Note: You'll need to decide how to format the symbol name (e.g., "BINANCE:" + syms.get(i) + "USDT") caps.set(i, f_getRSI("BINANCE:" + syms.get(i) + "USDT", "D", 14)) 2. Changing the Data Formatting: The ranking values are formatted for display using the f_fmtCap() function, which currently formats large numbers into "M" (millions), "B" (billions), etc. If you change the data source to something like RSI, you'll want to change the formatting. You can modify f_fmtCap() or create a new formatting function. Example: Formatting for RSI. // Modify f_fmtCap or create f_fmtRSI f_fmtRSI(float v) => str.tostring(v, "#.##") // Simply format to two decimal places Remember to update the calls to this function in the main drawing loop where the labels are created (e.g., str.format("{0}: {1}", crypto.symbol, f_fmtCap(crypto.cap)) ). By modifying these key functions ( f_getSortedCryptoData and f_fmtCap ), you can adapt the Market Cap Landscape 3D to visualize and rank almost any dataset you can imagine, from technical indicators to fundamental data. --- We hope you enjoy using the Market Cap Landscape 3D as much as we enjoyed creating it. Happy charting! ✨
Indikator Pine Script®
oleh hapharmonic
14
Color█ OVERVIEW This library is a Pine Script® programming tool for advanced color processing. It provides a comprehensive set of functions for specifying and analyzing colors in various color spaces, mixing and manipulating colors, calculating custom gradients and schemes, detecting contrast, and converting colors to or from hexadecimal strings. █ CONCEPTS Color Color refers to how we interpret light of different wavelengths in the visible spectrum . The colors we see from an object represent the light wavelengths that it reflects, emits, or transmits toward our eyes. Some colors, such as blue and red, correspond directly to parts of the spectrum. Others, such as magenta, arise from a combination of wavelengths to which our minds assign a single color. The human interpretation of color lends itself to many uses in our world. In the context of financial data analysis, the effective use of color helps transform raw data into insights that users can understand at a glance. For example, colors can categorize series, signal market conditions and sessions, and emphasize patterns or relationships in data. Color models and spaces A color model is a general mathematical framework that describes colors using sets of numbers. A color space is an implementation of a specific color model that defines an exact range (gamut) of reproducible colors based on a set of primary colors , a reference white point , and sometimes additional parameters such as viewing conditions. There are numerous different color spaces — each describing the characteristics of color in unique ways. Different spaces carry different advantages, depending on the application. Below, we provide a brief overview of the concepts underlying the color spaces supported by this library. RGB RGB is one of the most well-known color models. It represents color as an additive mixture of three primary colors — red, green, and blue lights — with various intensities. Each cone cell in the human eye responds more strongly to one of the three primaries, and the average person interprets the combination of these lights as a distinct color (e.g., pure red + pure green = yellow). The sRGB color space is the most common RGB implementation. Developed by HP and Microsoft in the 1990s, sRGB provided a standardized baseline for representing color across CRT monitors of the era, which produced brightness levels that did not increase linearly with the input signal. To match displays and optimize brightness encoding for human sensitivity, sRGB applied a nonlinear transformation to linear RGB signals, often referred to as gamma correction . The result produced more visually pleasing outputs while maintaining a simple encoding. As such, sRGB quickly became a standard for digital color representation across devices and the web. To this day, it remains the default color space for most web-based content. TradingView charts and Pine Script `color.*` built-ins process color data in sRGB. The red, green, and blue channels range from 0 to 255, where 0 represents no intensity, and 255 represents maximum intensity. Each combination of red, green, and blue values represents a distinct color, resulting in a total of 16,777,216 displayable colors. CIE XYZ and xyY The XYZ color space, developed by the International Commission on Illumination (CIE) in 1931, aims to describe all color sensations that a typical human can perceive. It is a cornerstone of color science, forming the basis for many color spaces used today. XYZ, and the derived xyY space, provide a universal representation of color that is not tethered to a particular display. Many widely used color spaces, including sRGB, are defined relative to XYZ or derived from it. The CIE built the color space based on a series of experiments in which people matched colors they perceived from mixtures of lights. From these experiments, the CIE developed color-matching functions to calculate three components — X, Y, and Z — which together aim to describe a standard observer's response to visible light. X represents a weighted response to light across the color spectrum, with the highest contribution from long wavelengths (e.g., red). Y represents a weighted response to medium wavelengths (e.g., green), and it corresponds to a color's relative luminance (i.e., brightness). Z represents a weighted response to short wavelengths (e.g., blue). From the XYZ space, the CIE developed the xyY chromaticity space, which separates a color's chromaticity (hue and colorfulness) from luminance. The CIE used this space to define the CIE 1931 chromaticity diagram , which represents the full range of visible colors at a given luminance. In color science and lighting design, xyY is a common means for specifying colors and visualizing the supported ranges of other color spaces. CIELAB and Oklab The CIELAB (L*a*b*) color space, derived from XYZ by the CIE in 1976, expresses colors based on opponent process theory. The L* component represents perceived lightness, and the a* and b* components represent the balance between opposing unique colors. The a* value specifies the balance between green and red , and the b* value specifies the balance between blue and yellow . The primary intention of CIELAB was to provide a perceptually uniform color space, where fixed-size steps through the space correspond to uniform perceived changes in color. Although relatively uniform, the color space has been found to exhibit some non-uniformities, particularly in the blue part of the color spectrum. Regardless, modern applications often use CIELAB to estimate perceived color differences and calculate smooth color gradients. In 2020, a new LAB-oriented color space, Oklab , was introduced by Björn Ottosson as an attempt to rectify the non-uniformities of other perceptual color spaces. Similar to CIELAB, the L value in Oklab represents perceived lightness, and the a and b values represent the balance between opposing unique colors. Oklab has gained widespread adoption as a perceptual space for color processing, with support in the latest CSS Color specifications and many software applications. Cylindrical models A cylindrical-coordinate model transforms an underlying color model, such as RGB or LAB, into an alternative expression of color information that is often more intuitive for the average person to use and understand. Instead of a mixture of primary colors or opponent pairs, these models represent color as a hue angle on a color wheel , with additional parameters that describe other qualities such as lightness and colorfulness (a general term for concepts like chroma and saturation). In cylindrical-coordinate spaces, users can select a color and modify its lightness or other qualities without altering the hue. The three most common RGB-based models are HSL (Hue, Saturation, Lightness), HSV (Hue, Saturation, Value), and HWB (Hue, Whiteness, Blackness). All three define hue angles in the same way, but they define colorfulness and lightness differently. Although they are not perceptually uniform, HSL and HSV are commonplace in color pickers and gradients. For CIELAB and Oklab, the cylindrical-coordinate versions are CIELCh and Oklch , which express color in terms of perceived lightness, chroma, and hue. They offer perceptually uniform alternatives to RGB-based models. These spaces create unique color wheels, and they have more strict definitions of lightness and colorfulness. Oklch is particularly well-suited for generating smooth, perceptual color gradients. Alpha and transparency Many color encoding schemes include an alpha channel, representing opacity . Alpha does not help define a color in a color space; it determines how a color interacts with other colors in the display. Opaque colors appear with full intensity on the screen, whereas translucent (semi-opaque) colors blend into the background. Colors with zero opacity are invisible. In Pine Script, there are two ways to specify a color's alpha:  • Using the `transp` parameter of the built-in `color.*()` functions. The specified value represents transparency (the opposite of opacity), which the functions translate into an alpha value.  • Using eight-digit hexadecimal color codes. The last two digits in the code represent alpha directly. A process called alpha compositing simulates translucent colors in a display. It creates a single displayed color by mixing the RGB channels of two colors (foreground and background) based on alpha values, giving the illusion of a semi-opaque color placed over another color. For example, a red color with 80% transparency on a black background produces a dark shade of red. Hexadecimal color codes A hexadecimal color code (hex code) is a compact representation of an RGB color. It encodes a color's red, green, and blue values into a sequence of hexadecimal ( base-16 ) digits. The digits are numerals ranging from `0` to `9` or letters from `a` (for 10) to `f` (for 15). Each set of two digits represents an RGB channel ranging from `00` (for 0) to `ff` (for 255). Pine scripts can natively define colors using hex codes in the format `#rrggbbaa`. The first set of two digits represents red, the second represents green, and the third represents blue. The fourth set represents alpha . If unspecified, the value is `ff` (fully opaque). For example, `#ff8b00` and `#ff8b00ff` represent an opaque orange color. The code `#ff8b0033` represents the same color with 80% transparency. Gradients A color gradient maps colors to numbers over a given range. Most color gradients represent a continuous path in a specific color space, where each number corresponds to a mix between a starting color and a stopping color. In Pine, coders often use gradients to visualize value intensities in plots and heatmaps, or to add visual depth to fills. The behavior of a color gradient depends on the mixing method and the chosen color space. Gradients in sRGB usually mix along a straight line between the red, green, and blue coordinates of two colors. In cylindrical spaces such as HSL, a gradient often rotates the hue angle through the color wheel, resulting in more pronounced color transitions. Color schemes A color scheme refers to a set of colors for use in aesthetic or functional design. A color scheme usually consists of just a few distinct colors. However, depending on the purpose, a scheme can include many colors. A user might choose palettes for a color scheme arbitrarily, or generate them algorithmically. There are many techniques for calculating color schemes. A few simple, practical methods are:  • Sampling a set of distinct colors from a color gradient.  • Generating monochromatic variants of a color (i.e., tints, tones, or shades with matching hues).  • Computing color harmonies — such as complements, analogous colors, triads, and tetrads — from a base color. This library includes functions for all three of these techniques. See below for details. █ CALCULATIONS AND USE Hex string conversion The `getHexString()` function returns a string containing the eight-digit hexadecimal code corresponding to a "color" value or set of sRGB and transparency values. For example, `getHexString(255, 0, 0)` returns the string `"#ff0000ff"`, and `getHexString(color.new(color.red, 80))` returns `"#f2364533"`. The `hexStringToColor()` function returns the "color" value represented by a string containing a six- or eight-digit hex code. The `hexStringToRGB()` function returns a tuple containing the sRGB and transparency values. For example, `hexStringToColor("#f23645")` returns the same value as color.red . Programmers can use these functions to parse colors from "string" inputs, perform string-based color calculations, and inspect color data in text outputs such as Pine Logs and tables. Color space conversion All other `get*()` functions convert a "color" value or set of sRGB channels into coordinates in a specific color space, with transparency information included. For example, the tuple returned by `getHSL()` includes the color's hue, saturation, lightness, and transparency values. To convert data from a color space back to colors or sRGB and transparency values, use the corresponding `*toColor()` or `*toRGB()` functions for that space (e.g., `hslToColor()` and `hslToRGB()`). Programmers can use these conversion functions to process inputs that define colors in different ways, perform advanced color manipulation, design custom gradients, and more. The color spaces this library supports are:  • sRGB  • Linear RGB (RGB without gamma correction)  • HSL, HSV, and HWB  • CIE XYZ and xyY  • CIELAB and CIELCh  • Oklab and Oklch Contrast-based calculations Contrast refers to the difference in luminance or color that makes one color visible against another. This library features two functions for calculating luminance-based contrast and detecting themes. The `contrastRatio()` function calculates the contrast between two "color" values based on their relative luminance (the Y value from CIE XYZ) using the formula from version 2 of the Web Content Accessibility Guidelines (WCAG) . This function is useful for identifying colors that provide a sufficient brightness difference for legibility. The `isLightTheme()` function determines whether a specified background color represents a light theme based on its contrast with black and white. Programmers can use this function to define conditional logic that responds differently to light and dark themes. Color manipulation and harmonies The `negative()` function calculates the negative (i.e., inverse) of a color by reversing the color's coordinates in either the sRGB or linear RGB color space. This function is useful for calculating high-contrast colors. The `grayscale()` function calculates a grayscale form of a specified color with the same relative luminance. The functions `complement()`, `splitComplements()`, `analogousColors()`, `triadicColors()`, `tetradicColors()`, `pentadicColors()`, and `hexadicColors()` calculate color harmonies from a specified source color within a given color space (HSL, CIELCh, or Oklch). The returned harmonious colors represent specific hue rotations around a color wheel formed by the chosen space, with the same defined lightness, saturation or chroma, and transparency. Color mixing and gradient creation The `add()` function simulates combining lights of two different colors by additively mixing their linear red, green, and blue components, ignoring transparency by default. Users can calculate a transparency-weighted mixture by setting the `transpWeight` argument to `true`. The `overlay()` function estimates the color displayed on a TradingView chart when a specific foreground color is over a background color. This function aids in simulating stacked colors and analyzing the effects of transparency. The `fromGradient()` and `fromMultiStepGradient()` functions calculate colors from gradients in any of the supported color spaces, providing flexible alternatives to the RGB-based color.from_gradient() function. The `fromGradient()` function calculates a color from a single gradient. The `fromMultiStepGradient()` function calculates a color from a piecewise gradient with multiple defined steps. Gradients are useful for heatmaps and for coloring plots or drawings based on value intensities. Scheme creation Three functions in this library calculate palettes for custom color schemes. Scripts can use these functions to create responsive color schemes that adjust to calculated values and user inputs. The `gradientPalette()` function creates an array of colors by sampling a specified number of colors along a gradient from a base color to a target color, in fixed-size steps. The `monoPalette()` function creates an array containing monochromatic variants (tints, tones, or shades) of a specified base color. Whether the function mixes the color toward white (for tints), a form of gray (for tones), or black (for shades) depends on the `grayLuminance` value. If unspecified, the function automatically chooses the mix behavior with the highest contrast. The `harmonyPalette()` function creates a matrix of colors. The first column contains the base color and specified harmonies, e.g., triadic colors. The columns that follow contain tints, tones, or shades of the harmonic colors for additional color choices, similar to `monoPalette()`. █ EXAMPLE CODE The example code at the end of the script generates and visualizes color schemes by processing user inputs. The code builds the scheme's palette based on the "Base color" input and the additional inputs in the "Settings/Inputs" tab:  • "Palette type" specifies whether the palette uses a custom gradient, monochromatic base color variants, or color harmonies with monochromatic variants.  • "Target color" sets the top color for the "Gradient" palette type.  • The "Gray luminance" inputs determine variation behavior for "Monochromatic" and "Harmony" palette types. If "Auto" is selected, the palette mixes the base color toward white or black based on its brightness. Otherwise, it mixes the color toward the grayscale color with the specified relative luminance (from 0 to 1).  • "Harmony type" specifies the color harmony used in the palette. Each row in the palette corresponds to one of the harmonious colors, starting with the base color. The code creates a table on the first bar to display the collection of calculated colors. Each cell in the table shows the color's `getHexString()` value in a tooltip for simple inspection. Look first. Then leap. █ EXPORTED FUNCTIONS Below is a complete list of the functions and overloads exported by this library. getRGB(source)   Retrieves the sRGB red, green, blue, and transparency components of a "color" value. getHexString(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channel values to a string representing the corresponding color's hexadecimal form. getHexString(source)   (Overload 2 of 2) Converts a "color" value to a string representing the sRGB color's hexadecimal form. hexStringToRGB(source)   Converts a string representing an sRGB color's hexadecimal form to a set of decimal channel values. hexStringToColor(source)   Converts a string representing an sRGB color's hexadecimal form to a "color" value. getLRGB(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channel values to a set of linear RGB values with specified transparency information. getLRGB(source)   (Overload 2 of 2) Retrieves linear RGB channel values and transparency information from a "color" value. lrgbToRGB(lr, lg, lb, t)   Converts a set of linear RGB channel values to a set of sRGB values with specified transparency information. lrgbToColor(lr, lg, lb, t)   Converts a set of linear RGB channel values and transparency information to a "color" value. getHSL(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of HSL values with specified transparency information. getHSL(source)   (Overload 2 of 2) Retrieves HSL channel values and transparency information from a "color" value. hslToRGB(h, s, l, t)   Converts a set of HSL channel values to a set of sRGB values with specified transparency information. hslToColor(h, s, l, t)   Converts a set of HSL channel values and transparency information to a "color" value. getHSV(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of HSV values with specified transparency information. getHSV(source)   (Overload 2 of 2) Retrieves HSV channel values and transparency information from a "color" value. hsvToRGB(h, s, v, t)   Converts a set of HSV channel values to a set of sRGB values with specified transparency information. hsvToColor(h, s, v, t)   Converts a set of HSV channel values and transparency information to a "color" value. getHWB(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of HWB values with specified transparency information. getHWB(source)   (Overload 2 of 2) Retrieves HWB channel values and transparency information from a "color" value. hwbToRGB(h, w, b, t)   Converts a set of HWB channel values to a set of sRGB values with specified transparency information. hwbToColor(h, w, b, t)   Converts a set of HWB channel values and transparency information to a "color" value. getXYZ(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of XYZ values with specified transparency information. getXYZ(source)   (Overload 2 of 2) Retrieves XYZ channel values and transparency information from a "color" value. xyzToRGB(x, y, z, t)   Converts a set of XYZ channel values to a set of sRGB values with specified transparency information xyzToColor(x, y, z, t)   Converts a set of XYZ channel values and transparency information to a "color" value. getXYY(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of xyY values with specified transparency information. getXYY(source)   (Overload 2 of 2) Retrieves xyY channel values and transparency information from a "color" value. xyyToRGB(xc, yc, y, t)   Converts a set of xyY channel values to a set of sRGB values with specified transparency information. xyyToColor(xc, yc, y, t)   Converts a set of xyY channel values and transparency information to a "color" value. getLAB(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of CIELAB values with specified transparency information. getLAB(source)   (Overload 2 of 2) Retrieves CIELAB channel values and transparency information from a "color" value. labToRGB(l, a, b, t)   Converts a set of CIELAB channel values to a set of sRGB values with specified transparency information. labToColor(l, a, b, t)   Converts a set of CIELAB channel values and transparency information to a "color" value. getOKLAB(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of Oklab values with specified transparency information. getOKLAB(source)   (Overload 2 of 2) Retrieves Oklab channel values and transparency information from a "color" value. oklabToRGB(l, a, b, t)   Converts a set of Oklab channel values to a set of sRGB values with specified transparency information. oklabToColor(l, a, b, t)   Converts a set of Oklab channel values and transparency information to a "color" value. getLCH(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of CIELCh values with specified transparency information. getLCH(source)   (Overload 2 of 2) Retrieves CIELCh channel values and transparency information from a "color" value. lchToRGB(l, c, h, t)   Converts a set of CIELCh channel values to a set of sRGB values with specified transparency information. lchToColor(l, c, h, t)   Converts a set of CIELCh channel values and transparency information to a "color" value. getOKLCH(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of Oklch values with specified transparency information. getOKLCH(source)   (Overload 2 of 2) Retrieves Oklch channel values and transparency information from a "color" value. oklchToRGB(l, c, h, t)   Converts a set of Oklch channel values to a set of sRGB values with specified transparency information. oklchToColor(l, c, h, t)   Converts a set of Oklch channel values and transparency information to a "color" value. contrastRatio(value1, value2)   Calculates the contrast ratio between two colors values based on the formula from version 2 of the Web Content Accessibility Guidelines (WCAG). isLightTheme(source)   Detects whether a background color represents a light theme or dark theme, based on the amount of contrast between the color and the white and black points. grayscale(source)   Calculates the grayscale version of a color with the same relative luminance (i.e., brightness). negative(source, colorSpace)   Calculates the negative (i.e., inverted) form of a specified color. complement(source, colorSpace)   Calculates the complementary color for a `source` color using a cylindrical color space. analogousColors(source, colorSpace)   Calculates the analogous colors for a `source` color using a cylindrical color space. splitComplements(source, colorSpace)   Calculates the split-complementary colors for a `source` color using a cylindrical color space. triadicColors(source, colorSpace)   Calculates the two triadic colors for a `source` color using a cylindrical color space. tetradicColors(source, colorSpace, square)   Calculates the three square or rectangular tetradic colors for a `source` color using a cylindrical color space. pentadicColors(source, colorSpace)   Calculates the four pentadic colors for a `source` color using a cylindrical color space. hexadicColors(source, colorSpace)   Calculates the five hexadic colors for a `source` color using a cylindrical color space. add(value1, value2, transpWeight)   Additively mixes two "color" values, with optional transparency weighting. overlay(fg, bg)   Estimates the resulting color that appears on the chart when placing one color over another. fromGradient(value, bottomValue, topValue, bottomColor, topColor, colorSpace)   Calculates the gradient color that corresponds to a specific value based on a defined value range and color space. fromMultiStepGradient(value, steps, colors, colorSpace)   Calculates a multi-step gradient color that corresponds to a specific value based on an array of step points, an array of corresponding colors, and a color space. gradientPalette(baseColor, stopColor, steps, strength, model)   Generates a palette from a gradient between two base colors. monoPalette(baseColor, grayLuminance, variations, strength, colorSpace)   Generates a monochromatic palette from a specified base color. harmonyPalette(baseColor, harmonyType, grayLuminance, variations, strength, colorSpace)   Generates a palette consisting of harmonious base colors and their monochromatic variants.
Perpustakaan Pine Script®
oleh TradingView
3
Custom Index CompositeCustom Index Composite calculates an unweighted composite index by averaging the daily returns of multiple stock tickers. Instead of using price-level weighting, it focuses solely on percentage change, allowing you to compare diverse market themes side by side on a common basis. Why Use a Custom Index Composite? Unlike traditional indices that often lean on market capitalization or price-level data, a custom composite based solely on returns strips out the bias inherent to high-priced stocks. This provides several benefits: Objective Cross-Comparison: When stocks or market themes trade at very different price levels, it can be difficult to assess performance objectively. Using percentage returns, the composite creates an even playing field, enabling a clear comparison between different assets or themes. Tailored Benchmarking: By selecting and combining specific tickers, you can create benchmarks that better represent the segments or strategies you’re interested in. This is particularly useful when standard indices do not capture the nuances of your investment approach. Performance Normalization: Converting raw price data into daily percentage returns minimizes distortions that arise from price differences. This normalization helps in understanding true performance trends across the chosen tickers, making the composite index a more reliable gauge of relative market movement. Custom Analysis Framework: The indicator offers flexibility to adjust the lookback period (defaulting to about 3 months) so you can fine-tune the sensitivity of the index to recent market behavior. This enables you to either smooth out volatility or capture a more immediate trend, depending on your analytical needs. Key Features: Configurable Appearance: You can easily configure the line color, line width, index name, and index name color via the options panel. Ticker Configuration: By default, you can enter up to 15 different tickers into the composite index. Technically, the indicator supports up to 40 tickers (these additional inputs are commented out by default to maintain performance), and you may enable them individually if required. Calculated Bars Length: The indicator uses a “Calculated bars length” setting, which is set by default to 63 days (approximately 3 months). This value can be adjusted, and it is recommended to use the greatest common denominator for consistent analysis. How To Configure Your Chart: Add the Indicator: Place the Custom Index Composite on your chart. Disable Main Symbol Visibility: Hide the primary symbol’s plot and set its scale to “None” to prevent interference with the composite display. Pin to Right Scale: Set the scale of the first composite indicator to “Pinned to right scale.” This helps maintain consistency across different composite indicators. Add Multiple Composites: You can add additional composite indicators and set their scales to “Pinned to right scale” (or alternatively to “A”) for convenient comparison. Limitations: If a ticker symbol is set once in the options, it cannot be cleared to an empty value later. As a result, the symbol will continue to appear in the indicator’s title on the chart. The only way to remove an unwanted symbol is to completely reset the settings and re-enter your desired tickers.
Indikator Pine Script®
oleh fyntrade
Dark & Light Theme [TradingFinder] Switching Colors Library🔵 Introduction One of the challenges of script users is matching the colors used in indicators or strategies. By default, colors are chosen to display based on either the dark theme or the light theme. In scripts with a large number of colors used, changing all colors to better display in dark mode or light mode can be a difficult and tedious process. This library provides developers with the ability to adjust the colors used in their scripts based on the theme of the display. 🔵 Logic To categorize the color spectrum, the range from 0 to 255 of all three main colors red, green and blue was divided into smaller ranges. Blue color, which is more effective in darkening or lightening colors, is divided into 8 categories, red color into 5 categories, and green color into 3 categories, because it has little effect on darkening or brightening colors. The combination of these categories creates 120 different modes for the color range, which leads to a more accurate identification of the color and its brightness, and helps to decide how to change it. Except for these 120 modes, there are 2 other modes that are related to colors almost white or black, which makes a total of 122 modes. 🔵 How to Use First, you can add the library to your code as shown in the example below. import TFlab/Dark_Light_Theme_TradingFinder_Switching_Colors_Library/1 as SC 🟣 Parameters SwitchingColorMode(Color, Mode) => Parameters: Color (color) Mode (string) Color : In this parameter, enter the color you want to adjust based on light mode and dark mode. Mode : Three modes "Off", "Light" and "Dark" are included in this parameter. "Light" mode is for color adjustment for use in "Light Mode". "Dark" mode is for color adjustment for use in "Dark Mode" and "Off" mode turns off the color adjustment function and the input color to the function is the same as the output color. 🔵 Function Outputs OriginalColor = input.color(color.red) = SC.SwitchingColorMode(OriginalColor, Mode)
Perpustakaan Pine Script®
oleh TFlab
Candles ThemesGood morning, Here is my first script as a pinecoder. So I present to you my indicator: the “Candles Theme”. Instead of searching for a long time in the chart settings to change the style of the chart, you can use this indicator which offers: - 8 default themes. - The ability to create a custom theme. Themes : - Pink - Blue : Dark and Light - Classic : Dark and Light - Blue - Orange Classic : Dark and Light - Dark Monochrome : Only Dark - Light Monochrome : Only Light - Blue - Orange 2 : Light and Dark - Pastel 1 : Light and Dark - Pastel 2 : Only Light Being a trader and PineScript developer, I often create scripts according to my needs like this, but this is the first time I have published it. If you have any questions or suggestions for improvement, please let me know in the comments. End
Indikator Pine Script®
oleh cacaprut
1
Material Design ColorsThis library provides a standard set of colors defined in Material Design 2.0. 🔵 API Step 1: Import this library. import algotraderdev/material/1 // remember to check the latest version of this library and replace the 1 above. Step 2: Get the color you like. Check the source code or the screenshot above to see all the supported colors. material.red() Each color function (except for `black()` and `white()`) accepts an optional `variant` parameter. You can choose any of 50, 100, 200, 300, 400, 500, 600, 700, 800, and 900. By default, 500 is chosen if this parameter is not provided.
Perpustakaan Pine Script®
oleh AlphaViz
3
UtilsLibrary "Utils" Utility functions. Mathematics, colors, and auxiliary algorithms. setTheme(vc, theme)   Set theme for levels (predefined colors).   Parameters:      vc : (valueColorSpectrum) Object to associate a color with a value, taking into account the previous value and its levels.      theme : (int) Theme (predefined colors). 0 = 'User defined' 1 = 'Spectrum Blue-Green-Red' 2 = 'Monokai' 3 = 'Green' 4 = 'Purple' 5 = 'Blue' 6 = 'Red'   Returns: (void) setTheme(vc, colorLevel_Lv1, colorLevel_Lv1_Lv2, colorLevel_Lv2_Lv3, colorLevel_Lv3_Lv4, colorLevel_Lv4_Lv5, colorLevel_Lv5)   Set theme for levels (customized colors).   Parameters:      vc : (valueColorSpectrum) Object to associate a color with a value, taking into account the previous value and its levels      colorLevel_Lv1 : (color) Color associeted with value when below Level 1.      colorLevel_Lv1_Lv2 : (color) Color associeted with value when between Level 1 and 2.      colorLevel_Lv2_Lv3 : (color) Color associeted with value when between Level 2 and 3.      colorLevel_Lv3_Lv4 : (color) Color associeted with value when between Level 3 and 4.      colorLevel_Lv4_Lv5 : (color) Color associeted with value when between Level 4 and 5.      colorLevel_Lv5 : (color) Color associeted with value when above Level 5.   Returns: (void) setCurrentColorValue(vc)   Set color to a current value, taking into account the previous value and its levels   Parameters:      vc : (valueColorSpectrum) Object to associate a color with a value, taking into account the previous value and its levels   Returns: (void) setCurrentColorValue(vc, gradient)   Set color to a current value, taking into account the previous value.   Parameters:      vc : (valueColor) Object to associate a color with a value, taking into account the previous value      gradient   Returns: (void) setCustomLevels(vc, level1, level2, level3, level4, level5)   Set boundaries for custom levels.   Parameters:      vc : (valueColorSpectrum) Object to associate a color with a value, taking into account the previous value and its levels      level1 : (float) Boundary for level 1      level2 : (float) Boundary for level 2      level3 : (float) Boundary for level 3      level4 : (float) Boundary for level 4      level5 : (float) Boundary for level 5   Returns: (void) getPeriodicColor(originalColor, density)   Returns a periodic color. Useful for creating dotted lines for example.   Parameters:      originalColor : (color) Original color.      density : (float) Density of color. Expression used in modulo to obtain the integer remainder. If the remainder equals zero, the color appears, otherwise it remains hidden.   Returns: (color) Periodic color. dinamicZone(source, sampleLength, pcntAbove, pcntBelow)   Get Dynamic Zones   Parameters:      source : (float) Source      sampleLength : (int) Sample Length      pcntAbove : (float) Calculates the top of the dynamic zone, considering that the maximum values are above x% of the sample      pcntBelow : (float) Calculates the bottom of the dynamic zone, considering that the minimum values are below x% of the sample   Returns: A tuple with 3 series of values: (1) Upper Line of Dynamic Zone; (2) Lower Line of Dynamic Zone; (3) Center of Dynamic Zone (x = 50%) valueColorSpectrum   # Object to associate a color with a value, taking into account the previous value and its levels.   Fields:      currentValue      previousValue      level1      level2      level3      level4      level5      currentColorValue      colorLevel_Lv1      colorLevel_Lv1_Lv2      colorLevel_Lv2_Lv3      colorLevel_Lv3_Lv4      colorLevel_Lv4_Lv5      colorLevel_Lv5      theme valueColor   # Object to associate a color with a value, taking into account the previous value   Fields:      currentValue      previousValue      currentColorValue      colorUp      colorDown
Perpustakaan Pine Script®
oleh andre_007
7
theme_presetsStyle Made Easy with 175 Reversable light/dark themes Built on to of my theme engine, so any tools built with one will work with the other. getTheme(_input)   Get a theme by name. (see lib for copy/paste list)   Parameters:      _input : string Name of Theme to use. apathy()   Theme preset -> "Apathy"   Returns: Theme object apprentice()   Theme preset -> "Apprentice"   Returns: Theme object ashes()   Theme preset -> "Ashes"   Returns: Theme object atelier_cave()   Theme preset -> "Atelier Cave"   Returns: Theme object atelier_dune()   Theme preset -> "Atelier Dune"   Returns: Theme object atelier_estuary()   Theme preset -> "Atelier Estuary"   Returns: Theme object atelier_forest()   Theme preset -> "Atelier Forest"   Returns: Theme object atelier_heath()   Theme preset -> "Atelier Heath"   Returns: Theme object atelier_lakeside()   Theme preset -> "Atelier Lakeside"   Returns: Theme object atelier_plateau()   Theme preset -> "Atelier Plateau"   Returns: Theme object atelier_savanna()   Theme preset -> "Atelier Savanna"   Returns: Theme object atelier_seaside()   Theme preset -> "Atelier Seaside"   Returns: Theme object atelier_sulphurpool()   Theme preset -> "Atelier Sulphurpool"   Returns: Theme object atlas()   Theme preset -> "Atlas"   Returns: Theme object ayu()   Theme preset -> "Ayu"   Returns: Theme object ayu_mirage()   Theme preset -> "Ayu Mirage"   Returns: Theme object bespin()   Theme preset -> "Bespin"   Returns: Theme object black_metal()   Theme preset -> "Black Metal"   Returns: Theme object black_metal_bathory()   Theme preset -> "Black Metal (bathory)"   Returns: Theme object black_metal_burzum()   Theme preset -> "Black Metal (burzum)"   Returns: Theme object black_metal_funeral()   Theme preset -> "Black Metal (dark Funeral)"   Returns: Theme object black_metal_gorgoroth()   Theme preset -> "Black Metal (gorgoroth)"   Returns: Theme object black_metal_immortal()   Theme preset -> "Black Metal (immortal)"   Returns: Theme object black_metal_khold()   Theme preset -> "Black Metal (khold)"   Returns: Theme object black_metal_marduk()   Theme preset -> "Black Metal (marduk)"   Returns: Theme object black_metal_mayhem()   Theme preset -> "Black Metal (mayhem)"   Returns: Theme object black_metal_nile()   Theme preset -> "Black Metal (nile)"   Returns: Theme object black_metal_venom()   Theme preset -> "Black Metal (venom)"   Returns: Theme object blue_forest()   Theme preset -> "Blue Forest"   Returns: Theme object blueish()   Theme preset -> "Blueish"   Returns: Theme object brewer()   Theme preset -> "Brewer"   Returns: Theme object bright()   Theme preset -> "Bright"   Returns: Theme object brogrammer()   Theme preset -> "Brogrammer"   Returns: Theme object brush_trees()   Theme preset -> "Brush Trees"   Returns: Theme object catppuccin()   Theme preset -> "Catppuccin"   Returns: Theme object chalk()   Theme preset -> "Chalk"   Returns: Theme object circus()   Theme preset -> "Circus"   Returns: Theme object classic()   Theme preset -> "Classic"   Returns: Theme object clrs()   Theme preset -> "Colors"   Returns: Theme object codeschool()   Theme preset -> "Codeschool"   Returns: Theme object cupcake()   Theme preset -> "Cupcake"   Returns: Theme object cupertino()   Theme preset -> "Cupertino"   Returns: Theme object da_one_black()   Theme preset -> "Da One Black"   Returns: Theme object da_one_gray()   Theme preset -> "Da One Gray"   Returns: Theme object da_one_ocean()   Theme preset -> "Da One Ocean"   Returns: Theme object da_one_paper()   Theme preset -> "Da One Paper"   Returns: Theme object da_one_sea()   Theme preset -> "Da One Sea"   Returns: Theme object da_one_white()   Theme preset -> "Da One White"   Returns: Theme object danqing()   Theme preset -> "Danqing"   Returns: Theme object darcula()   Theme preset -> "Darcula"   Returns: Theme object dark_violet()   Theme preset -> "Dark Violet"   Returns: Theme object darkmoss()   Theme preset -> "Darkmoss"   Returns: Theme object darktooth()   Theme preset -> "Darktooth"   Returns: Theme object decaf()   Theme preset -> "Decaf"   Returns: Theme object dirtysea()   Theme preset -> "Dirtysea"   Returns: Theme object dracula()   Theme preset -> "Dracula"   Returns: Theme object edge()   Theme preset -> "Edge"   Returns: Theme object eighties()   Theme preset -> "Eighties"   Returns: Theme object embers()   Theme preset -> "Embers"   Returns: Theme object emil()   Theme preset -> "Emil"   Returns: Theme object equilibrium()   Theme preset -> "Equilibrium"   Returns: Theme object equilibrium_gray()   Theme preset -> "Equilibrium Gray"   Returns: Theme object espresso()   Theme preset -> "Espresso"   Returns: Theme object eva()   Theme preset -> "Eva"   Returns: Theme object everforest()   Theme preset -> "Everforest"   Returns: Theme object flat()   Theme preset -> "Flat"   Returns: Theme object framer()   Theme preset -> "Framer"   Returns: Theme object fruit_soda()   Theme preset -> "Fruit Soda"   Returns: Theme object gigavolt()   Theme preset -> "Gigavolt"   Returns: Theme object github()   Theme preset -> "Github"   Returns: Theme object google()   Theme preset -> "Google"   Returns: Theme object gotham()   Theme preset -> "Gotham"   Returns: Theme object grayscale()   Theme preset -> "Grayscale"   Returns: Theme object green_screen()   Theme preset -> "Green Screen"   Returns: Theme object gruber()   Theme preset -> "Gruber"   Returns: Theme object gruvbox_hard()   Theme preset -> "Gruvbox Dark, Hard"   Returns: Theme object gruvbox_medium()   Theme preset -> "Gruvbox Dark, Medium"   Returns: Theme object gruvbox_pale()   Theme preset -> "Gruvbox Dark, Pale"   Returns: Theme object gruvbox_soft()   Theme preset -> "Gruvbox Dark, Soft"   Returns: Theme object gruvbox_material_hard()   Theme preset -> "Gruvbox Material Dark, Hard"   Returns: Theme object gruvbox_material_medium()   Theme preset -> "Gruvbox Material Dark, Medium"   Returns: Theme object gruvbox_material_soft()   Theme preset -> "Gruvbox Material Dark, Soft"   Returns: Theme object hardcore()   Theme preset -> "Hardcore"   Returns: Theme object harmonic16()   Theme preset -> "Harmonic16"   Returns: Theme object heetch()   Theme preset -> "Heetch"   Returns: Theme object helios()   Theme preset -> "Helios"   Returns: Theme object hopscotch()   Theme preset -> "Hopscotch"   Returns: Theme object horizon()   Theme preset -> "Horizon"   Returns: Theme object horizon_terminal()   Theme preset -> "Horizon Terminal"   Returns: Theme object humanoid()   Theme preset -> "Humanoid"   Returns: Theme object ia()   Theme preset -> "Ia"   Returns: Theme object icy()   Theme preset -> "Icy"   Returns: Theme object ir_black()   Theme preset -> "Ir Black"   Returns: Theme object isotope()   Theme preset -> "Isotope"   Returns: Theme object kanagawa()   Theme preset -> "Kanagawa"   Returns: Theme object katy()   Theme preset -> "Katy"   Returns: Theme object kimber()   Theme preset -> "Kimber"   Returns: Theme object lime()   Theme preset -> "Lime"   Returns: Theme object london_tube()   Theme preset -> "London Tube"   Returns: Theme object macintosh()   Theme preset -> "Macintosh"   Returns: Theme object marrakesh()   Theme preset -> "Marrakesh"   Returns: Theme object materia()   Theme preset -> "Materia"   Returns: Theme object material()   Theme preset -> "Material"   Returns: Theme object materialdarker()   Theme preset -> "Material Darker"   Returns: Theme object material_palenight()   Theme preset -> "Material Palenight"   Returns: Theme object material_vivid()   Theme preset -> "Material Vivid"   Returns: Theme object mellow_purple()   Theme preset -> "Mellow Purple"   Returns: Theme object mocha()   Theme preset -> "Mocha"   Returns: Theme object monokai()   Theme preset -> "Monokai"   Returns: Theme object Nebula()   Theme preset -> "Nebula"   Returns: Theme object nord()   Theme preset -> "Nord"   Returns: Theme object nova()   Theme preset -> "Nova"   Returns: Theme object ocean()   Theme preset -> "Ocean"   Returns: Theme object oceanicnext()   Theme preset -> "Oceanicnext"   Returns: Theme object onedark()   Theme preset -> "Onedark"   Returns: Theme object outrun()   Theme preset -> "Outrun"   Returns: Theme object pandora()   Theme preset -> "Pandora"   Returns: Theme object papercolor()   Theme preset -> "Papercolor"   Returns: Theme object paraiso()   Theme preset -> "Paraiso"   Returns: Theme object pasque()   Theme preset -> "Pasque"   Returns: Theme object phd()   Theme preset -> "Phd"   Returns: Theme object pico()   Theme preset -> "Pico"   Returns: Theme object pinky()   Theme preset -> "Pinky"   Returns: Theme object pop()   Theme preset -> "Pop"   Returns: Theme object porple()   Theme preset -> "Porple"   Returns: Theme object primer()   Theme preset -> "Primer"   Returns: Theme object purpledream()   Theme preset -> "Purpledream"   Returns: Theme object qualia()   Theme preset -> "Qualia"   Returns: Theme object railscasts()   Theme preset -> "Railscasts"   Returns: Theme object rebecca()   Theme preset -> "Rebecca"   Returns: Theme object rose_pine()   Theme preset -> "Rosé Pine"   Returns: Theme object rose_pine_dawn()   Theme preset -> "Rosé Pine Dawn"   Returns: Theme object rose_pine_moon()   Theme preset -> "Rosé Pine Moon"   Returns: Theme object sagelight()   Theme preset -> "Sagelight"   Returns: Theme object sakura()   Theme preset -> "Sakura"   Returns: Theme object sandcastle()   Theme preset -> "Sandcastle"   Returns: Theme object seti_ui()   Theme preset -> "Seti Ui"   Returns: Theme object shades_of_purple()   Theme preset -> "Shades Of Purple"   Returns: Theme object shadesmear()   Theme preset -> "Shadesmear"   Returns: Theme object shapeshifter()   Theme preset -> "Shapeshifter"   Returns: Theme object silk()   Theme preset -> "Silk"   Returns: Theme object snazzy()   Theme preset -> "Snazzy"   Returns: Theme object solar_flare()   Theme preset -> "Solar Flare"   Returns: Theme object solarized()   Theme preset -> "Solarized"   Returns: Theme object spaceduck()   Theme preset -> "Spaceduck"   Returns: Theme object spacemacs()   Theme preset -> "Spacemacs"   Returns: Theme object stella()   Theme preset -> "Stella"   Returns: Theme object still_alive()   Theme preset -> "Still Alive"   Returns: Theme object summercamp()   Theme preset -> "Summercamp"   Returns: Theme object summerfruit()   Theme preset -> "Summerfruit"   Returns: Theme object synth_midnight_terminal()   Theme preset -> "Synth Midnight Terminal"   Returns: Theme object tango()   Theme preset -> "Tango"   Returns: Theme object tender()   Theme preset -> "Tender"   Returns: Theme object tokyo_city()   Theme preset -> "Tokyo City"   Returns: Theme object tokyo_city_terminal()   Theme preset -> "Tokyo City Terminal"   Returns: Theme object tokyo_night()   Theme preset -> "Tokyo Night"   Returns: Theme object tokyo_night_storm()   Theme preset -> "Tokyo Night Storm"   Returns: Theme object tokyo_night_terminal()   Theme preset -> "Tokyo Night Terminal"   Returns: Theme object tokyo_night_terminal_storm()   Theme preset -> "Tokyo Night Terminal Storm"   Returns: Theme object tokyodark()   Theme preset -> "Tokyodark"   Returns: Theme object tokyodark_terminal()   Theme preset -> "Tokyodark Terminal"   Returns: Theme object tomorrow()   Theme preset -> "Tomorrow"   Returns: Theme object tomorrow_night()   Theme preset -> "Tomorrow Night"   Returns: Theme object tomorrow_night_eighties()   Theme preset -> "Tomorrow Night Eighties"   Returns: Theme object twilight()   Theme preset -> "Twilight"   Returns: Theme object unikitty()   Theme preset -> "Unikitty"   Returns: Theme object unikitty_reversible()   Theme preset -> "Unikitty Reversible"   Returns: Theme object uwunicorn()   Theme preset -> "Uwunicorn"   Returns: Theme object vice()   Theme preset -> "Vice"   Returns: Theme object vulcan()   Theme preset -> "Vulcan"   Returns: Theme object windows_10()   Theme preset -> "Windows 10"   Returns: Theme object windows_95()   Theme preset -> "Windows 95"   Returns: Theme object windows_high_contrast()   Theme preset -> "Windows High Contrast"   Returns: Theme object windows_nt()   Theme preset -> "Windows Nt"   Returns: Theme object woodland()   Theme preset -> "Woodland"   Returns: Theme object xcode_dusk()   Theme preset -> "Xcode Dusk"   Returns: Theme object
Perpustakaan Pine Script®
oleh kaigouthro
2
theme_engineLibrary "theme_engine" Theme Builder and Structure for live generative themes init(_name)   New theme object.   Parameters:      _name : (string) opptional name   Returns: a VAR theme (holds it's vals when updated if not overwritten) globals(theme, _h1, _h2, _h3, _h4, _s, _val, _contrast)   Create light/dark theme globals   Parameters:      theme : (theme) Theme to add theses to      _h1 : (float) Hue #1 for Template      _h2 : (float) Hue #2 for Template      _h3 : (float) Hue #3 for Template      _h4 : (float) Hue #4 for Template      _s : (float) Saturation of theme      _val : (float) Luminosity (light/dark)      _contrast : (float) Contrast to apply   Returns: Theme wwith adjusted colors setConfig(theme, setting)   Apply a Settings object to a theme   Parameters:      theme : Theme object to apply settings to.      setting : settings to apply   Returns: theme Types : settings   Settings for a theme   Fields:      h1 : (float) Hue #1 for Template      h2 : (float) Hue #2 for Template      h3 : (float) Hue #3 for Template      h4 : (float) Hue #4 for Template      sat : (float) Saturation of theme      lum : (float) Luminosity (light/dark)      vib : (float) Vibrance (Contrast)      r : (float) Hue of Red      o : (float) Hue of Orange      y : (float) Hue of Yellow      g : (float) Hue of Green      a : (float) Hue of Aqua      b : (float) Hue of Blue      i : (float) Hue of Indigo      v : (float) Hue of Violet      satvals : (settings) Array for use if desired to customize Saturation per color      lumvals : (settings) Array for use if desired to customize Luminancce per color mods   Modifiers Item for Use if desired   Fields:      val : (float)      size : (float)      depth : (float)      hue : (float)      sat : (float)      alpha : (float)      mix : (float)      emit : (float)      ch : (float)      step : (int)      dist : (int)      holds : (mods)      isin : (mods)      track : (color) varient   Light/Dark/Custom Theme Varients   Fields:      bg : (color) Bacckground Color      fg : (color) Foreground Color      accent : (color) Accccent Color      secondary : (color) Secondary Color      txt : (color) Text Color theme   Theme Object   Fields:      name : (string) Theme name      dark : (varient) Theme dark Varient      light : (varient) Theme light Varient      red : (color) Color for red      orange : (color) Color for orange      yellow : (color) Color for yellow      green : (color) Color for green      aqua : (color) Color for aqua      blue : (color) Color for blue      purple : (color) Color for purple      pink : (color) Color for pink      tweaks : (mods) Modifiers UDT to use for adjusters themedict   Fields:      names : (string ) Names of themes      themes : (theme ) Theme Items
Perpustakaan Pine Script®
oleh kaigouthro
1
base16Library "base16" Base16 Syntax Theme Collection. dark/light Pairs placed into 2 matched groups. included is tool for assembling your own themes, as well as all themes String names to create your own Input menus / add to your own theme matrix, and theme selectors addToMatrix(_mtx, _title, _choices, _theme)   To create a theme matrix with string index, use a color matrix global add theme name to string array of theme titles and last input a theme from above, or create your own theme arrays.   Parameters:      _mtx : (color ) matrix for storage      _title : (string ) Name of theme being added      _choices : (string ) name index      _theme : (color ) colors being added   Returns: void addToMatrix(_mtx, _theme)   Add theme to color matrix Non-indexed   Parameters:      _mtx : (color ) matrix for storage      _theme : (color ) colors being added dark()   Dark Themne Selection (With light Equivalent in same location)   Returns: Color matrix of dark themes light()   light Themne Selection (With dark Equivalent in same location)   Returns: Color matrix of light themes selectTheme(_mtx, _themes, _theme)   Get a Theme By Name   Parameters:      _mtx : (Matrix color) Name of Theme      _themes : (Array string) Array with Names of Themes      _theme : (string ) Name of Theme to select selectTheme(_mtx, _theme)   Get a Theme By Number   Parameters:      _mtx : (Matrix color) Name of Theme      _theme : (int ) Number of Theme to select /// all themes included: 3024 apathy apprentice ashes atelier_cave_light atelier_cave atelier_dune_light atelier_dune atelier_estuary_light atelier_estuary atelier_forest_light atelier_forest atelier_heath_light atelier_heath atelier_lakeside_light atelier_lakeside atelier_plateau_light atelier_plateau atelier_savanna_light atelier_savanna atelier_seaside_light atelier_seaside atelier_sulphurpool_light atelier_sulphurpool atlas ayu_dark ayu_light ayu_mirage bespin black_metal_bathory black_metal_burzum black_metal_dark_funeral black_metal_gorgoroth black_metal_immortal black_metal_khold black_metal_marduk black_metal_mayhem black_metal_nile black_metal_venom black_metal blue_forest blueish brewer bright brogrammer brush_trees_dark brush_trees catppuccin chalk circus classic_dark classic_light codeschool clrs cupcake cupertino da_one_black da_one_gray da_one_ocean da_one_paper da_one_sea da_one_white danqing_light danqing darcula darkmoss darktooth dark_violet decaf default_dark default_light dirtysea dracula edge_dark edge_light eighties embers emil equilibrium_dark equilibrium_gray_dark equilibrium_gray_light equilibrium_light espresso eva_dim eva everforest flat framer fruit_soda gigavolt github google_dark google_light gotham grayscale_dark grayscale_light green_screen gruber gruvbox_dark_hard gruvbox_dark_medium gruvbox_dark_pale gruvbox_dark_soft gruvbox_light_hard gruvbox_light_medium gruvbox_light_soft gruvbox_material_dark_hard gruvbox_material_dark_medium gruvbox_material_dark_soft gruvbox_material_light_hard gruvbox_material_light_medium gruvbox_material_light_soft hardcore harmonic16_dark harmonic16_light heetch_light heetch_dark helios hopscotch horizon_dark horizon_light horizon_terminal_dark horizon_terminal_light humanoid_dark humanoid_light ia_dark ia_light icy_dark ir_black isotope kanagawa katy kimber lime macintosh marrakesh materia material_darker material_lighter material_palenight material_vivid material mellow_purple mexico_light mocha monokai Nebula nord nova ocean oceanicnext one_light onedark outrun_dark pandora papercolor_dark papercolor_light paraiso pasque phd pico pinky pop porple primer_dark_dimmed primer_dark primer_light purpledream qualia railscasts rebecca rose_pine_dawn rose_pine_moon rose_pine sagelight sakura sandcastle seti_ui shades_of_purple shadesmear_dark shadesmear_light shapeshifter silk_dark silk_light snazzy solar_flare_light solar_flare solarized_dark solarized_light spaceduck spacemacs stella still_alive summercamp summerfruit_dark summerfruit_light synth_midnight_terminal_dark synth_midnight_terminal_light tango tender tokyo_city_dark tokyo_city_light tokyo_city_terminal_dark tokyo_city_terminal_light tokyo_night_dark tokyo_night_light tokyo_night_storm tokyo_night_terminal_dark tokyo_night_terminal_light tokyo_night_terminal_storm tokyodark_terminal tokyodark tomorrow_night_eighties tomorrow_night tomorrow london_tube twilight unikitty_dark unikitty_light unikitty_reversible uwunicorn vice vulcan windows_10_light windows_10 windows_95_light windows_95 windows_high_contrast_light windows_high_contrast windows_nt_light windows_nt woodland xcode_dusk zenburn
Perpustakaan Pine Script®
oleh kaigouthro
3