Category Trend Published on 11/12/2022

renko

Description

using cAlgo.API;

using cAlgo.API.Indicators;

using cAlgo.API.Internals;

using cAlgo.Indicators;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Windows.Forms;

using System.Runtime.InteropServices;

using System.Diagnostics;

using cT_MedianRenkoEngine;

namespace cAlgo

{

[Indicator("MedianRenko", IsOverlay = true, AutoRescale = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.FullAccess)]

public class MedianRenko : Indicator

{

[Parameter("Bar Size (Pips)", DefaultValue = 10, MinValue = 0.1, Step = 1)]

public double BarSizePips { get; set; }

[Parameter("Retracement factor (0.01 - 1.00)", DefaultValue = 0.5, MinValue = 0.01, MaxValue = 1.0, Step = 0.01)]

public double Retracement { get; set; }

[Parameter("Maximum Bars", DefaultValue = 300, MinValue = 1)]

public int BricksToShow { get; set; }

[Parameter("Symmetrical Reversals", DefaultValue = true)]

public bool SymmetricalReversals { get; set; }

[Parameter("Reset Open on new trading day", DefaultValue = false)]

public bool ResetOpenOnNewTradingDay { get; set; }

[Parameter("Apply offset to first renko bar", DefaultValue = false)]

public bool ApplyOffsetToFirstBar { get; set; }

[Parameter("Tick offset value", DefaultValue = 0, MinValue = 0)]

public int OffsetValue { get; set; }

[Parameter("Bullish Bar Color", DefaultValue = "SeaGreen")]

public string ColorBull { get; set; }

[Parameter("Bearish Bar Color", DefaultValue = "Tomato")]

public string ColorBear { get; set; }

[Output("Open", Color = Colors.DimGray, Thickness = 0, PlotType = PlotType.Points)]

public IndicatorDataSeries Open { get; set; }

[Output("High", Color = Colors.DimGray, Thickness = 1, PlotType = PlotType.Points)]

public IndicatorDataSeries High { get; set; }

[Output("Low", Color = Colors.DimGray, Thickness = 0, PlotType = PlotType.Points)]

public IndicatorDataSeries Low { get; set; }

[Output("Close", Color = Colors.DimGray, Thickness = 0, PlotType = PlotType.Points)]

public IndicatorDataSeries Close { get; set; }

private MedianRenkoCore core = null;

private bool coreOK = true;

private DateTime lastTime;

private bool appliedOffset = false;

private T_OLHCV pOLHCV;

private T_OLHCV OLHCV;

private T_OLHCV mOLHCV;

private T_OLHCV cOLHCV;

private T_OLHCV memRates;

private T_OLHCV lastBar;

private List<T_OLHCV> bars = new List<T_OLHCV>();

private double barSize;

private Colors colorBull, colorBear;

protected override void Initialize()

{

core = new MedianRenkoCore();

coreOK = core.StatusCheck();

barSize = BarSizePips * Symbol.PipSize;

lastTime = new DateTime();

lastTime = MarketSeries.OpenTime[MarketSeries.Close.Count - 1];

lastBar = new T_OLHCV();

pOLHCV = new T_OLHCV();

OLHCV = new T_OLHCV();

mOLHCV = new T_OLHCV();

cOLHCV = new T_OLHCV();

memRates = new T_OLHCV();

if (!Enum.TryParse<Colors>(ColorBull, out colorBull))

{

colorBull = Colors.SeaGreen;

}

if (!Enum.TryParse<Colors>(ColorBear, out colorBear))

{

colorBear = Colors.Tomato;

}

appliedOffset = false;

}

private bool NewBar(int index)

{

if (lastTime != MarketSeries.OpenTime[index])

{

lastTime = MarketSeries.OpenTime[index];

return true;

}

return false;

}

private static int cc = 0;

private void pushBars(T_OLHCV bar, bool display)

{

int count = bars.Count();

var newBar = new T_OLHCV();

newBar.Copy(bar);

newBar.Index = cc++;

bars.Insert(0, newBar);

count++;

if (display)

{

shiftBars(0);

}

if (count > BricksToShow)

{

if (display)

{

for (int i = BricksToShow - 1; i < count; i++)

{

ChartObjects.RemoveObject("mr_Wick_" + bars[i].Index);

ChartObjects.RemoveObject("mr_Bar_" + bars[i].Index);

}

bars.RemoveRange(BricksToShow, count - BricksToShow);

Open[count - BricksToShow] = double.NaN;

High[count - BricksToShow] = double.NaN;

Low[count - BricksToShow] = double.NaN;

Close[count - BricksToShow] = double.NaN;

}

}

private void shiftBars(int shift)

{

int count = bars.Count;

int ix = MarketSeries.Close.Count - 2;

for (int i = 0; i < count && i < BricksToShow; i++)

{

var candleColor = (bars[i].Close > bars[i].Open) ? colorBull : colorBear;

ChartObjects.DrawLine("mr_Wick_" + bars[i].Index, ix, bars[i].High, ix, bars[i].Low, candleColor, 1, LineStyle.Solid);

ChartObjects.DrawLine("mr_Bar_" + bars[i].Index, ix, bars[i].Close, ix, bars[i].Open, candleColor, 5, LineStyle.Solid);

Open[ix] = bars[i].Open;

High[ix] = bars[i].High;

Low[ix] = bars[i].Low;

Close[ix] = bars[i].Close;

ix--;

}

private void UpdateLastBar(int ix)

{

var candleColor = (memRates.Close > memRates.Open) ? colorBull : colorBear;

ChartObjects.DrawLine("mr_Wick_Live", ix, memRates.High, ix, memRates.Low, candleColor, 1, LineStyle.Solid);

ChartObjects.DrawLine("mr_Bar_Live", ix, memRates.Close, ix, memRates.Open, candleColor, 5, LineStyle.Solid);

Open[ix] = memRates.Open;

High[ix] = memRates.High;

Low[ix] = memRates.Low;

Close[ix] = memRates.Close;

}

public override void Calculate(int index)

{

if (ResetOpenOnNewTradingDay)

{

if (IsNewSession(MarketSeries.OpenTime[(index > 0) ? (index - 1) : index], MarketSeries.OpenTime[index]))

{

cOLHCV.Clear();

mOLHCV.Clear();

pOLHCV.Clear();

memRates.Copy(mOLHCV);

}

if (IsRealTime)

{

if (!coreOK)

{

ChartObjects.DrawText("TrialOverMsg", "MedianRenko Indicator - Trial period ended. Please purchase a license file at www.az-invest.eu", StaticPosition.Center, Colors.White);

return;

}

if (NewBar(index))

{

shiftBars(0);

Open[index - BricksToShow - 1] = double.NaN;

High[index - BricksToShow - 1] = double.NaN;

Low[index - BricksToShow - 1] = double.NaN;

Close[index - BricksToShow - 1] = double.NaN;

}

OLHCV.Open = MarketSeries.Close[index];

OLHCV.Low = MarketSeries.Close[index];

OLHCV.High = MarketSeries.Close[index];

OLHCV.Close = MarketSeries.Close[index];

OLHCV.OpenTime = MarketSeries.OpenTime[index];

OLHCV.TickVolume = 1;

ProcessMarketData(OLHCV);

UpdateLastBar(index);

}

else

{

OLHCV.Open = MarketSeries.Open[index];

OLHCV.Low = MarketSeries.Low[index];

OLHCV.High = MarketSeries.High[index];

OLHCV.Close = MarketSeries.Close[index];

OLHCV.OpenTime = MarketSeries.OpenTime[index];

OLHCV.TickVolume = MarketSeries.TickVolume[index];

if (ApplyOffsetToFirstBar && !appliedOffset)

{

OLHCV.Open = OffsetValue * Symbol.TickSize + Math.Floor(OLHCV.Open / barSize) * barSize;

appliedOffset = true;

}

ProcessMarketData(OLHCV);

if (IsLastBar)

UpdateLastBar(index);

}

private void ProcessMarketData(T_OLHCV ___OLHCV)

{

int rb_return = core.ProcessMedianRenko(barSize, Retracement, SymmetricalReversals, ___OLHCV, ref pOLHCV, ref mOLHCV, ref cOLHCV, 1);

while (true)

{

if ((rb_return >= 1) && (rb_return <= 4))

{

pushBars(cOLHCV, IsRealTime);

memRates.Copy(mOLHCV);

OLHCV.Copy(memRates);

cOLHCV.Clear();

mOLHCV.Clear();

rb_return = core.ProcessMedianRenko(barSize, Retracement, SymmetricalReversals, ___OLHCV, ref pOLHCV, ref mOLHCV, ref cOLHCV, 0);

continue;

}

else if (rb_return == 10)

{

memRates.Copy(mOLHCV);

break;

}

else if (rb_return == -1)

{

return;

}

else

{

throw new Exception("Unhandled return value = " + rb_return);

}

if (IsLastBar && !IsRealTime)

{

shiftBars(0);

}

private bool IsNewSession(DateTime prevTime, DateTime currTime)

{

if (prevTime.DayOfWeek != currTime.DayOfWeek)

return true;

else

return false;

}

}

Source Code


using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using cAlgo.Indicators;
using System;
using System.Collections.Generic;
using System.Linq;

namespace cAlgo
{
    [Indicator("Renko", IsOverlay = true, AutoRescale = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class Renko : Indicator
    {
        [Parameter("Renko (Pips)", DefaultValue = 10, MinValue = 0.1, Step = 1)]
        public double RenkoPips { get; set; }

        [Parameter("Bricks To Show", DefaultValue = 100, MinValue = 1)]
        public int BricksToShow { get; set; }

        [Parameter("Zoom Level", DefaultValue = 3, MinValue = 0, MaxValue = 5, Step = 1)]
        public double ZoomLevel { get; set; }

        [Parameter("Bullish Color", DefaultValue = "SeaGreen")]
        public string ColorBull { get; set; }

        [Parameter("Bearish Color", DefaultValue = "Tomato")]
        public string ColorBear { get; set; }

        [Output("Open", Color = Colors.DimGray, Thickness = 1, PlotType = PlotType.Points)]
        public IndicatorDataSeries Open { get; set; }

        [Output("High", Color = Colors.DimGray, Thickness = 1, PlotType = PlotType.Points)]
        public IndicatorDataSeries High { get; set; }

        [Output("Low", Color = Colors.DimGray, Thickness = 1, PlotType = PlotType.Points)]
        public IndicatorDataSeries Low { get; set; }

        [Output("Close", Color = Colors.DimGray, Thickness = 1, PlotType = PlotType.Points)]
        public IndicatorDataSeries Close { get; set; }

        public class Brick
        {
            public double Open { get; set; }
            public double Close { get; set; }
        }

        private List<Brick> renkos = new List<Brick>();
        private double closeLastValue, thickness, renkoPips, renkoLastValue;
        private Colors colorBull, colorBear;
        private bool colorError;
        private int lastCount;

        protected override void Initialize()
        {
            if (!Enum.TryParse<Colors>(ColorBull, out colorBull) || !Enum.TryParse<Colors>(ColorBear, out colorBear))
                colorError = true;

            renkoPips = RenkoPips * Symbol.PipSize;
            thickness = Math.Pow(2, ZoomLevel) - (ZoomLevel > 0 ? 1 : 0);
            renkoLastValue = 0;
        }

        public override void Calculate(int index)
        {
            if (colorError)
            {
                ChartObjects.DrawText("Error0", "{o,o}\n/)_)\n \" \"\nOops! Incorrect colors.", StaticPosition.TopCenter, Colors.Gray);
                return;
            }

            if (renkoLastValue == 0)
            {
                var open = MarketSeries.Open.LastValue;

                renkoLastValue = open - (open % renkoPips) + renkoPips / 2;
            }

            closeLastValue = MarketSeries.Close.LastValue;

            while (closeLastValue >= renkoLastValue + renkoPips * 1.5)
            {
                renkoLastValue += renkoPips;
                renkos.Insert(0, new Brick 
                {
                    Open = renkoLastValue - renkoPips / 2,
                    Close = renkoLastValue + renkoPips / 2
                });
                if (renkos.Count() > BricksToShow)
                    renkos.RemoveRange(BricksToShow, renkos.Count() - BricksToShow);
                if (IsLastBar)
                    UpdateHistory(index);
            }
            while (closeLastValue <= renkoLastValue - renkoPips * 1.5)
            {
                renkoLastValue -= renkoPips;
                renkos.Insert(0, new Brick 
                {
                    Open = renkoLastValue + renkoPips / 2,
                    Close = renkoLastValue - renkoPips / 2
                });
                if (renkos.Count() > BricksToShow)
                    renkos.RemoveRange(BricksToShow, renkos.Count() - BricksToShow);
                if (IsLastBar)
                    UpdateHistory(index);
            }

            bool isNewBar = MarketSeries.Close.Count > lastCount;

            if (IsLastBar && isNewBar)
            {
                UpdateHistory(index);

                Open[index - BricksToShow] = double.NaN;
                High[index - BricksToShow] = double.NaN;
                Low[index - BricksToShow] = double.NaN;
                Close[index - BricksToShow] = double.NaN;

                lastCount = MarketSeries.Close.Count;
            }

            if (IsRealTime)
                UpdateLive(index);
        }

        private void UpdateHistory(int index)
        {
            for (int i = 0; i < BricksToShow - 1 && i < renkos.Count() - 1; i++)
            {
                var color = renkos[i].Open < renkos[i].Close ? colorBull : colorBear;

                ChartObjects.DrawLine(string.Format("renko.Last({0})", i + 1), index - i - 1, renkos[i].Open, index - i - 1, renkos[i].Close, color, thickness, LineStyle.Solid);

                Open[index - i - 1] = renkos[i].Open;
                High[index - i - 1] = Math.Max(renkos[i].Open, renkos[i].Close);
                Low[index - i - 1] = Math.Min(renkos[i].Open, renkos[i].Close);
                Close[index - i - 1] = renkos[i].Close;
            }
        }

        private void UpdateLive(int index)
        {
            double y1, y2;
            var top = Math.Max(renkos[0].Open, renkos[0].Close);
            var bottom = Math.Min(renkos[0].Open, renkos[0].Close);

            if (closeLastValue > top)
                y1 = top;
            else if (closeLastValue < bottom)
                y1 = bottom;
            else
                y1 = closeLastValue;

            y2 = closeLastValue;

            var colorLive = y1 < y2 ? colorBull : colorBear;

            ChartObjects.DrawLine("renko.Live", index, y1, index, y2, colorLive, thickness, LineStyle.Solid);

            Open[index] = y1;
            High[index] = y1 > y2 ? y1 : y2;
            Low[index] = y1 < y2 ? y1 : y2;
            Close[index] = y2;
        }
    }
}

mrhung.tvt

Joined on 10.01.2022

Distribution: Free
Language: C#
Trading platform: cTrader Automate
File name: Renko.algo
Rating: 0
Installs: 577
Modified: 11/12/2022 03:14

Download

Note that publishing copyrighted material is strictly prohibited. If you believe there is copyrighted material in this section, please use the Copyright Infringement Notification form to submit a claim.

Comments

No comments found.

Copyright © 2024 Spotware Systems Ltd. All rights reserved.
The services provided by Spotware Systems Ltd. are not available to citizens or residents of the USA. Neither is the information on our websites directed toward soliciting citizens or residents of the USA.