UNITED TRADING COMMUNITY WaterMarkWATER MARK indicator. Will allow you to improve the order of the entries you need on the chart.
1. Name and date for the traded instrument
2. Watermarks to protect your charts (in the center and around the perimeter of the chart)
3. The new "notes" option will allow you to keep focus on the factors that are important to you on the chart.
Very flexible settings for any notes, labels, watermarks on the chart that are important to you.
Индикатор WATER MARK . Даст возможность вам улучшить порядок нужных вам записей на графике.
1. Название и дата для торгуемого инструмента
2. Водные знаки для защиты ваших графиков ( в центре и по периметру графика)
3. Новая опция "заметки" позволит вам держать фокус на важных для вас факторах на графике.
Очень гибкая настройка , любых значимых для вас заметок , лейблов , вотермарк на графике.
Graphics
Geo. Geo.
This library provides a comprehensive set of geometric functions based on 2 simple types for point and line manipulation, point array calculations, some vector operations (Borrowed from @ricardosantos ), angle calculations, and basic polygon analysis.  It offers tools for creating, transforming, and analyzing geometric shapes and their relationships.  
View the source code for detailed documentation on each function and type.
═════════════════════════════════════════════════════════════════════════
█  OVERVIEW 
This library enhances TradingView's Pine Script with robust geometric capabilities. It introduces the  Point  and  Line  types, along with a suite of functions for various geometric operations. These functionalities empower you to perform advanced calculations, manipulations, and analyses involving points, lines, vectors, angles, and polygons directly within your Pine scripts. The example is  at the bottom of the script. ( Commented out )
█  CONCEPTS 
This library revolves around two fundamental types:
 •  Point:  Represents a point in 2D space with x and y coordinates, along with optional 'a' (angle) and 'v' (value) fields for versatile use.  Crucially, for plotting, utilize the `.to_chart_point()` method to convert Points into plottable chart.point objects.
 •  Line:  Defined by a starting  Point  and a  slope , enabling calculations like getting y for a given x, or finding intersection points.
█  FEATURES 
 •  Point Manipulation:   Perform operations like addition, subtraction, scaling, rotation, normalization, calculating distances, dot products, cross products, midpoints, and more with  Point  objects.
 •  Line Operations:  Create lines, determine their slope, calculate y from x (and vice versa), and find the intersection points of two lines.
 •  Vector Operations:  Perform vector addition, subtraction, multiplication, division, negation, perpendicular vector calculation, floor, fractional part, sine, absolute value, modulus, sign, round, scaling, rescaling, rotation, and ceiling operations.
 •  Angle Calculations:   Compute angles between points in degrees or radians, including signed, unsigned, and 360-degree angles.
 •  Polygon Analysis:  Calculate the area, perimeter, and centroid of polygons. Check if a point is inside a given polygon and determine the convex hull perimeter.
 •  Chart Plotting:  Conveniently convert  Point  objects to  chart.point  objects for plotting lines and points on the chart.  The library also includes functions for plotting lines between individual and series of points.
 •  Utility Functions:  Includes helper functions such as square root, square, cosine, sine, tangent, arc cosine, arc sine, arc tangent, atan2, absolute distance, golden ratio tolerance check, fractional part, and safe index/check for chart plotting boundaries.
█  HOW TO USE 
1 — Include the library in your script using:
 
import kaigouthro/geo/1
 
2 — Create  Point  and  Line  objects:
 
p1 = geo.Point(bar_index, close)
p2 = geo.Point(bar_index , open)
myLine = geo.Line(p1, geo.slope(p1, p2))
// maybe use that line to detect a crossing for an alert ... hmmm
 
3 — Utilize the provided functions:
 
distance = geo.distance(p1, p2)
intersection = geo.intersection(line1, line2)
 
4 — For plotting labels, lines, convert  Point  to  chart.point :
 
label.new(p1.to_chart_point(), " Hi ")
line.new(p1.to_chart_point(),p2.to_chart_point())
 
█  NOTES 
This description provides a concise overview. Consult the library's source code for in-depth documentation, including detailed descriptions, parameter types, and return values for each function and method. The source code is structured with comprehensive comments using the `//@` format for seamless integration with TradingView's auto-documentation features.
█  Possibilities.. 
  
  
Library   "geo" 
This library provides a comprehensive set of geometric functions and types, including point and line manipulation, vector operations, angle calculations, and polygon analysis. It offers tools for creating, transforming, and analyzing geometric shapes and their relationships.
 sqrt(value) 
  Square root function
  Parameters:
     value (float) : (float) - The number to take the square root of
  Returns: (float) - The square root of the input value
 sqr(x) 
  Square function
  Parameters:
     x (float) : (float) - The number to square
  Returns: (float) - The square of the input value
 cos(v) 
  Cosine function
  Parameters:
     v (float) : (series float) - The value to find the cosine of
  Returns: (series float) - The cosine of the input value
 sin(v) 
  Sine function
  Parameters:
     v (float) : (series float) - The value to find the sine of
  Returns: (series float) - The sine of the input value
 tan(v) 
  Tangent function
  Parameters:
     v (float) : (series float) - The value to find the tangent of
  Returns: (series float) - The tangent of the input value
 acos(v) 
  Arc cosine function
  Parameters:
     v (float) : (series float) - The value to find the arc cosine of
  Returns: (series float) - The arc cosine of the input value
 asin(v) 
  Arc sine function
  Parameters:
     v (float) : (series float) - The value to find the arc sine of
  Returns: (series float) - The arc sine of the input value
 atan(v) 
  Arc tangent function
  Parameters:
     v (float) : (series float) - The value to find the arc tangent of
  Returns: (series float) - The arc tangent of the input value
 atan2(dy, dx) 
  atan2 function
  Parameters:
     dy (float) : (float) - The y-coordinate
     dx (float) : (float) - The x-coordinate
  Returns: (float) - The angle in radians
 gap(_value1, __value2) 
  Absolute distance between any two float values
  Parameters:
     _value1 (float) : First value
     __value2 (float) 
  Returns: Absolute Positive Distance
 phi_tol(a, b, tolerance) 
  Check if the ratio is within the tolerance of the golden ratio
  Parameters:
     a (float) : (float) The first number
     b (float) : (float) The second number
     tolerance (float) : (float) The tolerance percennt as 1 = 1 percent
  Returns: (bool) True if the ratio is within the tolerance, false otherwise
 frac(x) 
  frad Fractional
  Parameters:
     x (float) : (float) - The number to convert to fractional
  Returns: (float) - The number converted to fractional
 safeindex(x, limit) 
  limiting int to hold the value within the chart range
  Parameters:
     x (float) : (float) - The number to limit
     limit (int) 
  Returns: (int) - The number limited to the chart range
 safecheck(x, limit) 
  limiting int check if within the chartplottable range
  Parameters:
     x (float) : (float) - The number to limit
     limit (int) 
  Returns: (int) - The number limited to the chart range
 interpolate(a, b, t) 
  interpolate between two values
  Parameters:
     a (float) : (float) - The first value
     b (float) : (float) - The second value
     t (float) : (float) - The interpolation factor (0 to 1)
  Returns: (float) - The interpolated value
 gcd(_numerator, _denominator) 
  Greatest common divisor of two integers
  Parameters:
     _numerator (int) 
     _denominator (int) 
  Returns: (int) The greatest common divisor
 method set_x(self, value) 
  Set the x value of the point, and pass point for chaining
  Namespace types: Point
  Parameters:
     self (Point) : (Point) The point to modify
     value (float) : (float) The new x-coordinate
 method set_y(self, value) 
  Set the y value of the point, and pass point for chaining
  Namespace types: Point
  Parameters:
     self (Point) : (Point) The point to modify
     value (float) : (float) The new y-coordinate
 method get_x(self) 
  Get the x value of the point
  Namespace types: Point
  Parameters:
     self (Point) : (Point) The point to get the x-coordinate from
  Returns: (float) The x-coordinate
 method get_y(self) 
  Get the y value of the point
  Namespace types: Point
  Parameters:
     self (Point) : (Point) The point to get the y-coordinate from
  Returns: (float) The y-coordinate
 method vmin(self) 
  Lowest element of the point
  Namespace types: Point
  Parameters:
     self (Point) : (Point) The point
  Returns: (float) The lowest value between x and y
 method vmax(self) 
  Highest element of the point
  Namespace types: Point
  Parameters:
     self (Point) : (Point) The point
  Returns: (float) The highest value between x and y
 method add(p1, p2) 
  Addition
  Namespace types: Point
  Parameters:
     p1 (Point) : (Point) - The first point
     p2 (Point) : (Point) - The second point
  Returns: (Point) - the add of the two points
 method sub(p1, p2) 
  Subtraction
  Namespace types: Point
  Parameters:
     p1 (Point) : (Point) - The first point
     p2 (Point) : (Point) - The second point
  Returns: (Point) - the sub of the two points
 method mul(p, scalar) 
  Multiplication by scalar
  Namespace types: Point
  Parameters:
     p (Point) : (Point) - The point
     scalar (float) : (float) - The scalar to multiply by
  Returns: (Point) - the multiplied point of the point and the scalar
 method div(p, scalar) 
  Division by scalar
  Namespace types: Point
  Parameters:
     p (Point) : (Point) - The point
     scalar (float) : (float) - The scalar to divide by
  Returns: (Point) - the divided point of the point and the scalar
 method rotate(p, angle) 
  Rotate a point around the origin by an angle (in degrees)
  Namespace types: Point
  Parameters:
     p (Point) : (Point) - The point to rotate
     angle (float) : (float) - The angle to rotate by in degrees
  Returns: (Point) - the rotated point
 method length(p) 
  Length of the vector from origin to the point
  Namespace types: Point
  Parameters:
     p (Point) : (Point) - The point
  Returns: (float) - the length of the point
 method length_squared(p) 
  Length squared of the vector
  Namespace types: Point
  Parameters:
     p (Point) : (Point) The point
  Returns: (float) The squared length of the point
 method normalize(p) 
  Normalize the point to a unit vector
  Namespace types: Point
  Parameters:
     p (Point) : (Point) - The point to normalize
  Returns: (Point) - the normalized point
 method dot(p1, p2) 
  Dot product
  Namespace types: Point
  Parameters:
     p1 (Point) : (Point) - The first point
     p2 (Point) : (Point) - The second point
  Returns: (float) - the dot of the two points
 method cross(p1, p2) 
  Cross product result (in 2D, this is a scalar)
  Namespace types: Point
  Parameters:
     p1 (Point) : (Point) - The first point
     p2 (Point) : (Point) - The second point
  Returns: (float) - the cross of the two points
 method distance(p1, p2) 
  Distance between two points
  Namespace types: Point
  Parameters:
     p1 (Point) : (Point) - The first point
     p2 (Point) : (Point) - The second point
  Returns: (float) - the distance of the two points
 method Point(x, y, a, v) 
  Point Create Convenience
  Namespace types: series float, simple float, input float, const float
  Parameters:
     x (float) 
     y (float) 
     a (float) 
     v (float) 
  Returns: (Point) new point
 method angle(p1, p2) 
  Angle between two points in degrees
  Namespace types: Point
  Parameters:
     p1 (Point) : (Point) - The first point
     p2 (Point) : (Point) - The second point
  Returns: (float) - the angle of the first point and the second point
 method angle_between(p, pivot, other) 
  Angle between two points in degrees from a pivot point
  Namespace types: Point
  Parameters:
     p (Point) : (Point) - The point to calculate the angle from
     pivot (Point) : (Point) - The pivot point
     other (Point) : (Point) - The other point
  Returns: (float) - the angle between the two points
 method translate(p, from_origin, to_origin) 
  Translate a point from one origin to another
  Namespace types: Point
  Parameters:
     p (Point) : (Point) - The point to translate
     from_origin (Point) : (Point) - The origin to translate from
     to_origin (Point) : (Point) - The origin to translate to
  Returns: (Point) - the translated point
 method midpoint(p1, p2) 
  Midpoint of two points
  Namespace types: Point
  Parameters:
     p1 (Point) : (Point) - The first point
     p2 (Point) : (Point) - The second point
  Returns: (Point) - The midpoint of the two points
 method rotate_around(p, angle, pivot) 
  Rotate a point around a pivot point by an angle (in degrees)
  Namespace types: Point
  Parameters:
     p (Point) : (Point) - The point to rotate
     angle (float) : (float) - The angle to rotate by in degrees
     pivot (Point) : (Point) - The pivot point to rotate around
  Returns: (Point) - the rotated point
 method multiply(_a, _b) 
  Multiply vector _a with _b
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The first point
     _b (Point) : (Point) The second point
  Returns: (Point) The result of the multiplication
 method divide(_a, _b) 
  Divide vector _a by _b
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The first point
     _b (Point) : (Point) The second point
  Returns: (Point) The result of the division
 method negate(_a) 
  Negative of vector _a
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to negate
  Returns: (Point) The negated point
 method perp(_a) 
  Perpendicular Vector of _a
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
  Returns: (Point) The perpendicular point
 method vfloor(_a) 
  Compute the floor of argument vector _a
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
  Returns: (Point) The floor of the point
 method fractional(_a) 
  Compute the fractional part of the elements from vector _a
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
  Returns: (Point) The fractional part of the point
 method vsin(_a) 
  Compute the sine of argument vector _a
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
  Returns: (Point) The sine of the point
 lcm(a, b) 
  Least common multiple of two integers
  Parameters:
     a (int) : (int) The first integer
     b (int) : (int) The second integer
  Returns: (int) The least common multiple
 method vabs(_a) 
  Compute the absolute of argument vector _a
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
  Returns: (Point) The absolute of the point
 method vmod(_a, _b) 
  Compute the mod of argument vector _a
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
     _b (float) : (float) The mod
  Returns: (Point) The mod of the point
 method vsign(_a) 
  Compute the sign of argument vector _a
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
  Returns: (Point) The sign of the point
 method vround(_a) 
  Compute the round of argument vector _a
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
  Returns: (Point) The round of the point
 method normalize_y(p, height) 
  normalizes the y value of a point to an input height
  Namespace types: Point
  Parameters:
     p (Point) : (Point)      - The point to normalize
     height (float) : (float) - The height to normalize to
  Returns: (Point)      - the normalized point
 centroid(points) 
  Calculate the centroid of multiple points
  Parameters:
     points (array) : (array) The array of points
  Returns: (Point) The centroid point
 random_point(_height, _width, _origin, _centered) 
  Random Point in a given height and width
  Parameters:
     _height (float) : (float) The height of the area to generate the point in
     _width (float) : (float) The width of the area to generate the point in
     _origin (Point) : (Point) The origin of the area to generate the point in (default: na, will create a Point(0, 0))
     _centered (bool) : (bool) Center the origin point in the area, otherwise, positive h/w (default: false)
  Returns: (Point) The random point in the given area
 random_point_array(_origin, _height, _width, _centered, _count) 
  Random Point Array in a given height and width
  Parameters:
     _origin (Point) : (Point) The origin of the area to generate the array (default: na, will create a Point(0, 0))
     _height (float) : (float) The height of the area to generate the array
     _width (float) : (float) The width of the area to generate the array
     _centered (bool) : (bool) Center the origin point in the area, otherwise, positive h/w (default: false)
     _count (int) : (int) The number of points to generate (default: 50)
  Returns: (array) The random point array in the given area
 method sort_points(points, by_x) 
  Sorts an array of points by x or y coordinate
  Namespace types: array
  Parameters:
     points (array) : (array) The array of points to sort
     by_x (bool) : (bool) Whether to sort by x-coordinate (true) or y-coordinate (false)
  Returns: (array) The sorted array of points
 method equals(_a, _b) 
  Compares two points for equality
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The first point
     _b (Point) : (Point) The second point
  Returns: (bool) True if the points are equal, false otherwise
 method max(origin, _a, _b) 
  Maximum of two points from origin, using dot product
  Namespace types: Point
  Parameters:
     origin (Point) 
     _a (Point) : (Point) The first point
     _b (Point) : (Point) The second point
  Returns: (Point) The maximum point
 method min(origin, _a, _b) 
  Minimum of two points from origin, using dot product
  Namespace types: Point
  Parameters:
     origin (Point) 
     _a (Point) : (Point) The first point
     _b (Point) : (Point) The second point
  Returns: (Point) The minimum point
 method avg_x(points) 
  Average x of point array
  Namespace types: array
  Parameters:
     points (array) : (array) The array of points
  Returns: (float) The average x-coordinate
 method avg_y(points) 
  Average y of point array
  Namespace types: array
  Parameters:
     points (array) : (array) The array of points
  Returns: (float) The average y-coordinate
 method range_x(points) 
  Range of x values in point array
  Namespace types: array
  Parameters:
     points (array) : (array) The array of points
  Returns: (float) The range of x-coordinates
 method range_y(points) 
  Range of y values in point array
  Namespace types: array
  Parameters:
     points (array) : (array) The array of points
  Returns: (float) The range of y-coordinates
 method max_x(points) 
  max of x values in point array
  Namespace types: array
  Parameters:
     points (array) : (array) The array of points
  Returns: (float) The max of x-coordinates
 method min_y(points) 
  min of x values in point array
  Namespace types: array
  Parameters:
     points (array) : (array) The array of points
  Returns: (float) The min of x-coordinates
 method scale(_a, _scalar) 
  Scale a point by a scalar
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to scale
     _scalar (float) : (float) The scalar value
  Returns: (Point) The scaled point
 method rescale(_a, _length) 
  Rescale a point to a new magnitude
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to rescale
     _length (float) : (float) The new magnitude
  Returns: (Point) The rescaled point
 method rotate_rad(_a, _radians) 
  Rotate a point by an angle in radians
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to rotate
     _radians (float) : (float) The angle in radians
  Returns: (Point) The rotated point
 method rotate_degree(_a, _degree) 
  Rotate a point by an angle in degrees
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to rotate
     _degree (float) : (float) The angle in degrees
  Returns: (Point) The rotated point
 method vceil(_a, _digits) 
  Ceil a point to a certain number of digits
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to ceil
     _digits (int) : (int) The number of digits to ceil to
  Returns: (Point) The ceiled point
 method vpow(_a, _exponent) 
  Raise both point elements to a power
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
     _exponent (float) : (float) The exponent
  Returns: (Point) The point with elements raised to the power
 method perpendicular_distance(_a, _b, _c) 
  Distance from point _a to line between _b and _c
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
     _b (Point) : (Point) The start point of the line
     _c (Point) : (Point) The end point of the line
  Returns: (float) The perpendicular distance
 method project(_a, _axis) 
  Project a point onto another
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to project
     _axis (Point) : (Point) The point to project onto
  Returns: (Point) The projected point
 method projectN(_a, _axis) 
  Project a point onto a point of unit length
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to project
     _axis (Point) : (Point) The unit length point to project onto
  Returns: (Point) The projected point
 method reflect(_a, _axis) 
  Reflect a point on another
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to reflect
     _axis (Point) : (Point) The point to reflect on
  Returns: (Point) The reflected point
 method reflectN(_a, _axis) 
  Reflect a point to an arbitrary axis
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to reflect
     _axis (Point) : (Point) The axis to reflect to
  Returns: (Point) The reflected point
 method angle_rad(_a) 
  Angle in radians of a point
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point
  Returns: (float) The angle in radians
 method angle_unsigned(_a, _b) 
  Unsigned degree angle between 0 and +180 by given two points
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The first point
     _b (Point) : (Point) The second point
  Returns: (float) The unsigned angle in degrees
 method angle_signed(_a, _b) 
  Signed degree angle between -180 and +180 by given two points
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The first point
     _b (Point) : (Point) The second point
  Returns: (float) The signed angle in degrees
 method angle_360(_a, _b) 
  Degree angle between 0 and 360 by given two points
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The first point
     _b (Point) : (Point) The second point
  Returns: (float) The angle in degrees (0-360)
 method clamp(_a, _vmin, _vmax) 
  Restricts a point between a min and max value
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The point to restrict
     _vmin (Point) : (Point) The minimum point
     _vmax (Point) : (Point) The maximum point
  Returns: (Point) The restricted point
 method lerp(_a, _b, _rate_of_move) 
  Linearly interpolates between points a and b by _rate_of_move
  Namespace types: Point
  Parameters:
     _a (Point) : (Point) The starting point
     _b (Point) : (Point) The ending point
     _rate_of_move (float) : (float) The rate of movement (0-1)
  Returns: (Point) The interpolated point
 method slope(p1, p2) 
  Slope of a line between two points
  Namespace types: Point
  Parameters:
     p1 (Point) : (Point) - The first point
     p2 (Point) : (Point) - The second point
  Returns: (float) - The slope of the line
 method gety(self, x) 
  Get y-coordinate of a point on the line given its x-coordinate
  Namespace types: Line
  Parameters:
     self (Line) : (Line) - The line
     x (float) : (float) - The x-coordinate
  Returns: (float) - The y-coordinate
 method getx(self, y) 
  Get x-coordinate of a point on the line given its y-coordinate
  Namespace types: Line
  Parameters:
     self (Line) : (Line) - The line
     y (float) : (float) - The y-coordinate
  Returns: (float) - The x-coordinate
 method intersection(self, other) 
  Intersection point of two lines
  Namespace types: Line
  Parameters:
     self (Line) : (Line) - The first line
     other (Line) : (Line) - The second line
  Returns: (Point) - The intersection point
 method calculate_arc_point(self, b, p3) 
  Calculate a point on the arc defined by three points
  Namespace types: Point
  Parameters:
     self (Point) : (Point) The starting point of the arc
     b (Point) : (Point) The middle point of the arc
     p3 (Point) : (Point) The end point of the arc
  Returns: (Point) A point on the arc
 approximate_center(point1, point2, point3) 
  Approximate the center of a spiral using three points
  Parameters:
     point1 (Point) : (Point) The first point
     point2 (Point) : (Point) The second point
     point3 (Point) : (Point) The third point
  Returns: (Point) The approximate center point
 createEdge(center, radius, angle) 
  Get coordinate from center by radius and angle
  Parameters:
     center (Point) : (Point) - The center point
     radius (float) : (float) - The radius of the circle
     angle (float) : (float) - The angle in degrees
  Returns: (Point) - The coordinate on the circle
 getGrowthFactor(p1, p2, p3) 
  Get growth factor of spiral point
  Parameters:
     p1 (Point) : (Point) - The first point
     p2 (Point) : (Point) - The second point
     p3 (Point) : (Point) - The third point
  Returns: (float) - The growth factor
 method to_chart_point(point) 
  Convert Point to chart.point using chart.point.from_index(safeindex(point.x), point.y)
  Namespace types: Point
  Parameters:
     point (Point) : (Point) - The point to convert
  Returns: (chart.point) - The chart.point representation of the input point
 method plotline(p1, p2, col, width) 
  Draw a line from p1 to p2
  Namespace types: Point
  Parameters:
     p1 (Point) : (Point) First point
     p2 (Point) : (Point) Second point
     col (color) 
     width (int) 
  Returns: (line) Line object
 method drawlines(points, col, ignore_boundary) 
  Draw lines between points in an array
  Namespace types: array
  Parameters:
     points (array) : (array) The array of points
     col (color) : (color) The color of the lines
     ignore_boundary (bool) : (bool) The color of the lines
 method to_chart_points(points) 
  Draw an array of points as chart points on the chart with line.new(chartpoint1, chartpoint2, color=linecolor)
  Namespace types: array
  Parameters:
     points (array) : (array) - The points to draw
  Returns: (array) The array of chart points
 polygon_area(points) 
  Calculate the area of a polygon defined by an array of points
  Parameters:
     points (array) : (array) The array of points representing the polygon vertices
  Returns: (float) The area of the polygon
 polygon_perimeter(points) 
  Calculate the perimeter of a polygon
  Parameters:
     points (array) : (array) Array of points defining the polygon
  Returns: (float) Perimeter of the polygon
 is_point_in_polygon(point, _polygon) 
  Check if a point is inside a polygon
  Parameters:
     point (Point) : (Point) The point to check
     _polygon (array) 
  Returns: (bool) True if the point is inside the polygon, false otherwise
 method perimeter(points) 
  Calculates the convex hull perimeter of a set of points
  Namespace types: array
  Parameters:
     points (array) : (array) The array of points
  Returns: (array) The array of points forming the convex hull perimeter
 Point 
  A Point, can be used for vector, floating calcs, etc. Use the cp method for plots
  Fields:
     x (series float) : (float) The x-coordinate
     y (series float) : (float) The y-coordinate
     a (series float) : (float) An Angle storage spot
     v (series float) : (float) A Value
 Line 
  Line
  Fields:
     point (Point) : (Point) The starting point of the line
     slope (series float) : (float) The slope of the line
GOMTRY.
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. 
CommonTypesMathLibrary   "CommonTypesMath" 
Provides a common library source for common types of useful mathematical structures.
Includes: `complex, Vector2, Vector3, Vector4, Quaternion, Segment2, Segment3, Pole, Plane, M32, M44`
 complex 
  Representation of a Complex Number, a complex number `z` is a number in the form `z = x + yi`,
  Fields:
     re : Real part of the complex number.
     im : Imaginary part of the complex number.
 Vector2 
  Representation of a two dimentional vector with components `(x:float,y:float)`.
  Fields:
     x : Coordinate `x` of the vector.
     y : Coordinate `y` of the vector.
 Vector3 
  Representation of a three dimentional vector with components `(x:float,y:float,z:float)`.
  Fields:
     x : Coordinate `x` of the vector.
     y : Coordinate `y` of the vector.
     z : Coordinate `z` of the vector.
 Vector4 
  Representation of a four dimentional vector with components `(x:float,y:float,z:float,w:float)`.
  Fields:
     x : Coordinate `x` of the vector.
     y : Coordinate `y` of the vector.
     z : Coordinate `z` of the vector.
     w : Coordinate `w` of the vector.
 Quaternion 
  Representation of a four dimentional vector with components `(x:float,y:float,z:float,w:float)`.
  Fields:
     x : Coordinate `x` of the vector.
     y : Coordinate `y` of the vector.
     z : Coordinate `z` of the vector.
     w : Coordinate `w` of the vector, specifies the rotation component.
 Segment2 
  Representation of a line in two dimentional space.
  Fields:
     origin : Origin coordinates.
     target : Target coordinates.
 Segment3 
  Representation of a line in three dimentional space.
  Fields:
     origin : Origin coordinates.
     target : Target coordinates.
 Pole 
  Representation of polar coordinates `(radius:float,angle:float)`.
  Fields:
     radius : Radius of the pole.
     angle : Angle in radians of the pole.
 Plane 
  Representation of a 3D plane.
  Fields:
     normal : Normal vector of the plane.
     distance : Distance of the plane along its normal from the origin.
 M32 
  Representation of a 3x2 matrix.
  Fields:
     m11 : First element of the first row.
     m12 : Second element of the first row.
     m21 : First element of the second row.
     m22 : Second element of the second row.
     m31 : First element of the third row.
     m32 : Second element of the third row.
 M44 
  Representation of a 4x4 matrix.
  Fields:
     m11 : First element of the first row.
     m12 : Second element of the first row.
     m13 : Third element of the first row.
     m14 : fourth element of the first row.
     m21 : First element of the second row.
     m22 : Second element of the second row.
     m23 : Third element of the second row.
     m24 : fourth element of the second row.
     m31 : First element of the third row.
     m32 : Second element of the third row.
     m33 : Third element of the third row.
     m34 : fourth element of the third row.
     m41 : First element of the fourth row.
     m42 : Second element of the fourth row.
     m43 : Third element of the fourth row.
     m44 : fourth element of the fourth row.
watermark_asciiJust for fun... You can make an ascii watermark! The steps are:
1. Convert an image into ascii, e.g. using an online generator.
2. Split the ascii into strings that are no more than 4096 characters (pinescript limit).
3. Stack them together as cells on a table (as shown in the script).
I use code generation for step 2, by splitting the ascii file into chunks, then joining each line with a plus sign to make a large string concatenation statement, which I manually copy/paste into pine. Ideally, you could make this whole script into a template with a couple parameters.
Unfortunately, Pinescript doesn't use a monospaced font, so there will be some distortion. Feature request!




