Cumulative Delta Volume

using System;
using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.API.Indicators;
using cAlgo.Indicators;

namespace cAlgo.Indicators
{
    [Cloud("Close", "Open", FirstColor = "Lime", SecondColor = "Crimson")]
    [Indicator(IsOverlay = false, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class CumulativeDeltaVolume : Indicator
    {
        [Parameter("As Heiken Ashi", DefaultValue = false)]
        public bool AsHeikenAshi { get; set; }

        [Parameter("Smoothing", DefaultValue = 5)]
        public int Period { get; set; }

        [Parameter("Show Bars", DefaultValue = true)]
        public bool ShowBars { get; set; }



        [Output("Open", PlotType = PlotType.DiscontinuousLine, LineColor = "Gray", Thickness = 1)]
        public IndicatorDataSeries Open { get; set; }

        [Output("Close", PlotType = PlotType.DiscontinuousLine, LineColor = "Gray", Thickness = 1)]
        public IndicatorDataSeries Close { get; set; }

        [Output("High", PlotType = PlotType.Points, LineColor = "Green", Thickness = 3)]
        public IndicatorDataSeries High { get; set; }

        [Output("Low", PlotType = PlotType.Points, LineColor = "Red", Thickness = 3)]
        public IndicatorDataSeries Low { get; set; }



        private IndicatorDataSeries delta;
        private IndicatorDataSeries cumDelta;
        private IndicatorDataSeries O;
        private IndicatorDataSeries C;
        private IndicatorDataSeries H;
        private IndicatorDataSeries L;
        private ExponentialMovingAverage ema;
        private int candleWidth;



        protected override void Initialize()
        {
            delta = CreateDataSeries();
            cumDelta = CreateDataSeries();
            O = CreateDataSeries();
            C = CreateDataSeries();
            H = CreateDataSeries();
            L = CreateDataSeries();

            ema = Indicators.ExponentialMovingAverage(cumDelta, Period);

            if (ShowBars)
            {
                UpdateVisibleCandles();

                Chart.ZoomChanged += OnZoomChanged;
                Chart.SizeChanged += OnSizeChanged;
                Chart.DragEnd += OnDragEnd;
                Chart.ScrollChanged += OnScrollChanged;
            }
        }

        void OnZoomChanged(ChartZoomEventArgs obj)
        {
            UpdateVisibleCandles();
        }

        void OnSizeChanged(ChartSizeEventArgs obj)
        {
            UpdateVisibleCandles();
        }

        void OnDragEnd(ChartDragEventArgs obj)
        {
            UpdateVisibleCandles();
        }

        void OnScrollChanged(ChartScrollEventArgs obj)
        {
            UpdateVisibleCandles();
        }

        public override void Calculate(int index)
        {
            double volume = Bars.TickVolumes[index];
            double open = Bars.OpenPrices[index];
            double close = Bars.ClosePrices[index];
            double high = Bars.HighPrices[index];
            double low = Bars.LowPrices[index];

            double topWick = high - Math.Max(open, close);
            double bottomWick = Math.Min(open, close) - low;
            double body = Math.Abs(close - open);

            delta[index] = ((topWick + bottomWick) / 2.0 + body) / (topWick + bottomWick + body);
            delta[index] = volume * (double.IsNaN(delta[index]) ? 0.5 : close >= open ? delta[index] : -delta[index]);

            double cumDeltaPrev = double.IsNaN(cumDelta[index - 1]) ? 0.0 : cumDelta[index - 1];
            cumDelta[index] = delta[index] + cumDeltaPrev;

            O[index] = ema.Result[index - 1];
            C[index] = ema.Result[index];
            H[index] = double.IsNaN(ema.Result[index - 1]) ? ema.Result[index] : Math.Max(ema.Result[index], ema.Result[index - 1]);
            L[index] = double.IsNaN(ema.Result[index - 1]) ? ema.Result[index] : Math.Min(ema.Result[index], ema.Result[index - 1]);

            if (AsHeikenAshi)
            {
                Open[index] = double.IsNaN(Open[index - 1]) ? (O[index] + C[index]) / 2.0 : (Open[index - 1] + Close[index - 1]) / 2.0;
                Close[index] = (O[index] + H[index] + L[index] + C[index]) / 4.0;
                High[index] = Math.Max(Math.Max(H[index], Open[index]), Close[index]);
                Low[index] = Math.Min(Math.Min(L[index], Open[index]), Close[index]);
            }
            else
            {
                Open[index] = O[index];
                Close[index] = C[index];
                High[index] = H[index];
                Low[index] = L[index];
            }

            if (ShowBars)
            {
                UpdateCandle(index);
            }
        }

        void UpdateVisibleCandles()
        {
            candleWidth = (int)(IndicatorArea.Width / (0.666 * Chart.MaxVisibleBars));
            candleWidth = candleWidth < 3 ? 3 : candleWidth;

            for (int i = Chart.FirstVisibleBarIndex; i <= Chart.LastVisibleBarIndex; i++)
            {
                UpdateCandle(i);
            }
        }

        void UpdateCandle(int index)
        {
            Color color = Open[index] > Close[index] ? Color.OrangeRed : Color.Lime;

            IndicatorArea.DrawTrendLine("line" + index, index, High[index], index, Low[index], color, 1, LineStyle.Solid);
            IndicatorArea.DrawTrendLine("candle" + index, index, Open[index], index, Close[index], color, candleWidth, LineStyle.Solid);
        }
    }
}