QuanTAlib/quantower/IndicatorExtensions.cs

using TradingPlatform.BusinessLayer;
using TradingPlatform.BusinessLayer.Chart;
using System.Drawing;
using System.Drawing.Drawing2D;

#nullable disable

namespace QuanTAlib;

public enum SourceType
{
    Open, High, Low, Close, HL2, OC2, OHL3, HLC3, OHLC4, HLCC4
}

public enum MaType
{
    Alma, Dema, Dsma, Dwma, Ema, Epma, Frama, Fwma, Gma, Hma, Hwma, Jma, Kama, Maaf, Mgdi, MMa, Pwma, Rema, Rma, Sinema, Sma, Smma, T3, Tema, Trima, Vidya, Wma, Zlema
}

public static class IndicatorExtensions
{
    public static readonly Color Averages = Color.FromArgb(255, 255, 128); // #FFFF80 - Yellow
    public static readonly Color Volume = Color.FromArgb(128, 255, 128); // #80FF80 - Green
    public static readonly Color Volatility = Color.FromArgb(255, 128, 128); // #FF8080 - Red
    public static readonly Color Statistics = Color.FromArgb(128, 128, 255); // #8080FF - Blue
    public static readonly Color Oscillators = Color.FromArgb(255, 128, 255); // #FF80FF - Magenta
    public static readonly Color Momentum = Color.FromArgb(128, 255, 255); // #80FFFF - Cyan
    public static readonly Color Experiments = Color.FromArgb(255, 165, 0); // #FFA500 - Orange

    [AttributeUsage(AttributeTargets.Property)]
    public class DataSourceInputAttribute : InputParameterAttribute
    {
        public DataSourceInputAttribute(string label = "Data source", int sortIndex = 20)
            : base(label, sortIndex, variants: new object[]
            {
                "Open", SourceType.Open,
                "High", SourceType.High,
                "Low", SourceType.Low,
                "Close", SourceType.Close,
                "HL/2 (Median)", SourceType.HL2,
                "OC/2 (Midpoint)", SourceType.OC2,
                "OHL/3 (Mean)", SourceType.OHL3,
                "HLC/3 (Typical)", SourceType.HLC3,
                "OHLC/4 (Average)", SourceType.OHLC4,
                "HLCC/4 (Weighted)", SourceType.HLCC4
            })
        { }
    }

    public static TValue GetInputValue(this Indicator indicator, UpdateArgs args, SourceType source)
    {
        var historicalData = indicator.HistoricalData;
        TBar bar = new TBar(
            time: historicalData.Time(),
            open: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.Open],
            high: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.High],
            low: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.Low],
            close: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.Close],
            volume: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.Volume]
        );

        double price = source switch
        {
            SourceType.Open => bar.Open,
            SourceType.High => bar.High,
            SourceType.Low => bar.Low,
            SourceType.Close => bar.Close,
            SourceType.HL2 => bar.HL2,
            SourceType.OC2 => bar.OC2,
            SourceType.OHL3 => bar.OHL3,
            SourceType.HLC3 => bar.HLC3,
            SourceType.OHLC4 => bar.OHLC4,
            SourceType.HLCC4 => bar.HLCC4,
            _ => bar.Close
        };

        return new TValue(bar.Time, price);
    }

    public static TBar GetInputBar(this Indicator indicator, UpdateArgs args)
    {
        var historicalData = indicator.HistoricalData;
        return new TBar(
            time: historicalData.Time(),
            open: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.Open],
            high: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.High],
            low: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.Low],
            close: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.Close],
            volume: historicalData[indicator.Count - 1, SeekOriginHistory.Begin][PriceType.Volume]
        );
    }

#pragma warning disable CA1416 // Validate platform compatibility
    public static int GetHLineY(IChartWindowCoordinatesConverter converter, double value)
    {
        return (int)converter.GetChartY(value);
    }

    public static void PaintHLine(this Indicator indicator, PaintChartEventArgs args, double value, Pen pen)
    {
        if (indicator.CurrentChart == null)
            return;

        Graphics gr = args.Graphics;
        var mainWindow = indicator.CurrentChart.Windows[args.WindowIndex];
        var converter = mainWindow.CoordinatesConverter;
        var clientRect = mainWindow.ClientRectangle;

        gr.SetClip(clientRect);
        int leftX = clientRect.Left;
        int rightX = clientRect.Right;
        int Y = GetHLineY(converter, value);

        using (pen)
        {
            gr.DrawLine(pen, new Point(leftX, Y), new Point(rightX, Y));
        }
    }

    public static List<Point> GetSmoothCurvePoints(Indicator indicator, IChartWindowCoordinatesConverter converter, Rectangle clientRect, LineSeries series)
    {
        ArgumentNullException.ThrowIfNull(indicator);
        ArgumentNullException.ThrowIfNull(converter);
        var data = indicator.HistoricalData;
        if (data == null) return new List<Point>();

        var lastTime = data.Time(data.Count - 1);
        var firstTime = data.Time(0);

        IChartWindowCoordinatesConverter safeConverter = converter!;
        DateTime tLeft = safeConverter.GetTime(clientRect.Left);
        DateTime leftTime = tLeft > lastTime ? tLeft : lastTime;

        DateTime tRight = safeConverter.GetTime(clientRect.Right);
        DateTime rightTime = tRight < firstTime ? tRight : firstTime;

        int leftIndex = (int)data.GetIndexByTime(leftTime.Ticks) + 1;
        int rightIndex = (int)data.GetIndexByTime(rightTime.Ticks);

        List<Point> allPoints = new List<Point>();

        for (int i = rightIndex; i < leftIndex; i++)
        {
            int barX = (int)converter.GetChartX(data.Time(i));
            int barY = (int)converter.GetChartY(series[i]);
            int halfBarWidth = indicator.CurrentChart.BarsWidth / 2;
            Point point = new Point(barX + halfBarWidth, barY);
            allPoints.Add(point);
        }
        return allPoints;
    }

    public static void PaintSmoothCurve(this Indicator indicator, PaintChartEventArgs args, LineSeries series, int warmupPeriod, bool showColdValues = true, double tension = 0.2)
    {
        if (!series.Visible || indicator.CurrentChart == null)
            return;

        Graphics gr = args.Graphics;
        gr.SmoothingMode = SmoothingMode.AntiAlias;
        var mainWindow = indicator.CurrentChart.Windows[args.WindowIndex];
        var converter = mainWindow.CoordinatesConverter;
        var clientRect = mainWindow.ClientRectangle;

        gr.SetClip(clientRect);
        
        List<Point> allPoints = GetSmoothCurvePoints(indicator, converter, clientRect, series);

        if (allPoints.Count > 1)
        {
            DateTime rightTime = new[] { converter.GetTime(clientRect.Right), indicator.HistoricalData.Time(0) }.Min();
            int rightIndex = (int)indicator.HistoricalData.GetIndexByTime(rightTime.Ticks);

            using Pen defaultPen = new(series.Color, series.Width) { DashStyle = ConvertLineStyleToDashStyle(series.Style) };
            using Pen coldPen = new(series.Color, series.Width) { DashStyle = DashStyle.Dot };

            int hotCount = indicator.Count - warmupPeriod - rightIndex;

            // Draw the hot part
            if (hotCount > 0)
            {
                var hotPoints = allPoints.Take(Math.Min(hotCount + 1, allPoints.Count)).ToArray();
                gr.DrawCurve(defaultPen, hotPoints, 0, hotPoints.Length - 1, (float)tension);
            }

            // Draw the cold part
            if (showColdValues && hotCount < allPoints.Count)
            {
                var coldPoints = allPoints.Skip(Math.Max(0, hotCount)).ToArray();
                gr.DrawCurve(coldPen, coldPoints, 0, coldPoints.Length - 1, (float)tension);
            }
        }
    }

    public static List<(Rectangle Rect, Color Color)> GetHistogramRectangles(Indicator indicator, IChartWindowCoordinatesConverter converter, Rectangle clientRect, LineSeries series)
    {
        ArgumentNullException.ThrowIfNull(indicator);
        ArgumentNullException.ThrowIfNull(converter);
        var data = indicator.HistoricalData;
        if (data == null) return new List<(Rectangle, Color)>();

        var lastTime = data.Time(data.Count - 1);
        var firstTime = data.Time(0);

        IChartWindowCoordinatesConverter safeConverter = converter!;
        DateTime tLeft = safeConverter.GetTime(clientRect.Left);
        DateTime leftTime = tLeft > lastTime ? tLeft : lastTime;

        DateTime tRight = safeConverter.GetTime(clientRect.Right);
        DateTime rightTime = tRight < firstTime ? tRight : firstTime;

        int leftIndex = (int)data.GetIndexByTime(leftTime.Ticks) + 1;
        int rightIndex = (int)data.GetIndexByTime(rightTime.Ticks);

        var result = new List<(Rectangle, Color)>();

        for (int i = rightIndex; i < leftIndex; i++)
        {
            int barX = (int)converter.GetChartX(data.Time(i));
            int barY = (int)converter.GetChartY(series[i]);
            int barY0 = (int)converter.GetChartY(0);
            int HistBarWidth = indicator.CurrentChart.BarsWidth - 2;

            if (series[i] > 0)
            {
                result.Add((new Rectangle(barX, barY, HistBarWidth, Math.Abs(barY - barY0)), Color.FromArgb(150, 0, 255, 0)));
            }
            else
            {
                result.Add((new Rectangle(barX, barY0, HistBarWidth, Math.Abs(barY0 - barY)), Color.FromArgb(150, 255, 0, 0)));
            }
        }
        return result;
    }

    public static void PaintHistogram(this Indicator indicator, PaintChartEventArgs args, LineSeries series, int warmupPeriod, bool showColdValues = true)
    {
        if (!series.Visible || indicator.CurrentChart == null)
            return;

        Graphics gr = args.Graphics;
        gr.SmoothingMode = SmoothingMode.AntiAlias;
        var mainWindow = indicator.CurrentChart.Windows[args.WindowIndex];
        var converter = mainWindow.CoordinatesConverter;
        var clientRect = mainWindow.ClientRectangle;

        gr.SetClip(clientRect);
        
        var rects = GetHistogramRectangles(indicator, converter, clientRect, series);

        foreach (var (rect, color) in rects)
        {
            using (Brush hist = new SolidBrush(color))
            {
                gr.FillRectangle(hist, rect);
            }
        }
    }

    public static void DrawText(this Indicator indicator, PaintChartEventArgs args, string text)
    {
        if (indicator.CurrentChart == null)
            return;

        Graphics gr = args.Graphics;
        var clientRect = indicator.CurrentChart.MainWindow.ClientRectangle;
        Font font = new Font("Inter", 8);
        SizeF textSize = gr.MeasureString(text, font);
        RectangleF textRect = new RectangleF(clientRect.Left + 5,
                                           clientRect.Bottom - textSize.Height - 10,
                                           textSize.Width + 10, textSize.Height + 10);

        gr.FillRectangle(Brushes.DarkBlue, textRect);
        gr.DrawString(text, font, Brushes.White, new PointF(textRect.X + 6, textRect.Y + 5));
    }

    private static DashStyle ConvertLineStyleToDashStyle(LineStyle lineStyle)
    {
        return lineStyle switch
        {
            LineStyle.Solid => DashStyle.Solid,
            LineStyle.Dash => DashStyle.Dash,
            LineStyle.Dot => DashStyle.Dot,
            LineStyle.DashDot => DashStyle.DashDot,
            _ => DashStyle.Solid,
        };
    }
}