Keltner Channel MA Guild

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

namespace cAlgo
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class KeltnerMAAdjust : Indicator
    {
        private IndicatorDataSeries dataseries;
        private IndicatorDataSeries masmooth;
        private MovingAverage _ma;
        private KeltnerChannels _keltner;

        [Parameter("Period", Group = "Guild MA Settings", DefaultValue = 55)]
        public int period { get; set; }

        [Parameter("MA Smooth Period", Group = "Guild MA Settings", DefaultValue = 20)]
        public int smoothperiod { get; set; }

        [Parameter("Type", Group = "Guild MA Settings", DefaultValue = MovingAverageType.Exponential)]
        public MovingAverageType matype { get; set; }

        [Parameter("Guild MA Line On", Group = "Setup Settings", DefaultValue = false)]
        public bool malineon { get; set; }

        [Parameter("Correction Factor", Group = "Band Settings", DefaultValue = 0.6)]
        public double B { get; set; }

        [Parameter("Height Offset", Group = "Band Settings", DefaultValue = 0.0)]
        public double C { get; set; }

        [Parameter("Extend to Future", Group = "Band Settings", DefaultValue = 0)]
        public int D { get; set; }

        [Parameter("Period", Group = "Keltner Settings", DefaultValue = 60)]
        public int keltnerperiod { get; set; }

        [Parameter("ATR Period", Group = "Keltner Settings", DefaultValue = 120)]
        public int atrperiod { get; set; }

        [Parameter("Deviation", Group = "Keltner Settings", DefaultValue = 2)]
        public double deviation { get; set; }

        [Parameter("Type", Group = "Keltner Settings", DefaultValue = MovingAverageType.Exponential)]
        public MovingAverageType keltnermatype { get; set; }

        [Parameter("ATR Type", Group = "Keltner Settings", DefaultValue = MovingAverageType.Simple)]
        public MovingAverageType atrmatype { get; set; }


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

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

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

        [Output("Guild MA Line", LineColor = "Purple", Thickness = 1, PlotType = PlotType.DiscontinuousLine)]
        public IndicatorDataSeries guildmaline { get; set; }

        double slopemax, slopeaverage, correction, maslope, maslopeback1;
        double pipsize;

        protected override void Initialize()
        {
            dataseries = CreateDataSeries();
            masmooth = CreateDataSeries();
            _ma = Indicators.MovingAverage(dataseries, period, matype);
            _keltner = Indicators.KeltnerChannels(keltnerperiod, keltnermatype, atrperiod, atrmatype, deviation);
            pipsize = Symbol.PipSize;

        }

        public override void Calculate(int index)
        {
//---------                                                                                  This improves smoothness by 5%. Rather than using Bars.ClosePrices.
            dataseries[index] = (Bars.OpenPrices[index] + Bars.ClosePrices[index]) / 2;

            if (index > 2)
            {
//---------                                                                                   Primary smooth the MA           
                masmooth[index] = _ma.Result.Sum(smoothperiod) / smoothperiod;

//---------                                                                                   Tried using this little trick (maslopeback1 = maslope)  but this doesnt seem to be reliable ?. So recalculated it here, instead.
                maslopeback1 = (masmooth[index - 1] - masmooth[index - 2]) / pipsize;

//---------                                                                                   This calculates the Slope or Angle of the moving average.. This indicator uses the Slope Angle to adjust the Keltner.
                maslope = (masmooth[index] - masmooth[index - 1]) / pipsize;
//---------                                                                                   This code makes the slope angle - more stable.
//---------                                                                                   I have found that some currencies have large "gap ups" or "gaps down", in the prices. This messes up the slopemax.
//---------                                                                                   I have added limiter code.  This stops any value, that is too large adding to slopemax.
                if (maslope > 2 * slopemax)
                    maslope = maslopeback1;

//---------                                                                                   This code, finds the largest, maximum size that the slope can be.. for a benchmark for the averaging in the next step.
//---------                                                                                   Its so, the indicator can be used on all currencies and timeframes.
                if (maslope > slopemax)
                    slopemax = maslope;

//---------                                                                                   This averages, so that the maximum will never exceed 100 or 100%
                slopeaverage = ((maslope / slopemax) + C) * 100;
//---------                                                                                   correction - variably adjusts the band distance. B - is the variable band distance sensitivity.
                correction = slopeaverage * (B / 100);


                upper[index + D] = _keltner.Top[index] + (_keltner.Top[index] * correction) / 100;
                lower[index + D] = _keltner.Bottom[index] - (_keltner.Bottom[index] * -correction) / 100;
                middle[index + D] = (upper[index] - lower[index]) / 2 + lower[index];

                if (malineon == true)
                    guildmaline[index] = masmooth[index];
            }


        }
    }
}