示例#1
0
        private bool isSwingHighTest(int bar)
        {
            double thisBarHigh      = Bars.GetHigh(bar);
            bool   nextHighBarLower = Bars.GetHigh(bar + 1) <= thisBarHigh;

            //Check enough previous bars
            if (!nextHighBarLower)
            {
                //	return false;
            }

            // check previous X bars higher than this bar's low
            double highestPreviousPeriod = Bars.GetLow(bar);
            int    previousBarIndex      = bar - 1;
            int    lastBarToCheckIndex   = bar - SwingPeriod;

            for (int i = previousBarIndex; i >= lastBarToCheckIndex; i--)
            {
                //	bool doubleTop = (i == previousBarIndex) && Bars.GetHigh(i).Equals(thisBarHigh);
                //	if (!doubleTop) {
                if (isInsideBar(i))
                {
                    lastBarToCheckIndex--;
                }
                else
                {
                    highestPreviousPeriod = Math.Max(highestPreviousPeriod, Bars.GetHigh(i));
                }
                //	}
            }

            return(thisBarHigh > highestPreviousPeriod);
        }
示例#2
0
        private bool isSwingLowTest(int bar)
        {
            double thisBarLow       = Bars.GetLow(bar);
            bool   nextLowBarHigher = Bars.GetLow(bar + 1) >= thisBarLow;

            //Check enough previous bars
            if (!nextLowBarHigher)
            {
                //	return false;
            }

            // check previous X bars higher than this bar's low
            double lowestPreviousPeriod = Bars.GetHigh(bar);
            int    previousBarIndex     = bar - 1;
            int    lastBarToCheckIndex  = bar - SwingPeriod;

            for (int i = previousBarIndex; i >= lastBarToCheckIndex; i--)
            {
                //bool doubleBottom = (i == previousBarIndex) && Bars.GetLow(i).Equals(thisBarLow);
                //if (!doubleBottom) {
                if (isInsideBar(i))
                {
                    lastBarToCheckIndex--;
                }
                else
                {
                    lowestPreviousPeriod = Math.Min(lowestPreviousPeriod, Bars.GetLow(i));
                }
                //	}
            }

            return(thisBarLow < lowestPreviousPeriod);
        }
示例#3
0
        public override void GetMinMaxValues(ChartControl chartControl, ref double min, ref double max)
        {
            if (Bars == null)
            {
                return;
            }
            int lastBar  = Math.Min(LastBarIndexPainted, Bars.Count - 1);
            int firstBar = FirstBarIndexPainted;

            min = Double.MaxValue;
            max = Double.MinValue;

            for (int indx = firstBar; indx <= lastBar; ++indx)
            {
                if ((indx <= CurrentBar) && (indx >= 1))
                {
                    min = Math.Min(min, Bars.GetLow(indx));
                    max = Math.Max(max, Bars.GetHigh(indx));
                }
            }

            if (max < 0)
            {
                return;
            }

            // extend the top by 1 tick, to make room for text
            max = max + quantizeFactor;
            min = min - quantizeFactor;
        }
示例#4
0
        /// <summary>
        /// Hold the indicator volume from the underlining indicator
        ///
        /// </summary>

        #region Methods
        public double GetPriceByType(int barNo, PriceSubtype priceType)
        {
            Print(CurrentBar + ":GetPriceByType=" + barNo + "," + priceType);
            double prc = 0;

            switch (priceType)
            {
            case PriceSubtype.Low:
                prc = Bars.GetLow(barNo);
                break;

            case PriceSubtype.High:
                prc = Bars.GetHigh(barNo);
                break;

            case PriceSubtype.Open:
                prc = Bars.GetOpen(barNo);
                break;

            case PriceSubtype.Close:
                prc = Bars.GetClose(barNo);
                break;
            }
            return(prc);
        }
        //#region plotstuff

        public override void GetMinMaxValues(ChartControl chartControl, ref double min, ref double max)
        {
            if (Bars == null)
            {
                return;
            }
            int lastBar  = Math.Min(LastBarIndexPainted, Bars.Count - 1);
            int firstBar = FirstBarIndexPainted;

            min = Double.MaxValue;
            max = Double.MinValue;

            var canht = ChartControl.CanvasBottom - ChartControl.CanvasTop;

            for (int indx = firstBar; indx <= lastBar; ++indx)
            {
                if ((indx <= CurrentBar) && (indx >= 1))
                {
                    min = Math.Min(min, Bars.GetLow(indx));
                    max = Math.Max(max, Bars.GetHigh(indx));
                }
            }

            chartedMin = min;             // store off the charted values
            chartedMax = max;

            if (max < 0)
            {
                return;
            }

            // extend the top by 1 tick, to make room for text
            max = max + TickSize;
        }
示例#6
0
        private bool isInsideBar(int barIndex)
        {
            int  previousBarIndex = barIndex - 1;
            bool withinHigh       = Bars.GetHigh(barIndex) <= Bars.GetHigh(previousBarIndex);
            bool withinLow        = Bars.GetLow(barIndex) >= Bars.GetLow(previousBarIndex);

            return(withinHigh && withinLow);
        }
示例#7
0
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            Bars    bars      = chartBars.Bars;
            float   lineWidth = (float)Math.Max(1, BarWidth);
            Vector2 point0    = new Vector2();
            Vector2 point1    = new Vector2();
            Vector2 point2    = new Vector2();
            Vector2 point3    = new Vector2();
            Vector2 point4    = new Vector2();
            Vector2 point5    = new Vector2();

            for (int idx = chartBars.FromIndex; idx <= chartBars.ToIndex; idx++)
            {
                SharpDX.Direct2D1.Brush overriddenBrush = chartControl.GetBarOverrideBrush(chartBars, idx);
                double closeValue = bars.GetClose(idx);
                float  close      = chartScale.GetYByValue(closeValue);
                float  high       = chartScale.GetYByValue(bars.GetHigh(idx));
                float  low        = chartScale.GetYByValue(bars.GetLow(idx));
                double openValue  = bars.GetOpen(idx);
                float  open       = chartScale.GetYByValue(openValue);
                float  x          = chartControl.GetXByBarIndex(chartBars, idx);

                point0.X = point1.X = x;
                point0.Y = high - lineWidth * 0.5f;
                point1.Y = low + lineWidth * 0.5f;

                SharpDX.Direct2D1.Brush b = overriddenBrush ?? (closeValue >= openValue ? UpBrushDX : DownBrushDX);

                if (!(b is SharpDX.Direct2D1.SolidColorBrush))
                {
                    TransformBrush(b, new RectangleF(point0.X - lineWidth * 1.5f, point0.Y, lineWidth * 3, point1.Y - point0.Y));
                }

                RenderTarget.DrawLine(point0, point1, b, lineWidth);

                if (!Equals(Mode, OhlcMode.HiLo))
                {
                    point2.X = x + lineWidth * 1.5f;
                    point2.Y = close;
                    point3.X = x;
                    point3.Y = close;

                    RenderTarget.DrawLine(point2, point3, b, lineWidth);

                    if (Equals(Mode, OhlcMode.OHLC))
                    {
                        point4.X = x - lineWidth * 1.5f;
                        point4.Y = open;
                        point5.X = x;
                        point5.Y = open;

                        RenderTarget.DrawLine(point4, point5, b, lineWidth);
                    }
                }
            }
        }
        //#region plotstuff

        public override void GetMinMaxValues(ChartControl chartControl, ref double min, ref double max)
        {
            if (Bars == null)
            {
                return;
            }
            int lastBar  = Math.Min(LastBarIndexPainted, Bars.Count - 1);
            int firstBar = FirstBarIndexPainted;

            min = Double.MaxValue;
            max = Double.MinValue;

            var canht = ChartControl.CanvasBottom - ChartControl.CanvasTop;

            for (int indx = firstBar; indx <= lastBar; ++indx)
            {
                if ((indx <= CurrentBar) && (indx >= 1))
                {
                    min = Math.Min(min, Bars.GetLow(indx));
                    max = Math.Max(max, Bars.GetHigh(indx));
                }
            }

            chartedMin = min;             // store off the charted values
            chartedMax = max;

            if (max < 0)
            {
                return;
            }

            // extend the top by 1 tick, to make room for text
            max = max + TickSize;

            if (displaytotals)
            {
                // extend the bottom by enough ticks to make a reasonable area for the
                // data zone...
                var cwidth  = Math.Min(18, Math.Max(ChartControl.BarSpace / 4.0, 2.0));
                var cheight = 5 * 1.25 * cwidth;             // assume 5:4 height/width in font, and we need 5 lines
                // derivation:
                //  we need cheight pix.   ticks_needed = pix_needed/pix per tick
                //  pix per tick ==  numpix / numticks, so
                //  x = pix_needed*(numticks+x)/numpix
                //  x*numpix = pix_needed *numticks + pix_needed*x
                //  x(numpix - pix_needed) = pix_needed*numticks
                //   x = pix_needed*numticks / (numpix - pix_needed)
                var denom = canht - cheight;
                if (denom == 0)
                {
                    denom = 1;
                }
                min = min - ((cheight * ((max - min) / TickSize)) / denom) * TickSize;
            }
        }
 protected override void OnBarUpdate()
 {
     //	smaFast = SMA(5);
     //  smaSlow = SMA(20);
     if (CurrentBar > 1)
     {
         if (Bars.GetHigh(CurrentBar) - Bars.GetHigh(CurrentBar - 1) < 0 && direction > 0)
         {
             max.Add(Bars.GetHigh(CurrentBar - 1));
             maxIndex.Add(CurrentBar - 1);
             upperLines.Clear();
             if (min.Count > 15)
             {
                 min.RemoveAt(0);
             }
             if (max.Count > 15)
             {
                 max.RemoveAt(0);
                 upperTrend();
             }
         }
         if (Bars.GetLow(CurrentBar) - Bars.GetLow(CurrentBar - 1) > 0 && direction < 0)
         {
             min.Add(Bars.GetLow(CurrentBar - 1));
             minIndex.Add(CurrentBar - 1);
         }
         direction = Bars.GetHigh(CurrentBar) - Bars.GetHigh(CurrentBar - 1);
         if (max.Count > 15)
         {
             max.RemoveAt(0);
             maxIndex.RemoveAt(0);
         }
         PrintTo = PrintTo.OutputTab1;
         Print(Bars.GetTime(CurrentBar - 1) + ": " + trendState());
         if (upperLines.Count > 0)
         {
             PrintTo = PrintTo.OutputTab2;
             Print(Bars.GetTime(CurrentBar) + ": " + upperLines[upperLines.Count - 1].slope + "  " + upperLines[upperLines.Count - 1].intercept + "  " + upperLines.Count + "  " + upperLines[upperLines.Count - 1].tipCount);
             upperTest = upperLines[upperLines.Count - 1].slope * (CurrentBar - upperLines[upperLines.Count - 1].index) + upperLines[upperLines.Count - 1].intercept;
             //	bottomTest = bottomSlope*(CurrentBar - bottomIndex) + bottomIntercept;
             if (Bars.GetClose(CurrentBar) > upperTest)
             {
                 // stopLoss = Math.Round((upperTest - bottomTest)/0.25);
                 //targetProfit = stopLoss*2;
                 SetProfitTarget(CalculationMode.Ticks, 4);
                 SetStopLoss(CalculationMode.Ticks, 4);
                 EnterLong(3);
                 upperLines.RemoveAt(upperLines.Count - 1);
             }
         }
     }
 }
示例#10
0
        private void plotSwings(Dictionary <int, string> reducedPivots, string prefix)
        {
            List <int> orderedMarkers = reducedPivots.Keys.ToList();

            orderedMarkers.Sort();

            int    objnum         = 0;
            int    previousMarker = 0;
            double previousValue  = 0;
            string previous       = "";

            foreach (int marker in orderedMarkers)
            {
                double value = 0;
                if (reducedPivots[marker].Equals(MIN_MAX) && previous.Equals(MIN))
                {
                    value = Bars.GetHigh(marker);
                }
                else if (reducedPivots[marker].Equals(MIN_MAX) && previous.Equals(MAX))
                {
                    value = Bars.GetLow(marker);
                }
                else if (reducedPivots[marker].Equals(MAX))
                {
                    value = Bars.GetHigh(marker);
                }
                else
                {
                    value = Bars.GetLow(marker);
                }

                if (objnum == 0)
                {
                    previousMarker = marker;
                    previousValue  = value;
                    objnum++;
                    continue;
                }
                DateTime startTimeValue = Bars.GetTime(previousMarker);
                DateTime endTimeValue   = Bars.GetTime(marker);
                Draw.Line(this, objnum.ToString() + prefix + "PivotLine", false, startTimeValue, previousValue, endTimeValue, value, Brushes.White,
                          DashStyleHelper.Dot, 1, true);

                objnum++;
                previousValue  = value;
                previousMarker = marker;
                previous       = reducedPivots[marker];
            }
        }
示例#11
0
 protected override void OnDataPoint(Bars bars, double open, double high, double low, double close, DateTime time, long volume, bool isBar, double bid, double ask)
 {
     if (bars.Count == 0)
     {
         AddBar(bars, open, high, low, close, TimeToBarTime(time, bars.BarsPeriod.Value), volume);
     }
     else if (time.Month <= bars.LastBarTime.Month && time.Year == bars.LastBarTime.Year || time.Year < bars.LastBarTime.Year)
     {
         if (high.ApproxCompare(bars.GetHigh(bars.Count - 1)) != 0 || low.ApproxCompare(bars.GetLow(bars.Count - 1)) != 0 || close.ApproxCompare(bars.GetClose(bars.Count - 1)) != 0 || volume > 0)
         {
             UpdateBar(bars, high, low, close, bars.LastBarTime, volume);
         }
     }
     else
     {
         AddBar(bars, open, high, low, close, TimeToBarTime(time, bars.BarsPeriod.Value), volume);
     }
 }
示例#12
0
        protected override void OnBarUpdate()
        {
            if (BarsInProgress != 0)
            {
                return;
            }

            double close = Close[0];
            double open  = Open[0];
            double max   = Bars.GetHigh(CurrentBar);
            double min   = Bars.GetLow(CurrentBar);
            double size  = Math.Abs(open - close);

            if (size >= BodySize && open >= min)
            {
                EnterLong();
            }
        }
示例#13
0
        private void UpdateHiLoPrice()
        {
            String strPrint = string.Format("StopEnBarIndex={0}", StopEnBarIndex);

            if (StopEnBarIndex >= 0)
            {
                int barsBack = CurrentBars[0] - StopEnBarIndex;
                strPrint = string.Format("Hi[{0}]={1} \r\nLo[{2}]={3}",
                                         barsBack, Bars.GetHigh(StopEnBarIndex), barsBack, Bars.GetLow(StopEnBarIndex));
            }

            //Draw.ArrowUp(this, "tag1", true, 0, Lows[0][0] - TickSize, Brushes.Red);
            //Draw.Diamond(this, "tag1", true, Bars.GetTime(StopEnBarIndex), Bars.GetLow(StopEnBarIndex) - TickSize, Brushes.Red);
            //Draw.Diamond(this, "tag1", true, 0, Low[0] - TickSize, Brushes.Red);
            //giChartTrader.SetStopPrice(Bars.GetLow(StopEnBarIndex).ToString());
            RemoveDrawObject(tagHiLoPriceTextField);
            Draw.TextFixed(this, tagHiLoPriceTextField, strPrint, TextPosition.BottomRight, Brushes.Blue,
                           new Gui.Tools.SimpleFont("Arial", 12), Brushes.Transparent, Brushes.Transparent, 100);
        }
示例#14
0
        void activateBearSwing(int firstIndex, int secondIndex, int thirdIndex)
        {
            //Take last 3

            //Check if bear swing
            double firstBarValue  = Bars.GetHigh(firstIndex);
            double secondBarValue = Bars.GetLow(secondIndex);
            double thirdBarValue  = Bars.GetHigh(thirdIndex);

            bool firstIsMoreThanThird = firstBarValue > thirdBarValue;

            if (!firstIsMoreThanThird)
            {
                return;
            }

            bool secondLower = secondBarValue < firstBarValue && secondBarValue < thirdBarValue;

            if (!secondLower)
            {
                return;
            }

            if (thirdIndex > lastPatternIndex)
            {
                observePattern   = OBSERVE_BEAR;
                observeTrigger   = secondBarValue;
                lastPatternIndex = thirdIndex;
                triggerStatus    = WAITING_FOR_TRIGGER;
                triggerRisk      = (thirdBarValue - secondBarValue) * 1.2;


                DateTime startTimeValue = Bars.GetTime(firstIndex);
                DateTime endTimeValue   = Bars.GetTime(secondIndex);
                Draw.Line(this, "ActiveSwing1", false, startTimeValue, firstBarValue, endTimeValue, secondBarValue, Brushes.Yellow,
                          DashStyleHelper.Solid, 2, true);
                startTimeValue = Bars.GetTime(secondIndex);
                endTimeValue   = Bars.GetTime(thirdIndex);
                Draw.Line(this, "ActiveSwing2", false, startTimeValue, secondBarValue, endTimeValue, thirdBarValue, Brushes.Yellow,
                          DashStyleHelper.Solid, 2, true);
            }
        }
示例#15
0
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            Bars       bars     = chartBars.Bars;
            float      barWidth = GetBarPaintWidth(BarWidthUI);
            Vector2    point0   = new Vector2();
            Vector2    point1   = new Vector2();
            RectangleF rect     = new RectangleF();

            for (int idx = chartBars.FromIndex; idx <= chartBars.ToIndex; idx++)
            {
                Brush  overriddenBarBrush     = chartControl.GetBarOverrideBrush(chartBars, idx);
                Brush  overriddenOutlineBrush = chartControl.GetCandleOutlineOverrideBrush(chartBars, idx);
                double closeValue             = bars.GetClose(idx);
                int    close     = chartScale.GetYByValue(closeValue);
                int    high      = chartScale.GetYByValue(bars.GetHigh(idx));
                int    low       = chartScale.GetYByValue(bars.GetLow(idx));
                double openValue = bars.GetOpen(idx);
                int    open      = chartScale.GetYByValue(openValue);
                int    x         = chartControl.GetXByBarIndex(chartBars, idx);

                if (Math.Abs(open - close) < 0.0000001)
                {
                    // Line
                    point0.X = x - barWidth * 0.5f;
                    point0.Y = close;
                    point1.X = x + barWidth * 0.5f;
                    point1.Y = close;
                    Brush b = overriddenOutlineBrush ?? Stroke.BrushDX;
                    if (!(b is SolidColorBrush))
                    {
                        TransformBrush(overriddenOutlineBrush ?? Stroke.BrushDX, new RectangleF(point0.X, point0.Y - Stroke.Width, barWidth, Stroke.Width));
                    }
                    RenderTarget.DrawLine(point0, point1, b, Stroke.Width, Stroke.StrokeStyle);
                }
                else
                {
                    // Candle
                    rect.X      = x - barWidth * 0.5f + 0.5f;
                    rect.Y      = Math.Min(close, open);
                    rect.Width  = barWidth - 1;
                    rect.Height = Math.Max(open, close) - Math.Min(close, open);
                    Brush brush = overriddenBarBrush ?? (closeValue >= openValue ? UpBrushDX : DownBrushDX);
                    if (!(brush is SolidColorBrush))
                    {
                        TransformBrush(brush, rect);
                    }
                    RenderTarget.FillRectangle(rect, brush);
                    brush = overriddenOutlineBrush ?? Stroke.BrushDX;
                    if (!(brush is SolidColorBrush))
                    {
                        TransformBrush(brush, rect);
                    }
                    RenderTarget.DrawRectangle(rect, overriddenOutlineBrush ?? Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                }

                Brush br = overriddenOutlineBrush ?? Stroke2.BrushDX;

                // High wick
                if (high < Math.Min(open, close))
                {
                    point0.X = x;
                    point0.Y = high;
                    point1.X = x;
                    point1.Y = Math.Min(open, close);
                    if (!(br is SolidColorBrush))
                    {
                        TransformBrush(br, new RectangleF(point0.X - Stroke2.Width, point0.Y, Stroke2.Width, point1.Y - point0.Y));
                    }
                    RenderTarget.DrawLine(point0, point1, br, Stroke2.Width, Stroke2.StrokeStyle);
                }

                // Low wick
                if (low > Math.Max(open, close))
                {
                    point0.X = x;
                    point0.Y = low;
                    point1.X = x;
                    point1.Y = Math.Max(open, close);
                    if (!(br is SolidColorBrush))
                    {
                        TransformBrush(br, new RectangleF(point1.X - Stroke2.Width, point1.Y, Stroke2.Width, point0.Y - point1.Y));
                    }
                    RenderTarget.DrawLine(point0, point1, br, Stroke2.Width, Stroke2.StrokeStyle);
                }
            }
        }
        protected override void OnDataPoint(Bars bars, double open, double high, double low, double close, DateTime time, long volume, bool isBar, double bid, double ask)
        {
            if (SessionIterator == null)
            {
                SessionIterator = new SessionIterator(bars);
            }
            bool isNewSession = SessionIterator.IsNewSession(time, isBar);

            if (isNewSession)
            {
                SessionIterator.GetNextSession(time, isBar);
            }

            #region Building Bars from Base Period

            if (bars.Count != tmpCount)             // Reset cache when bars are trimmed
            {
                if (bars.Count == 0)
                {
                    tmpTime      = Core.Globals.MinDate;
                    tmpVolume    = 0;
                    tmpDayCount  = 0;
                    tmpTickCount = 0;
                }
                else
                {
                    tmpTime        = bars.GetTime(bars.Count - 1);
                    tmpVolume      = bars.GetVolume(bars.Count - 1);
                    tmpTickCount   = bars.TickCount;
                    tmpDayCount    = bars.DayCount;
                    bars.LastPrice = anchorPrice = bars.GetClose(bars.Count - 1);
                }
            }

            switch (BarsPeriod.BaseBarsPeriodType)
            {
            case BarsPeriodType.Day:
                tmpTime = time.Date;
                if (!isBar)
                {
                    tmpDayCount++;
                    if (tmpTime < time.Date)
                    {
                        tmpTime = time.Date;                                                  // Make sure timestamps are ascending
                    }
                }

                if (isBar && prevTimeD != tmpTime)
                {
                    tmpDayCount++;
                }

                if (isBar && bars.Count > 0 && tmpTime == bars.LastBarTime.Date ||
                    !isBar && bars.Count > 0 && tmpTime <= bars.LastBarTime.Date ||
                    tmpDayCount < BarsPeriod.BaseBarsPeriodValue)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime  = prevTimeD == Core.Globals.MinDate ? tmpTime : prevTimeD;
                    prevTimeD = tmpTime;
                    endOfBar  = true;
                }

                break;

            case BarsPeriodType.Minute:
                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeMinute(bars, time, isBar);
                }

                if (isBar && time <= tmpTime || !isBar && time < tmpTime)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    tmpTime  = TimeToBarTimeMinute(bars, time, isBar);
                    endOfBar = true;
                }
                break;

            case BarsPeriodType.Volume:
                if (tmpTime == Core.Globals.MinDate)
                {
                    tmpVolume = volume;
                    endOfBar  = tmpVolume >= BarsPeriod.BaseBarsPeriodValue;
                    prevTime  = tmpTime = time;
                    if (endOfBar)
                    {
                        tmpVolume = 0;
                    }
                    break;
                }

                tmpVolume += volume;
                endOfBar   = tmpVolume >= BarsPeriod.BaseBarsPeriodValue;
                if (endOfBar)
                {
                    prevTime  = tmpTime;
                    tmpVolume = 0;
                    tmpTime   = time;
                }
                break;

            case BarsPeriodType.Month:
                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeMonth(time, BarsPeriod.BaseBarsPeriodValue);
                }

                if (time.Month <= tmpTime.Month && time.Year == tmpTime.Year || time.Year < tmpTime.Year)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    endOfBar = true;
                    tmpTime  = TimeToBarTimeMonth(time, BarsPeriod.BaseBarsPeriodValue);
                }
                break;

            case BarsPeriodType.Second:
                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeSecond(bars, time, isBar);
                }
                if (time <= tmpTime)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    tmpTime  = TimeToBarTimeSecond(bars, time, isBar);
                    endOfBar = true;
                }
                break;

            case BarsPeriodType.Tick:
                if (tmpTime == Core.Globals.MinDate || BarsPeriod.BaseBarsPeriodValue == 1)
                {
                    prevTime = tmpTime;
                    if (prevTime == Core.Globals.MinDate)
                    {
                        prevTime = time;
                    }
                    tmpTime  = time;
                    endOfBar = BarsPeriod.BaseBarsPeriodValue == 1;
                    break;
                }

                if (tmpTickCount < BarsPeriod.BaseBarsPeriodValue)
                {
                    tmpTime  = time;
                    endOfBar = false;
                    tmpTickCount++;
                }
                else
                {
                    prevTime     = tmpTime;
                    tmpTime      = time;
                    endOfBar     = true;
                    tmpTickCount = 1;
                }
                break;

            case BarsPeriodType.Week:
                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeWeek(time.Date, tmpTime.Date, BarsPeriod.BaseBarsPeriodValue);
                }
                if (time.Date <= tmpTime.Date)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    endOfBar = true;
                    tmpTime  = TimeToBarTimeWeek(time.Date, tmpTime.Date, BarsPeriod.BaseBarsPeriodValue);
                }
                break;

            case BarsPeriodType.Year:
                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeYear(time, BarsPeriod.BaseBarsPeriodValue);
                }
                if (time.Year <= tmpTime.Year)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    endOfBar = true;
                    tmpTime  = TimeToBarTimeYear(time, BarsPeriod.BaseBarsPeriodValue);
                }
                break;
            }
            #endregion
            #region P&F logic
            double tickSize = bars.Instrument.MasterInstrument.TickSize;
            boxSize      = Math.Floor(10000000.0 * BarsPeriod.Value * tickSize) / 10000000.0;
            reversalSize = BarsPeriod.Value2 * boxSize;

            if (bars.Count == 0 || IsIntraday && bars.IsResetOnNewTradingDay && isNewSession)
            {
                if (bars.Count > 0)
                {
                    double   lastHigh  = bars.GetHigh(bars.Count - 1);
                    double   lastLow   = bars.GetLow(bars.Count - 1);
                    double   lastClose = bars.GetClose(bars.Count - 1);
                    DateTime lastTime  = bars.GetTime(bars.Count - 1);
                    bars.LastPrice = anchorPrice = lastClose;

                    if (bars.Count == tmpCount)
                    {
                        CalculatePfBar(bars, lastHigh, lastLow, lastClose, prevTime == Core.Globals.MinDate ? time : prevTime, lastTime);
                    }
                }

                AddBar(bars, close, close, close, close, tmpTime, volume);

                anchorPrice    = close;
                trend          = Trend.Undetermined;
                prevTime       = tmpTime;
                volumeCount    = 0;
                bars.LastPrice = close;
                tmpCount       = bars.Count;
                tmpHigh        = high;
                tmpLow         = low;
                return;
            }

            double   c = bars.GetClose(bars.Count - 1);
            double   h = bars.GetHigh(bars.Count - 1);
            double   l = bars.GetLow(bars.Count - 1);
            DateTime t = bars.GetTime(bars.Count - 1);

            if (endOfBar)
            {
                CalculatePfBar(bars, h, l, c, prevTime, t);
                volumeCount = volume;
                tmpHigh     = high;
                tmpLow      = low;
            }
            else
            {
                tmpHigh      = high > tmpHigh ? high : tmpHigh;
                tmpLow       = low < tmpLow ? low : tmpLow;
                volumeCount += volume;
            }

            bars.LastPrice = close;
            tmpCount       = bars.Count;
            #endregion
        }
示例#17
0
        private void bearSwing(Dictionary <int, string> reducedPivots, string prefix)
        {
            List <int> orderedMarkers = reducedPivots.Keys.ToList();

            orderedMarkers.Sort();
            int objnum = 0;

            for (int markerIndex = 0; markerIndex < (orderedMarkers.Count() - 4); markerIndex++)
            {
                int firstIndex  = markerIndex;
                int secondIndex = markerIndex + 1;
                int thirdIndex  = markerIndex + 2;
                int fourthIndex = markerIndex + 3;

                int firstBarIndex  = orderedMarkers[firstIndex];
                int secondBarIndex = orderedMarkers[secondIndex];
                int thirdBarIndex  = orderedMarkers[thirdIndex];
                int fourthBarIndex = orderedMarkers[fourthIndex];

                bool firstValueIsMax = reducedPivots[firstBarIndex].Equals(MAX);

                if (!firstValueIsMax)
                {
                    continue;
                }

                double firstBarValue  = Bars.GetHigh(firstBarIndex);
                double secondBarValue = Bars.GetLow(secondBarIndex);
                double thirdBarValue  = Bars.GetHigh(thirdBarIndex);
                double fourthBarValue = Bars.GetLow(fourthBarIndex);

                bool firstIsMoreThanThird = firstBarValue > thirdBarValue;

                if (!firstIsMoreThanThird)
                {
                    continue;
                }

                bool secondLower = secondBarValue < firstBarValue && secondBarValue < thirdBarValue;

                if (!secondLower)
                {
                    continue;
                }

                bool isSecondTriggered = false;

                for (int i = thirdBarIndex; i < fourthBarIndex; i++)
                {
                    if (Bars.GetLow(i) < secondBarValue)
                    {
                        isSecondTriggered = true;
                    }
                }

                if (isSecondTriggered)
                {
                    DateTime startTimeValue = Bars.GetTime(firstBarIndex);
                    DateTime endTimeValue   = Bars.GetTime(secondBarIndex);
                    Draw.Line(this, objnum.ToString() + prefix + "Bear", false, startTimeValue, firstBarValue, endTimeValue, secondBarValue, Brushes.Purple,
                              DashStyleHelper.Solid, 2, true);
                    objnum++;
                    startTimeValue = Bars.GetTime(secondBarIndex);
                    endTimeValue   = Bars.GetTime(thirdBarIndex);
                    Draw.Line(this, objnum.ToString() + prefix + "Bear", false, startTimeValue, secondBarValue, endTimeValue, thirdBarValue, Brushes.Purple,
                              DashStyleHelper.Solid, 2, true);
                    objnum++;
                }
            }
        }
示例#18
0
        protected override void OnDataPoint(Bars bars, double open, double high, double low, double close, DateTime time, long volume, bool isBar, double bid, double ask)
        {
            if (SessionIterator == null)
            {
                SessionIterator = new SessionIterator(bars);
            }

            double haClose = 0.0;
            double haHigh  = 0.0;
            double haLow   = 0.0;
            double haOpen  = 0.0;

            switch (BarsPeriod.BaseBarsPeriodType)
            {
            case BarsPeriodType.Day:
            {
                if (bars.Count == 0)
                {
                    if (isBar || bars.TradingHours.Sessions.Count == 0)
                    {
                        AddBar(bars, open, high, low, close, time.Date, volume);
                    }
                    else
                    {
                        SessionIterator.CalculateTradingDay(time, false);
                        AddBar(bars, open, high, low, close, SessionIterator.ActualTradingDayExchange, volume);
                    }
                }
                else
                {
                    DateTime barTime;
                    if (isBar)
                    {
                        barTime = time.Date;
                    }
                    else
                    {
                        if (bars.TradingHours.Sessions.Count > 0 && SessionIterator.IsNewSession(time, false))
                        {
                            SessionIterator.CalculateTradingDay(time, false);
                            barTime = SessionIterator.ActualTradingDayExchange;
                            if (barTime < bars.LastBarTime.Date)
                            {
                                barTime = bars.LastBarTime.Date;                                                 // Make sure timestamps are ascending
                            }
                        }
                        else
                        {
                            barTime = bars.LastBarTime.Date;                                             // Make sure timestamps are ascending
                        }
                    }

                    if (bars.DayCount < bars.BarsPeriod.BaseBarsPeriodValue ||
                        isBar && bars.Count > 0 && barTime == bars.LastBarTime.Date ||
                        !isBar && bars.Count > 0 && barTime <= bars.LastBarTime.Date)
                    {
                        haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, bars.GetOpen(bars.Count - 1)));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, bars.GetOpen(bars.Count - 1)));
                        UpdateBar(bars, haHigh, haLow, haClose, barTime, volume);
                    }
                    else
                    {
                        haOpen  = bars.Instrument.MasterInstrument.RoundToTickSize((bars.GetOpen(bars.Count - 1) + bars.GetClose(bars.Count - 1)) / 2.0);
                        haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                        AddBar(bars, haOpen, haHigh, haLow, haClose, barTime, volume);
                    }
                }

                break;
            }

            case BarsPeriodType.Minute:
            {
                if (bars.Count == 0)
                {
                    AddBar(bars, open, high, low, close, TimeToBarTimeMinute(bars, time, isBar), volume);
                }
                else if (!isBar && time < bars.LastBarTime)
                {
                    haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                    haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, bars.GetOpen(bars.Count - 1)));
                    haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, bars.GetOpen(bars.Count - 1)));
                    UpdateBar(bars, haHigh, haLow, haClose, bars.LastBarTime, volume);
                }
                else if (isBar && time <= bars.LastBarTime)
                {
                    haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                    haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, bars.GetOpen(bars.Count - 1)));
                    haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, bars.GetOpen(bars.Count - 1)));
                    UpdateBar(bars, haHigh, haLow, haClose, bars.LastBarTime, volume);
                }
                else
                {
                    haOpen  = bars.Instrument.MasterInstrument.RoundToTickSize((bars.GetOpen(bars.Count - 1) + bars.GetClose(bars.Count - 1)) / 2.0);
                    haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                    haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                    haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                    time    = TimeToBarTimeMinute(bars, time, isBar);
                    AddBar(bars, haOpen, haHigh, haLow, haClose, time, volume);
                }

                break;
            }

            case BarsPeriodType.Month:
            {
                if (bars.Count == 0)
                {
                    AddBar(bars, open, high, low, close, TimeToBarTimeMonth(time, bars.BarsPeriod.BaseBarsPeriodValue), volume);
                }
                else if (time.Month <= bars.LastBarTime.Month && time.Year == bars.LastBarTime.Year || time.Year < bars.LastBarTime.Year)
                {
                    if (high.ApproxCompare(bars.GetHigh(bars.Count - 1)) != 0 || low.ApproxCompare(bars.GetLow(bars.Count - 1)) != 0 || close.ApproxCompare(bars.GetClose(bars.Count - 1)) != 0 || volume > 0)
                    {
                        haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, bars.GetOpen(bars.Count - 1)));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, bars.GetOpen(bars.Count - 1)));
                        UpdateBar(bars, haHigh, haLow, haClose, bars.LastBarTime, volume);
                    }
                }
                else
                {
                    haOpen  = bars.Instrument.MasterInstrument.RoundToTickSize((bars.GetOpen(bars.Count - 1) + bars.GetClose(bars.Count - 1)) / 2.0);
                    haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                    haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                    haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                    AddBar(bars, haOpen, haHigh, haLow, haClose, TimeToBarTimeMonth(time, bars.BarsPeriod.BaseBarsPeriodValue), volume);
                }
                break;
            }

            case BarsPeriodType.Second:
            {
                if (bars.Count == 0)
                {
                    DateTime barTime = TimeToBarTimeSecond(bars, time, isBar);
                    AddBar(bars, open, high, low, close, barTime, volume);
                }
                else
                {
                    if (bars.BarsPeriod.BaseBarsPeriodValue > 1 && time < bars.LastBarTime || bars.BarsPeriod.BaseBarsPeriodValue == 1 && time <= bars.LastBarTime)
                    {
                        haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, bars.GetOpen(bars.Count - 1)));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, bars.GetOpen(bars.Count - 1)));
                        UpdateBar(bars, haHigh, haLow, haClose, bars.LastBarTime, volume);
                    }
                    else
                    {
                        haOpen  = bars.Instrument.MasterInstrument.RoundToTickSize((bars.GetOpen(bars.Count - 1) + bars.GetClose(bars.Count - 1)) / 2.0);
                        haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                        time    = TimeToBarTimeSecond(bars, time, isBar);
                        AddBar(bars, haOpen, haHigh, haLow, haClose, time, volume);
                    }
                }
                break;
            }

            case BarsPeriodType.Tick:
            {
                bool isNewSession = SessionIterator.IsNewSession(time, isBar);
                if (isNewSession)
                {
                    SessionIterator.GetNextSession(time, isBar);
                }

                if (bars.BarsPeriod.BaseBarsPeriodValue == 1)
                {
                    haOpen  = haOpen.ApproxCompare(0.0) == 0 ? open : (haOpen + haClose) / 2.0;
                    haClose = haClose.ApproxCompare(0.0) == 0 ? close : bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                    haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                    haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                    AddBar(bars, haOpen, haHigh, haLow, haClose, time, volume);
                }
                else if (bars.Count == 0)
                {
                    AddBar(bars, open, high, low, close, time, volume);
                }
                else if (bars.Count > 0 && (!isNewSession || !bars.IsResetOnNewTradingDay) && bars.BarsPeriod.BaseBarsPeriodValue > 1 && bars.TickCount < bars.BarsPeriod.BaseBarsPeriodValue)
                {
                    haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                    haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, bars.GetOpen(bars.Count - 1)));
                    haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, bars.GetOpen(bars.Count - 1)));
                    UpdateBar(bars, haHigh, haLow, haClose, time, volume);
                }
                else
                {
                    haOpen  = bars.Instrument.MasterInstrument.RoundToTickSize((bars.GetOpen(bars.Count - 1) + bars.GetClose(bars.Count - 1)) / 2.0);
                    haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                    haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                    haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                    AddBar(bars, haOpen, haHigh, haLow, haClose, time, volume);
                }
                break;
            }

            case BarsPeriodType.Volume:
            {
                if (bars.Count == 0)
                {
                    while (volume > bars.BarsPeriod.BaseBarsPeriodValue)
                    {
                        haOpen  = haOpen.ApproxCompare(0.0) == 0 ? open : (haOpen + haClose) / 2.0;
                        haClose = haClose.ApproxCompare(0) == 0 ? close : bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                        AddBar(bars, haOpen, haHigh, haLow, haClose, time, bars.BarsPeriod.BaseBarsPeriodValue);
                        volume -= bars.BarsPeriod.BaseBarsPeriodValue;
                    }
                    if (volume > 0)
                    {
                        haOpen  = haOpen.ApproxCompare(0.0) == 0 ? open : bars.Instrument.MasterInstrument.RoundToTickSize((haOpen + haClose) / 2.0);
                        haClose = haClose.ApproxCompare(0.0) == 0 ? close : bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                        AddBar(bars, haOpen, haHigh, haLow, haClose, time, volume);
                    }
                }
                else
                {
                    long volumeTmp    = 0;
                    bool isNewSession = SessionIterator.IsNewSession(time, isBar);
                    if (!bars.IsResetOnNewTradingDay || !isNewSession)
                    {
                        volumeTmp = Math.Min(bars.BarsPeriod.BaseBarsPeriodValue - bars.GetVolume(bars.Count - 1), volume);
                        if (volumeTmp > 0)
                        {
                            haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                            haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, bars.GetOpen(bars.Count - 1)));
                            haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, bars.GetOpen(bars.Count - 1)));
                            UpdateBar(bars, haHigh, haLow, haClose, time, volumeTmp);
                        }
                    }

                    if (isNewSession)
                    {
                        SessionIterator.GetNextSession(time, isBar);
                    }

                    volumeTmp = volume - volumeTmp;
                    while (volumeTmp > 0)
                    {
                        haOpen  = bars.Instrument.MasterInstrument.RoundToTickSize((bars.GetOpen(bars.Count - 1) + bars.GetClose(bars.Count - 1)) / 2.0);
                        haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                        AddBar(bars, haOpen, haHigh, haLow, haClose, time, Math.Min(volumeTmp, bars.BarsPeriod.BaseBarsPeriodValue));
                        volumeTmp -= bars.BarsPeriod.BaseBarsPeriodValue;
                    }
                }

                break;
            }

            case BarsPeriodType.Week:
            {
                if (bars.Count == 0)
                {
                    AddBar(bars, open, high, low, close, TimeToBarTimeWeek(time, time.AddDays(6 - ((int)time.DayOfWeek + 1) % 7 + (bars.BarsPeriod.BaseBarsPeriodValue - 1) * 7), bars.BarsPeriod.BaseBarsPeriodValue), volume);
                }
                else if (time.Date <= bars.LastBarTime.Date)
                {
                    haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                    haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, bars.GetOpen(bars.Count - 1)));
                    haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, bars.GetOpen(bars.Count - 1)));
                    UpdateBar(bars, haHigh, haLow, haClose, bars.LastBarTime, volume);
                }
                else
                {
                    haOpen  = bars.Instrument.MasterInstrument.RoundToTickSize((bars.GetOpen(bars.Count - 1) + bars.GetClose(bars.Count - 1)) / 2.0);
                    haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                    haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                    haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                    AddBar(bars, haOpen, haHigh, haLow, haClose, TimeToBarTimeWeek(time.Date, bars.LastBarTime.Date, bars.BarsPeriod.BaseBarsPeriodValue), volume);
                }

                break;
            }

            case BarsPeriodType.Year:
            {
                if (bars.Count == 0)
                {
                    AddBar(bars, open, high, low, close, TimeToBarTimeYear(time, bars.BarsPeriod.BaseBarsPeriodValue), volume);
                }
                else
                {
                    if (time.Year <= bars.LastBarTime.Year)
                    {
                        haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, bars.GetOpen(bars.Count - 1)));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, bars.GetOpen(bars.Count - 1)));
                        UpdateBar(bars, haHigh, haLow, haClose, bars.LastBarTime, volume);
                    }
                    else
                    {
                        haOpen  = bars.Instrument.MasterInstrument.RoundToTickSize((bars.GetOpen(bars.Count - 1) + bars.GetClose(bars.Count - 1)) / 2.0);
                        haClose = bars.Instrument.MasterInstrument.RoundToTickSize((open + high + low + close) / 4.0);
                        haHigh  = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Max(high, haOpen));
                        haLow   = bars.Instrument.MasterInstrument.RoundToTickSize(Math.Min(low, haOpen));
                        AddBar(bars, haOpen, haHigh, haLow, haClose, TimeToBarTimeYear(time.Date, bars.BarsPeriod.BaseBarsPeriodValue), volume);
                    }
                }

                break;
            }
            }

            bars.LastPrice = haClose;
        }
示例#19
0
        protected override void OnBarUpdate()
        {
            /* When working with multiple bar series objects it is important to understand the sequential order in which the
             * OnBarUpdate() method is triggered. The bars will always run with the primary first followed by the secondary and
             * so on.
             *
             * Important: Primary bars will always execute before the secondary bar series.
             * If a bar is timestamped as 12:00PM on the 5min bar series, the call order between the equally timestamped 12:00PM
             * bar on the 1min bar series is like this:
             *  12:00PM 5min
             *  12:00PM 1min
             *  12:01PM 1min
             *  12:02PM 1min
             *  12:03PM 1min
             *  12:04PM 1min
             *  12:05PM 5min
             *  12:05PM 1min
             *
             * When the OnBarUpdate() is called from the primary bar series (2000 ticks series in this example), do the following */
            if (BarsInProgress == 0)
            {
                if (CurrentBar < BarsRequiredToTrade)
                {
                    return;
                }

                //Print("Current Bar time=" + Bars.GetTime(CurrentBar).ToString("HHmmss"));

                // if the bar elapsed time span across 12 mid night
                DateTime t1 = Bars.GetTime(CurrentBar - 1);
                DateTime t2 = Bars.GetTime(CurrentBar);
                if (TimeSpan.Compare(t1.TimeOfDay, t2.TimeOfDay) > 0)
                {
                    Print("EOD Session");
                    HandleEOD();

                    string resetString = "-1";
                    byte[] resetMsg    = Encoding.UTF8.GetBytes(resetString);

                    // Send reset string of "-1" to the server
                    int resetSent = sender.Send(resetMsg);
                    lineNo = 0;

                    //reset global flags
                    currPos             = Position.posFlat;
                    profitChasingFlag   = false;
                    stopLossEncountered = false;
                    return;
                }

                // prior Stop-Loss observed, construct the lineNo with special code before sending msg to the server - so that the server will flatten the position
                if (stopLossEncountered)
                {
                    lineNo += 10000;
                }

                // construct the string buffer to be sent to DLNN
                string bufString = lineNo.ToString() + ',' +
                                   Bars.GetTime(CurrentBar - 1).ToString("HHmmss") + ',' + Bars.GetTime(CurrentBar).ToString("HHmmss") + ',' +
                                   Bars.GetOpen(CurrentBar).ToString() + ',' + Bars.GetClose(CurrentBar).ToString() + ',' +
                                   Bars.GetHigh(CurrentBar).ToString() + ',' + Bars.GetLow(CurrentBar).ToString() + ',' +
                                   Bars.GetVolume(CurrentBar).ToString() + ',' +
                                   SMA(9)[0].ToString() + ',' + SMA(20)[0].ToString() + ',' + SMA(50)[0].ToString() + ',' +
                                   MACD(12, 26, 9).Diff[0].ToString() + ',' + RSI(14, 3)[0].ToString() + ',' +
                                   Bollinger(2, 20).Lower[0].ToString() + ',' + Bollinger(2, 20).Upper[0].ToString() + ',' +
                                   CCI(20)[0].ToString() + ',' +
                                   Bars.GetHigh(CurrentBar).ToString() + ',' + Bars.GetLow(CurrentBar).ToString() + ',' +
                                   Momentum(20)[0].ToString() + ',' +
                                   DM(14).DiPlus[0].ToString() + ',' + DM(14).DiMinus[0].ToString() + ',' +
                                   VROC(25, 3)[0].ToString() + ',' +
                                   '0' + ',' + '0' + ',' + '0' + ',' + '0' + ',' + '0' + ',' +
                                   '0' + ',' + '0' + ',' + '0' + ',' + '0' + ',' + '0';

                //Print("CurrentBar = " + CurrentBar + ": " + "bufString = " + bufString);

                byte[] msg = Encoding.UTF8.GetBytes(bufString);

                // Send the data through the socket.
                int bytesSent = sender.Send(msg);

                // Receive the response from the remote device.
                int bytesRec = sender.Receive(bytes);

                // prior Stop-Loss observed, hence ignore the returned signal from server and move on to the next bar, reset lineNo to next counter and reset stopLossEncountered flag
                if (stopLossEncountered)
                {
                    lineNo -= 10000;
                    lineNo++;
                    stopLossEncountered = false;

                    //svrSignal = ExtractResponse(System.Text.Encoding.UTF8.GetString(bytes, 0, bytes.Length));
                    svrSignal = System.Text.Encoding.UTF8.GetString(bytes, 0, bytes.Length).Split(',')[1];
                    Print(Bars.GetTime(CurrentBar).ToString("yyyy-MM-ddTHH:mm:ss.ffffffK") + " Ignore Post STOP-LOSS Server response= <" + svrSignal + "> Current Bar: Open=" + Bars.GetOpen(CurrentBar) + " Close=" + Bars.GetClose(CurrentBar) + " High=" + Bars.GetHigh(CurrentBar) + " Low=" + Bars.GetLow(CurrentBar));

                    return;
                }

                //svrSignal = ExtractResponse(System.Text.Encoding.UTF8.GetString(bytes, 0, bytes.Length));
                svrSignal = System.Text.Encoding.UTF8.GetString(bytes, 0, bytes.Length).Split(',')[1];
                Print(Bars.GetTime(CurrentBar).ToString("yyyy-MM-ddTHH:mm:ss.ffffffK") + " Server response= <" + svrSignal + "> Current Bar: Open=" + Bars.GetOpen(CurrentBar) + " Close=" + Bars.GetClose(CurrentBar) + " High=" + Bars.GetHigh(CurrentBar) + " Low=" + Bars.GetLow(CurrentBar));
                //Print(Bars.GetTime(CurrentBar).ToString("yyyy-MM-ddTHH:mm:ss.ffffffK") + " Server response= <" + svrSignal + ">");

                // Return signal from DLNN is not we expected, close outstanding position and restart
                if (bytesRec == -1)
                {
                    lineNo = 0;
                    // TODO: close current position?
                }
                else
                {
                    lineNo++;
                }

                // Start processing signal after 8th signal and beyond, otherwise ignore
                if (lineNo >= 8)
                {
                    ExecuteAITrade(svrSignal);

                    // if position is flat, no need to do anything
                    if (currPos == Position.posFlat)
                    {
                        return;
                    }

                    // handle stop loss or profit chasing if there is existing position and order action is either SellShort or Buy
                    if (entryOrder != null && (entryOrder.OrderAction == OrderAction.Buy || entryOrder.OrderAction == OrderAction.SellShort) && (entryOrder.OrderState == OrderState.Filled || entryOrder.OrderState == OrderState.PartFilled))
                    {
                        // if Close[0] violates soft deck, if YES handle stop loss accordingly
                        if (ViolateSoftDeck())
                        {
                            HandleSoftDeck(svrSignal);
                        }

                        // if profitChasingFlag is TRUE or TouchedProfitChasing then handle profit chasing
                        if ((profitChasingFlag || TouchedProfitChasing()))
                        {
                            HandleProfitChasing();
                        }
                    }
                }
            }
            // When the OnBarUpdate() is called from the secondary bar series, in our case for each tick, handle stop loss and profit chasing accordingly
            else
            {
                return;
            }
        }
        protected override void OnCalculate()
        {
            string strReversalTradeLong  = "ReversalTradeLong" + ProcessingBarIndex;
            string strReversalTradeShort = "ReversalTradeShort" + ProcessingBarIndex;
            string strTradeResultLong;
            string strTradeResultShort;
            Color  colorTextBox;

            // 1 umkehr fallend auf steigend
            //-1 umkehr steigend auf fallend

            if (IsReversalLongTrade() == true)
            {
                ReversalTradeStartTSLong = Bars[0].Time;
                //TargetBarTime = GetTargetBar(Bars[0].Time);
                TargetBarTime = GlobalUtilities.GetTargetBar(Bars, Bars[0].Time, TimeFrame, 1);
                OutSeries.Set(100);
                Reversal2NextBar.Set(100);
            }
            else if (IsReversalShortTrade() == true)
            {
                ReversalTradeStartTSShort = Bars[0].Time;
                //TargetBarTime = GetTargetBar(Bars[0].Time);
                TargetBarTime = GlobalUtilities.GetTargetBar(Bars, Bars[0].Time, TimeFrame, 1);
                OutSeries.Set(-100);
            }
            else
            {
                Reversal2NextBar.Set(0);
            }

            //TradingKerze ist fertig, Zeiteinheit ist abgelaufen
            if (Bars[0].Time == TargetBarTime)
            {
                ReversalTradeResult = (decimal)Bars.GetClose(ProcessingBarIndex) - (decimal)Bars.GetOpen(ProcessingBarIndex);
                TradeCounter       += 1;

                if (ReversalTradeStartTSLong > DateTime.MinValue)
                {
                    ReversalTradeResultTotalLong = ReversalTradeResultTotalLong + ReversalTradeResult;
                    if (ReversalTradeResult < 0)
                    {
                        strTradeResultLong    = "Fail " + ReversalTradeResult.ToString();
                        colorTextBox          = colFail;
                        TradeCounterLongFail += 1;
                    }
                    else
                    {
                        strTradeResultLong   = "Win " + ReversalTradeResult.ToString();
                        colorTextBox         = colWin;
                        TradeCounterLongWin += 1;
                    }
                    AddChartText(strReversalTradeLong, true, strTradeResultLong, Time[1], Bars.GetHigh(ProcessingBarIndex) + (100 * TickSize), 9, Color.Black, new Font("Arial", 9), StringAlignment.Center, Color.Black, colorTextBox, 70);
                }
                else if (ReversalTradeStartTSShort > DateTime.MinValue)
                {
                    ReversalTradeResultTotalShort = ReversalTradeResultTotalShort + ReversalTradeResult;
                    if (ReversalTradeResult < 0)
                    {
                        strTradeResultShort   = "Win " + ReversalTradeResult.ToString();
                        colorTextBox          = colWin;
                        TradeCounterShortWin += 1;
                    }
                    else
                    {
                        strTradeResultShort    = "Fail " + ReversalTradeResult.ToString();
                        colorTextBox           = colFail;
                        TradeCounterShortFail += 1;
                    }
                    AddChartText(strReversalTradeShort, true, strTradeResultShort, Time[1], Bars.GetHigh(ProcessingBarIndex) - (100 * TickSize), 9, Color.Black, new Font("Arial", 9), StringAlignment.Center, Color.Black, colorTextBox, 70);
                }

                //Variablen Resetten
                ReversalTradeStartTSLong  = DateTime.MinValue;
                ReversalTradeStartTSShort = DateTime.MinValue;
            }

            if (IsProcessingBarIndexLast)
            {
                //       Print("LongWin: " + TradeCounterLongWin + " LongFail: " + TradeCounterLongFail + " ShortWin: " + TradeCounterShortWin + " ShortFail: " + TradeCounterShortFail);
                //       Print(Instrument.Name + "Trades: " + TradeCounter + " LongPunkte: " + ReversalTradeResultTotalLong + " ShortPunkte: " + ReversalTradeResultTotalShort);
            }
        }
示例#21
0
        protected override void OnDataPoint(Bars bars, double open, double high, double low, double close, DateTime time, long volume, bool isBar, double bid, double ask)
        {
            if (SessionIterator == null)
            {
                SessionIterator = new SessionIterator(bars);
            }

            #region Building Bars from Base Period
            if (bars.Count != tmpCount)             // Reset cache when bars are trimmed
            {
                if (bars.Count == 0)
                {
                    tmpTime      = Core.Globals.MinDate;
                    tmpVolume    = 0;
                    tmpDayCount  = 0;
                    tmpTickCount = 0;
                }
                else
                {
                    tmpTime        = bars.GetTime(bars.Count - 1);
                    tmpVolume      = bars.GetVolume(bars.Count - 1);
                    tmpTickCount   = bars.TickCount;
                    tmpDayCount    = bars.DayCount;
                    bars.LastPrice = bars.GetClose(bars.Count - 1);
                    anchorPrice    = bars.LastPrice;
                }
            }

            bool isNewSession = SessionIterator.IsNewSession(time, isBar);
            bool isCalculateTradingDayDone = false;

            switch (bars.BarsPeriod.BaseBarsPeriodType)
            {
            case BarsPeriodType.Day:
                tmpTime = time.Date;                         // Will be modified for realtime only
                if (!isBar && time >= cacheSessionEnd /* on realtime includesEndTimeStamp is always false */)
                {
                    if (isNewSession)
                    {
                        SessionIterator.GetNextSession(time, isBar);
                        isCalculateTradingDayDone = true;
                    }
                    cacheSessionEnd = SessionIterator.ActualSessionEnd;
                    if (tmpTime < time.Date)
                    {
                        tmpTime = time.Date;                                                  // Make sure timestamps are ascending
                    }
                }

                if (prevTime != tmpTime)
                {
                    tmpDayCount++;
                }

                if (tmpDayCount < bars.BarsPeriod.BaseBarsPeriodValue ||
                    isBar && bars.Count > 0 && tmpTime == bars.LastBarTime.Date ||
                    !isBar && bars.Count > 0 && tmpTime <= bars.LastBarTime.Date)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    endOfBar = true;
                }

                break;

            case BarsPeriodType.Minute:

                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeMinute(bars, time, isBar);
                }

                if (isBar && time <= tmpTime || !isBar && time < tmpTime)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    tmpTime  = TimeToBarTimeMinute(bars, time, isBar);
                    endOfBar = true;
                }
                break;

            case BarsPeriodType.Volume:
                if (tmpTime == Core.Globals.MinDate)
                {
                    tmpVolume = volume;
                    endOfBar  = tmpVolume >= bars.BarsPeriod.BaseBarsPeriodValue;
                    prevTime  = tmpTime = time;
                    if (endOfBar)
                    {
                        tmpVolume = 0;
                    }
                    break;
                }

                tmpVolume += volume;
                endOfBar   = tmpVolume >= bars.BarsPeriod.BaseBarsPeriodValue;
                if (endOfBar)
                {
                    prevTime  = tmpTime;
                    tmpVolume = 0;
                }
                tmpTime = time;
                break;

            case BarsPeriodType.Tick:
                if (tmpTime == Core.Globals.MinDate || bars.BarsPeriod.BaseBarsPeriodValue == 1)
                {
                    prevTime     = tmpTime == Core.Globals.MinDate ? time : tmpTime;
                    tmpTime      = time;
                    tmpTickCount = bars.BarsPeriod.BaseBarsPeriodValue == 1 ? 0 : 1;
                    endOfBar     = bars.BarsPeriod.BaseBarsPeriodValue == 1;
                    break;
                }

                if (tmpTickCount < bars.BarsPeriod.BaseBarsPeriodValue)
                {
                    tmpTime  = time;
                    endOfBar = false;
                    tmpTickCount++;
                }
                else
                {
                    prevTime     = tmpTime;
                    tmpTime      = time;
                    endOfBar     = true;
                    tmpTickCount = 1;
                }
                break;

            case BarsPeriodType.Month:
                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeMonth(time, bars.BarsPeriod.BaseBarsPeriodValue);
                }

                if (time.Month <= tmpTime.Month && time.Year == tmpTime.Year || time.Year < tmpTime.Year)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    endOfBar = true;
                    tmpTime  = TimeToBarTimeMonth(time, bars.BarsPeriod.BaseBarsPeriodValue);
                }
                break;

            case BarsPeriodType.Second:
                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeSecond(bars, time, isBar);
                }
                if (bars.BarsPeriod.BaseBarsPeriodValue > 1 && time < tmpTime || bars.BarsPeriod.BaseBarsPeriodValue == 1 && time <= tmpTime)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    tmpTime  = TimeToBarTimeSecond(bars, time, isBar);
                    endOfBar = true;
                }
                break;

            case BarsPeriodType.Week:
                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeWeek(time.Date, tmpTime.Date, bars.BarsPeriod.BaseBarsPeriodValue);
                }
                if (time.Date <= tmpTime.Date)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    endOfBar = true;
                    tmpTime  = TimeToBarTimeWeek(time.Date, tmpTime.Date, bars.BarsPeriod.BaseBarsPeriodValue);
                }
                break;

            case BarsPeriodType.Year:
                if (tmpTime == Core.Globals.MinDate)
                {
                    prevTime = tmpTime = TimeToBarTimeYear(time, bars.BarsPeriod.Value);
                }
                if (time.Year <= tmpTime.Year)
                {
                    endOfBar = false;
                }
                else
                {
                    prevTime = tmpTime;
                    endOfBar = true;
                    tmpTime  = TimeToBarTimeYear(time, bars.BarsPeriod.Value);
                }
                break;
            }
            #endregion
            #region Kagi Logic

            reversalPoint = bars.BarsPeriod.ReversalType == ReversalType.Tick ? bars.BarsPeriod.Value * bars.Instrument.MasterInstrument.TickSize : bars.BarsPeriod.Value / 100.0 * anchorPrice;

            if (bars.Count == 0 || IsIntraday && (bars.BarsPeriod.BaseBarsPeriodType != BarsPeriodType.Second && bars.IsResetOnNewTradingDay && isNewSession ||
                                                  bars.BarsPeriod.BaseBarsPeriodType == BarsPeriodType.Second && bars.IsResetOnNewTradingDay && isNewSession))
            {
                if (isNewSession && !isCalculateTradingDayDone)
                {
                    SessionIterator.GetNextSession(tmpTime, isBar);
                }

                if (bars.Count > 0)
                {
                    double lastOpen  = bars.GetOpen(bars.Count - 1);
                    double lastHigh  = bars.GetHigh(bars.Count - 1);
                    double lastLow   = bars.GetLow(bars.Count - 1);
                    double lastClose = bars.GetClose(bars.Count - 1);

                    if (bars.Count == tmpCount)
                    {
                        CalculateKagiBar(bars, lastOpen, lastHigh, lastLow, lastClose, prevTime, volume);
                    }
                }

                AddBar(bars, close, close, close, close, tmpTime, volume);
                anchorPrice    = close;
                trend          = Trend.Undetermined;
                prevTime       = tmpTime;
                volumeCount    = 0;
                bars.LastPrice = close;
                tmpCount       = bars.Count;
                return;
            }

            double c = bars.GetClose(bars.Count - 1);
            double o = bars.GetOpen(bars.Count - 1);
            double h = bars.GetHigh(bars.Count - 1);
            double l = bars.GetLow(bars.Count - 1);

            if (endOfBar)
            {
                CalculateKagiBar(bars, o, h, l, c, prevTime, volume);
            }
            else
            {
                volumeCount += volume;
            }

            bars.LastPrice = close;
            tmpCount       = bars.Count;
            #endregion
        }
示例#22
0
        protected override void OnRender(ChartControl chartControl, ChartScale chartScale)
        {
            if (IsInHitTest)
            {
                return;
            }

            int    lastBar   = ChartBars.ToIndex;
            int    firstBar  = ChartBars.FromIndex;
            double highPrice = 0;
            double lowPrice  = double.MaxValue;

            SharpDX.Direct2D1.Brush brushDown = BarDownBrush.ToDxBrush(RenderTarget);
            SharpDX.Direct2D1.Brush lineBrush = LineBrush.ToDxBrush(RenderTarget);
            SharpDX.Direct2D1.Brush brushUp   = BarUpBrush.ToDxBrush(RenderTarget);
            brushDown.Opacity = (float)(Opacity / 100.0);
            brushUp.Opacity   = (float)(Opacity / 100.0);

            for (int idx = firstBar; idx <= lastBar && idx >= 0; idx++)
            {
                highPrice = Math.Max(highPrice, Bars.GetHigh(idx));
                lowPrice  = Math.Min(lowPrice, Bars.GetLow(idx));
            }

            int    volumeBarCount = BarCount;
            double priceRange     = highPrice - lowPrice;
            double priceBoxSize   = priceRange / volumeBarCount;
            double volumeMax      = 0;

            // Pass 1: Fill all VolumeInfo structures with appropriate data
            for (int i = 0; i < volumeBarCount; i++)
            {
                double priceUpper = lowPrice + priceBoxSize * (i + 1);
                double priceLower = lowPrice + priceBoxSize * i;

                double priceVolumeUp   = 0;
                double priceVolumeDown = 0;

                for (int idx = firstBar; idx <= lastBar; idx++)
                {
                    double checkPrice;

                    PriceSeries series = (Inputs[0] as PriceSeries);

                    switch (series.PriceType)
                    {
                    case PriceType.Open:            checkPrice = Bars.GetOpen(idx); break;

                    case PriceType.Close:           checkPrice = Bars.GetClose(idx); break;

                    case PriceType.High:            checkPrice = Bars.GetHigh(idx); break;

                    case PriceType.Low:                     checkPrice = Bars.GetLow(idx); break;

                    case PriceType.Median:          checkPrice = (Bars.GetHigh(idx) + Bars.GetLow(idx)) / 2; break;

                    case PriceType.Typical:         checkPrice = (Bars.GetHigh(idx) + Bars.GetLow(idx) + Bars.GetClose(idx)) / 3; break;

                    case PriceType.Weighted:        checkPrice = (Bars.GetHigh(idx) + Bars.GetLow(idx) + 2 * Bars.GetClose(idx)) / 4; break;

                    default:                                        checkPrice = Bars.GetClose(idx); break;
                    }

                    if (checkPrice >= priceLower && checkPrice < priceUpper)
                    {
                        if (Bars.GetOpen(idx) < Bars.GetClose(idx))
                        {
                            priceVolumeUp += Bars.GetVolume(idx);
                        }
                        else
                        {
                            priceVolumeDown += Bars.GetVolume(idx);
                        }
                    }
                }

                volumeInfo[i].up    = priceVolumeUp;
                volumeInfo[i].down  = priceVolumeDown;
                volumeInfo[i].total = priceVolumeUp + priceVolumeDown;

                volumeMax = Math.Max(volumeMax, volumeInfo[i].total);
            }

            // Pass 2: Paint the volume bars
            for (int i = 0; i < Math.Min(volumeBarCount, lastBar - firstBar + 1); i++)
            {
                double priceUpper   = lowPrice + priceBoxSize * (i + 1);
                double priceLower   = lowPrice + priceBoxSize * i;
                int    yUpper       = Convert.ToInt32(chartScale.GetYByValue(priceUpper)) + BarSpacing;
                int    yLower       = Convert.ToInt32(chartScale.GetYByValue(priceLower));
                int    barWidthUp   = (int)((chartScale.Height / 2) * (volumeInfo[i].up / volumeMax));
                int    barWidthDown = (int)((chartScale.Height / 2) * (volumeInfo[i].down / volumeMax));

                SharpDX.RectangleF rect = new SharpDX.RectangleF(ChartPanel.X, yUpper, barWidthUp, Math.Abs(yUpper - yLower));
                RenderTarget.FillRectangle(rect, brushUp);
                RenderTarget.DrawRectangle(rect, brushUp);

                SharpDX.RectangleF rect2 = new SharpDX.RectangleF(ChartPanel.X + barWidthUp, yUpper, barWidthDown, Math.Abs(yUpper - yLower));
                RenderTarget.DrawRectangle(rect2, brushDown);
                RenderTarget.FillRectangle(rect2, brushDown);

                if (DrawLines)
                {
                    RenderTarget.DrawLine(new SharpDX.Vector2(ChartPanel.X, yLower), new SharpDX.Vector2(ChartPanel.X + ChartPanel.W, yLower), lineBrush);
                    if (i == volumeBarCount - 1)
                    {
                        RenderTarget.DrawLine(new SharpDX.Vector2(ChartPanel.X, yUpper), new SharpDX.Vector2(ChartPanel.X + ChartPanel.W, yUpper), lineBrush);
                    }
                }
            }

            lineBrush.Dispose();
            brushDown.Dispose();
            brushUp.Dispose();
        }
示例#23
0
        private Dictionary <int, string> removeDuplicatePivots(Dictionary <int, string> periodSwingsPivots)
        {
            Log("Remove Duplicate Pivots", NinjaTrader.Cbi.LogLevel.Information);
            //Remove duplicate highs / lows
            List <int> orderedMarkers = periodSwingsPivots.Keys.ToList();

            orderedMarkers.Sort();
            int    previousMarker     = -1;
            string previousMarkerType = "";

            Dictionary <int, string> reducedPivots =
                new Dictionary <int, string>();

            foreach (int marker in orderedMarkers)
            {
                if (previousMarker == -1)
                {
                    previousMarker     = marker;
                    previousMarkerType = periodSwingsPivots[previousMarker];
                }
                if (previousMarkerType.Equals(MAX) && periodSwingsPivots[marker].Equals(MAX) && Bars.GetHigh(marker) > Bars.GetHigh(previousMarker))
                {
                    reducedPivots.Remove(previousMarker);
                }
                if (previousMarkerType.Equals(MIN) && periodSwingsPivots[marker].Equals(MIN) && Bars.GetLow(marker) < Bars.GetLow(previousMarker))
                {
                    reducedPivots.Remove(previousMarker);
                }
                if (previousMarkerType.Equals(MAX) && periodSwingsPivots[marker].Equals(MAX) && Bars.GetHigh(marker) <= Bars.GetHigh(previousMarker))
                {
                    continue;
                }
                if (previousMarkerType.Equals(MIN) && periodSwingsPivots[marker].Equals(MIN) && Bars.GetLow(marker) >= Bars.GetLow(previousMarker))
                {
                    continue;
                }

                reducedPivots.Add(marker, periodSwingsPivots[marker]);
                previousMarker     = marker;
                previousMarkerType = periodSwingsPivots[previousMarker];
            }

            Log("Duplicate pivots removed", NinjaTrader.Cbi.LogLevel.Information);
            return(reducedPivots);
        }
示例#24
0
        protected override void OnDataPoint(Bars bars, double open, double high, double low, double close, DateTime time, long volume, bool isBar, double bid, double ask)
        {
            // method variables
            bool   isNewSession = SessionIterator.IsNewSession(time, isBar);
            double tickSize     = bars.Instrument.MasterInstrument.TickSize;

            if (SessionIterator == null)
            {
                SessionIterator = new SessionIterator(bars);
            }

            if (isNewSession)
            {
                SessionIterator.GetNextSession(time, isBar);
            }

            if (bars.Count == 0 || (bars.IsResetOnNewTradingDay && isNewSession))
            {
                // update fields
                rangeMax = AddTwoDoubles(bars, bars.BarsPeriod.BaseBarsPeriodValue * tickSize, 0);
                rangeMin = AddTwoDoubles(bars, bars.BarsPeriod.Value * tickSize, 0);

                // set initial range, factoring dynamic
                thisRange = isDynamic ? rangeMin : rangeMax;
                AdjustMaxMin(bars, close, close);

                // add first bar
                AddBar(bars, thisOpen, thisOpen, thisOpen, thisOpen, time, volume);
            }
            else
            {
                // local variables
                double barOpen    = bars.GetOpen(bars.Count - 1);
                double barHigh    = bars.GetHigh(bars.Count - 1);
                double barLow     = bars.GetLow(bars.Count - 1);
                int    maxCompare = bars.Instrument.MasterInstrument.Compare(close, thisMax);
                int    minCompare = bars.Instrument.MasterInstrument.Compare(close, thisMin);
                double thisClose  = maxCompare > 0 ? Math.Min(close, thisMax) : minCompare < 0 ? Math.Max(close, thisMin) : close;

                // range exceeded; create new bar(s)
                if (maxCompare > 0 || minCompare < 0)
                {
                    // local variables
                    bool newBar = true;

                    // update bias
                    prevBias = thisBias;
                    thisBias = close > barOpen ? 1 : close < barOpen ? -1 : 0;

                    // close current bar; volume included for on-touch only
                    // see this post for more info on volume calculation: http://www.ninjatrader.com/support/forum/showthread.php?p=302208#post302208
                    UpdateBar(bars, (maxCompare > 0 ? thisClose : barHigh), (minCompare < 0 ? thisClose : barLow), thisClose, time, 0);

                    // add next bar and loop phantom bars, if needed
                    do
                    {
                        // update thisRange for dynamic
                        if (isDynamic)
                        {
                            // increment range for same bias, if range has not exceeded max
                            if ((thisBias == prevBias || prevBias == 0) && thisRange < rangeMax)
                            {
                                thisRange = AddTwoDoubles(bars, thisRange, tickSize);
                            }

                            // increment range after trend change (will only fire once)
                            else if (thisBias != prevBias && prevBias != 0)
                            {
                                thisRange = AddTwoDoubles(bars, rangeMin, tickSize);
                            }

                            // ensure valid range
                            thisRange = Math.Min(thisRange, rangeMax);
                        }

                        // update fields
                        AdjustMaxMin(bars, thisClose, close);
                        thisClose = (maxCompare > 0) ? Math.Min(close, thisMax) : (minCompare < 0) ? Math.Max(close, thisMin) : close;

                        // add new bar; include volume once (except for on-touch), then create phantom bars
                        // see this post for more info on volume calculation: http://www.ninjatrader.com/support/forum/showthread.php?p=302208#post302208
                        AddBar(bars, thisOpen, (maxCompare > 0 ? thisClose : thisOpen), (minCompare < 0 ? thisClose : thisOpen), thisClose, time, (newBar ? volume : 0));
                        newBar = false;

                        // update fields
                        maxCompare = bars.Instrument.MasterInstrument.Compare(close, thisMax);
                        minCompare = bars.Instrument.MasterInstrument.Compare(close, thisMin);
                    }while (maxCompare > 0 || minCompare < 0);
                }
                else
                {
                    UpdateBar(bars, (close > barHigh ? close : barHigh), (close < barLow ? close : barLow), close, time, volume);
                }
            }
            bars.LastPrice = close;
        }
示例#25
0
		/// <summary>
		/// </summary>
		/// <param name="bars"></param>
		/// <param name="open"></param>
		/// <param name="high"></param>
		/// <param name="low"></param>
		/// <param name="close"></param>
		/// <param name="time"></param>
		/// <param name="volume"></param>
		/// <param name="isRealtime"></param>
		public override void Add(Bars bars, double open, double high, double low, double close, DateTime time, long volume, bool isRealtime)
		{
			#region Building Bars from Base Period
			if (bars.Count != tmpCount) // reset cache when bars are trimmed
				if (bars.Count == 0)
				{
					tmpTime			= Cbi.Globals.MinDate;
					tmpVolume		= 0;
					tmpDayCount		= 0;
					tmpTickCount	= 0;
				}
				else
				{
					tmpTime			= bars.GetTime(bars.Count - 1);
					tmpVolume		= bars.GetVolume(bars.Count - 1);
					tmpTickCount	= bars.TickCount;
					tmpDayCount		= bars.DayCount;
					bars.LastPrice	= bars.GetClose(bars.Count - 1);
					anchorPrice		= bars.LastPrice;
				}

			switch (bars.Period.BasePeriodType)
			{
				case PeriodType.Day:
					tmpTime = time.Date; // will be modified for realtime only
					if (isRealtime && time >= cacheSessionEnd /* on realtime include60 is always false */)
					{
						bars.Session.GetSessionDate(time, false, out tmpTime, out cacheSessionEnd);
						if (tmpTime < time.Date) tmpTime = time.Date; // make sure timestamps are ascending
					}

					if (prevTime != tmpTime) tmpDayCount++;

					if (tmpDayCount < bars.Period.BasePeriodValue
						|| (!isRealtime && bars.Count > 0 && tmpTime == bars.TimeLastBar.Date)
						|| (isRealtime && bars.Count > 0 && tmpTime <= bars.TimeLastBar.Date))
						endOfBar = false;
					else
					{
						prevTime = tmpTime;
						endOfBar = true;
					}

					break;

				case PeriodType.Minute:

					if (tmpTime == Cbi.Globals.MinDate)
						prevTime = tmpTime = TimeToBarTimeMinute(bars, time, bars.Session.NextBeginTime, bars.Period.BasePeriodValue, isRealtime);

					if (!isRealtime && time <= tmpTime || isRealtime && time < tmpTime)
						endOfBar = false;
					else
					{
						prevTime	= tmpTime;
						tmpTime		= TimeToBarTimeMinute(bars, time, bars.Session.NextBeginTime, bars.Period.BasePeriodValue, isRealtime);
						endOfBar	= true;
					}
					break;

				case PeriodType.Volume:
					if (tmpTime == Cbi.Globals.MinDate)
					{
						tmpVolume	= volume;
						endOfBar	= tmpVolume >= bars.Period.BasePeriodValue;
						prevTime	= tmpTime = time;
						if (endOfBar) tmpVolume = 0;
						break;
					}

					tmpVolume	+= volume;
					endOfBar	= tmpVolume >= bars.Period.BasePeriodValue;
					if (endOfBar)
					{
						prevTime	= tmpTime;
						tmpVolume	= 0;
					}
                    tmpTime = time;
                    break;

                case PeriodType.Tick:
                    if (tmpTime == Cbi.Globals.MinDate || bars.Period.BasePeriodValue == 1)
                    {
                        prevTime        = tmpTime == Cbi.Globals.MinDate ? time : tmpTime;
                        tmpTime         = time;
                        tmpTickCount    = bars.Period.BasePeriodValue == 1 ? 0 : 1;
                        endOfBar        = bars.Period.BasePeriodValue == 1;
                        break;
                    }

                    if (tmpTickCount < bars.Period.BasePeriodValue)
                    {
                        tmpTime         = time;
                        endOfBar        = false;
                        tmpTickCount++;
                    }
                    else
                    {
                        prevTime        = tmpTime;
                        tmpTime         = time;
                        endOfBar        = true;
                        tmpTickCount    = 1;
                    }
                    break;

                case PeriodType.Month:
					if (tmpTime == Cbi.Globals.MinDate)
						prevTime = tmpTime = TimeToBarTimeMonth(time, bars.Period.BasePeriodValue);

					if (time.Month <= tmpTime.Month && time.Year == tmpTime.Year || time.Year < tmpTime.Year)
						endOfBar = false;
					else
					{
						prevTime	= tmpTime;
						endOfBar	= true;
						tmpTime		= TimeToBarTimeMonth(time, bars.Period.BasePeriodValue);
					}
					break;

				case PeriodType.Second:
					if (tmpTime == Cbi.Globals.MinDate)
					{
						prevTime = tmpTime = TimeToBarTimeSecond(bars, time,
																	new DateTime(	bars.Session.NextBeginTime.Year,
																					bars.Session.NextBeginTime.Month,
																					bars.Session.NextBeginTime.Day,
																					bars.Session.NextBeginTime.Hour,
																					bars.Session.NextBeginTime.Minute, 0),
																	bars.Period.BasePeriodValue);
					}
					if ((bars.Period.Value > 1 && time < tmpTime) || (bars.Period.Value == 1 && time <= tmpTime))
						endOfBar	= false;
					else
					{
						prevTime	= tmpTime;
						tmpTime		= TimeToBarTimeSecond(bars, time, bars.Session.NextBeginTime, bars.Period.BasePeriodValue);
						endOfBar	= true;
					}
					break;

				case PeriodType.Week:
					if (tmpTime == Cbi.Globals.MinDate)
						prevTime = tmpTime = TimeToBarTimeWeek(time.Date, tmpTime.Date, bars.Period.BasePeriodValue);
					if (time.Date <= tmpTime.Date)
						endOfBar = false;
					else
					{
						prevTime	= tmpTime;
						endOfBar	= true;
						tmpTime		= TimeToBarTimeWeek(time.Date, tmpTime.Date, bars.Period.BasePeriodValue);
					}
					break;

				case PeriodType.Year:
					if (tmpTime == Cbi.Globals.MinDate)
						prevTime = tmpTime = TimeToBarTimeYear(time, bars.Period.Value);
					if (time.Year <= tmpTime.Year)
						endOfBar = false;
					else
					{
						prevTime	= tmpTime;
						endOfBar	= true;
						tmpTime		= TimeToBarTimeYear(time, bars.Period.Value);
					}
					break;
			}
			#endregion
			#region Kagi Logic

			reversalPoint = bars.Period.ReversalType == ReversalType.Tick ? bars.Period.Value * bars.Instrument.MasterInstrument.TickSize : bars.Period.Value * 0.01 * anchorPrice;

			if (bars.Count == 0 || (IsIntraday && ((bars.Period.BasePeriodType != PeriodType.Second && bars.IsNewSession(time, isRealtime))
									|| (bars.Period.BasePeriodType == PeriodType.Second && bars.IsNewSession(tmpTime, isRealtime)))))
			{
				if (bars.Count > 0)
				{
					double		lastOpen		= bars.GetOpen(bars.Count - 1);
					double		lastHigh		= bars.GetHigh(bars.Count - 1);
					double		lastLow			= bars.GetLow(bars.Count - 1);
					double		lastClose		= bars.GetClose(bars.Count - 1);

					if (bars.Count == tmpCount)
						CalculateKagiBar(bars, lastOpen, lastHigh, lastLow, lastClose, prevTime, volume, isRealtime);
				}

				AddBar(bars, close, close, close, close, tmpTime, volume, isRealtime);
				anchorPrice		= close;
				trend			= Trend.Undetermined;
				prevTime		= tmpTime;
				volumeCount		= 0;
				bars.LastPrice	= close;
				tmpCount		= bars.Count;
				return;
			}

			Bar		bar		= (Bar)bars.Get(bars.Count - 1);
			double	c		= bar.Close;
			double	o		= bar.Open;
			double	h		= bar.High;
			double	l		= bar.Low;

			if (endOfBar)
				CalculateKagiBar(bars, o, h, l, c, prevTime, volume, isRealtime);
			else
				volumeCount += volume;

			bars.LastPrice	= close;
			tmpCount		= bars.Count;

			#endregion
		}
        protected override void OnBarUpdate()
        {
            switch (pOrT)
            {
            case PriceOrTime.Price:
            {
                MAX_HIGH = Math.Max(MAX_HIGH, High[0]);
                MIN_LOW  = Math.Min(MIN_LOW, Low[0]);

                if (CurrentBar == Bars.Count - 2)
                {
                    MAX_HIGH = Math.Round(MAX_HIGH * 1.05, PriceDigits);
                    MIN_LOW  = Math.Round(MIN_LOW * 0.95, PriceDigits);

                    if (InitialPrice < MIN_LOW || InitialPrice > MAX_HIGH)
                    {
                        Log("InitialPrice parameter MUST be between the high price and low price on this chart", NinjaTrader.Cbi.LogLevel.Information);
                        if (InitialPrice > MAX_HIGH)
                        {
                            InitialPrice = MAX_HIGH;
                        }
                        if (InitialPrice < MIN_LOW)
                        {
                            InitialPrice = MIN_LOW;
                        }
                    }


                    double LevelUp = -1.0, LevelDown = -1.0;
                    i = 1;

                    do
                    {
                        if (Angle000Flag)
                        {
                            LevelUp = InitialPrice + Angle0[i] * TickSize * MultiplierForPriceScale;    LevelDown = InitialPrice - Angle0[i] * TickSize * MultiplierForPriceScale;   MakePriceLine(LevelUp, LevelDown, Color0);
                        }
                        if (Angle090Flag)
                        {
                            LevelUp = InitialPrice + Angle90[i] * TickSize * MultiplierForPriceScale;   LevelDown = InitialPrice - Angle90[i] * TickSize * MultiplierForPriceScale;  MakePriceLine(LevelUp, LevelDown, Color90);
                        }
                        if (Angle180Flag)
                        {
                            LevelUp = InitialPrice + Angle180[i] * TickSize * MultiplierForPriceScale;  LevelDown = InitialPrice - Angle180[i] * TickSize * MultiplierForPriceScale; MakePriceLine(LevelUp, LevelDown, Color180);
                        }
                        if (Angle270Flag)
                        {
                            LevelUp = InitialPrice + Angle270[i] * TickSize * MultiplierForPriceScale;  LevelDown = InitialPrice - Angle270[i] * TickSize * MultiplierForPriceScale; MakePriceLine(LevelUp, LevelDown, Color270);
                        }
                        i++;
                        if (LevelUp < 0.0 || LevelDown < 0.0)
                        {
                            break;
                        }
                        if (i >= Angle0.Length)
                        {
                            break;
                        }
                        if (i >= Angle90.Length)
                        {
                            break;
                        }
                        if (i >= Angle180.Length)
                        {
                            break;
                        }
                        if (i >= Angle270.Length)
                        {
                            break;
                        }

                        if (LevelUp > MaxLevelUp)
                        {
                            MaxLevelUp = LevelUp;
                        }
                        if (LevelDown < MinLevelDown)
                        {
                            MinLevelDown = LevelDown;
                        }
                    }while (1 == 1);
                }
                break;
            }

            case PriceOrTime.Time:
            {
                if (ZuluTime.CompareTo(Time[0]) < 0 && ZuluBar < 0)
                {
                    ZuluBar = CurrentBar;                                                                   //set ZuluBar to time the user selected
                }
                Print("Zulubar" + ZuluBar.ToString());

                if (ZuluBar > 0)
                {
                    OutString = null;
                    if (Angle000Flag)
                    {
                        i = Angle0[NextBar0] + ZuluBar;
                        if (i == CurrentBar)
                        {
                            MakeVerticalLine(0, Color0); NextBar0++;
                        }
                        OutString = "Zero line coming in " + (i - CurrentBar).ToString() + " bars" + Environment.NewLine;
                    }
                    if (Angle090Flag)
                    {
                        i = Angle90[NextBar90] + ZuluBar;
                        if (i == CurrentBar)
                        {
                            MakeVerticalLine(0, Color90); NextBar90++;
                        }
                        OutString = OutString + "90 line coming in " + (i - CurrentBar).ToString() + " bars" + Environment.NewLine;
                    }
                    if (Angle180Flag)
                    {
                        i = Angle180[NextBar180] + ZuluBar;
                        if (i == CurrentBar)
                        {
                            MakeVerticalLine(0, Color180); NextBar180++;
                        }
                        OutString = OutString + "180 line coming in " + (i - CurrentBar).ToString() + " bars" + Environment.NewLine;
                    }
                    if (Angle270Flag)

                    {
                        i = Angle270[NextBar270] + ZuluBar;
                        if (i == CurrentBar)
                        {
                            MakeVerticalLine(0, Color270); NextBar270++;
                        }
                        OutString = OutString + "270 line coming in " + (i - CurrentBar).ToString() + " bars";
                    }

                    if (OutString.Length > 0 && DisplayCountDown)
                    {
                        lastBar  = Math.Min(ChartControl.LastSlotPainted, Bars.Count - 1);
                        firstBar = (lastBar - ChartControl.SlotsPainted) + 1;
                        int i;
                        // Find highest and lowest price points
                        HighestPaintedPrice = double.MinValue;
                        LowestPaintedPrice  = double.MaxValue;
                        for (i = firstBar; i <= lastBar && i >= 0; i++)
                        {
                            HighestPaintedPrice = Math.Max(HighestPaintedPrice, Bars.GetHigh(i));
                            LowestPaintedPrice  = Math.Min(LowestPaintedPrice, Bars.GetLow(i));
                        }

                        double Outprice = (HighestPaintedPrice + LowestPaintedPrice) / 2.0;
                        if (Bars.GetClose(lastBar - 1) < Outprice)
                        {
                            Outprice = HighestPaintedPrice;
                        }
                        if (Bars.GetClose(lastBar - 1) >= Outprice)
                        {
                            Outprice = (Outprice + LowestPaintedPrice) / 2.0;
                        }

                        Print(OutString);

                        NinjaTrader.Gui.Tools.SimpleFont myFont = new NinjaTrader.Gui.Tools.SimpleFont("Arial", 10)
                        {
                            Size = 20, Bold = false
                        };

                        if (CurrentBar > 10)
                        {
                            Draw.Text(this, "Info", true, OutString, 10, Outprice, 0, Brushes.Gray, myFont, TextAlignment.Justify, Brushes.White, Brushes.Transparent, 50);
                        }
                    }
                }

                break;
            }
            }
        }
示例#27
0
        protected override void OnDataPoint(Bars bars, double open, double high, double low, double close, DateTime time, long volume, bool isBar, double bid, double ask)
        {
            double lastBarClose = bars.GetClose(bars.Count - 1);                 // Trae el último precio de cierre

            if (SessionIterator == null)
            {
                SessionIterator = new SessionIterator(bars);
            }

            offset = bars.BarsPeriod.Value * bars.Instrument.MasterInstrument.TickSize;             // Periocidad * tick (Tamaño de la caja)
            bool isNewSession = SessionIterator.IsNewSession(time, isBar);

            if (isNewSession)
            {
                SessionIterator.GetNextSession(time, isBar);
            }

            // Si es una gráfica nueva o una sesión nueva y está en un nuevo día
            if (bars.Count == 0 || bars.IsResetOnNewTradingDay && isNewSession)
            {
                // una sesión nueva y está en un nuevo día
                if (bars.Count > 0)
                {
                    // Close out last bar in session and set open == close
                    DateTime lastBarTime   = bars.GetTime(bars.Count - 1);                                            // Trae la última fecha del precio de cierre
                    long     lastBarVolume = bars.GetVolume(bars.Count - 1);                                          // Trae el último volumen de precio de cierre
                    RemoveLastBar(bars);                                                                              // Elimina la última barra
                    AddBar(bars, lastBarClose, lastBarClose, lastBarClose, lastBarClose, lastBarTime, lastBarVolume); // Crea una nueva barra con la información obtenida
                }

                renkoHigh = close + offset;                       // Suma el valor de cierre y tamaño de la caja
                renkoLow  = close - offset;                       // Diferencia del valor de cierre y el tamaño de la caja

                // ¿Hay un nuevo precio negociado?
                isNewSession = SessionIterator.IsNewSession(time, isBar);
                if (isNewSession)
                {
                    SessionIterator.GetNextSession(time, isBar);                     // Entonces traiga el último precio
                }
                // Pinte el último precio negociado
                AddBar(bars, close, close, close, close, time, volume);
                bars.LastPrice = close;

                return;
            }

            double   barOpen   = bars.GetOpen(bars.Count - 1);                            // Obtiene el valor de apertura de la última barra
            double   barHigh   = bars.GetHigh(bars.Count - 1);                            // Obtiene el valor más alto negociado de la última barra
            double   barLow    = bars.GetLow(bars.Count - 1);                             // Obtiene el valor más bajo negociado de la última barra
            long     barVolume = bars.GetVolume(bars.Count - 1);                          // Obtiene el volumen de la última barra
            DateTime barTime   = bars.GetTime(bars.Count - 1);                            // Obtiene la fecha de la última barra

            // renkoHigh == 0 || renkoLow == 0
            // ApproxCompare: Compares two double or float values for equality or being greater than / less than the compared to value.
            if (renkoHigh.ApproxCompare(0.0) == 0 || renkoLow.ApproxCompare(0.0) == 0)
            {
                if (bars.Count == 1)
                {
                    renkoHigh = barOpen + offset;                           // suma = valor de apertura de la última barra + el tamaño de la caja
                    renkoLow  = barOpen - offset;                           // diferencia = valor de apertura de la última barra - el tamaño de la caja
                }
                // Penultimo valor de cierre es mayor al penultimo valor de apertura?
                else if (bars.GetClose(bars.Count - 2) > bars.GetOpen(bars.Count - 2))
                {
                    renkoHigh = bars.GetClose(bars.Count - 2) + offset;                                 // Suma tamaño de la caja + el penultimo valor de cierre
                    renkoLow  = bars.GetClose(bars.Count - 2) - offset * 2;                             // Resta el doble del tamaño de la caja - el penultimo valor de cierre
                }
                else
                {
                    renkoHigh = bars.GetClose(bars.Count - 2) + offset * 2;                             // Suma el doble tamaño de la caja + el penultimo valor de cierre
                    renkoLow  = bars.GetClose(bars.Count - 2) - offset;                                 // Resta el tamaño de la caja - el penultimo valor de cierre
                }
            }

            bool isRail2Rail = false;

            // Hay cambio de tendencia hacia bajista?
            if (close <= (renkoHigh))
            {
                // Elimina la barra de Update
                RemoveLastBar(bars);

                // Agrega la nueva barra con los nuevos valores
                renkoLow  = renkoHigh - 2.0 * offset;                       // RenkoHigh - el doble del tamaño de la caja
                renkoHigh = renkoHigh + offset;                             // Renkohigh + el tamaño de la caja
                // Agrega barra alcista
                //AddBar(bars, _renkoLow - offset, Math.Max(_renkoLow - offset, _renkoLow), Math.Min(_renkoLow - offset, _renkoLow), _renkoLow, barTime, barVolume);
                //AddBar(bars, _renkoHigh + offset, Math.Max(_renkoHigh + offset, _renkoHigh), Math.Min(_renkoHigh + offset, _renkoHigh), _renkoHigh, barTime, barVolume);
                //AddBar(Bars bars, double open, double high, double low, double close, DateTime time, long volume)

                //Barra de una gráfica bajista
                AddBar(bars, renkoLow + offset, Math.Max(renkoLow + offset, renkoLow), Math.Min(renkoLow + offset, renkoLow), renkoLow, barTime, barVolume);

                isRail2Rail = true;
            }
            //bool isRail2Rail = false;
            // Hay cambio de tendencia hacia alcista?
            if (close >= (renkoLow))
            {
                // Elimina la barra la barra de Update
                RemoveLastBar(bars);
                // Agrega la nueva barra con los nuevos valores
                // Original
                //AddBar(bars, renkoLow + offset, Math.Max(renkoLow + offset, renkoLow), Math.Min(renkoLow + offset, renkoLow), renkoLow, barTime, barVolume);
                // Bajista
                renkoHigh = renkoLow + 2.0 * offset;                            // RenkoLow - el doble del tamaño de la caja
                renkoLow  = renkoLow - offset;                                  // RenkoLow - el tamaño de la caja
                //AddBar(bars, _renkoHigh + offset, Math.Max(_renkoHigh + offset, _renkoHigh), Math.Min(_renkoHigh + offset, _renkoHigh), _renkoHigh, barTime, barVolume);
                //AddBar(bars, _renkoLow - offset, Math.Max(_renkoLow - offset, _renkoLow), Math.Min(_renkoLow - offset, _renkoLow), _renkoLow, barTime, barVolume);

                //Barra de gráfica alcista
                AddBar(bars, renkoHigh - offset, Math.Max(renkoHigh - offset, renkoHigh), Math.Min(renkoHigh - offset, renkoHigh), renkoHigh, barTime, barVolume);

                isRail2Rail = true;
            }
            // el precio de cierre es mayor renkohigh?
            // [DETECTA COMPORTAMIENTO ALCISTA]
            if (close.ApproxCompare(renkoHigh) >= 0)
            {
                /* if (trend != 0 && trend != 1) {
                 *      // Elimina la barra de Update
                 *      RemoveLastBar(bars);
                 *
                 *      // Agrega la nueva barra con los nuevos valores
                 *      var _renkoLow	= renkoHigh - 1.0 * offset; // RenkoHigh - el doble del tamaño de la caja
                 *      var _renkoHigh	= renkoHigh + offset;		// Renkohigh + el tamaño de la caja
                 *      // Agrega barra alcista
                 *      AddBar(bars, _renkoLow - offset, Math.Max(_renkoLow - offset, _renkoLow), Math.Min(_renkoLow - offset, _renkoLow), _renkoLow, barTime, barVolume);
                 *
                 *      isRail2Rail = true;
                 * } */
                // (1) Obtiene el valor mayor entre renkoHigh y, renkoHigh - tamaño de la caja
                // (2) Si el valor de x es igual a y entonces retorna 0
                //		Si el valor de x es mayor a y entonces retorna 1
                //		Si el valor de x es menor a y entonces retorna -1
                if (barOpen.ApproxCompare(renkoHigh - offset) != 0 ||              // valor de apertura de la (última barra - el tamño de la caja) es mayor o menor a barOpen?
                    barHigh.ApproxCompare(Math.Max(renkoHigh - offset, renkoHigh)) != 0 ||                     // Es barHigh mayor o menor a (1)?
                    barLow.ApproxCompare(Math.Min(renkoHigh - offset, renkoHigh)) != 0)                       // Es barLow mayor o menor a (1)?
                {
                    // No hubo cambio de tendencia
                    if (!isRail2Rail)
                    {
                        // Elimina la última barra de Update
                        RemoveLastBar(bars);
                    }

                    // Agrega una barra nueva con los nuevos valores
                    // Alcista
                    AddBar(bars, renkoHigh - offset, Math.Max(renkoHigh - offset, renkoHigh), Math.Min(renkoHigh - offset, renkoHigh), renkoHigh, barTime, barVolume);
                }

                renkoLow  = renkoHigh - 2.0 * offset;                       // RenkoHigh - el doble del tamaño de la caja
                renkoHigh = renkoHigh + offset;                             // Renkohigh + el tamaño de la caja

                // ¿Hay un nuevo valor negociado?
                isNewSession = SessionIterator.IsNewSession(time, isBar);
                if (isNewSession)
                {
                    SessionIterator.GetNextSession(time, isBar);                     // Obtiene el último valor negociado
                }
                // Agrega barras vacías para llenar el gap si el precio salta
                while (close.ApproxCompare(renkoHigh) >= 0)
                {
                    AddBar(bars, renkoHigh - offset, Math.Max(renkoHigh - offset, renkoHigh), Math.Min(renkoHigh - offset, renkoHigh), renkoHigh, time, 0);
                    renkoLow  = renkoHigh - 2.0 * offset;
                    renkoHigh = renkoHigh + offset;
                }

                // Agrega la barra final parcial
                AddBar(bars, renkoHigh - offset, Math.Max(renkoHigh - offset, close), Math.Min(renkoHigh - offset, close), close, time, volume);
                trend = 1;
            }
            // el precio de cierre es menor o igual a renkohigh?
            // El precio de cierre es menor o igual al renkolow
            // [DETECTA COMPORTAMIENTO BAJISTA]
            else if (close.ApproxCompare(renkoLow) <= 0)
            {
                /* if (trend != 0 && trend != -1) {
                 *      // Elimina la barra la barra de Update
                 *      RemoveLastBar(bars);
                 *      // Agrega la nueva barra con los nuevos valores
                 *      // Original
                 *      //AddBar(bars, renkoLow + offset, Math.Max(renkoLow + offset, renkoLow), Math.Min(renkoLow + offset, renkoLow), renkoLow, barTime, barVolume);
                 *      // Bajista
                 *      var _renkoHigh	= renkoLow + 1.0 * offset;	// RenkoLow - el doble del tamaño de la caja
                 *      var _renkoLow	= renkoLow - offset;		// RenkoLow - el tamaño de la caja
                 *      AddBar(bars, _renkoHigh + offset, Math.Max(_renkoHigh + offset, _renkoHigh), Math.Min(_renkoHigh + offset, _renkoHigh), _renkoHigh, barTime, barVolume);
                 *      isRail2Rail = true;
                 * } */
                // (1) Obtiene el valor mayor entre renkoLow y, renkoLow + tamaño de la caja
                // (2) Si el valor de x es igual a y entonces retorna 0
                //		Si el valor de x es mayor a y entonces retorna 1
                //		Si el valor de x es menor a y entonces retorna -1
                if (barOpen.ApproxCompare(renkoLow + offset) != 0 ||              // Valor de apertura de (renkolow + el tamaño de la caja) es mayor o menor a barOpen?
                    barHigh.ApproxCompare(Math.Max(renkoLow + offset, renkoLow)) != 0 ||                     // Es barHigh mayor o menor a (1)?
                    barLow.ApproxCompare(Math.Min(renkoLow + offset, renkoLow)) != 0)                         // Es barlow mayor o menor a (1)?
                {
                    // TODO: Validar si la condición cambia, si si, entonces no elimine la última barra
                    if (!isRail2Rail)
                    {
                        // Elimine la barra de Update
                        RemoveLastBar(bars);
                    }

                    // Agrega la nueva barra con los nuevos valores
                    // AddBar(Bars bars, double open, double high, double low, double close, DateTime time, long volume)
                    //Bajista
                    AddBar(bars, renkoLow + offset, Math.Max(renkoLow + offset, renkoLow), Math.Min(renkoLow + offset, renkoLow), renkoLow, barTime, barVolume);
                }

                renkoHigh = renkoLow + 2.0 * offset;                            // RenkoLow - el doble del tamaño de la caja
                renkoLow  = renkoLow - offset;                                  // RenkoLow - el tamaño de la caja

                // ¿Hay un nuevo valor negociado?
                isNewSession = SessionIterator.IsNewSession(time, isBar);
                if (isNewSession)
                {
                    SessionIterator.GetNextSession(time, isBar);                      // Obtiene el último valor negociado
                }
                // Agrega barras vacías para llenar el gap si el precio salta
                while (close.ApproxCompare(renkoLow) <= 0)
                {
                    AddBar(bars, renkoLow + offset, Math.Max(renkoLow + offset, renkoLow), Math.Min(renkoLow + offset, renkoLow), renkoLow, time, 0);
                    renkoHigh = renkoLow + 2.0 * offset;
                    renkoLow  = renkoLow - offset;
                }

                // Agrega la barra final parcial
                AddBar(bars, renkoLow + offset, Math.Max(renkoLow + offset, close), Math.Min(renkoLow + offset, close), close, time, volume);
                trend = -1;
            }
            // El precio de cierre mayor al renkolow
            else
            {
                // Actualiza la barra
                UpdateBar(bars, close, close, close, time, volume);
            }

            // El último precio el valor de cierre
            bars.LastPrice = close;
        }
示例#28
0
文件: BoxStyle.cs 项目: theprofe8/nt8
        public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
        {
            Bars       bars      = chartBars.Bars;
            float      chartMinX = ConvertToHorizontalPixels(chartControl, chartControl.CanvasLeft + chartControl.Properties.BarMarginRight);
            RectangleF rect      = new RectangleF();
            int        toIndex   = chartBars.ToIndex;

            if (toIndex >= 0 && toIndex < bars.Count - 1)
            {
                toIndex++;
            }

            for (int idx = chartBars.FromIndex; idx <= toIndex; idx++)
            {
                double closeValue             = bars.GetClose(idx);
                float  high                   = chartScale.GetYByValue(bars.GetHigh(idx));
                float  low                    = chartScale.GetYByValue(bars.GetLow(idx));
                double openValue              = bars.GetOpen(idx);
                Brush  overriddenBarBrush     = chartControl.GetBarOverrideBrush(chartBars, idx);
                Brush  overriddenOutlineBrush = chartControl.GetCandleOutlineOverrideBrush(chartBars, idx);
                float  x = chartControl.GetXByBarIndex(chartBars, idx);
                float  boxStartPosition;

                if (idx == chartBars.FromIndex && (toIndex == 0 || idx == 0))
                {
                    if (toIndex == 0)
                    {
                        boxStartPosition = chartMinX;
                    }
                    else
                    {
                        boxStartPosition = 2 * x - chartControl.GetXByBarIndex(chartBars, idx + 1);
                    }
                }
                else
                {
                    boxStartPosition = chartControl.GetXByBarIndex(chartBars, idx - 1);
                }

                if (Math.Abs(x - boxStartPosition) < 0.2)
                {
                    continue;
                }

                float width = Math.Max(2f, Math.Abs(x - boxStartPosition));

                if (closeValue > openValue)
                {
                    width      -= Stroke.Width;
                    rect.X      = boxStartPosition;
                    rect.Y      = high;
                    rect.Width  = width;
                    rect.Height = low - high;
                    TransformBrush(overriddenBarBrush ?? UpBrushDX, rect);
                    TransformBrush(overriddenOutlineBrush ?? Stroke.BrushDX, rect);
                    RenderTarget.FillRectangle(rect, overriddenBarBrush ?? UpBrushDX);
                    RenderTarget.DrawRectangle(rect, overriddenOutlineBrush ?? Stroke.BrushDX, Stroke.Width, Stroke.StrokeStyle);
                }
                else
                {
                    width      -= Stroke2.Width;
                    rect.X      = boxStartPosition;
                    rect.Y      = high;
                    rect.Width  = width;
                    rect.Height = low - high;
                    TransformBrush(overriddenBarBrush ?? DownBrushDX, rect);
                    TransformBrush(overriddenOutlineBrush ?? Stroke2.BrushDX, rect);
                    RenderTarget.FillRectangle(rect, overriddenBarBrush ?? DownBrushDX);
                    RenderTarget.DrawRectangle(rect, overriddenOutlineBrush ?? Stroke2.BrushDX, Stroke2.Width, Stroke2.StrokeStyle);
                }
            }
        }
示例#29
0
        protected override void OnDataPoint(Bars bars, double open, double high, double low, double close, DateTime time, long volume, bool isBar, double bid, double ask)
        {
            if (SessionIterator == null)
            {
                SessionIterator = new SessionIterator(bars);
            }

            bool isNewSession = SessionIterator.IsNewSession(time, isBar);

            if (isNewSession)
            {
                SessionIterator.GetNextSession(time, isBar);
            }
            if (bars.Count == 0 || bars.IsResetOnNewTradingDay && isNewSession)
            {
                AddBar(bars, open, high, low, close, time, volume);
            }
            else
            {
                double barClose   = bars.GetClose(bars.Count - 1);
                double barHigh    = bars.GetHigh(bars.Count - 1);
                double barLow     = bars.GetLow(bars.Count - 1);
                double tickSize   = bars.Instrument.MasterInstrument.TickSize;
                double rangeValue = Math.Floor(10000000.0 * bars.BarsPeriod.Value * tickSize) / 10000000.0;

                if (close.ApproxCompare(barLow + rangeValue) > 0)
                {
                    double newClose = barLow + rangeValue;                                     // Every bar closes either with high or low
                    if (newClose.ApproxCompare(barClose) > 0)
                    {
                        UpdateBar(bars, newClose, barLow, newClose, time, 0);
                    }

                    // If there's still a gap, fill with phantom bars
                    double newBarOpen = newClose + tickSize;
                    while (close.ApproxCompare(newClose) > 0)
                    {
                        newClose = Math.Min(close, newBarOpen + rangeValue);
                        AddBar(bars, newBarOpen, newClose, newBarOpen, newClose, time, close.ApproxCompare(newClose) > 0 ? 0 : volume);
                        newBarOpen = newClose + tickSize;
                    }
                }
                else if ((barHigh - rangeValue).ApproxCompare(close) > 0)
                {
                    double newClose = barHigh - rangeValue;                                     // Every bar closes either with high or low
                    if (barClose.ApproxCompare(newClose) > 0)
                    {
                        UpdateBar(bars, barHigh, newClose, newClose, time, 0);
                    }

                    // if there's still a gap, fill with phantom bars
                    double newBarOpen = newClose - tickSize;
                    while (newClose.ApproxCompare(close) > 0)
                    {
                        newClose = Math.Max(close, newBarOpen - rangeValue);
                        AddBar(bars, newBarOpen, newBarOpen, newClose, newClose, time, newClose.ApproxCompare(close) > 0 ? 0 : volume);
                        newBarOpen = newClose - tickSize;
                    }
                }
                else
                {
                    UpdateBar(bars, close > barHigh ? close : barHigh, close < barLow ? close : barLow, close, time, volume);
                }
            }
            bars.LastPrice = close;
        }
示例#30
0
		/// <summary>
		/// </summary>
		/// <param name="bars"></param>
		/// <param name="open"></param>
		/// <param name="high"></param>
		/// <param name="low"></param>
		/// <param name="close"></param>
		/// <param name="time"></param>
		/// <param name="volume"></param>
		/// <param name="isRealtime"></param>
		public override void Add(Bars bars, double open, double high, double low, double close, DateTime time, long volume, bool isRealtime)
		{
			#region Building Bars from Base Period

			if (bars.Count != tmpCount) // reset cache when bars are trimmed
				if (bars.Count == 0)
				{
					tmpTime			= Cbi.Globals.MinDate;
					tmpVolume		= 0;
					tmpDayCount		= 0;
					tmpTickCount	= 0;
				}
				else
				{
					tmpTime			= bars.GetTime(bars.Count - 1);
					tmpVolume		= bars.GetVolume(bars.Count - 1);
					tmpTickCount	= bars.TickCount;
					tmpDayCount		= bars.DayCount;
					bars.LastPrice	= anchorPrice = bars.GetClose(bars.Count - 1);
				}

			switch (bars.Period.BasePeriodType)
			{
				case PeriodType.Day:
					tmpTime = time.Date;
					if (isRealtime && time >= cacheSessionEnd)
					{
						tmpDayCount++;
						bars.Session.GetSessionDate(time, false, out tmpTime, out cacheSessionEnd);
						if (tmpTime < time.Date) tmpTime = time.Date; // make sure timestamps are ascending
					}

					if (!isRealtime && prevTimeD != tmpTime) tmpDayCount++;

					if ((!isRealtime && bars.Count > 0 && tmpTime == bars.TimeLastBar.Date)
						|| (isRealtime && bars.Count > 0 && tmpTime <= bars.TimeLastBar.Date)
						|| tmpDayCount < bars.Period.BasePeriodValue)
						endOfBar = false;
					else
					{
						prevTime	= prevTimeD == Cbi.Globals.MinDate ? tmpTime : prevTimeD;
						prevTimeD	= tmpTime;
						endOfBar	= true;
					}

					break;

				case PeriodType.Minute:

					if (tmpTime == Cbi.Globals.MinDate)
						prevTime = tmpTime = TimeToBarTimeMinute(bars, time, bars.Session.NextBeginTime, bars.Period.BasePeriodValue, isRealtime);

					if (!isRealtime && time <= tmpTime || isRealtime && time < tmpTime)
						endOfBar	= false;
					else
					{
						prevTime	= tmpTime;
						tmpTime		= TimeToBarTimeMinute(bars, time, bars.Session.NextBeginTime, bars.Period.BasePeriodValue, isRealtime);
						endOfBar	= true;
					}
					break;

				case PeriodType.Volume:
					if (tmpTime == Cbi.Globals.MinDate)
					{
						tmpVolume	= volume;
						endOfBar	= tmpVolume >= bars.Period.BasePeriodValue;
						prevTime	= tmpTime = time;
						if (endOfBar) 
							tmpVolume = 0;
						break;
					}

					tmpVolume += volume;
					endOfBar = tmpVolume >= bars.Period.BasePeriodValue;
					if (endOfBar)
					{
						prevTime = tmpTime;
						tmpVolume = 0;
						tmpTime = time;
					}
					break;

				case PeriodType.Month:
					if (tmpTime == Cbi.Globals.MinDate)
						prevTime	= tmpTime = TimeToBarTimeMonth(time, bars.Period.BasePeriodValue);

					if (time.Month <= tmpTime.Month && time.Year == tmpTime.Year || time.Year < tmpTime.Year)
						endOfBar	= false;
					else
					{
						prevTime	= tmpTime;
						endOfBar	= true;
						tmpTime		= TimeToBarTimeMonth(time, bars.Period.BasePeriodValue);
					}
					break;

				case PeriodType.Second:
					if (tmpTime == Cbi.Globals.MinDate)
					{
						prevTime = tmpTime = TimeToBarTimeSecond(bars, time,
																	new DateTime(bars.Session.NextBeginTime.Year,
																				bars.Session.NextBeginTime.Month,
																				bars.Session.NextBeginTime.Day,
																				bars.Session.NextBeginTime.Hour,
																				bars.Session.NextBeginTime.Minute, 0),
																	bars.Period.BasePeriodValue);
					}
					if (time <= tmpTime)
						endOfBar	= false;
					else
					{
						prevTime	= tmpTime;
						tmpTime		= TimeToBarTimeSecond(bars, time, bars.Session.NextBeginTime, bars.Period.BasePeriodValue);
						endOfBar	= true;
					}
					break;

				case PeriodType.Tick:
					if (tmpTime == Cbi.Globals.MinDate || bars.Period.BasePeriodValue == 1)
					{
						prevTime		= tmpTime = time;
						tmpTickCount	= bars.Period.BasePeriodValue == 1 ? 0 : 1;
						endOfBar		= bars.Period.BasePeriodValue == 1;
						break;
					}

					if (tmpTickCount < bars.Period.BasePeriodValue)
					{
						tmpTime			= time;
						endOfBar		= false;
						tmpTickCount++;
					}
					else
					{
						prevTime		= tmpTime;
						tmpTime			= time;
						endOfBar		= true;
						tmpTickCount	= 1;
					}
					break;

				case PeriodType.Week:
					if (tmpTime == Cbi.Globals.MinDate)
						prevTime = tmpTime = TimeToBarTimeWeek(time.Date, tmpTime.Date, bars.Period.BasePeriodValue);
					if (time.Date <= tmpTime.Date)
						endOfBar	= false;
					else
					{
						prevTime	= tmpTime;
						endOfBar	= true;
						tmpTime		= TimeToBarTimeWeek(time.Date, tmpTime.Date, bars.Period.BasePeriodValue);
					}
					break;

				case PeriodType.Year:
					if (tmpTime == Cbi.Globals.MinDate)
						prevTime = tmpTime = TimeToBarTimeYear(time, bars.Period.Value);
					if (time.Year <= tmpTime.Year)
						endOfBar	= false;
					else
					{
						prevTime	= tmpTime;
						endOfBar	= true;
						tmpTime		= TimeToBarTimeYear(time, bars.Period.Value);
					}
					break;
				default:
					break;
			}
			#endregion
			#region P&F logic
			double tickSize		= bars.Instrument.MasterInstrument.TickSize;
			boxSize				= Math.Floor(10000000.0 * bars.Period.Value * tickSize) / 10000000.0;
			reversalSize		= bars.Period.Value2 * boxSize;

			if (bars.Count == 0 || (IsIntraday && bars.IsNewSession(time, isRealtime)))
			{
				if (bars.Count > 0)
				{
					double		lastOpen	= bars.GetOpen(bars.Count - 1);
					double		lastHigh	= bars.GetHigh(bars.Count - 1);
					double		lastLow		= bars.GetLow(bars.Count - 1);
					double		lastClose	= bars.GetClose(bars.Count - 1);
					DateTime	lastTime	= bars.GetTime(bars.Count - 1);
					bars.LastPrice			= anchorPrice = lastClose;

					if (bars.Count == tmpCount)
						CalculatePfBar(bars, lastOpen, lastHigh, lastLow, lastClose, prevTime, lastTime, isRealtime);
				}

				AddBar(bars, close, close, close, close, tmpTime, volume, isRealtime);
				anchorPrice		= close;
				trend			= Trend.Undetermined;
				prevTime		= tmpTime;
				volumeCount		= 0;
				bars.LastPrice	= close;
				tmpCount		= bars.Count;
				tmpHigh			= high;
				tmpLow			= low;
				return;
			}

			Bar			bar		= (Bar)bars.Get(bars.Count - 1);
			double		c		= bar.Close;
			double		o		= bar.Open;
			double		h		= bar.High;
			double		l		= bar.Low;
			DateTime	t		= bar.Time;

			if (endOfBar)
			{
				CalculatePfBar(bars, o, h, l, c, prevTime, t, isRealtime);
				volumeCount		= volume;
				tmpHigh			= high;
				tmpLow			= low;
			}
			else
			{
				tmpHigh			= (high > tmpHigh ? high : tmpHigh);
				tmpLow			= (low < tmpLow ? low : tmpLow);
				volumeCount		+= volume;
			}

			bars.LastPrice		= close;
			tmpCount			= bars.Count;

			#endregion
		}
        //protected override void OnBarUpdate()
        //{
        //    //TODO: Write your owner OnBarUpdate handling


        //    //DrawArrowUp("Arrowup" + CurrentBar, true, Bars.GetTime(Count - 1), Bars.GetLow(CurrentBar) - 300 * TickSize, Color.Red);
        //    //DrawArrowDown("Arrowdown" + CurrentBar, true, Bars.GetTime(Count - 1), Bars.GetHigh(CurrentBar) + 300 * TickSize, Color.Green);

        //    //Occurred.Set(-1);
        //    //Entry.Set(Close[0]);

        //}

        protected override void OnBarUpdate()
        {
            //MyGap.Set(Input[0]);

            if (Bars != null && Bars.Count > 0)
            //             && TimeFrame.Periodicity == DatafeedHistoryPeriodicity.Minute
            //             && TimeFrame.PeriodicityValue == 15)
            {
            }
            else
            {
                return;
            }

            if (Bars.BarsSinceSession == 0)
            {
                sessionprocessed = false;
            }

            //08.00, 08.15, 08.30, 08.45, 09.00 sind abgeschlossen -> es ist 09.15)
            //                if(Bars.BarsSinceSession == 5)
            if (ToTime(Bars.GetTime(CurrentBar)) > 90000 && //größer 09.00 geht für 15M und 1Std (und 1Tag?)
                sessionprocessed == false)       //Tag noch nicht verarbeitet
            {
                sessionprocessed = true;
                GapTradeLong     = GapTradeShort = false;

                IBar   GapOpenBar = Bars.Where(x => x.Time.Date == Bars[0].Time.Date).FirstOrDefault(); //liefert erster kerze des tages
                double GapOpen    = GapOpenBar.Open;

                double   LastDayClose     = PriorDayOHLC().PriorClose[0];
                double   GapSize          = GapOpen - LastDayClose;
                DateTime LastDayCloseDate = Bars.GetTime(Count - 7);
                DateTime LastPeriod       = Time[1];

                if (LastDayClose != null &&
                    Math.Abs(LastDayClose - GapOpen) > _PunkteGapMin &&
                    Math.Abs(LastDayClose - GapOpen) < _PunkteGapMax)
                {  //Wenn Gap größer 50 und kleiner 100
                    existgap = true;


                    //Gap markieren (08.00 - 09.15)
                    string strMyRect    = "MyRect" + Count;
                    string strMyGapSize = "MyGapSize" + Count;


                    if (LastDayClose - GapOpen < 0)   //Long
                    {
                        //Long
                        //DrawRectangle(strMyRect, true, LastDayCloseDate, LastDayClose, LastPeriod, HighestHighPrice(5)[0], _col_gap, _col_gap, 70);
                        DrawText(strMyGapSize, true, Math.Round(GapSize, 1).ToString(), LastDayCloseDate, LastDayClose + 25, 9, Color.Black, new Font("Areal", 9), StringAlignment.Center, Color.Black, Color.Azure, 1);

                        // if (LinReg(5)[0] > GapOpen)
                        if (LinReg(Closes[0], 5)[0] > GapOpen)
                        {
                            //Chancenreicher SuccessTrade
                            string strArrowUp = "ArrowUp" + Bars.GetTime(CurrentBar);
                            DrawArrowUp(strArrowUp, true, Bars.GetTime(Count - 1), Bars.GetOpen(CurrentBar) - 300 * TickSize, Color.Green);
                            GapTradeLong = true;

                            Occurred.Set(1);
                            Entry.Set(Bars.GetOpen(CurrentBar));
                        }
                    }
                    else
                    {
                        //Short
                        //DrawRectangle(strMyRect, true, LastDayCloseDate, LastDayClose, LastPeriod, LowestLowPrice(5)[0], Color.Pink, Color.Pink, 70);
                        DrawText(strMyGapSize, true, Math.Round(GapSize, 1).ToString(), LastDayCloseDate, LastDayClose - 25, 9, Color.Black, new Font("Areal", 9), StringAlignment.Center, Color.Black, Color.Azure, 1);

                        if (LinReg(Closes[0], 5)[0] < GapOpen)
                        {
                            ////Chancenreicher SuccessTrade
                            string strArrowDown = "ArrowDown" + Bars.GetTime(CurrentBar);
                            DrawArrowDown(strArrowDown, true, Bars.GetTime(Count - 1), Bars.GetOpen(CurrentBar) + 300 * TickSize, Color.Red);
                            GapTradeShort = true;

                            Occurred.Set(-1);
                            Entry.Set(Bars.GetOpen(CurrentBar));
                        }
                    }

                    if (GapTradeShort == true || GapTradeLong == true)
                    {
                        Print("------------------" + Time[5] + "------------------");
                        Print("LineReg: " + Math.Round(LinReg(5)[0]), 1);
                        Print("Gap Open: " + GapOpen);
                    }
                }
                else
                {
                    existgap = false;
                }
            }

//09.15. - 09.30 Kerze
            else if (Bars.BarsSinceSession == 6 && existgap == true)
            {
                //Auswertung
                decimal GapTradeResult;
                Color   colorTextBox;

                GapTradeResult = (decimal)Bars.GetClose(CurrentBar - 1) - (decimal)Bars.GetOpen(CurrentBar - 1);
                if (GapTradeLong == true)
                {
                    //Long
                    GapTradeCounterLong    += 1;
                    GapTradeResultTotalLong = GapTradeResultTotalLong + GapTradeResult;


                    string strGapeTradeLong = "GapTradeLong" + CurrentBar;
                    string strTradeResultLong;

                    if (GapTradeResult < 0)
                    {
                        Print("FAAAAAAAAAAAAAAAIIIIIIIIIIIIIILLLLLLLLLL");
                        GapTradeFailCounterLong += 1;
                        strTradeResultLong       = "Fail " + GapTradeResult.ToString();
                        colorTextBox             = colFail;
                    }
                    else
                    {
                        GapTradeWinCounterLong += 1;
                        strTradeResultLong      = "Win " + GapTradeResult.ToString();
                        colorTextBox            = colWin;
                    }
                    DrawText(strGapeTradeLong, true, strTradeResultLong, Time[1], Bars.GetHigh(CurrentBar - 1) + 10, 9, Color.Black, new Font("Areal", 9), StringAlignment.Center, Color.Black, colorTextBox, 70);
                }
                else if (GapTradeShort == true)
                {
                    //Short
                    GapTradeCounterShort    += 1;
                    GapTradeResultTotalShort = GapTradeResultTotalShort - GapTradeResult;


                    string strGapeTradeShort = "GapTradeLong" + CurrentBar;
                    string strTradeResultShort;

                    if (GapTradeResult > 0)
                    {
                        Print("FAAAAAAAAAAAAAAAIIIIIIIIIIIIIILLLLLLLLLL");
                        GapTradeFailCounterShort += 1;
                        strTradeResultShort       = "Fail " + GapTradeResult.ToString();
                        colorTextBox              = colFail;
                    }
                    else
                    {
                        GapTradeWinCounterShort += 1;
                        strTradeResultShort      = "Win " + GapTradeResult.ToString();
                        colorTextBox             = colWin;
                    }
                    DrawText(strGapeTradeShort, true, strTradeResultShort, Time[1], Bars.GetLow(CurrentBar - 1) - 10, 9, Color.Black, new Font("Areal", 9), StringAlignment.Center, Color.Black, colorTextBox, 70);
                }

                Print("Gap Trade Result: " + GapTradeResult);
            }

            if (Count == Bars.Count - 1)
            {
                Print("Total Trades Long:  " + GapTradeCounterLong);
                Print("Wins Long: " + GapTradeWinCounterLong);
                Print("Fails Long: " + GapTradeFailCounterLong);

                Print("Total Trades Short: " + GapTradeCounterShort);
                Print("Wins Short: " + GapTradeWinCounterShort);
                Print("Fails Short: " + GapTradeFailCounterShort);

                if (GapTradeCounterLong > 0)
                {
                    Print("Avg Long: " + (GapTradeResultTotalLong / GapTradeCounterLong));
                }
                if (GapTradeCounterShort > 0)
                {
                    Print("Avg Short: " + (GapTradeResultTotalShort / GapTradeCounterShort));
                }
            }
        }
示例#32
0
        private void plotSwingPivots(Dictionary <int, string> reducedPivots, string prefix)
        {
            List <int> orderedMarkers = reducedPivots.Keys.ToList();

            orderedMarkers.Sort();

            int    objnum   = 0;
            string previous = "";

            foreach (int marker in orderedMarkers)
            {
                if (reducedPivots[marker].Equals(MIN_MAX) && previous.Equals(MAX))
                {
                    DateTime timeValue = Bars.GetSessionEndTime(marker);
                    Draw.Diamond(this, objnum.ToString() + prefix + "M", false, timeValue, Bars.GetLow(marker), Brushes.Blue);
                    objnum++;
                    timeValue = Bars.GetSessionEndTime(marker);
                    Draw.Diamond(this, objnum.ToString() + prefix + "M", false, timeValue, Bars.GetHigh(marker), Brushes.White);
                    objnum++;
                }
                else if (reducedPivots[marker].Equals(MIN_MAX) && previous.Equals(MIN))
                {
                    DateTime timeValue = Bars.GetSessionEndTime(marker);
                    Draw.Diamond(this, objnum.ToString() + prefix + "M", false, timeValue, Bars.GetHigh(marker), Brushes.White);
                    objnum++;
                    timeValue = Bars.GetSessionEndTime(marker);
                    Draw.Diamond(this, objnum.ToString() + prefix + "M", false, timeValue, Bars.GetLow(marker), Brushes.Blue);
                    objnum++;
                }
                else if (reducedPivots[marker].Equals(MAX))
                {
                    DateTime timeValue = Bars.GetSessionEndTime(marker);
                    Draw.Diamond(this, objnum.ToString() + prefix + "M", false, timeValue, Bars.GetHigh(marker), Brushes.White);
                    objnum++;
                }
                else
                {
                    DateTime timeValue = Bars.GetSessionEndTime(marker);
                    Draw.Diamond(this, objnum.ToString() + prefix + "M", false, timeValue, Bars.GetLow(marker), Brushes.Blue);
                    objnum++;
                }
                previous = reducedPivots[marker];
            }
        }