Polyline — Indicators and Strategies

Market Stats Panel [Daveatt]█ Introduction I've created a script that brings TradingView's watchlist stats panel functionality directly to your charts. This isn't just another performance indicator - it's a pixel-perfect (kidding) recreation of TradingView's native stats panel. Important Notes You might need to adjust manually the scaling the firs time you're using this script to display nicely all the elements. █ Core Features Performance Metrics The panel displays key performance metrics (1W, 1M, 3M, 6M, YTD, 1Y) in real-time, with color-coded boxes (green for positive, red for negative) for instant performance assessment. Display Modes Switch seamlessly between absolute prices and percentage returns, making it easy to compare assets across different price scales. Absolute mode Percent mode Historical Comparison View year-over-year performance with color-coded lines, allowing for quick historical pattern recognition and analysis. Data Structure Innovation Let's talk about one of the most interesting challenges I faced. PineScript has this quirky limitation where request.security() can only return 127 tuples at most. £To work around this, I implemented a dual-request system. The first request handles indices 0-63, while the second one takes care of indices 64-127.   This approach lets us maintain extensive historical data without compromising script stability. And here's the cool part: if you need to handle even more years of historical data, you can simply extend this pattern by adding more request.security() calls.   Each additional call can fetch another batch of monthly open prices and timestamps, following the same structure I've used.   Think of it as building with LEGO blocks - you can keep adding more pieces to extend your historical reach. Flexible Date Range Unlike many scripts that box you into specific timeframes, I've designed this one to be completely flexible with your date selection. You can set any start year, any end year, and the script will dynamically scale everything to match. The visual presentation automatically adjusts to whatever range you choose, ensuring your data is always displayed optimally. █ Customization Options Visual Settings The panel's visual elements are highly customizable. You can adjust the panel width to perfectly fit your workspace, fine-tune the line thickness to match your preferences, and enjoy the pre-defined year color scheme that makes tracking historical performance intuitive and visually appealing. Box Dimensions Every aspect of the performance boxes can be tailored to your needs. Adjust their height and width, fine-tune the spacing between them, and position the entire panel exactly where you want it on your chart. The goal is to make this tool feel like it's truly yours. █ Technical Challenges Solved Polyline Precision Creating precise polylines was perhaps the most demanding aspect of this project. The challenge was ensuring accurate positioning across both time and price axes, while handling percentage mode scaling with precision. The script constantly updates the current year's data in real-time, seamlessly integrating new information as it comes in. Axis Management Getting the axes right was like solving a complex puzzle. The Y-axis needed to scale dynamically whether you're viewing absolute prices or percentages. The X-axis required careful month labeling that stays clean and readable regardless of your selected timeframe. Everything needed to align perfectly while maintaining proper spacing in all conditions. █ Final Notes This tool transforms complex market data into clear, actionable insights. Whether you're day trading or analyzing long-term trends, it provides the information you need to make informed decisions. And remember, while we can't predict the future, we can certainly be better prepared for it with the right tools at hand. A word of warning though - seeing those red numbers in a beautifully formatted panel doesn't make them any less painful! 😉 --- Happy Trading! May your charts be green and your stops be far away! Daveatt

Patrick [TFO]This Patrick indicator was made for the 1 year anniversary of my Spongebob indicator, which was an experiment in using the polyline features of Pine Script to draw complex subjects. This indicator was made with the same methodology, with some helper functions to make things a bit easier on myself. It's sole purpose is to display a picture of Patrick Star on your chart, particularly the "I have $3" meme. The initial Spongebob indicator included more than 1300 lines of code, as there were several more shapes to account for compared to Patrick, however it was done rather inefficiently. I essentially used an anchor point for each "layer" or shape (eye, nose, mouth, etc.), and drew from that point. This resulted in a ton of trial and error as I had to be very careful about the anchor points for each and every layer, and then draw around that point. In this indicator, however, I gave myself a frame to work with by specifying fixed bounds that you'll see in the code: LEFT, RIGHT, TOP, and BOTTOM. var y_size = 4 atr = ta.atr(50) LEFT = bar_index + 10 RIGHT = LEFT + 200 TOP = open + atr * y_size BOTTOM = open - atr * y_size You may notice that the top and bottom scale with the atr, or Average True Range to account for varying price fluctuations on different assets. With these limits established, I could write some simple functions to translate my coordinates, using a range of 0-100 to describe how far the X coordinates should be from left to right, where left is 0 and right is 100; and likewise how far the Y coordinates should be from bottom to top, where bottom is 0 and top is 100. X(float P) => result = LEFT + math.floor((RIGHT - LEFT)*P/100) Y(float P) => result = BOTTOM + (TOP - BOTTOM)*P/100 With these functions, I could then start drawing points much simpler, with respect to the overall frame of the picture. If I wanted a point in the dead center of the frame, I would choose X(50), Y(50) for example. At this point, the process just became tediously drawing each layer of my reference picture, including but not limited to Patrick's body, arm, mouth, eyes, eyebrows, etc. I've attached the reference picture here (left), without the text enabled. As tedious as this was to create, it was done much more efficiently than Spongebob, and the ideas used here will make it much easier to draw more complex subjects in the future.

Speedometer Revisited Speedometer Revisited is a new way to draw custom metric speedometers and is intended to be a utility for other coders to use. @rumpypumpydumpy originally introduced the Speedometer Toolkit in version 4 of Pine Script. Since then, Pine Script has been updated to version 5, introducing some amazing new features such as polylines and chart.points. This indicator is an example of what can be done with these newer features. The indicator starts off with a handful of functions that will be used to create the drawings. Notes are left throughout the code explaining what each line of the functions does. My goal was to make these functions user-friendly and somewhat easy to understand. I then demonstrate two examples: one speedometer with five segments and another with three. The first example demonstrates how to visually represent the analysts' ratings for a stock using the built-in syminfo.recommendations. The speedometer is divided into five segments, each representing a different level of analyst recommendation: strong sell, sell, hold, buy, and strong buy. Each segment is drawn using a polyline from the createSeg function, with colors assigned as follows: Red for 'Strong Sell' Maroon for 'Sell' Yellow for 'Hold' Green for 'Buy' Lime for 'Strong Buy' The script identifies the maximum value among the analyst ratings, calculates the midpoint of the corresponding segment, and draws a needle pointing to this midpoint. The second example employs the speedometer design to display market sentiment through the put-call ratio. The put-call ratio is a gauge of investor sentiment, where values above 1 indicate a bearish sentiment (more puts being bought relative to calls), and values below 1 suggest a bullish outlook (more calls being bought relative to puts). The speedometer is divided into three segments, reflecting different ranges of the put-call ratio: Red for a ratio greater than 1 (bearish sentiment) Yellow for a ratio between 0.8 and 1 (neutral to bearish sentiment) Lime for a ratio less than 0.8 (bullish sentiment) Depending on the value of the put-call ratio, the script calculates which segment the current value falls into and determines the appropriate segment number. The script calculates the midpoint of the selected segment and draws a needle pointing to this value. Both examples show how the speedometer can be used as a visual indicator of certain market conditions, helping traders quickly recognize trends and adjust their strategies accordingly. A big thanks to @rumpypumpydumpy for his original Speedometer Toolbox. I hope this take on it can be useful for other coders.

DeleteArrayType █ OVERVIEW Here are common functions usually delete drawing once array of drawing is recall. Method is used as in pine script version 5 instead of custom function. It is an upgrade from DeleteArrayObject , which may not support overload parameter in future. Library "DeleteArrayType" TODO: Delete array type especially for drawings method deleteLabel(id) TODO: Delete array Namespace types: array Parameters: id (array) Returns: TODO: label.delete() method deleteLine(id) TODO: Delete array Namespace types: array Parameters: id (array) Returns: TODO: line.delete() method deleteLineFill(id) TODO: Delete array Namespace types: array Parameters: id (array) Returns: TODO: linefill.delete() method deletePolyLine(id) TODO: Delete array Namespace types: array Parameters: id (array) Returns: TODO: polyline.delete() method deleteBox(id) TODO: Delete array Namespace types: array Parameters: id (array) Returns: TODO: box.delete() method deleteTable(id) TODO: Delete array Namespace types: array Parameters: id (array) Returns: TODO: table.delete()

Polyline Plus This library introduces the `PolylinePlus` type, which is an enhanced version of the built-in PineScript `polyline`. It enables two features that are absent from the built-in type: 1. Developers can now efficiently add or remove points from the polyline. In contrast, the built-in `polyline` type is immutable, requiring developers to create a new instance of the polyline to make changes, which is cumbersome and incurs a significant performance penalty. 2. Each `PolylinePlus` instance can theoretically hold up to ~1M points, surpassing the built-in `polyline` type's limit of 10K points, as long as it does not exceed the memory limit of the PineScript runtime. Internally, each `PolylinePlus` instance utilizes an array of `line`s and an array of `polyline`s. The `line`s array serves as a buffer to store lines formed by recently added points. When the buffer reaches its capacity, it flushes the contents and converts the lines into polylines. These polylines are expected to undergo fewer updates. This approach is similiar to the concept of "Buffered I/O" in file and network systems. By connecting the underlying lines and polylines, this library achieves an enhanced polyline that is dynamic, efficient, and capable of surpassing the maximum number of points imposed by the built-in polyline. 🔵 API Step 1: Import this library import algotraderdev/polylineplus/1 as pp // remember to check the latest version of this library and replace the 1 above. Step 2: Initialize the `PolylinePlus` type. var p = pp.PolylinePlus.new() There are a few optional params that developers can specify in the constructor to modify the behavior and appearance of the polyline instance. var p = pp.PolylinePlus.new( // If true, the drawing will also connect the first point to the last point, resulting in a closed polyline. closed = false, // Determines the field of the chart.point objects that the polyline will use for its x coordinates. Either xloc.bar_index (default), or xloc.bar_time. xloc = xloc.bar_index, // Color of the polyline. Default is blue. line_color = color.blue, // Style of the polyline. Default is line.style_solid. line_style = line.style_solid, // Width of the polyline. Default is 1. line_width = 1, // The maximum number of points that each built-in `polyline` instance can contain. // NOTE: this is not to be confused with the maximum of points that each `PolylinePlus` instance can contain. max_points_per_builtin_polyline = 10000, // The number of lines to keep in the buffer. If more points are to be added while the buffer is full, then all the lines in the buffer will be flushed into the poylines. // The higher the number, the less frequent we'll need to // flush the buffer, and thus lead to better performance. // NOTE: the maximum total number of lines per chart allowed by PineScript is 500. But given there might be other places where the indicator or strategy are drawing lines outside this polyline context, the default value is 50 to be safe. lines_bffer_size = 50) Step 3: Push / Pop Points // Push a single point p.push_point(chart.point.now()) // Push multiple points chart.point points = array.from(p1, p2, p3) // Where p1, p2, p3 are all chart.point type. p.push_points(points) // Pop point p.pop_point() // Resets all the points in the polyline. p.set_points(points) // Deletes the polyline. p.delete() 🔵 Benchmark Below is a simple benchmark comparing the performance between `PolylinePlus` and the native `polyline` type for incrementally adding 10K points to a polyline. import algotraderdev/polylineplus/2 as pp var t1 = 0 var t2 = 0 if bar_index < 10000 int start = timenow var p = pp.PolylinePlus.new(xloc = xloc.bar_time, closed = true) p.push_point(chart.point.now()) t1 += timenow - start start := timenow var polyline pl = na var points = array.new() points.push(chart.point.now()) if not na(pl) pl.delete() pl := polyline.new(points) t2 += timenow - start if barstate.islast log.info('{0} {1}', t1, t2) For this benchmark, `PolylinePlus` took ~300ms, whereas the native `polyline` type took ~6000ms. We can also fine-tune the parameters for `PolylinePlus` to have a larger buffer size for `line`s and a smaller buffer for `polyline`s. var p = pp.PolylinePlus.new(xloc = xloc.bar_time, closed = true, lines_buffer_size = 500, max_points_per_builtin_polyline = 1000) With the above optimization, it only took `PolylinePlus` ~80ms to process the same 10K points, which is ~75x the performance compared to the native `polyline`.

RSI Radar Multi Time Frame Hello All! First of all many Thanks to Tradingview and Pine Team for developing Pine Language all the time! Now we have a new feature and it's called Polylines and I developed RSI Radar Multi Time Frame . This script is an example and experimental work, you can use it as you wish. The scripts gets RSI values from 6 different time frames, it doesn't matter the time frame you choose is higher/lower or chart time frame. it means that the script can get RSI values from higher or lower time frames than chart time frame. It's designed to show RSI Radar all the time on the chart even if you zoom in/out or scroll left/right. You can set OB/OS or RSI line colors. Also RSI polyline is shown as Curved/Hexagon optionally. Some screenshots here: Doesn't matter if you zoom out, it can show RSI radar in the visible area: Another example: You can change the colors, or see the RSI as Hexagon: Time frames from seconds to 1Day in this example while chart time frame is any ( 30mins here ) Enjoy!