Auf geht's

In den Scripts nach "3d走势全图" suchen

3D Engine OverlayThe Overlay 3D Engine is an advanced and innovative indicator designed to render 3D objects on a trading chart using Pine Script language. This tool enables users to visualize complex geometric shapes and structures on their charts, providing a unique perspective on market trends and data. It is recommended to use this indicator with a time frame of 1 week or greater. The code defines various data structures, such as vectors, faces, meshes, locations, objects, and cameras, to represent the 3D objects and their position in the 3D space. It also provides a set of functions to manipulate these structures, such as scaling, rotating, and translating the objects, as well as calculating their perspective transformation based on a given camera. The main function, "render," takes a list of 3D objects (the scene) and a camera as input, processes the scene, and then generates the corresponding 2D lines to be drawn on the chart. The true range of the asset's price is calculated using an Exponential Moving Average (EMA), which helps adjust the rendering based on the asset's volatility. The perspective transformation function "perspective_transform" takes a mesh, a camera, an object's vertical offset, and the true range as input and computes the 2D coordinates for each vertex in the mesh. These coordinates are then used to create a list of polygons that represent the visible faces of the objects in the scene. The "process_scene" function takes a list of 3D objects and a camera as input and applies the perspective transformation to each object in the scene, generating a list of 2D polygons that represent the visible faces of the objects. Finally, the "render" function iterates through the list of 2D polygons and draws the corresponding lines on the chart, effectively rendering the 3D objects in a 2D projection on the trading chart. The rendering is done using Pine Script's built-in "line" function, which allows for scalable and efficient visualization of the objects. One of the challenges faced while developing the Overlay 3D Engine indicator was ensuring that the 3D objects rendered on the chart would automatically scale correctly for different time frames and trading pairs. Various assets and time frames exhibit different price ranges and volatilities, which can make it difficult to create a one-size-fits-all solution for rendering the 3D objects in a visually appealing and easily interpretable manner. To overcome this challenge, I implemented a dynamic scaling mechanism that leverages the true range of the asset's price and a calculated ratio. The true range is calculated using an Exponential Moving Average (EMA) of the difference between the high and low prices of the asset. This measure provides a smooth estimate of the asset's volatility, which is then used to adjust the scaling of the 3D objects rendered on the chart. The ratio is calculated by dividing the asset's opening price by the true range, which is then divided by a constant factor (32 in this case). This ratio effectively normalizes the scaling of the 3D objects based on the asset's price and volatility, ensuring that the rendered objects appear correctly sized and positioned on the chart, regardless of the time frame or trading pair being analyzed. By incorporating the true range and the calculated ratio into the rendering process, the Overlay 3D Engine indicator is able to automatically adjust the scaling of the 3D objects on the chart, providing a consistent and visually appealing representation of the objects across various time frames and trading pairs. This dynamic scaling mechanism enhances the overall utility and versatility of the indicator, making it a valuable tool for traders and analysts seeking a unique perspective on market trends. In addition to the dynamic scaling mechanism mentioned earlier, the Overlay 3D Engine indicator also employs a sophisticated perspective transformation to render the 3D objects on the chart. Perspective transformation is an essential aspect of 3D graphics, as it provides the necessary conversion from 3D coordinates to 2D coordinates, allowing the 3D objects to be displayed on a 2D chart. The perspective transformation process in the Overlay 3D Engine indicator begins by taking the 3D mesh data of the objects and transforming their vertices based on the position, orientation, and field of view of a virtual camera. The camera's field of view (FOV) is adjusted using a tangent function, which ensures that the rendered objects appear with the correct perspective, regardless of the chart's aspect ratio. Once the vertices of the 3D objects have been transformed, the perspective-transformed 2D coordinates are then used to create polygons that can be rendered on the chart. These polygons represent the visible faces of the 3D objects and are drawn using lines that connect the transformed vertices. The incorporation of perspective transformation in the Overlay 3D Engine indicator ensures that the 3D objects are rendered with a realistic appearance, providing a visually engaging and informative representation of the market trends. This technique, combined with the dynamic scaling mechanism, makes the Overlay 3D Engine indicator a powerful and innovative tool for traders and analysts seeking to visualize and interpret market data in a unique and insightful manner. In summary, the Overlay 3D Engine indicator offers a novel way to interpret and visualize market data, enhancing the overall trading experience by providing a unique perspective on market trends.
Pine Script® Indikator
von The_Peaceful_Lizard
18
3D EngineHello everyone, I am excited to share with you the first 3D engine in Pine Script! This is a remarkable achievement that will enable traders to explore the possibilities of 3D objects in their technical analysis. To use this engine, you will need to use a higher time frame (1W or greater) to load the 3D objects in time. The code is straightforward and easy to use, with various input options to customize the object's position, rotation, and scale. You can select between two default 3D objects, Pin or Ball, by changing the 'list' input string. The 3D engine is based on the vector and mesh data structures, and it includes several utility functions to perform operations such as rotation, translation, and scaling on these structures. It also includes functions to calculate perspective transformation for projecting 3D objects onto a 2D surface, which is the essential step in rendering the object in a 2D chart. The 'process_scene' function is the main function that converts the 3D object data into 2D polygon data, which can be rendered on the chart. This function uses the 'process_object' function, which applies the object's transformation (position, rotation, and scale) and returns a scaled and rotated mesh that is ready for projection. At the end of the code, there is a camera object that defines the camera's position, target, and field of view. You can customize this camera object to change the perspective of the rendered object. To make your own 3D object, you can use the included Python program to convert an OBJ file into the format used by the engine. This program converts the OBJ file into a list of vector4 objects, which can be copy-pasted into the 'pin_vertex_list' array or a similar array. Please note that this process requires some knowledge of Python and the OBJ file format. Overall, this is a fantastic achievement that opens up new possibilities for technical analysis in Pine Script. I encourage you to try it out and see what you can create with it. In this code, there are several functions and data structures used to represent and manipulate 3D objects in a simple 3D engine. I will explain each function in detail below: radians(degree): Converts an angle in degrees to radians. quat_identity(): Returns a quaternion representing the identity rotation. quat_from_axis_angle(axis, angle): Creates a quaternion from an axis of rotation and an angle. quat_multiply(q1, q2): Multiplies two quaternions, q1 and q2, and returns the result. quat_conjugate(q): Returns the conjugate of a quaternion, q. quat_rotate(q, v): Rotates a 3D vector, v, by a quaternion, q, and returns the result. rotate_vector_by_quaternion(v, q): Rotates a 3D vector, v, by a quaternion, q, and returns the result. scale_vector(vector, constant): Scales a 3D vector by a constant and returns the result. scale_mesh(mesh_obj, constant): Scales a mesh by a constant and returns the new mesh. rotate_mesh(mesh_obj, axis, angle): Rotates a mesh around a specified axis by a given angle and returns the new mesh. quat_translate(src, offset): Translates a 3D vector, src, by an offset and returns the result. translate_mesh(mesh_obj, offset): Translates a mesh by an offset and returns the new mesh. perspective_transform(msh, cam): Transforms a 3D mesh into a 2D mesh using a camera. process_object(obj, cam): Processes a 3D object with a camera and returns a 2D mesh. size(scene): Calculates the total number of vertices in a scene. make_poly(scene): Converts a scene of 2D meshes into an array of polygons. process_scene(scn, cam): Processes an entire scene of 3D objects with a camera and returns an array of polygons. These functions work together to create a simple 3D engine that can manipulate, transform, and render 3D objects as 2D polygons. The main part of the script defines the camera, vertices, and faces for a pin object, and then uses the functions to process and render the object. Note that some types are also defined in the code, including vector2, vector3, vector4, face, mesh, mesh2d, location, object, poly4, polyg, and camera. These types represent various mathematical structures and entities used in 3D graphics, such as vectors, faces, meshes, and cameras. Here is an explanation of the inputs for all the functions in the given code: radians(degree): degree: Angle in degrees to be converted to radians. quat_from_axis_angle(axis, angle): axis: A vector3 object representing the axis of rotation. angle: The angle in radians to rotate about the axis. quat_multiply(q1, q2): q1, q2: Two quaternion objects to be multiplied. quat_conjugate(q): q: A quaternion object whose conjugate is to be calculated. quat_rotate(q, v): q: The quaternion representing the rotation. v: The vector3 object to be rotated. rotate_vector_by_quaternion(v, q): v: The vector3 object to be rotated. q: The quaternion representing the rotation. scale_vector(vector, constant): vector: A vector4 object to be scaled. constant: The scaling factor. scale_mesh(mesh_obj, constant): mesh_obj: A mesh object to be scaled. constant: The scaling factor. rotate_mesh(mesh_obj, axis, angle): mesh_obj: A mesh object to be rotated. axis: A vector3 object representing the axis of rotation. angle: The angle in radians to rotate the mesh. quat_translate(src, offset): src: A vector4 object representing the source position. offset: A vector3 object representing the translation offset. translate_mesh(mesh_obj, offset): mesh_obj: A mesh object to be translated. offset: A vector3 object representing the translation offset. perspective_transform(msh, cam): msh: A mesh object to be transformed. cam: A camera object used for the transformation. process_object(obj, cam): obj: An object containing a mesh and its location. cam: A camera object used for processing the object. make_poly(scene): scene: An array of mesh2d objects to generate polygons from. process_scene(scn, cam): scn: An array of objects containing meshes and their locations. cam: A camera object used for processing the scene. Note that some of these functions are utility functions or internal functions, and their inputs are derived from other functions or user inputs. I will make a library eventually.
Pine Script® Indikator
von The_Peaceful_Lizard
6
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! ✨
Pine Script® Indikator
von hapharmonic
8
PSv5 3D Array/Matrix Super Hack"In a world of ever pervasive and universal deceit, telling a simple truth is considered a revolutionary act." INTRO: First, how about a little bit of philosophic poetry with another dimension applied to it? The "matrix of control" is everywhere... It is all around us, even now in the very place you reside. You can see it when you look at your digitized window outwards into the world, or when you turn on regularly scheduled television "programs" to watch news narratives and movies that subliminally influence your thoughts, feelings, and emotions. You have felt it every time you have clocked into dead end job workplaces... when you unknowingly worshiped on the conformancy alter to cultish ideologies... and when you pay your taxes to a godvernment that is poisoning you softly and quietly by injecting your mind and body with (psyOps + toxicCompounds). It is a fictitiously generated world view that has been pulled over your eyes to blindfold, censor, and mentally prostrate you from spiritually hearing the real truth. What TRUTH you must wonder? That you are cognitively enslaved, like everyone else. You were born into mental bondage, born into an illusory societal prison complex that you are entirely incapable of smelling, tasting, or touching. Its a contrived monetary prison enterprise for your mind and eternal soul, built by pretending politicians, corporate CONartists, and NonGoverning parasitic Organizations deploying any means of infiltration and deception by using every tactic unimaginable. You are slowly being convinced into becoming a genetically altered cyborg by acclimation, socially engineered and chipped to eventually no longer be 100% human. Unfortunately no one can be told eloquently enough in words what the matrix of control truly is. You have to experience it and witness it for yourself. This is your chance to program a future paradigm that doesn't yet exist. After visiting here, there is absolutely no turning back. You can continually take the blue pill BIGpharmacide wants you to repeatedly intake. The story ends if you continually sleep walk through a 2D hologram life, believing whatever you wish to believe until you cease to exist. OR, you can take the red pill challenge, explore "question every single thing" wonderland, program your arse off with 3D capabilities, ultimately ascertaining a new mathematical empyrean. Only then can you fully awaken to discover how deep the rabbit hole state of affairs transpire worldwide with a genuine open mind. Remember, all I'm offering is a mathematical truth, nothing more... PURPOSE: With that being said above, it is now time for advanced developers to start creating their own matrix constructs in 3D, in Pine, just as the universe is created spatially. For those of you who instantly know what this script's potential is easily capable of, you already know what you have to do with it. While this is simplistically just a 3D array for either integers or floats, additional companion functions can in the future be constructed by other members to provide a more complete matrix/array library for millions of folks on TV. I do encourage the most courageous of mathemagicians on TV to do so. I have been employing very large 2D/3D array structures for quite some time, and their utility seems to be of great benefit. Discovering that for myself, I fully realized that Pine is incomplete and must be provided with this agility to process complex datasets that traders WILL use in the future. Mark my words! CONCEPTION: While I have long realized and theorized this code for a great duration of time, I was finally able to turn it into a Pine reality with the assistance and training of an "artificially intuitive" program while probing its aptitude. Even though it knows virtually nothing about Pine Script 4.0 or 5.0 syntax, functions, and behavior, I was able to conjure code into an identity similar to what you see now within a few minutes. Close enough for me! Many manual edits later for pine compliance, and I had it in chart, presto! While most people consider the service to be an "AI", it didn't pass my Pine Turing test. I did have to repeatedly correct it, suffered through numerous apologies from it, was forced to use specifically tailored words, and also rationally debate AND argued with it. It is a handy helper but beware of generating Pine code from it, trust me on this one. However... this artificially intuitive service is currently available in its infancy as version 3. Version 4 most likely will have more diversity to enhance my algorithmic expertise of Pine wizardry. I do have to thank E.M. and his developers for an eye opening experience, or NONE of this code below would be available as you now witness it today. LIMITATIONS: As of this initial release, Pine only supports 100,000 array elements maximum. For example, when using this code, a 50x50x40 element configuration will exceed this limit, but 50x50x39 will work. You will always have to keep that in mind during development. Running that size of an array structure on every single bar will most likely time out within 20-40 seconds. This is not the most efficient method compared to a real native 3D array in action. Ehlers adepts, this might not be 100% of what you require to "move forward". You can try, but head room with a low ceiling currently will be challenging to walk in for now, even with extremely optimized Pine code. A few common functions are provided, but this can be extended extensively later if you choose to undertake that endeavor. Use the code as is and/or however you deem necessary. Any TV member is granted absolute freedom to do what they wish as they please. I ultimately wish to eventually see a fully equipped library version for both matrix3D AND array3D created by collaborative efforts that will probably require many Pine poets testing collectively. This is just a bare bones prototype until that day arrives. Considerably more computational server power will be required also. Anyways, I hope you shall find this code somewhat useful. Notice: Unfortunately, I will not provide any integration support into members projects at all. I have my own projects that require too much of my time already. POTENTIAL APPLICATIONS: The creation of very large coefficient 3D caches/buffers specifically at bar_index==0 can dramatically increase runtime agility for thousands of bars onwards. Generating 1000s of values once and just accessing those generated values is much faster. Also, when running dozens of algorithms simultaneously, a record of performance statistics can be kept, self-analyzed, and visually presented to the developer/user. And, everything else under the sun can be created beyond a developers wildest dreams... EPILOGUE: Free your mind!!! And unleash weapons of mass financial creation upon the earth for all to utilize via the "Power of Pine". Flying monkeys and minions are waging economic sabotage upon humanity, decimating markets and exchanges. You can always see it your market charts when things go horribly wrong. This is going to be an astronomical technical challenge to continually navigate very choppy financial markets that are increasingly becoming more and more unstable and volatile. Ordinary one plot algorithms simply are not enough anymore. Statistics and analysis sits above everything imagined. This includes banking, godvernment, corporations, REAL science, technology, health, medicine, transportation, energy, food, etc... We have a unique perspective of the world that most people will never get to see, depending on where you look. With an ever increasingly complex world in constant dynamic flux, novel ways to process data intricately MUST emerge into existence in order to tackle phenomenal tasks required in the future. Achieving data analysis in 3D forms is just one lonely step of many more to come. At this time the WesternEconomicFraudsters and the WorldHealthOrders are attempting to destroy/reset the world's financial status in order to rain in chaos upon most nations, causing asset devaluation and hyper-inflation. Every form of deception, infiltration, and theft is occurring with a result of destroyed wealth in preparation to consolidate it. Open discussions, available to the public, by world leaders/moguls are fantasizing about new dystopian system as a one size fits all nations solution of digitalID combined with programmableDemonicCurrencies to usher in a new form of obedient servitude to a unipolar digitized hegemony of monetary vampires. If they do succeed with economic conquest, as they have publicly stated, people will be converted into human cattle, herded within smart cities, you will own nothing, eat bugs for breakfast/lunch/dinner, live without heat during severe winter conditions, and be happy. They clearly haven't done the math, as they are far outnumbered by a ratio of 1 to millions. Sith Lords do not own planet Earth! The new world disorder of human exploitation will FAIL. History, my "greatest teacher" for decades reminds us over, and over, and over again, and what are time series for anyways? They are for an intense mathematical analysis of prior historical values/conditions in relation to today's values/conditions... I imagine one day we will be able to ask an all-seeing AI, "WHO IS TO BLAME AND WHY AND WHEN?" comprised of 300 pages in great detail with images, charts, and statistics. What are the true costs of malignant lies? I will tell you... 64bit numbers are NOT even capable of calculating the extreme cost of pernicious lies and deceit. That's how gigantic this monstrous globalization problem has become and how awful the "matrix of control" truly is now. ALL nations need a monumental revision of its CODE OF ETHICS, and that's definitely a multi-dimensional problem that needs solved sooner than later. If it was up to me, economies and technology would be developed so extensively to eliminate scarcity and increase the standard of living so high, that the notion of war and conflict would be considered irrelevant and extremely appalling to the future generations of humanity, our grandchildren born and unborn. The future will not be owned and operated by geriatric robber barons destined to expire quickly. The future will most likely be intensely "guided" by intelligent open source algorithms that youthful generations will inherit as their birth right. P.S. Don't give me that politco-my-diction crap speech below in comments. If they weren't meddling with economics mucking up 100% of our chart results in 100% of tickers, I wouldn't have any cause to analyze any effects generated by them, nor provide this script's code. I am performing my analytical homework, but have you? Do you you know WHY international affairs are in dire jeopardy? Without why, the "Power of Pine" would have never existed as it specifically does today. I'm giving away much of my mental power generously to TV members so you are specifically empowered beyond most mathematical agilities commonly existing. I'm just a messenger of profound ideas. Loving and loathing of words is ALWAYS in the eye of beholders, and that's why the freedom of speech is enshrined as #1 in the constitutional code of the USA. Without it, this entire site might not have been allowed to exist from its founder's inceptions.
Pine Script® Indikator
von ImmortalFreedom
12
Solar System in 3D [Astro Tool w/ Zodiac]Hello Traders and Developers, I am excited to announce my latest Open Source indicator. At the core, this is a demonstration of PineScript’s capabilities in Rendering 3D Animations, while at the same time being a practical tool for Financial Astrologists. This 3D Engine dynamically renders all the major celestial bodies with their individual orbits, rotation speeds, polar inclinations and astrological aspects, all while maintaining accurate spatial relationships and perspective. This is a Geocentric model of the solar system (viewed from the perspective of Earth), since that is what most Astrologists use. Thanks to the AstroLib Library created by @BarefootJoey, this model uses the real coordinates of cosmic bodies for every timestamp. This script truly comes to life when using the “Bar Replay” mode in TradingView, as you can observe the relationships between planets and price action as time progresses, with the full animation capabilities as mentioned above. In addition to what I have described, this indicator also displays the orbital trajectories for each cosmic body, and has labels for everything. I have also added the ability to hover on all the labels, and see a short description of what they imply in Astrology. Optional Planetary Aspect Computation This indicator supports all the Major Planetary Aspects, with an accuracy defined by the user (1° by default). Conjunction: 0° Alignment. This draws a RED line starting from the center, and going through both planets. Sextile: 60° Alignment. This draws three YELLOW lines, connecting the planets to each other and to the center. Square: 90° Alignment. This draws three BLUE lines, connecting the planets to each other and to the center. Trine: 120° Alignment. This draws three PURPLE lines, connecting the planets to each other and to the center. Opposition: 180° Alignment. This draws a GREEN line starting from one planet, passing through the center and ending on the second planet. The below image depicts a Top-Down view of the system, with the Moon in Opposition to Venus and with Mars in Square with Neptune . Retrograde Computation This indicator also displays when a planet enters Retrograde (Apparent Backward Motion) by making its orbital trajectory dashed and the planet name getting a red background. The image below displays an example of Jupiter, Saturn, Neptune and Pluto in Retrograde Motion, from the camera perspective of a 65 degree inclination. Optional Zodiac Computation (Tropical and Sidereal) Zodiac represents the relatively stationary star formations that rest along the ecliptic plane, with planets transitioning from one to the next, each with a 30° separation (making 12 in total). I have implemented the option to switch between Tropical mode (where these stars were 2,000 years ago) and Sidereal (where these stars are today). The image below displays the Zodiac labels with clear lines denoting where each planet falls into. While this indicator is deployed in a separate pane, it is trivial to transfer it onto your price chart, just by clicking and dragging the graphics. After that, you can adjust the visuals by dragging the scale on the side, or optimizing model settings. You can also drag the model above or below the price, as shown in the following image: Of course, there are a lot of options to customize this planetary model to your tastes and analytical needs. Aside from visual changes for the labels, colors or resolution you can also disable certain planets that don’t meet your needs as shown below: Once can also infer the current lunar phases using the Aspects between the Sun and Moon. When the Moon is Opposite the Sun that is a Full Moon, while when they are Conjunct that is a New Moon (and sometimes Eclipse). —--------------------------------------------------------------------------- I have made this indicator open source to help PineScript programmers understand how to approach 3D graphics rendering, enabling them to develop ever more capable scripts and continuously push the boundaries of what's possible on TradingView. The code is well documented with comments and has a clear naming convention for functions and variables, to aid developers understand how everything operates. For financial astrologists, this indicator offers a new way to visualize and correlate planetary movements, adding depth and ease to astrological market analysis. Regards, Hawk
Pine Script® Indikator
von Alien_Algorithms
64
Trend Following MAs 3DHello All, This is Moving Averages Trend Following 3D indicator. The idea is based on direction of MAs and relation between 20 moving averages (5 to 100 period). Option to show different type of MAs: EMA, SMA, RMA, WMA, VWMA. As I haved tested it looks succesful at calculating trend direction and trend strength. For a better look I tried to make it 3D, it looks good I think, waiting comments ;) Some screenshots: By using RMA type: When it gets tiny it means there is no trend: An example for down trend: ENJOY!
Pine Script® Indikator
von LonesomeTheBlue
31
Moving Averages 3DHello All, This is an experimental work to show 10 moving averages in 3D by using linefill.new() feature of the Pine language. You can set moving average type as Simple (SMA) or Exponential (EMA) You can set "Starting Length" and set the "Step" to calculate other lengths. For example; if "Starting Length" is 10 and "step" is 5 then the lengths are 10, 15, 20, 25... You can set the colors as Red, Green, Blue for each direction. And you can change the width. you can see the examples below In following example Green and Blue used: In following example Blue and Red is used and Width is set as 5: Enjoy!
Pine Script® Indikator
von LonesomeTheBlue
68
Wave Channel 3D Wave Channel 3D Built by Ricardo idea from JR & Aloakdutt from indieTrades Jan. 2010 This indicator is very easy to build. We utilize Moving Averages with a set multiplier and an offset. Specially we try to use Fibonacci sequence series numbers (1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144...) as time space and multiplier (default 89, 8). Also included is Donchian Channel to locate strong trends and possible future support - resistance. Examples of support/resistance on chart. Dominant Price Trends Future Support Resistance Comparing Fibonacci Series Time Space - Multiplier When Comparing make note of confluence support/resistance showing up with Fibonacci Series Example uses DC When Comparing make note of confluence support/resistance showing up with Fibonacci Series Example without DC / Smooth MA
Pine Script® Indikator
von QuantitativeExhaustion
16
3D Surface Modeling [PhenLabs]📊 3D Surface Modeling Version: PineScript™ v6 📌 Description The 3D Surface Modeling indicator revolutionizes technical analysis by generating three-dimensional visualizations of multiple technical indicators across various timeframes. This advanced analytical tool processes and renders complex indicator data through a sophisticated matrix-based calculation system, creating an intuitive 3D surface representation of market dynamics. The indicator employs array-based computations to simultaneously analyze multiple instances of selected technical indicators, mapping their behavior patterns across different temporal dimensions. This unique approach enables traders to identify complex market patterns and relationships that may be invisible in traditional 2D charts. 🚀 Points of Innovation Matrix-Based Computation Engine: Processes up to 500 concurrent indicator calculations in real-time Dynamic 3D Rendering System: Creates depth perception through sophisticated line arrays and color gradients Multi-Indicator Integration: Seamlessly combines VWAP, Hurst, RSI, Stochastic, CCI, MFI, and Fractal Dimension analyses Adaptive Scaling Algorithm: Automatically adjusts visualization parameters based on indicator type and market conditions 🔧 Core Components Indicator Processing Module: Handles real-time calculation of multiple technical indicators using array-based mathematics 3D Visualization Engine: Converts indicator data into three-dimensional surfaces using line arrays and color mapping Dynamic Scaling System: Implements custom normalization algorithms for different indicator types Color Gradient Generator: Creates depth perception through programmatic color transitions 🔥 Key Features Multi-Indicator Support: Comprehensive analysis across seven different technical indicators Customizable Visualization: User-defined color schemes and line width parameters Real-time Processing: Continuous calculation and rendering of 3D surfaces Cross-Timeframe Analysis: Simultaneous visualization of indicator behavior across multiple periods 🎨 Visualization Surface Plot: Three-dimensional representation using up to 500 lines with dynamic color gradients Depth Indicators: Color intensity variations showing indicator value magnitude Pattern Recognition: Visual identification of market structures across multiple timeframes 📖 Usage Guidelines Indicator Selection Type: VWAP, Hurst, RSI, Stochastic, CCI, MFI, Fractal Dimension Default: VWAP Starting Length: Minimum 5 periods Default: 10 Step Size: Interval between calculations Range: 1-10 Visualization Parameters Color Scheme: Green, Red, Blue options Line Width: 1-5 pixels Surface Resolution: Up to 500 lines ✅ Best Use Cases Multi-timeframe market analysis Pattern recognition across different technical indicators Trend strength assessment through 3D visualization Market behavior study across multiple periods ⚠️ Limitations High computational resource requirements Maximum 500 line restriction Requires substantial historical data Complex visualization learning curve 🔬 How It Works 1. Data Processing: Calculates selected indicator values across multiple timeframes Stores results in multi-dimensional arrays Applies custom scaling algorithms 2. Visualization Generation: Creates line arrays for 3D surface representation Applies color gradients based on value magnitude Renders real-time updates to surface plot 3. Display Integration: Synchronizes with chart timeframe Updates surface plot dynamically Maintains visual consistency across updates 🌟 Credits: Inspired by LonesomeTheBlue (modified for multiple indicator types with scaling fixes and additional unique mappings) 💡 Note: Optimal performance requires sufficient computing resources and historical data. Users should start with default settings and gradually adjust parameters based on their analysis requirements and system capabilities.
Pine Script® Indikator
von PhenLabs
3
3D BowlingIntroducing the "3D Bowling Game" – a fun and interactive demo scene project in Pine Script, powered by a custom 3D engine! This bowling game showcases the potential of Pine Script for developing engaging and immersive experiences, even within the confines of a trading platform. To play the game, you'll first be prompted to choose where you want to throw the ball. Next, you'll be asked to draw a line indicating the direction you want the ball to go. Sit back and enjoy as the game takes care of the rest! The source code features various sections, including: Types and helper functions to manipulate vectors, matrices, and angles Routines for calculating cross products, dot products, and vector normalization Transformation matrices for rotation and scaling Functions for perspective transformation, mesh transformations, and face normal calculations Culling and shading algorithms to provide a more realistic visual experience The project's source code is an excellent starting point for anyone interested in exploring the capabilities of Pine Script beyond the typical trading indicators and strategies. The 3D Bowling Game demonstrates the flexibility of Pine Script and its potential for creating interactive experiences in a seemingly unconventional environment. So, what are you waiting for? Dive into the source code, tweak it to your liking, or build upon it to create your own interactive 3D experiences. Enjoy the game, and happy coding! With light. I will say there is an issue with the fact that you cant draw as may linefills as you can lines.
Pine Script® Indikator
von The_Peaceful_Lizard
6
Markov Chain [3D] | FractalystWhat exactly is a Markov Chain? This indicator uses a Markov Chain model to analyze, quantify, and visualize the transitions between market regimes (Bull, Bear, Neutral) on your chart. It dynamically detects these regimes in real-time, calculates transition probabilities, and displays them as animated 3D spheres and arrows, giving traders intuitive insight into current and future market conditions. How does a Markov Chain work, and how should I read this spheres-and-arrows diagram? Think of three weather modes: Sunny, Rainy, Cloudy. Each sphere is one mode. The loop on a sphere means “stay the same next step” (e.g., Sunny again tomorrow). The arrows leaving a sphere show where things usually go next if they change (e.g., Sunny moving to Cloudy). Some paths matter more than others. A more prominent loop means the current mode tends to persist. A more prominent outgoing arrow means a change to that destination is the usual next step. Direction isn’t symmetric: moving Sunny→Cloudy can behave differently than Cloudy→Sunny. Now relabel the spheres to markets: Bull, Bear, Neutral. Spheres: market regimes (uptrend, downtrend, range). Self‑loop: tendency for the current regime to continue on the next bar. Arrows: the most common next regime if a switch happens. How to read: Start at the sphere that matches current bar state. If the loop stands out, expect continuation. If one outgoing path stands out, that switch is the typical next step. Opposite directions can differ (Bear→Neutral doesn’t have to match Neutral→Bear). What states and transitions are shown? The three market states visualized are: Bullish (Bull): Upward or strong-market regime. Bearish (Bear): Downward or weak-market regime. Neutral: Sideways or range-bound regime. Bidirectional animated arrows and probability labels show how likely the market is to move from one regime to another (e.g., Bull → Bear or Neutral → Bull). How does the regime detection system work? You can use either built-in price returns (based on adaptive Z-score normalization) or supply three custom indicators (such as volume, oscillators, etc.). Values are statistically normalized (Z-scored) over a configurable lookback period. The normalized outputs are classified into Bull, Bear, or Neutral zones. If using three indicators, their regime signals are averaged and smoothed for robustness. How are transition probabilities calculated? On every confirmed bar, the algorithm tracks the sequence of detected market states, then builds a rolling window of transitions. The code maintains a transition count matrix for all regime pairs (e.g., Bull → Bear). Transition probabilities are extracted for each possible state change using Laplace smoothing for numerical stability, and frequently updated in real-time. What is unique about the visualization? 3D animated spheres represent each regime and change visually when active. Animated, bidirectional arrows reveal transition probabilities and allow you to see both dominant and less likely regime flows. Particles (moving dots) animate along the arrows, enhancing the perception of regime flow direction and speed. All elements dynamically update with each new price bar, providing a live market map in an intuitive, engaging format. Can I use custom indicators for regime classification? Yes! Enable the "Custom Indicators" switch and select any three chart series as inputs. These will be normalized and combined (each with equal weight), broadening the regime classification beyond just price-based movement. What does the “Lookback Period” control? Lookback Period (default: 100) sets how much historical data builds the probability matrix. Shorter periods adapt faster to regime changes but may be noisier. Longer periods are more stable but slower to adapt. How is this different from a Hidden Markov Model (HMM)? It sets the window for both regime detection and probability calculations. Lower values make the system more reactive, but potentially noisier. Higher values smooth estimates and make the system more robust. How is this Markov Chain different from a Hidden Markov Model (HMM)? Markov Chain (as here): All market regimes (Bull, Bear, Neutral) are directly observable on the chart. The transition matrix is built from actual detected regimes, keeping the model simple and interpretable. Hidden Markov Model: The actual regimes are unobservable ("hidden") and must be inferred from market output or indicator "emissions" using statistical learning algorithms. HMMs are more complex, can capture more subtle structure, but are harder to visualize and require additional machine learning steps for training. A standard Markov Chain models transitions between observable states using a simple transition matrix, while a Hidden Markov Model assumes the true states are hidden (latent) and must be inferred from observable “emissions” like price or volume data. In practical terms, a Markov Chain is transparent and easier to implement and interpret; an HMM is more expressive but requires statistical inference to estimate hidden states from data. Markov Chain: states are observable; you directly count or estimate transition probabilities between visible states. This makes it simpler, faster, and easier to validate and tune. HMM: states are hidden; you only observe emissions generated by those latent states. Learning involves machine learning/statistical algorithms (commonly Baum–Welch/EM for training and Viterbi for decoding) to infer both the transition dynamics and the most likely hidden state sequence from data. How does the indicator avoid “repainting” or look-ahead bias? All regime changes and matrix updates happen only on confirmed (closed) bars, so no future data is leaked, ensuring reliable real-time operation. Are there practical tuning tips? Tune the Lookback Period for your asset/timeframe: shorter for fast markets, longer for stability. Use custom indicators if your asset has unique regime drivers. Watch for rapid changes in transition probabilities as early warning of a possible regime shift. Who is this indicator for? Quants and quantitative researchers exploring probabilistic market modeling, especially those interested in regime-switching dynamics and Markov models. Programmers and system developers who need a probabilistic regime filter for systematic and algorithmic backtesting: The Markov Chain indicator is ideally suited for programmatic integration via its bias output (1 = Bull, 0 = Neutral, -1 = Bear). Although the visualization is engaging, the core output is designed for automated, rules-based workflows—not for discretionary/manual trading decisions. Developers can connect the indicator’s output directly to their Pine Script logic (using input.source()), allowing rapid and robust backtesting of regime-based strategies. It acts as a plug-and-play regime filter: simply plug the bias output into your entry/exit logic, and you have a scientifically robust, probabilistically-derived signal for filtering, timing, position sizing, or risk regimes. The MC's output is intentionally "trinary" (1/0/-1), focusing on clear regime states for unambiguous decision-making in code. If you require nuanced, multi-probability or soft-label state vectors, consider expanding the indicator or stacking it with a probability-weighted logic layer in your scripting. Because it avoids subjectivity, this approach is optimal for systematic quants, algo developers building backtested, repeatable strategies based on probabilistic regime analysis. What's the mathematical foundation behind this? The mathematical foundation behind this Markov Chain indicator—and probabilistic regime detection in finance—draws from two principal models: the (standard) Markov Chain and the Hidden Markov Model (HMM). How to use this indicator programmatically? The Markov Chain indicator automatically exports a bias value (+1 for Bullish, -1 for Bearish, 0 for Neutral) as a plot visible in the Data Window. This allows you to integrate its regime signal into your own scripts and strategies for backtesting, automation, or live trading. Step-by-Step Integration with Pine Script (input.source) Add the Markov Chain indicator to your chart. This must be done first, since your custom script will "pull" the bias signal from the indicator's plot. In your strategy, create an input using input.source() Example: //@version=5 strategy("MC Bias Strategy Example") mcBias = input.source(close, "MC Bias Source") After saving, go to your script’s settings. For the “MC Bias Source” input, select the plot/output of the Markov Chain indicator (typically its bias plot). Use the bias in your trading logic Example (long only on Bull, flat otherwise): if mcBias == 1 strategy.entry("Long", strategy.long) else strategy.close("Long") For more advanced workflows, combine mcBias with additional filters or trailing stops. How does this work behind-the-scenes? TradingView’s input.source() lets you use any plot from another indicator as a real-time, “live” data feed in your own script (source). The selected bias signal is available to your Pine code as a variable, enabling logical decisions based on regime (trend-following, mean-reversion, etc.). This enables powerful strategy modularity : decouple regime detection from entry/exit logic, allowing fast experimentation without rewriting core signal code. Integrating 45+ Indicators with Your Markov Chain — How & Why The Enhanced Custom Indicators Export script exports a massive suite of over 45 technical indicators—ranging from classic momentum (RSI, MACD, Stochastic, etc.) to trend, volume, volatility, and oscillator tools—all pre-calculated, centered/scaled, and available as plots. // Enhanced Custom Indicators Export - 45 Technical Indicators // Comprehensive technical analysis suite for advanced market regime detection //@version=6 indicator('Enhanced Custom Indicators Export | Fractalyst', shorttitle='Enhanced CI Export', overlay=false, scale=scale.right, max_labels_count=500, max_lines_count=500) // |----- Input Parameters -----| // momentum_group = "Momentum Indicators" trend_group = "Trend Indicators" volume_group = "Volume Indicators" volatility_group = "Volatility Indicators" oscillator_group = "Oscillator Indicators" display_group = "Display Settings" // Common lengths length_14 = input.int(14, "Standard Length (14)", minval=1, maxval=100, group=momentum_group) length_20 = input.int(20, "Medium Length (20)", minval=1, maxval=200, group=trend_group) length_50 = input.int(50, "Long Length (50)", minval=1, maxval=200, group=trend_group) // Display options show_table = input.bool(true, "Show Values Table", group=display_group) table_size = input.string("Small", "Table Size", options= , group=display_group) // |----- MOMENTUM INDICATORS (15 indicators) -----| // // 1. RSI (Relative Strength Index) rsi_14 = ta.rsi(close, length_14) rsi_centered = rsi_14 - 50 // 2. Stochastic Oscillator stoch_k = ta.stoch(close, high, low, length_14) stoch_d = ta.sma(stoch_k, 3) stoch_centered = stoch_k - 50 // 3. Williams %R williams_r = ta.stoch(close, high, low, length_14) - 100 // 4. MACD (Moving Average Convergence Divergence) = ta.macd(close, 12, 26, 9) // 5. Momentum (Rate of Change) momentum = ta.mom(close, length_14) momentum_pct = (momentum / close ) * 100 // 6. Rate of Change (ROC) roc = ta.roc(close, length_14) // 7. Commodity Channel Index (CCI) cci = ta.cci(close, length_20) // 8. Money Flow Index (MFI) mfi = ta.mfi(close, length_14) mfi_centered = mfi - 50 // 9. Awesome Oscillator (AO) ao = ta.sma(hl2, 5) - ta.sma(hl2, 34) // 10. Accelerator Oscillator (AC) ac = ao - ta.sma(ao, 5) // 11. Chande Momentum Oscillator (CMO) cmo = ta.cmo(close, length_14) // 12. Detrended Price Oscillator (DPO) dpo = close - ta.sma(close, length_20) // 13. Price Oscillator (PPO) ppo = ta.sma(close, 12) - ta.sma(close, 26) ppo_pct = (ppo / ta.sma(close, 26)) * 100 // 14. TRIX trix_ema1 = ta.ema(close, length_14) trix_ema2 = ta.ema(trix_ema1, length_14) trix_ema3 = ta.ema(trix_ema2, length_14) trix = ta.roc(trix_ema3, 1) * 10000 // 15. Klinger Oscillator klinger = ta.ema(volume * (high + low + close) / 3, 34) - ta.ema(volume * (high + low + close) / 3, 55) // 16. Fisher Transform fisher_hl2 = 0.5 * (hl2 - ta.lowest(hl2, 10)) / (ta.highest(hl2, 10) - ta.lowest(hl2, 10)) - 0.25 fisher = 0.5 * math.log((1 + fisher_hl2) / (1 - fisher_hl2)) // 17. Stochastic RSI stoch_rsi = ta.stoch(rsi_14, rsi_14, rsi_14, length_14) stoch_rsi_centered = stoch_rsi - 50 // 18. Relative Vigor Index (RVI) rvi_num = ta.swma(close - open) rvi_den = ta.swma(high - low) rvi = rvi_den != 0 ? rvi_num / rvi_den : 0 // 19. Balance of Power (BOP) bop = (close - open) / (high - low) // |----- TREND INDICATORS (10 indicators) -----| // // 20. Simple Moving Average Momentum sma_20 = ta.sma(close, length_20) sma_momentum = ((close - sma_20) / sma_20) * 100 // 21. Exponential Moving Average Momentum ema_20 = ta.ema(close, length_20) ema_momentum = ((close - ema_20) / ema_20) * 100 // 22. Parabolic SAR sar = ta.sar(0.02, 0.02, 0.2) sar_trend = close > sar ? 1 : -1 // 23. Linear Regression Slope lr_slope = ta.linreg(close, length_20, 0) - ta.linreg(close, length_20, 1) // 24. Moving Average Convergence (MAC) mac = ta.sma(close, 10) - ta.sma(close, 30) // 25. Trend Intensity Index (TII) tii_sum = 0.0 for i = 1 to length_20 tii_sum += close > close ? 1 : 0 tii = (tii_sum / length_20) * 100 // 26. Ichimoku Cloud Components ichimoku_tenkan = (ta.highest(high, 9) + ta.lowest(low, 9)) / 2 ichimoku_kijun = (ta.highest(high, 26) + ta.lowest(low, 26)) / 2 ichimoku_signal = ichimoku_tenkan > ichimoku_kijun ? 1 : -1 // 27. MESA Adaptive Moving Average (MAMA) mama_alpha = 2.0 / (length_20 + 1) mama = ta.ema(close, length_20) mama_momentum = ((close - mama) / mama) * 100 // 28. Zero Lag Exponential Moving Average (ZLEMA) zlema_lag = math.round((length_20 - 1) / 2) zlema_data = close + (close - close ) zlema = ta.ema(zlema_data, length_20) zlema_momentum = ((close - zlema) / zlema) * 100 // |----- VOLUME INDICATORS (6 indicators) -----| // // 29. On-Balance Volume (OBV) obv = ta.obv // 30. Volume Rate of Change (VROC) vroc = ta.roc(volume, length_14) // 31. Price Volume Trend (PVT) pvt = ta.pvt // 32. Negative Volume Index (NVI) nvi = 0.0 nvi := volume < volume ? nvi + ((close - close ) / close ) * nvi : nvi // 33. Positive Volume Index (PVI) pvi = 0.0 pvi := volume > volume ? pvi + ((close - close ) / close ) * pvi : pvi // 34. Volume Oscillator vol_osc = ta.sma(volume, 5) - ta.sma(volume, 10) // 35. Ease of Movement (EOM) eom_distance = high - low eom_box_height = volume / 1000000 eom = eom_box_height != 0 ? eom_distance / eom_box_height : 0 eom_sma = ta.sma(eom, length_14) // 36. Force Index force_index = volume * (close - close ) force_index_sma = ta.sma(force_index, length_14) // |----- VOLATILITY INDICATORS (10 indicators) -----| // // 37. Average True Range (ATR) atr = ta.atr(length_14) atr_pct = (atr / close) * 100 // 38. Bollinger Bands Position bb_basis = ta.sma(close, length_20) bb_dev = 2.0 * ta.stdev(close, length_20) bb_upper = bb_basis + bb_dev bb_lower = bb_basis - bb_dev bb_position = bb_dev != 0 ? (close - bb_basis) / bb_dev : 0 bb_width = bb_dev != 0 ? (bb_upper - bb_lower) / bb_basis * 100 : 0 // 39. Keltner Channels Position kc_basis = ta.ema(close, length_20) kc_range = ta.ema(ta.tr, length_20) kc_upper = kc_basis + (2.0 * kc_range) kc_lower = kc_basis - (2.0 * kc_range) kc_position = kc_range != 0 ? (close - kc_basis) / kc_range : 0 // 40. Donchian Channels Position dc_upper = ta.highest(high, length_20) dc_lower = ta.lowest(low, length_20) dc_basis = (dc_upper + dc_lower) / 2 dc_position = (dc_upper - dc_lower) != 0 ? (close - dc_basis) / (dc_upper - dc_lower) : 0 // 41. Standard Deviation std_dev = ta.stdev(close, length_20) std_dev_pct = (std_dev / close) * 100 // 42. Relative Volatility Index (RVI) rvi_up = ta.stdev(close > close ? close : 0, length_14) rvi_down = ta.stdev(close < close ? close : 0, length_14) rvi_total = rvi_up + rvi_down rvi_volatility = rvi_total != 0 ? (rvi_up / rvi_total) * 100 : 50 // 43. Historical Volatility hv_returns = math.log(close / close ) hv = ta.stdev(hv_returns, length_20) * math.sqrt(252) * 100 // 44. Garman-Klass Volatility gk_vol = math.log(high/low) * math.log(high/low) - (2*math.log(2)-1) * math.log(close/open) * math.log(close/open) gk_volatility = math.sqrt(ta.sma(gk_vol, length_20)) * 100 // 45. Parkinson Volatility park_vol = math.log(high/low) * math.log(high/low) parkinson = math.sqrt(ta.sma(park_vol, length_20) / (4 * math.log(2))) * 100 // 46. Rogers-Satchell Volatility rs_vol = math.log(high/close) * math.log(high/open) + math.log(low/close) * math.log(low/open) rogers_satchell = math.sqrt(ta.sma(rs_vol, length_20)) * 100 // |----- OSCILLATOR INDICATORS (5 indicators) -----| // // 47. Elder Ray Index elder_bull = high - ta.ema(close, 13) elder_bear = low - ta.ema(close, 13) elder_power = elder_bull + elder_bear // 48. Schaff Trend Cycle (STC) stc_macd = ta.ema(close, 23) - ta.ema(close, 50) stc_k = ta.stoch(stc_macd, stc_macd, stc_macd, 10) stc_d = ta.ema(stc_k, 3) stc = ta.stoch(stc_d, stc_d, stc_d, 10) // 49. Coppock Curve coppock_roc1 = ta.roc(close, 14) coppock_roc2 = ta.roc(close, 11) coppock = ta.wma(coppock_roc1 + coppock_roc2, 10) // 50. Know Sure Thing (KST) kst_roc1 = ta.roc(close, 10) kst_roc2 = ta.roc(close, 15) kst_roc3 = ta.roc(close, 20) kst_roc4 = ta.roc(close, 30) kst = ta.sma(kst_roc1, 10) + 2*ta.sma(kst_roc2, 10) + 3*ta.sma(kst_roc3, 10) + 4*ta.sma(kst_roc4, 15) // 51. Percentage Price Oscillator (PPO) ppo_line = ((ta.ema(close, 12) - ta.ema(close, 26)) / ta.ema(close, 26)) * 100 ppo_signal = ta.ema(ppo_line, 9) ppo_histogram = ppo_line - ppo_signal // |----- PLOT MAIN INDICATORS -----| // // Plot key momentum indicators plot(rsi_centered, title="01_RSI_Centered", color=color.purple, linewidth=1) plot(stoch_centered, title="02_Stoch_Centered", color=color.blue, linewidth=1) plot(williams_r, title="03_Williams_R", color=color.red, linewidth=1) plot(macd_histogram, title="04_MACD_Histogram", color=color.orange, linewidth=1) plot(cci, title="05_CCI", color=color.green, linewidth=1) // Plot trend indicators plot(sma_momentum, title="06_SMA_Momentum", color=color.navy, linewidth=1) plot(ema_momentum, title="07_EMA_Momentum", color=color.maroon, linewidth=1) plot(sar_trend, title="08_SAR_Trend", color=color.teal, linewidth=1) plot(lr_slope, title="09_LR_Slope", color=color.lime, linewidth=1) plot(mac, title="10_MAC", color=color.fuchsia, linewidth=1) // Plot volatility indicators plot(atr_pct, title="11_ATR_Pct", color=color.yellow, linewidth=1) plot(bb_position, title="12_BB_Position", color=color.aqua, linewidth=1) plot(kc_position, title="13_KC_Position", color=color.olive, linewidth=1) plot(std_dev_pct, title="14_StdDev_Pct", color=color.silver, linewidth=1) plot(bb_width, title="15_BB_Width", color=color.gray, linewidth=1) // Plot volume indicators plot(vroc, title="16_VROC", color=color.blue, linewidth=1) plot(eom_sma, title="17_EOM", color=color.red, linewidth=1) plot(vol_osc, title="18_Vol_Osc", color=color.green, linewidth=1) plot(force_index_sma, title="19_Force_Index", color=color.orange, linewidth=1) plot(obv, title="20_OBV", color=color.purple, linewidth=1) // Plot additional oscillators plot(ao, title="21_Awesome_Osc", color=color.navy, linewidth=1) plot(cmo, title="22_CMO", color=color.maroon, linewidth=1) plot(dpo, title="23_DPO", color=color.teal, linewidth=1) plot(trix, title="24_TRIX", color=color.lime, linewidth=1) plot(fisher, title="25_Fisher", color=color.fuchsia, linewidth=1) // Plot more momentum indicators plot(mfi_centered, title="26_MFI_Centered", color=color.yellow, linewidth=1) plot(ac, title="27_AC", color=color.aqua, linewidth=1) plot(ppo_pct, title="28_PPO_Pct", color=color.olive, linewidth=1) plot(stoch_rsi_centered, title="29_StochRSI_Centered", color=color.silver, linewidth=1) plot(klinger, title="30_Klinger", color=color.gray, linewidth=1) // Plot trend continuation plot(tii, title="31_TII", color=color.blue, linewidth=1) plot(ichimoku_signal, title="32_Ichimoku_Signal", color=color.red, linewidth=1) plot(mama_momentum, title="33_MAMA_Momentum", color=color.green, linewidth=1) plot(zlema_momentum, title="34_ZLEMA_Momentum", color=color.orange, linewidth=1) plot(bop, title="35_BOP", color=color.purple, linewidth=1) // Plot volume continuation plot(nvi, title="36_NVI", color=color.navy, linewidth=1) plot(pvi, title="37_PVI", color=color.maroon, linewidth=1) plot(momentum_pct, title="38_Momentum_Pct", color=color.teal, linewidth=1) plot(roc, title="39_ROC", color=color.lime, linewidth=1) plot(rvi, title="40_RVI", color=color.fuchsia, linewidth=1) // Plot volatility continuation plot(dc_position, title="41_DC_Position", color=color.yellow, linewidth=1) plot(rvi_volatility, title="42_RVI_Volatility", color=color.aqua, linewidth=1) plot(hv, title="43_Historical_Vol", color=color.olive, linewidth=1) plot(gk_volatility, title="44_GK_Volatility", color=color.silver, linewidth=1) plot(parkinson, title="45_Parkinson_Vol", color=color.gray, linewidth=1) // Plot final oscillators plot(rogers_satchell, title="46_RS_Volatility", color=color.blue, linewidth=1) plot(elder_power, title="47_Elder_Power", color=color.red, linewidth=1) plot(stc, title="48_STC", color=color.green, linewidth=1) plot(coppock, title="49_Coppock", color=color.orange, linewidth=1) plot(kst, title="50_KST", color=color.purple, linewidth=1) // Plot final indicators plot(ppo_histogram, title="51_PPO_Histogram", color=color.navy, linewidth=1) plot(pvt, title="52_PVT", color=color.maroon, linewidth=1) // |----- Reference Lines -----| // hline(0, "Zero Line", color=color.gray, linestyle=hline.style_dashed, linewidth=1) hline(50, "Midline", color=color.gray, linestyle=hline.style_dotted, linewidth=1) hline(-50, "Lower Midline", color=color.gray, linestyle=hline.style_dotted, linewidth=1) hline(25, "Upper Threshold", color=color.gray, linestyle=hline.style_dotted, linewidth=1) hline(-25, "Lower Threshold", color=color.gray, linestyle=hline.style_dotted, linewidth=1) // |----- Enhanced Information Table -----| // if show_table and barstate.islast table_position = position.top_right table_text_size = table_size == "Tiny" ? size.tiny : table_size == "Small" ? size.small : size.normal var table info_table = table.new(table_position, 3, 18, bgcolor=color.new(color.white, 85), border_width=1, border_color=color.gray) // Headers table.cell(info_table, 0, 0, 'Category', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.blue, 70)) table.cell(info_table, 1, 0, 'Indicator', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.blue, 70)) table.cell(info_table, 2, 0, 'Value', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.blue, 70)) // Key Momentum Indicators table.cell(info_table, 0, 1, 'MOMENTUM', text_color=color.purple, text_size=table_text_size, bgcolor=color.new(color.purple, 90)) table.cell(info_table, 1, 1, 'RSI Centered', text_color=color.purple, text_size=table_text_size) table.cell(info_table, 2, 1, str.tostring(rsi_centered, '0.00'), text_color=color.purple, text_size=table_text_size) table.cell(info_table, 0, 2, '', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 1, 2, 'Stoch Centered', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 2, 2, str.tostring(stoch_centered, '0.00'), text_color=color.blue, text_size=table_text_size) table.cell(info_table, 0, 3, '', text_color=color.red, text_size=table_text_size) table.cell(info_table, 1, 3, 'Williams %R', text_color=color.red, text_size=table_text_size) table.cell(info_table, 2, 3, str.tostring(williams_r, '0.00'), text_color=color.red, text_size=table_text_size) table.cell(info_table, 0, 4, '', text_color=color.orange, text_size=table_text_size) table.cell(info_table, 1, 4, 'MACD Histogram', text_color=color.orange, text_size=table_text_size) table.cell(info_table, 2, 4, str.tostring(macd_histogram, '0.000'), text_color=color.orange, text_size=table_text_size) table.cell(info_table, 0, 5, '', text_color=color.green, text_size=table_text_size) table.cell(info_table, 1, 5, 'CCI', text_color=color.green, text_size=table_text_size) table.cell(info_table, 2, 5, str.tostring(cci, '0.00'), text_color=color.green, text_size=table_text_size) // Key Trend Indicators table.cell(info_table, 0, 6, 'TREND', text_color=color.navy, text_size=table_text_size, bgcolor=color.new(color.navy, 90)) table.cell(info_table, 1, 6, 'SMA Momentum %', text_color=color.navy, text_size=table_text_size) table.cell(info_table, 2, 6, str.tostring(sma_momentum, '0.00'), text_color=color.navy, text_size=table_text_size) table.cell(info_table, 0, 7, '', text_color=color.maroon, text_size=table_text_size) table.cell(info_table, 1, 7, 'EMA Momentum %', text_color=color.maroon, text_size=table_text_size) table.cell(info_table, 2, 7, str.tostring(ema_momentum, '0.00'), text_color=color.maroon, text_size=table_text_size) table.cell(info_table, 0, 8, '', text_color=color.teal, text_size=table_text_size) table.cell(info_table, 1, 8, 'SAR Trend', text_color=color.teal, text_size=table_text_size) table.cell(info_table, 2, 8, str.tostring(sar_trend, '0'), text_color=color.teal, text_size=table_text_size) table.cell(info_table, 0, 9, '', text_color=color.lime, text_size=table_text_size) table.cell(info_table, 1, 9, 'Linear Regression', text_color=color.lime, text_size=table_text_size) table.cell(info_table, 2, 9, str.tostring(lr_slope, '0.000'), text_color=color.lime, text_size=table_text_size) // Key Volatility Indicators table.cell(info_table, 0, 10, 'VOLATILITY', text_color=color.yellow, text_size=table_text_size, bgcolor=color.new(color.yellow, 90)) table.cell(info_table, 1, 10, 'ATR %', text_color=color.yellow, text_size=table_text_size) table.cell(info_table, 2, 10, str.tostring(atr_pct, '0.00'), text_color=color.yellow, text_size=table_text_size) table.cell(info_table, 0, 11, '', text_color=color.aqua, text_size=table_text_size) table.cell(info_table, 1, 11, 'BB Position', text_color=color.aqua, text_size=table_text_size) table.cell(info_table, 2, 11, str.tostring(bb_position, '0.00'), text_color=color.aqua, text_size=table_text_size) table.cell(info_table, 0, 12, '', text_color=color.olive, text_size=table_text_size) table.cell(info_table, 1, 12, 'KC Position', text_color=color.olive, text_size=table_text_size) table.cell(info_table, 2, 12, str.tostring(kc_position, '0.00'), text_color=color.olive, text_size=table_text_size) // Key Volume Indicators table.cell(info_table, 0, 13, 'VOLUME', text_color=color.blue, text_size=table_text_size, bgcolor=color.new(color.blue, 90)) table.cell(info_table, 1, 13, 'Volume ROC', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 2, 13, str.tostring(vroc, '0.00'), text_color=color.blue, text_size=table_text_size) table.cell(info_table, 0, 14, '', text_color=color.red, text_size=table_text_size) table.cell(info_table, 1, 14, 'EOM', text_color=color.red, text_size=table_text_size) table.cell(info_table, 2, 14, str.tostring(eom_sma, '0.000'), text_color=color.red, text_size=table_text_size) // Key Oscillators table.cell(info_table, 0, 15, 'OSCILLATORS', text_color=color.purple, text_size=table_text_size, bgcolor=color.new(color.purple, 90)) table.cell(info_table, 1, 15, 'Awesome Osc', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 2, 15, str.tostring(ao, '0.000'), text_color=color.blue, text_size=table_text_size) table.cell(info_table, 0, 16, '', text_color=color.red, text_size=table_text_size) table.cell(info_table, 1, 16, 'Fisher Transform', text_color=color.red, text_size=table_text_size) table.cell(info_table, 2, 16, str.tostring(fisher, '0.000'), text_color=color.red, text_size=table_text_size) // Summary Statistics table.cell(info_table, 0, 17, 'SUMMARY', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.gray, 70)) table.cell(info_table, 1, 17, 'Total Indicators: 52', text_color=color.black, text_size=table_text_size) regime_color = rsi_centered > 10 ? color.green : rsi_centered < -10 ? color.red : color.gray regime_text = rsi_centered > 10 ? "BULLISH" : rsi_centered < -10 ? "BEARISH" : "NEUTRAL" table.cell(info_table, 2, 17, regime_text, text_color=regime_color, text_size=table_text_size) This makes it the perfect “indicator backbone” for quantitative and systematic traders who want to prototype, combine, and test new regime detection models—especially in combination with the Markov Chain indicator. How to use this script with the Markov Chain for research and backtesting: Add the Enhanced Indicator Export to your chart. Every calculated indicator is available as an individual data stream. Connect the indicator(s) you want as custom input(s) to the Markov Chain’s “Custom Indicators” option. In the Markov Chain indicator’s settings, turn ON the custom indicator mode. For each of the three custom indicator inputs, select the exported plot from the Enhanced Export script—the menu lists all 45+ signals by name. This creates a powerful, modular regime-detection engine where you can mix-and-match momentum, trend, volume, or custom combinations for advanced filtering. Backtest regime logic directly. Once you’ve connected your chosen indicators, the Markov Chain script performs regime detection (Bull/Neutral/Bear) based on your selected features—not just price returns. The regime detection is robust, automatically normalized (using Z-score), and outputs bias (1, -1, 0) for plug-and-play integration. Export the regime bias for programmatic use. As described above, use input.source() in your Pine Script strategy or system and link the bias output. You can now filter signals, control trade direction/size, or design pairs-trading that respect true, indicator-driven market regimes. With this framework, you’re not limited to static or simplistic regime filters. You can rigorously define, test, and refine what “market regime” means for your strategies—using the technical features that matter most to you. Optimize your signal generation by backtesting across a universe of meaningful indicator blends. Enhance risk management with objective, real-time regime boundaries. Accelerate your research: iterate quickly, swap indicator components, and see results with minimal code changes. Automate multi-asset or pairs-trading by integrating regime context directly into strategy logic. Add both scripts to your chart, connect your preferred features, and start investigating your best regime-based trades—entirely within the TradingView ecosystem. References & Further Reading Ang, A., & Bekaert, G. (2002). “Regime Switches in Interest Rates.” Journal of Business & Economic Statistics, 20(2), 163–182. Hamilton, J. D. (1989). “A New Approach to the Economic Analysis of Nonstationary Time Series and the Business Cycle.” Econometrica, 57(2), 357–384. Markov, A. A. (1906). "Extension of the Limit Theorems of Probability Theory to a Sum of Variables Connected in a Chain." The Notes of the Imperial Academy of Sciences of St. Petersburg. Guidolin, M., & Timmermann, A. (2007). “Asset Allocation under Multivariate Regime Switching.” Journal of Economic Dynamics and Control, 31(11), 3503–3544. Murphy, J. J. (1999). Technical Analysis of the Financial Markets. New York Institute of Finance. Brock, W., Lakonishok, J., & LeBaron, B. (1992). “Simple Technical Trading Rules and the Stochastic Properties of Stock Returns.” Journal of Finance, 47(5), 1731–1764. Zucchini, W., MacDonald, I. L., & Langrock, R. (2017). Hidden Markov Models for Time Series: An Introduction Using R (2nd ed.). Chapman and Hall/CRC. On Quantitative Finance and Markov Models: Lo, A. W., & Hasanhodzic, J. (2009). The Heretics of Finance: Conversations with Leading Practitioners of Technical Analysis. Bloomberg Press. Patterson, S. (2016). The Man Who Solved the Market: How Jim Simons Launched the Quant Revolution. Penguin Press. TradingView Pine Script Documentation: www.tradingview.com TradingView Blog: “Use an Input From Another Indicator With Your Strategy” www.tradingview.com GeeksforGeeks: “What is the Difference Between Markov Chains and Hidden Markov Models?” www.geeksforgeeks.org What makes this indicator original and unique? - On‑chart, real‑time Markov. The chain is drawn directly on your chart. You see the current regime, its tendency to stay (self‑loop), and the usual next step (arrows) as bars confirm. - Source‑agnostic by design. The engine runs on any series you select via input.source() — price, your own oscillator, a composite score, anything you compute in the script. - Automatic normalization + regime mapping. Different inputs live on different scales. The script standardizes your chosen source and maps it into clear regimes (e.g., Bull / Bear / Neutral) without you micromanaging thresholds each time. - Rolling, bar‑by‑bar learning. Transition tendencies are computed from a rolling window of confirmed bars. What you see is exactly what the market did in that window. - Fast experimentation. Switch the source, adjust the window, and the Markov view updates instantly. It’s a rapid way to test ideas and feel regime persistence/switch behavior. Integrate your own signals (using input.source()) - In settings, choose the Source . This is powered by input.source() . - Feed it price, an indicator you compute inside the script, or a custom composite series. - The script will automatically normalize that series and process it through the Markov engine, mapping it to regimes and updating the on‑chart spheres/arrows in real time. Credits: Deep gratitude to @RicardoSantos for both the foundational Markov chain processing engine and inspiring open-source contributions, which made advanced probabilistic market modeling accessible to the TradingView community. Special thanks to @Alien_Algorithms for the innovative and visually stunning 3D sphere logic that powers the indicator’s animated, regime-based visualization. Disclaimer This tool summarizes recent behavior. It is not financial advice and not a guarantee of future results.
Pine Script® Indikator
von Fractalyst
5
MACD 3D with Signals [Quantigenics]Quantigenics MACD 3D with Buy Sell Signals is a MACD-based trading indicator that aims to identify market trends and potential turning points, for Buy/Sell opportunities, by leveraging price data and volatility. Unlike the traditional MACD indicator, the average price is calculated from the high, low, and close prices, from which a specialized MACD value is derived. This MACD value, combined with an average and standard deviation, takes into account volatility, and is used to generate an upper and lower boundary. The indicator color-codes market trends: aqua indicates upward trends (signifying increased buying pressure), red suggests downward trends (increased selling pressure). When the MACD value crosses above the upper boundary or falls below the lower boundary, the color changes to yellow indicating a possible reversal point and "Momentum Crossover Signals" can be plotted at this point. "Standard Signal" arrows can also plotted when the MACD 3D changes from auqa to red and vice-versa. A trendline is drawn at the median value, providing a baseline for comparison. A differential value, which measures the distance between the MACD value and the median line, provides additional insight into the price's deviation from this baseline (divergences from the underlying price can be spotted using this data as well). The differential is color-coded: green when MACD is above the median, and red when it's below, with darker shades representing a decreasing gap. Alerts can be set to trigger with the "Standard Signal" arrows appearing after MACD 3D changes from auqa to red and vice-versa and when the "Momentum Crossover Signal" arrows appear when the MACD value crosses above the upper boundary or falls below the lower boundary indicating a potential reversal. Providing immediate notifications which can be especially helpful in larger time frames where it may take time for a trade setup to develop. CME_MINI:NQ1! OANDA:XAUUSD Enjoy the MACD 3D indicator. Happy Trading!
Pine Script® Indikator
von Quantigenics
Vector3Library "Vector3" Representation of 3D vectors and points. This structure is used to pass 3D positions and directions around. It also contains functions for doing common vector operations. Besides the functions listed below, other classes can be used to manipulate vectors and points as well. For example the Quaternion and the Matrix4x4 classes are useful for rotating or transforming vectors and points. ___ **Reference:** - github.com - github.com - github.com - www.movable-type.co.uk - docs.unity3d.com - referencesource.microsoft.com - github.com \ new(x, y, z)   Create a new `Vector3`.   Parameters:      x (float) : `float` Property `x` value, (optional, default=na).      y (float) : `float` Property `y` value, (optional, default=na).      z (float) : `float` Property `z` value, (optional, default=na).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .new(1.1, 1, 1) ``` from(value)   Create a new `Vector3` from a single value.   Parameters:      value (float) : `float` Properties positional value, (optional, default=na).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .from(1.1) ``` from_Array(values, fill_na)   Create a new `Vector3` from a list of values, only reads up to the third item.   Parameters:      values (float ) : `array` Vector property values.      fill_na (float) : `float` Parameter value to replace missing indexes, (optional, defualt=na).   Returns: `Vector3` Generated new vector. ___ **Notes:** - Supports any size of array, fills non available fields with `na`. ___ **Usage:** ``` .from_Array(array.from(1.1, fill_na=33)) .from_Array(array.from(1.1, 2, 3)) ``` from_Vector2(values)   Create a new `Vector3` from a `Vector2`.   Parameters:      values (Vector2 type from RicardoSantos/CommonTypesMath/1) : `Vector2` Vector property values.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .from:Vector2(.Vector2.new(1, 2.0)) ``` ___ **Notes:** - Type `Vector2` from CommonTypesMath library. from_Quaternion(values)   Create a new `Vector3` from a `Quaternion`'s `x, y, z` properties.   Parameters:      values (Quaternion type from RicardoSantos/CommonTypesMath/1) : `Quaternion` Vector property values.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .from_Quaternion(.Quaternion.new(1, 2, 3, 4)) ``` ___ **Notes:** - Type `Quaternion` from CommonTypesMath library. from_String(expression, separator, fill_na)   Create a new `Vector3` from a list of values in a formated string.   Parameters:      expression (string) : `array` String with the list of vector properties.      separator (string) : `string` Separator between entries, (optional, default=`","`).      fill_na (float) : `float` Parameter value to replace missing indexes, (optional, defualt=na).   Returns: `Vector3` Generated new vector. ___ **Notes:** - Supports any size of array, fills non available fields with `na`. - `",,"` Empty fields will be ignored. ___ **Usage:** ``` .from_String("1.1", fill_na=33)) .from_String("(1.1,, 3)") // 1.1 , 3.0, NaN // empty field will be ignored!! ``` back()   Create a new `Vector3` object in the form `(0, 0, -1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .back() ``` front()   Create a new `Vector3` object in the form `(0, 0, 1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .front() ``` up()   Create a new `Vector3` object in the form `(0, 1, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .up() ``` down()   Create a new `Vector3` object in the form `(0, -1, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .down() ``` left()   Create a new `Vector3` object in the form `(-1, 0, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .left() ``` right()   Create a new `Vector3` object in the form `(1, 0, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .right() ``` zero()   Create a new `Vector3` object in the form `(0, 0, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .zero() ``` one()   Create a new `Vector3` object in the form `(1, 1, 1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .one() ``` minus_one()   Create a new `Vector3` object in the form `(-1, -1, -1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .minus_one() ``` unit_x()   Create a new `Vector3` object in the form `(1, 0, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .unit_x() ``` unit_y()   Create a new `Vector3` object in the form `(0, 1, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .unit_y() ``` unit_z()   Create a new `Vector3` object in the form `(0, 0, 1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .unit_z() ``` nan()   Create a new `Vector3` object in the form `(na, na, na)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .nan() ``` random(max, min)   Generate a vector with random properties.   Parameters:      max (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Maximum defined range of the vector properties.      min (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Minimum defined range of the vector properties.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .random(.from(math.pi), .from(-math.pi)) ``` random(max)   Generate a vector with random properties (min set to 0.0).   Parameters:      max (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Maximum defined range of the vector properties.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .random(.from(math.pi)) ``` method copy(this)   Copy a existing `Vector3`   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .one().copy() ``` method i_add(this, other)   Modify a instance of a vector by adding a vector to it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_add(.up()) ``` method i_add(this, value)   Modify a instance of a vector by adding a vector to it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_add(3.2) ``` method i_subtract(this, other)   Modify a instance of a vector by subtracting a vector to it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_subtract(.down()) ``` method i_subtract(this, value)   Modify a instance of a vector by subtracting a vector to it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_subtract(3) ``` method i_multiply(this, other)   Modify a instance of a vector by multiplying a vector with it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_multiply(.left()) ``` method i_multiply(this, value)   Modify a instance of a vector by multiplying a vector with it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_multiply(3) ``` method i_divide(this, other)   Modify a instance of a vector by dividing it by another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_divide(.forward()) ``` method i_divide(this, value)   Modify a instance of a vector by dividing it by another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_divide(3) ``` method i_mod(this, other)   Modify a instance of a vector by modulo assignment with another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_mod(.back()) ``` method i_mod(this, value)   Modify a instance of a vector by modulo assignment with another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_mod(3) ``` method i_pow(this, exponent)   Modify a instance of a vector by modulo assignment with another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      exponent (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Exponent Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_pow(.up()) ``` method i_pow(this, exponent)   Modify a instance of a vector by modulo assignment with another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      exponent (float) : `float` Exponent Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_pow(2) ``` method length_squared(this)   Squared length of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1)   Returns: `float` The squared length of this vector. ___ **Usage:** ``` a = .one().length_squared() ``` method magnitude_squared(this)   Squared magnitude of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` The length squared of this vector. ___ **Usage:** ``` a = .one().magnitude_squared() ``` method length(this)   Length of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` The length of this vector. ___ **Usage:** ``` a = .one().length() ``` method magnitude(this)   Magnitude of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` The Length of this vector. ___ **Usage:** ``` a = .one().magnitude() ``` method normalize(this, magnitude, eps)   Normalize a vector with a magnitude of 1(optional).   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      magnitude (float) : `float` Value to manipulate the magnitude of normalization, (optional, default=1.0).      eps (float)   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(33, 50, 100).normalize() // (x=0.283, y=0.429, z=0.858) a = .new(33, 50, 100).normalize(2) // (x=0.142, y=0.214, z=0.429) ``` method to_String(this, precision)   Converts source vector to a string format, in the form `"(x, y, z)"`.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      precision (string) : `string` Precision format to apply to values (optional, default='').   Returns: `string` Formated string in a `"(x, y, z)"` format. ___ **Usage:** ``` a = .one().to_String("#.###") ``` method to_Array(this)   Converts source vector to a array format.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `array` List of the vector properties. ___ **Usage:** ``` a = .new(1, 2, 3).to_Array() ``` method to_Vector2(this)   Converts source vector to a Vector2 in the form `x, y`.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector2` Generated new vector. ___ **Usage:** ``` a = .from(1).to_Vector2() ``` method to_Quaternion(this, w)   Converts source vector to a Quaternion in the form `x, y, z, w`.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Sorce vector.      w (float) : `float` Property of `w` new value.   Returns: `Quaternion` Generated new vector. ___ **Usage:** ``` a = .from(1).to_Quaternion(w=1) ``` method add(this, other)   Add a vector to source vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).add(.unit_z()) ``` method add(this, value)   Add a value to each property of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).add(2.0) ``` add(value, other)   Add each property of a vector to a base value as a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(2) , b = .add(1.0, a) ``` method subtract(this, other)   Subtract vector from source vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).subtract(.left()) ``` method subtract(this, value)   Subtract a value from each property in source vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).subtract(2.0) ``` subtract(value, other)   Subtract each property in a vector from a base value and create a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .subtract(1.0, .right()) ``` method multiply(this, other)   Multiply a vector by another.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).multiply(.up()) ``` method multiply(this, value)   Multiply each element in source vector with a value.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).multiply(2.0) ``` multiply(value, other)   Multiply a value with each property in a vector and create a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .multiply(1.0, .new(1, 2, 1)) ``` method divide(this, other)   Divide a vector by another.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).divide(.from(2)) ``` method divide(this, value)   Divide each property in a vector by a value.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).divide(2.0) ``` divide(value, other)   Divide a base value by each property in a vector and create a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .divide(1.0, .from(2)) ``` method mod(this, other)   Modulo a vector by another.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).mod(.from(2)) ``` method mod(this, value)   Modulo each property in a vector by a value.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).mod(2.0) ``` mod(value, other)   Modulo a base value by each property in a vector and create a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .mod(1.0, .from(2)) ``` method negate(this)   Negate a vector in the form `(zero - this)`.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .one().negate() ``` method pow(this, other)   Modulo a vector by another.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(2).pow(.from(3)) ``` method pow(this, exponent)   Raise the vector elements by a exponent.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      exponent (float) : `float` The exponent to raise the vector by.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).pow(2.0) ``` pow(value, exponent)   Raise value into a vector raised by the elements in exponent vector.   Parameters:      value (float) : `float` Base value.      exponent (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` The exponent to raise the vector of base value by.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .pow(1.0, .from(2)) ``` method sqrt(this)   Square root of the elements in a vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).sqrt() ``` method abs(this)   Absolute properties of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).abs() ``` method max(this)   Highest property of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` Highest value amongst the vector properties. ___ **Usage:** ``` a = .new(1, 2, 3).max() ``` method min(this)   Lowest element of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` Lowest values amongst the vector properties. ___ **Usage:** ``` a = .new(1, 2, 3).min() ``` method floor(this)   Floor of vector a.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(1.33, 1.66, 1.99).floor() ``` method ceil(this)   Ceil of vector a.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(1.33, 1.66, 1.99).ceil() ``` method round(this)   Round of vector elements.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(1.33, 1.66, 1.99).round() ``` method round(this, precision)   Round of vector elements to n digits.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      precision (int) : `int` Number of digits to round the vector elements.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(1.33, 1.66, 1.99).round(1) // 1.3, 1.7, 2 ``` method fractional(this)   Fractional parts of vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1.337).fractional() // 0.337 ``` method dot_product(this, other)   Dot product of two vectors.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `float` Dot product. ___ **Usage:** ``` a = .from(2).dot_product(.left()) ``` method cross_product(this, other)   Cross product of two vectors.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).cross_produc(.right()) ``` method scale(this, scalar)   Scale vector by a scalar value.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      scalar (float) : `float` Value to scale the the vector by.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).scale(2) ``` method rescale(this, magnitude)   Rescale a vector to a new magnitude.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      magnitude (float) : `float` Value to manipulate the magnitude of normalization.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(20).rescale(1) ``` method equals(this, other)   Compares two vectors.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).equals(.one()) ``` method sin(this)   Sine of vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).sin() ``` method cos(this)   Cosine of vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).cos() ``` method tan(this)   Tangent of vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).tan() ``` vmax(a, b)   Highest elements of the properties from two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .vmax(.one(), .from(2)) ``` vmax(a, b, c)   Highest elements of the properties from three vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      c (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .vmax(.new(0.1, 2.5, 3.4), .from(2), .from(3)) ``` vmin(a, b)   Lowest elements of the properties from two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .vmin(.one(), .from(2)) ``` vmin(a, b, c)   Lowest elements of the properties from three vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      c (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .vmin(.one(), .from(2), .new(3.3, 2.2, 0.5)) ``` distance(a, b)   Distance between vector `a` and `b`.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = distance(.from(3), .unit_z()) ``` clamp(a, min, max)   Restrict a vector between a min and max vector.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      min (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Minimum boundary vector.      max (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Maximum boundary vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .clamp(a=.new(2.9, 1.5, 3.9), min=.from(2), max=.new(2.5, 3.0, 3.5)) ``` clamp_magnitude(a, radius)   Vector with its magnitude clamped to a radius.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.object, vector with properties that should be restricted to a radius.      radius (float) : `float` Maximum radius to restrict magnitude of vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .clamp_magnitude(.from(21), 7) ``` lerp_unclamped(a, b, rate)   `Unclamped` linearly interpolates between provided vectors by a rate.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      rate (float) : `float` Rate of interpolation, range(0 > 1) where 0 == source vector and 1 == target vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .lerp_unclamped(.from(1), .from(2), 1.2) ``` lerp(a, b, rate)   Linearly interpolates between provided vectors by a rate.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      rate (float) : `float` Rate of interpolation, range(0 > 1) where 0 == source vector and 1 == target vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = lerp(.one(), .from(2), 0.2) ``` herp(start, start_tangent, end, end_tangent, rate)   Hermite curve interpolation between provided vectors.   Parameters:      start (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Start vector.      start_tangent (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Start vector tangent.      end (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` End vector.      end_tangent (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` End vector tangent.      rate (int) : `float` Rate of the movement from `start` to `end` to get position, should be range(0 > 1).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` s = .new(0, 0, 0) , st = .new(0, 1, 1) e = .new(1, 2, 2) , et = .new(-1, -1, 3) h = .herp(s, st, e, et, 0.3) ``` ___ **Reference:** en.m.wikibooks.org herp_2(a, b, rate)   Hermite curve interpolation between provided vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      rate (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Rate of the movement per component from `start` to `end` to get position, should be range(0 > 1).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` h = .herp_2(.one(), .new(0.1, 3, 2), 0.6) ``` noise(a)   3D Noise based on Morgan McGuire @morgan3d   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = noise(.one()) ``` ___ **Reference:** - thebookofshaders.com - www.shadertoy.com rotate(a, axis, angle)   Rotate a vector around a axis.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      axis (string) : `string` The plane to rotate around, `option="x", "y", "z"`.      angle (float) : `float` Angle in radians.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .rotate(.from(3), 'y', math.toradians(45.0)) ``` rotate_x(a, angle)   Rotate a vector on a fixed `x`.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      angle (float) : `float` Angle in radians.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .rotate_x(.from(3), math.toradians(90.0)) ``` rotate_y(a, angle)   Rotate a vector on a fixed `y`.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      angle (float) : `float` Angle in radians.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .rotate_y(.from(3), math.toradians(90.0)) ``` rotate_yaw_pitch(a, yaw, pitch)   Rotate a vector by yaw and pitch values.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      yaw (float) : `float` Angle in radians.      pitch (float) : `float` Angle in radians.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .rotate_yaw_pitch(.from(3), math.toradians(90.0), math.toradians(45.0)) ``` project(a, normal, eps)   Project a vector off a plane defined by a normal.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      normal (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` The normal of the surface being reflected off.      eps (float) : `float` Minimum resolution to void division by zero (default=0.000001).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .project(.one(), .down()) ``` project_on_plane(a, normal, eps)   Projects a vector onto a plane defined by a normal orthogonal to the plane.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      normal (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` The normal of the surface being reflected off.      eps (float) : `float` Minimum resolution to void division by zero (default=0.000001).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .project_on_plane(.one(), .left()) ``` project_to_2d(a, camera_position, camera_target)   Project a vector onto a two dimensions plane.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      camera_position (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Camera position.      camera_target (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Camera target plane position.   Returns: `Vector2` Generated new vector. ___ **Usage:** ``` a = .project_to_2d(.one(), .new(2, 2, 3), .zero()) ``` reflect(a, normal)   Reflects a vector off a plane defined by a normal.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      normal (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` The normal of the surface being reflected off.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .reflect(.one(), .right()) ``` angle(a, b, eps)   Angle in degrees between two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      eps (float) : `float` Minimum resolution to void division by zero (default=1.0e-15).   Returns: `float` Angle value in degrees. ___ **Usage:** ``` a = .angle(.one(), .up()) ``` angle_signed(a, b, axis)   Signed angle in degrees between two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      axis (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Axis vector.   Returns: `float` Angle value in degrees. ___ **Usage:** ``` a = .angle_signed(.one(), .left(), .down()) ``` ___ **Notes:** - The smaller of the two possible angles between the two vectors is returned, therefore the result will never be greater than 180 degrees or smaller than -180 degrees. - If you imagine the from and to vectors as lines on a piece of paper, both originating from the same point, then the /axis/ vector would point up out of the paper. - The measured angle between the two vectors would be positive in a clockwise direction and negative in an anti-clockwise direction. ___ **Reference:** - github.com angle2d(a, b)   2D angle between two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.   Returns: `float` Angle value in degrees. ___ **Usage:** ``` a = .angle2d(.one(), .left()) ``` transform_Matrix(a, M)   Transforms a vector by the given matrix.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      M (matrix) : `matrix` A 4x4 matrix. The transformation matrix.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` mat = matrix.new(4, 0) mat.add_row(0, array.from(0.0, 0.0, 0.0, 1.0)) mat.add_row(1, array.from(0.0, 0.0, 1.0, 0.0)) mat.add_row(2, array.from(0.0, 1.0, 0.0, 0.0)) mat.add_row(3, array.from(1.0, 0.0, 0.0, 0.0)) b = .transform_Matrix(.one(), mat) ``` transform_M44(a, M)   Transforms a vector by the given matrix.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      M (M44 type from RicardoSantos/CommonTypesMath/1) : `M44` A 4x4 matrix. The transformation matrix.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .transform_M44(.one(), .M44.new(0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0)) ``` ___ **Notes:** - Type `M44` from `CommonTypesMath` library. transform_normal_Matrix(a, M)   Transforms a vector by the given matrix.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      M (matrix) : `matrix` A 4x4 matrix. The transformation matrix.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` mat = matrix.new(4, 0) mat.add_row(0, array.from(0.0, 0.0, 0.0, 1.0)) mat.add_row(1, array.from(0.0, 0.0, 1.0, 0.0)) mat.add_row(2, array.from(0.0, 1.0, 0.0, 0.0)) mat.add_row(3, array.from(1.0, 0.0, 0.0, 0.0)) b = .transform_normal_Matrix(.one(), mat) ``` transform_normal_M44(a, M)   Transforms a vector by the given matrix.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      M (M44 type from RicardoSantos/CommonTypesMath/1) : `M44` A 4x4 matrix. The transformation matrix.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .transform_normal_M44(.one(), .M44.new(0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0)) ``` ___ **Notes:** - Type `M44` from `CommonTypesMath` library. transform_Array(a, rotation)   Transforms a vector by the given Quaternion rotation value.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector. The source vector to be rotated.      rotation (float ) : `array` A 4 element array. Quaternion. The rotation to apply.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .transform_Array(.one(), array.from(0.2, 0.2, 0.2, 1.0)) ``` ___ **Reference:** - referencesource.microsoft.com transform_Quaternion(a, rotation)   Transforms a vector by the given Quaternion rotation value.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector. The source vector to be rotated.      rotation (Quaternion type from RicardoSantos/CommonTypesMath/1) : `array` A 4 element array. Quaternion. The rotation to apply.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .transform_Quaternion(.one(), .Quaternion.new(0.2, 0.2, 0.2, 1.0)) ``` ___ **Notes:** - Type `Quaternion` from `CommonTypesMath` library. ___ **Reference:** - referencesource.microsoft.com
Pine Script® Bibliothek
von RicardoSantos
7
Multi Time Frame Candles with Volume Info / 3DHello Traders, This is my second Multi Time Frame Candles script but with this new one, you will have some new features such volume info, remaining time to close of higher time frame candle and also developed using new features of Pine such array of lines. also I tried to make it 3D for better visualization ;) also it shows new highs/lows / breakouts. I tried to make many things optional, so you can change almost everything using options. What you can change using options: - Higher time frame - Number of Candles - Candle Colors Up/Down - Wick Color - Volume colors Up/Down - Text color of Remaining Time - Shadow Color - Background color - Start bar of the candles (so you can see many higher times frame candles in same window) - 3D effect, by default it's enables but you can disable 3D view Lets see some examples: Remaining time: Breakouts: You can combine different higher time frames: if you don't want 3D view then combining different higher time frames: You can change background color: Enjoy!
Pine Script® Indikator
von LonesomeTheBlue
102
WaveTrend 3D█  OVERVIEW WaveTrend 3D (WT3D) is a novel implementation of the famous WaveTrend (WT) indicator and has been completely redesigned from the ground up to address some of the inherent shortcomings associated with the traditional WT algorithm. █  BACKGROUND The WaveTrend (WT) indicator has become a widely popular tool for traders in recent years. WT was first ported to PineScript in 2014 by the user @LazyBear, and since then, it has ascended to become one of the Top 5 most popular scripts on TradingView. The WT algorithm appears to have origins in a lesser-known proprietary algorithm called Trading Channel Index (TCI), created by AIQ Systems in 1986 as an integral part of their commercial software suite, TradingExpert Pro. The software’s reference manual states that “TCI identifies changes in price direction” and is “an adaptation of Donald R. Lambert’s Commodity Channel Index (CCI)”, which was introduced to the world six years earlier in 1980. Interestingly, a vestige of this early beginning can still be seen in the source code of LazyBear’s script, where the final EMA calculation is stored in an intermediate variable called “tci” in the code. █  IMPLEMENTATION DETAILS WaveTrend 3D is an alternative implementation of WaveTrend that directly addresses some of the known shortcomings of the indicator, including its unbounded extremes, susceptibility to whipsaw, and lack of insight into other timeframes. In the canonical WT approach, an exponential moving average (EMA) for a given lookback window is used to assess the variability between price and two other EMAs relative to a second lookback window. Since the difference between the average price and its associated EMA is essentially unbounded, an arbitrary scaling factor of 0.015 is typically applied as a crude form of rescaling but still fails to capture 20-30% of values between the range of -100 to 100. Additionally, the trigger signal for the final EMA (i.e., TCI) crossover-based oscillator is a four-bar simple moving average (SMA), which further contributes to the net lag accumulated by the consecutive EMA calculations in the previous steps. The core idea behind WT3D is to replace the EMA-based crossover system with modern Digital Signal Processing techniques. By assuming that price action adheres approximately to a Gaussian distribution, it is possible to sidestep the scaling nightmare associated with unbounded price differentials of the original WaveTrend method by focusing instead on the alteration of the underlying Probability Distribution Function (PDF) of the input series. Furthermore, using a signal processing filter such as a Butterworth Filter, we can eliminate the need for consecutive exponential moving averages along with the associated lag they bring. Ideally, it is convenient to have the resulting probability distribution oscillate between the values of -1 and 1, with the zero line serving as a median. With this objective in mind, it is possible to borrow a common technique from the field of Machine Learning that uses a sigmoid-like activation function to transform our data set of interest. One such function is the hyperbolic tangent function (tanh), which is often used as an activation function in the hidden layers of neural networks due to its unique property of ensuring the values stay between -1 and 1. By taking the first-order derivative of our input series and normalizing it using the quadratic mean, the tanh function performs a high-quality redistribution of the input signal into the desired range of -1 to 1. Finally, using a dual-pole filter such as the Butterworth Filter popularized by John Ehlers, excessive market noise can be filtered out, leaving behind a crisp moving average with minimal lag. Furthermore, WT3D expands upon the original functionality of WT by providing: First-class support for multi-timeframe (MTF) analysis Kernel-based regression for trend reversal confirmation Various options for signal smoothing and transformation A unique mode for visualizing an input series as a symmetrical, three-dimensional waveform useful for pattern identification and cycle-related analysis █  SETTINGS This is a summary of the settings used in the script listed in roughly the order in which they appear. By default, all default colors are from Google's TensorFlow framework and are considered to be colorblind safe. Source: The input series. Usually, it is the close or average price, but it can be any series. Use Mirror: Whether to display a mirror image of the source series; for visualizing the series as a 3D waveform similar to a soundwave. Use EMA: Whether to use an exponential moving average of the input series. EMA Length: The length of the exponential moving average. Use COG: Whether to use the center of gravity of the input series. COG Length: The length of the center of gravity. Speed to Emphasize: The target speed to emphasize. Width: The width of the emphasized line. Display Kernel Moving Average: Whether to display the kernel moving average of the signal. Like PCA, an unsupervised Machine Learning technique whereby neighboring vectors are projected onto the Principal Component. Display Kernel Signal: Whether to display the kernel estimator for the emphasized line. Like the Kernel MA, it can show underlying shifts in bias within a more significant trend by the colors reflected on the ribbon itself. Show Oscillator Lines: Whether to show the oscillator lines. Offset: The offset of the emphasized oscillator plots. Fast Length: The length scale factor for the fast oscillator. Fast Smoothing: The smoothing scale factor for the fast oscillator. Normal Length: The length scale factor for the normal oscillator. Normal Smoothing: The smoothing scale factor for the normal frequency. Slow Length: The length scale factor for the slow oscillator. Slow Smoothing: The smoothing scale factor for the slow frequency. Divergence Threshold: The number of bars for the divergence to be considered significant. Trigger Wave Percent Size: How big the current wave should be relative to the previous wave. Background Area Transparency Factor: Transparency factor for the background area. Foreground Area Transparency Factor: Transparency factor for the foreground area. Background Line Transparency Factor: Transparency factor for the background line. Foreground Line Transparency Factor: Transparency factor for the foreground line. Custom Transparency: Transparency of the custom colors. Total Gradient Steps: The maximum amount of steps supported for a gradient calculation is 256. Fast Bullish Color: The color of the fast bullish line. Normal Bullish Color: The color of the normal bullish line. Slow Bullish Color: The color of the slow bullish line. Fast Bearish Color: The color of the fast bearish line. Normal Bearish Color: The color of the normal bearish line. Slow Bearish Color: The color of the slow bearish line. Bullish Divergence Signals: The color of the bullish divergence signals. Bearish Divergence Signals: The color of the bearish divergence signals. █  ACKNOWLEDGEMENTS @LazyBear - For authoring the original WaveTrend port on TradingView @PineCoders - For the beautiful color gradient framework used in this indicator @veryfid - For the inspiration of using mirrored signals for cycle analysis and using multiple lookback windows as proxies for other timeframes
Pine Script® Indikator
von jdehorty
86
T-Virus Sentiment [hapharmonic]🧬 T-Virus Sentiment: Visualize the Market's DNA Remember the iconic T-Virus vial from the first Resident Evil? That powerful, swirling helix of potential has always fascinated me. It sparked an idea: what if we could visualize the market's underlying health in a similar way? What if we could capture the "genetic code" of market sentiment and contain it within a dynamic, 3D indicator? This project is the result of that idea, brought to life with Pine Script. The indicator's main goal is to measure the strength and direction of market sentiment by analyzing the "genetic code" of price action through a variety of trusted indicators. The result is displayed as a liquid level within a DNA helix, a bubble density representing buying pressure, and a T-Virus mascot that reflects the overall mood. 🧐 Core Concept: How It Works The primary output of the indicator is the "Active %" gauge you see on the right side of the vial. This percentage represents the overall sentiment score, calculated as an average from 7 different technical analysis tools. Each tool is analyzed on every bar and assigned a score from 1 (strong bearish pressure) to 5 (strong bullish potential). In this indicator, we re-imagine market dynamics through the lens of a viral outbreak. A strong bear market is like a virus taking hold, pulling all technical signals down into a state of weakness. Conversely, a powerful bull market is like an antiviral serum ; positive signals rise and spread toward the top of the vial, indicating that the system is being injected with strength. This is not just another line on a chart. It's a comprehensive sentiment dashboard designed to give an immediate, at-a-glance understanding of the confluence between 7 classic technical indicators. The incredible 3D model of the vial itself was inspired by a design concept found here . ⚛️ The 4 Core Elements of T-Virus Sentiment These four elements work in harmony to give a complete, multi-faceted picture of market sentiment. Each component tells a different part of the story. The Virus Mascot: An instant emotional cue. This character provides the quickest possible read on the overall market mood, combining sentiment with volume pressure. The Antiviral Serum Level: The main quantitative output. This is the liquid level in the DNA helix and the percentage gauge on the right, representing the average sentiment score from all 7 indicators. Buy Pressure & Bubble Density: This visualizes volume flow. The density of bubbles represents the intensity of accumulation (buying) versus distribution (selling). It's the "power" behind the move. The Signal Distribution: This shows the confluence (or dispersion) of sentiment. Are all signals bullish and clustered at the top, or are they scattered, indicating a conflicted market? The position of the indicator labels is crucial, as each is assigned to one of five distinct zones: Base Bottom: The market is at its weakest. Signals here suggest strong bearish control and distribution. Lower Zone: The market is still bearish, but signals may be showing early signs of accumulation or bottoming. Neutral Core (Center): A state of balance or sideways consolidation. The market is waiting for a new direction. Upper Zone: Bullish momentum is becoming clear. Signals are strengthening and showing bullish control. Top Cap: The market is "heating up" with strong bullish sentiment, potentially nearing overbought conditions. 🐂🐻 The Virus Mascot: The At-a-Glance Indicator This character acts as a shortcut to confirm market health. It combines the sentiment score with volume, preventing false confidence in a low-volume rally. Its state is determined by a dual-check: the overall "Antiviral Serum Level" and the "Buy Pressure" must both be above 50%. Green & Smiling: The 'all clear' signal. This means that not only is the overall technical sentiment bullish, but it's also being supported by real buying pressure. This is a sign of a healthy bull market. Red & Angry: A warning sign. This appears if either the sentiment is weak, or a bullish sentiment is not being confirmed by buying volume. The latter could indicate a potential "bull trap" or an exhaustive move. This mascot can be disabled from the settings page under "Virus Mascot Styling" if a cleaner look is preferred. 🫧 Bubble Density: Gauging Buy vs. Sell Pressure The bubbles visualize the battle between buyers and sellers. There are two modes to control how this is calculated: Mode 1: Visible Range (The 'Big Picture' View) This default mode is best for getting a broad, contextual understanding of the current session. It dynamically analyzes the volume of every single candlestick currently visible on the screen to calculate the buy/sell pressure ratio. It answers the question: "Over the entire period I'm looking at, who is in control?" As you zoom in or out, the calculation adapts. Mode 2: Custom Lookback (The 'Precision' View) This mode is for traders who need to analyze short-term pressure. You can define a fixed number of recent bars to analyze, which is perfect for scalping or understanding the volume dynamics leading into a key level. It answers the question: "What is happening right now ?" In the example above, a lookback of 2 focuses only on the most recent action, clearly showing intense, immediate selling pressure (few bubbles) and a corresponding drop in the sentiment score to 29%. ℹ️ Interactive Tooltips: Dive Deeper We believe in transparency, not 'black box' indicators. This feature transforms the indicator from a visual aid into an active learning tool. Simply hover the mouse over any indicator label (like EMA, OBV, etc.) to get a detailed tooltip. It will explain the specific data points and thresholds that signal met to be placed in its current zone. This helps build trust in the signals and allows users to fine-tune the indicator settings to better match their own trading style. 🎯 The Scoring Logic Breakdown The "Antiviral Serum Level" gauge is the average score from 7 technical analysis tools. Each is graded on a 5-point scale (1=Strong Bearish to 5=Strong Bullish). Here’s a detailed, transparent look at how each "gene" is evaluated: Relative Strength Index (RSI) Measures momentum and overbought/oversold conditions. Group 1 (Strong Bearish): RSI > 80 (Extreme Overbought) Group 2 (Bearish): 70 < RSI ≤ 80 (Overbought) Group 3 (Neutral): 30 ≤ RSI ≤ 70 Group 4 (Bullish): 20 ≤ RSI < 30 (Oversold) Group 5 (Strong Bullish): RSI < 20 (Extreme Oversold) Exponential Moving Averages (EMA) Evaluates the trend's strength and structure based on the alignment of multiple EMAs (9, 21, 50, 100, 200, 250). Group 1 (Strong Bearish): A perfect bearish sequence (9 < 21 < 50 < ...) Group 2 (Bearish Transition): Early signs of a potential reversal (e.g., 9 > 21 but still below 50) Group 3 (Neutral / Mixed): MAs are intertwined or showing a partial bullish sequence. Group 4 (Bullish): A strong bullish sequence is forming (e.g., 9 > 21 > 50 > 100) Group 5 (Strong Bullish): A perfect bullish sequence (9 > 21 > 50 > 100 > 200 > 250) Moving Average Convergence Divergence (MACD) Analyzes the relationship between two moving averages to gauge momentum. Group 1 (Strong Bearish): MACD & Histogram are negative and momentum is falling. Group 2 (Weakening Bearish): MACD is negative but the histogram is rising or positive. Group 3 (Neutral / Crossover): A crossover event is occurring near the zero line. Group 4 (Bullish): MACD & Histogram are positive. Group 5 (Strong Bullish): MACD & Histogram are positive, rising strongly, and accelerating. Average Directional Index (ADX) Measures trend strength, not direction. The score is based on both ADX value and the dominance of DI+ vs DI-. Group 1 (Bearish / No Trend): ADX < 20 and DI- is dominant. Group 2 (Developing Bearish Trend): 20 ≤ ADX < 25 and DI- is dominant. Group 3 (Neutral / Indecision): Trend is weak or DI+ and DI- are nearly equal. Group 4 (Developing Bullish Trend): 25 ≤ ADX ≤ 40 and DI+ is dominant. Group 5 (Strong Bullish Trend): ADX > 40 and DI+ is dominant. Ichimoku Cloud (IKH) A comprehensive indicator that defines support/resistance, momentum, and trend direction. Group 1 (Strong Bearish): Price is below the Kumo, Tenkan < Kijun, and Chikou is below price. Group 2 (Bearish): Price is inside or below the Kumo, with mixed secondary signals. Group 3 (Neutral / Ranging): Price is inside the Kumo, often with a Tenkan/Kijun cross. Group 4 (Bullish): Price is above the Kumo with strong primary signals. Group 5 (Strong Bullish): All signals are aligned bullishly: price above Kumo, bullish Tenkan/Kijun cross, bullish future Kumo, and Chikou above price. Bollinger Bands (BB) Measures volatility and relative price levels. Group 1 (Strong Bearish): Price is below the lower band. Group 2 (Bearish Territory): Price is between the lower band and the basis line. Group 3 (Neutral): Price is hovering around the basis line. Group 4 (Bullish Territory): Price is between the basis line and the upper band. Group 5 (Strong Bullish): Price is above the upper band. On-Balance Volume (OBV) Uses volume flow to predict price changes. The score is based on OBV's trend and its position relative to its moving average. Group 1 (Strong Bearish): OBV is below its MA and falling. Group 2 (Weakening Bearish): OBV is below its MA but showing signs of rising. Group 3 (Neutral): OBV is very close to its MA. Group 4 (Bullish): OBV is above its MA and rising. Group 5 (Strong Bullish): OBV is above its MA, rising strongly, and showing signs of a volume spike. 🧭 How to Use the T-Virus Sentiment Indicator IMPORTANT: This indicator is a sentiment dashboard , not a direct buy/sell signal generator. Its strength lies in showing confluence and providing a quick, holistic view of the market's technical health. Confirmation Tool: Use the "Active %" gauge to confirm a trade setup from your primary strategy. For example, if you see a bullish chart pattern, a high and rising sentiment score can add confidence to your trade. Momentum & Trend Gauge: A consistently high score (e.g., > 75%) suggests strong, established bullish momentum. A consistently low score (< 25%) suggests strong bearish control. A score hovering around 50% often indicates a ranging or indecisive market. Divergence & Warning System: Pay attention to divergences. If the price is making new highs but the sentiment score is failing to follow or is actively decreasing, it could be an early warning sign that the underlying momentum is weakening. ⚙️ Settings & Customization The indicator is highly customizable to fit any trading style. Position & Anchor: Control where the vial appears on the chart. Styling (Vial, Helix, etc.): Nearly every visual element can be color-customized. Signals: This is where the real power is. All underlying indicator parameters (RSI length, MACD settings, etc.) can be fine-tuned to match a personal strategy. The text labels can also be disabled if the chart feels cluttered. Enjoy visualizing the market's DNA with the T-Virus Sentiment indicator
Pine Script® Indikator
von hapharmonic
15