public override void Calculate(int index) { if (_incorrectColors) { var errorColor = _random.Next(2) == 0 ? Colors.Red : Colors.White; ChartObjects.DrawText("Error", "Incorrect colors", StaticPosition.Center, errorColor); return; } var open = MarketSeries.Open[index]; var high = MarketSeries.High[index]; var low = MarketSeries.Low[index]; var close = MarketSeries.Close[index]; var MA = _ma.Result[index]; MaResult[index] = MA; if (MA < close) { color = open > close ? _AboveDownColor : _AboveUpColor; } if (MA >= close) { color = open > close ? _BelowDownColor : _BelowUpColor; } ChartObjects.DrawLine("candle" + index, index, open, index, close, color, CandleWidth, LineStyle.Solid); ChartObjects.DrawLine("line" + index, index, high, index, low, color, WickWidth, LineStyle.Solid); }
public override void Calculate(int index) { for (int i = 0; i < DaysToShow; i++) { DateTime startOfDay = daily.OpenTime.Last(i).Date.AddDays(1).AddHours(ShiftInHours); DateTime endOfDay = startOfDay.AddDays(1); var dailyHigh = daily.High.Last(i); var dailyLow = daily.Low.Last(i); var fib618n = dailyLow - (dailyHigh - dailyLow) * 0.618; var fib382 = dailyLow + (dailyHigh - dailyLow) * 0.382; var fib500 = dailyLow + (dailyHigh - dailyLow) * 0.5; var fib618 = dailyLow + (dailyHigh - dailyLow) * 0.618; var fib1618 = dailyLow + (dailyHigh - dailyLow) * 0.618; ChartObjects.DrawLine("-61.8%" + i, startOfDay, fib618n, endOfDay, fib618n, Colors.Gray, 1, LineStyle.LinesDots); ChartObjects.DrawLine("0.0%" + i, startOfDay, dailyHigh, endOfDay, dailyHigh, Colors.Gray, 1); ChartObjects.DrawLine("38.2%" + i, startOfDay, fib382, endOfDay, fib382, Colors.Gray, 1, LineStyle.LinesDots); ChartObjects.DrawLine("50.0%" + i, startOfDay, fib500, endOfDay, fib500, Colors.Gray, 1, LineStyle.Solid); ChartObjects.DrawLine("61.8%" + i, startOfDay, fib618, endOfDay, fib618, Colors.Gray, 1, LineStyle.LinesDots); ChartObjects.DrawLine("100.0%" + i, startOfDay, dailyLow, endOfDay, dailyLow, Colors.Gray, 1); ChartObjects.DrawLine("161.8%" + i, startOfDay, fib1618, endOfDay, fib1618, Colors.Gray, 1, LineStyle.LinesDots); } }
//----------------------------------------------------------------------------------------------- // SCALPER SIGNAL FUNCTION ---------------------------------------------------------------------- //----------------------------------------------------------------------------------------------- private void SignalScalper_Main(int index) { if (!NewBar(index) || (index < 6)) { return; } ATR = Indicators.AverageTrueRange(14, MovingAverageType.Exponential); double bs = BuySignal(index); double ss = SellSignal(index); if (bs > 0) { BuyIndicator[index] = bs; SignalBarHigh[index - 3] = MarketSeries.High[index - 3]; SignalBarLow[index - 3] = MarketSeries.Low[index - 3]; ChartObjects.DrawLine("SignalBar" + (index - 3), index - 3, SignalBarHigh[index - 3], index - 3, SignalBarLow[index - 3], Colors.Gold, 3, LineStyle.Solid); } else if (ss > 0) { SellIndicator[index] = ss; SignalBarHigh[index - 3] = MarketSeries.High[index - 3]; SignalBarLow[index - 3] = MarketSeries.Low[index - 3]; ChartObjects.DrawLine("SignalBar" + (index - 3), index - 3, SignalBarHigh[index - 3], index - 3, SignalBarLow[index - 3], Colors.Gold, 3, LineStyle.Solid); } }
public override void Calculate(int index) { if (!IsLastBar) { c = M1.Close.Last(7000) / Symbol.PipSize; nu = (c - (c % pips)) * Symbol.PipSize; onu = nu; buff[0] = nu; for (int i = 7000; i > 0; i--) { c = M1.Median.Last(i); push(); } return; } ind = index; c = M1.Close.Last(0); push(); for (int i = 0; i < 150; i++) { if (buff[i + 1] < buff[i]) { ChartObjects.DrawLine(string.Format("li_{0}", ind - i), ind - i, buff[i + 1], ind - i, buff[i], Colors.SeaGreen, 5, LineStyle.Solid); } else { ChartObjects.DrawLine(string.Format("li_{0}", ind - i), ind - i, buff[i + 1] - Symbol.PipSize * pips, ind - i, buff[i] - Symbol.PipSize * pips, Colors.Tomato, 5, LineStyle.Solid); } } }
public override void Calculate(int index) { if (TimeFrame >= TimeFrame.Daily) { return; } var todayStartIndex = GetStartDayIndex(index); if (todayStartIndex == 0) { return; } var yesterdayStartIndex = GetStartDayIndex(todayStartIndex - 1); var yHigh = GetHigh(yesterdayStartIndex, todayStartIndex - 1); var yLow = GetLow(yesterdayStartIndex, todayStartIndex - 1); var yClose = MarketSeries.Close[todayStartIndex - 1]; var pivot = (yHigh + yLow + yClose) / 3; var bc = (yHigh + yLow) / 2; var tc = pivot - bc + pivot; ChartObjects.DrawLine("pivot" + todayStartIndex, todayStartIndex, pivot, index + 1, pivot, Colors.Yellow); ChartObjects.DrawLine("bc" + todayStartIndex, todayStartIndex, bc, index + 1, bc, Colors.Yellow); ChartObjects.DrawLine("tc" + todayStartIndex, todayStartIndex, tc, index + 1, tc, Colors.Yellow); }
public override void Calculate(int index) { if (index <= HeikenPeriod) { xOpen[index] = Math.Round((MarketSeries.Open[index] + MarketSeries.Close[index]) / 2, Symbol.Digits); xClose[index] = Math.Round((MarketSeries.Open[index] + MarketSeries.Low[index] + MarketSeries.High[index] + MarketSeries.Close[index]) / 4, Symbol.Digits); xHigh[index] = MarketSeries.High[index]; xLow[index] = MarketSeries.Low[index]; return; } xOpen[index] = Math.Round((xOpen[index - 1] + xClose[index - 1]) / 2, Symbol.Digits); xClose[index] = Math.Round((MarketSeries.Open[index] + MarketSeries.Low[index] + MarketSeries.High[index] + MarketSeries.Close[index]) / 4, Symbol.Digits); xHigh[index] = Math.Max(MarketSeries.High[index], Math.Max(xOpen[index], xClose[index])); xLow[index] = Math.Min(MarketSeries.Low[index], Math.Min(xOpen[index], xClose[index])); if (xClose[index] < xOpen[index]) { ChartObjects.DrawLine("OpenClose-" + index.ToString(), index, xOpen[index], index, xClose[index], Colors.Magenta, 5, LineStyle.Solid); ChartObjects.DrawLine("HighLow-" + index.ToString(), index, xHigh[index], index, xLow[index], Colors.Magenta, 1, LineStyle.Solid); } else { ChartObjects.DrawLine("OpenClose-" + index.ToString(), index, xOpen[index], index, xClose[index], Colors.Lime, 5, LineStyle.Solid); ChartObjects.DrawLine("HighLow-" + index.ToString(), index, xHigh[index], index, xLow[index], Colors.Lime, 1, LineStyle.Solid); } }
private void RefreshRenkoChart(int index) { foreach (var renko in renkos) { var i = renkos.Count() - renko.Index; if (ReferenceMode) { Result[index - i] = renko.Movement > 0 ? 1 : -1; } else { Result[index - i] = renko.Value; var y1 = renkoLastValue + (Result[index] > renkoLastValue ? +renkoPips / 2 : -renkoPips / 2); var y2 = Result[index] + (Result[index] > renkoLastValue ? +renkoPips / 2 : -renkoPips / 2); var color = Result[index] > Result[index - 1] ? colorBull : colorBear; ChartObjects.DrawLine("renko0", index, y1, index, y2, color, thickness, LineStyle.Solid); if (i < BricksToShow) { ChartObjects.DrawLine("renko" + i, index - i, Result[index - i] - renkoPips / 2, index - i, Result[index - i] + renkoPips / 2, renko.Movement > 0 ? colorBull : colorBear, thickness, LineStyle.Solid); } } } }
//+-------------------------------------------------------------------------------------------------+ private void DrawRectangle(string objectName, int x, double y, int width, double height, Colors color, int thickness, LineStyle style) { ChartObjects.DrawLine(objectName + "a", x, y, x + width, y, color, thickness, style); ChartObjects.DrawLine(objectName + "b", x + width, y, x + width, y + height, color, thickness, style); ChartObjects.DrawLine(objectName + "c", x + width, y + height, x, y + height, color, thickness, style); ChartObjects.DrawLine(objectName + "d", x, y + height, x, y, color, thickness, style); }
private void ReDraw() { ChartObjects.RemoveAllObjects(); foreach (Alert alert in alerts) { if (MarketSeries.OpenTime.LastValue.AddMinutes(Period()) < alert.setup) { return; } if (!alert.inArgs) { continue; } Colors color; int periods = MarketSeries.OpenTime.Count - MarketSeries.OpenTime.GetIndexByTime(alert.setup); bool crossed = MarketSeries.Close.HasCrossedAbove(alert.price, periods) || MarketSeries.Close.HasCrossedBelow(alert.price, periods); bool near = Math.Abs(MarketSeries.Close.LastValue - alert.price) <= AlertDiapasone * Symbol.PipSize; if (near && Sound && alert.played > 0 && (alert.lastPlayed == null || DateTime.UtcNow.AddMinutes(-1) >= alert.lastPlayed)) { Notifications.PlaySound(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "Ring.wav")); alert.lastPlayed = DateTime.UtcNow; --alert.played; } if (Visual && (crossed || near)) { color = Colors.Red; } else { color = Colors.CornflowerBlue; } ChartObjects.DrawText(string.Format("alert_{0}", alert.price), string.Format("| {0}{1}", alert.price, near ? string.Format(" ({0})", Math.Round(Math.Abs(MarketSeries.Close.LastValue - alert.price) / Symbol.PipSize), 1) : ""), MarketSeries.OpenTime.Count + 1, alert.price, VerticalAlignment.Center, HorizontalAlignment.Right, color); if (ContignousType == 0) { for (int j = MarketSeries.Close.Count - 1; j > 0 && alert.index == 0; --j) { if (MarketSeries.Low[j] <= alert.price && MarketSeries.High[j] >= alert.price) { alert.index = j; } } } else { alert.index = 1; } if (alert.index != 0) { ChartObjects.DrawLine(string.Format("alert_{0}_l", alert.price), alert.index, alert.price, MarketSeries.OpenTime.Count + 1, alert.price, color, Thickness, LineStyle.Dots); } } }
public override void Calculate(int index) { if (_incorrectColors) { var errorColor = _random.Next(2) == 0 ? Colors.Red : Colors.White; ChartObjects.DrawText("Error", "Incorrect colors", StaticPosition.Center, errorColor); return; } var open = MarketSeries.Open[index]; var high = MarketSeries.High[index]; var low = MarketSeries.Low[index]; var close = MarketSeries.Close[index]; var haClose = (open + high + low + close) / 4; double haOpen; if (index > 0) { haOpen = (_haOpen[index - 1] + _haClose[index - 1]) / 2; } else { haOpen = (open + close) / 2; } _haOpen[index] = haOpen; _haClose[index] = haClose; var color = haOpen > haClose ? _downColor : _upColor; //Print("", haOpen, haClose, color); ChartObjects.DrawLine("upback" + index, index, high + BackHeight / 7, index, high + BackHeight / 2, color, BackWidth, LineStyle.Solid); ChartObjects.DrawLine("downback" + index, index, low - BackHeight / 7, index, low - BackHeight / 2, color, BackWidth, LineStyle.Solid); }
public override void Calculate(int index) { if (!IsLastBar) { return; } ChartObjects.DrawVerticalLine("vLine", index - Period, _colorLine); int maxIndex = index; double max = Source[index]; for (int i = index - Period; i <= index; i++) { if (max >= Source[i]) { continue; } max = Source[i]; maxIndex = i; } var text = "max " + max.ToString("0.0000"); var top = VerticalAlignment.Top; var center = HorizontalAlignment.Center; ChartObjects.DrawText("max", text, maxIndex, max + 0.0002, top, center, _colorText); ChartObjects.DrawLine("line", maxIndex, max, index, Source[index], _colorLine); }
public override void Calculate(int index) { double middle = (((MarketSeries.High[index] + MarketSeries.Low[index]) / 2) + ((MarketSeries.High[index - 1] + MarketSeries.Low[index - 1]) / 2) + ((MarketSeries.High[index - 2] + MarketSeries.Low[index - 2]) / 2) + ((MarketSeries.High[index - 3] + MarketSeries.Low[index - 3]) / 2) + ((MarketSeries.High[index - 4] + MarketSeries.Low[index - 4]) / 2)) / 5; double scale = (((MarketSeries.High[index] - MarketSeries.Low[index]) + (MarketSeries.High[index - 1] - MarketSeries.Low[index - 1]) + (MarketSeries.High[index - 2] - MarketSeries.Low[index - 2]) + (MarketSeries.High[index - 3] - MarketSeries.Low[index - 3]) + (MarketSeries.High[index - 4] - MarketSeries.Low[index - 4])) / 5) * 0.2; High[index] = (MarketSeries.High[index] - middle) / scale; Low[index] = (MarketSeries.Low[index] - middle) / scale; Open[index] = (MarketSeries.Open[index] - middle) / scale; Close[index] = (MarketSeries.Close[index] - middle) / scale; if (Open[index] > Close[index]) { ChartObjects.DrawLine(string.Format("CRS_High_{0}", index), index, High[index], index, Low[index], Colors.Gray, 1, LineStyle.Solid); ChartObjects.DrawLine(string.Format("CRS_Open_{0}", index), index, Open[index], index, Close[index], Colors.DimGray, 11, LineStyle.Solid); } else { ChartObjects.DrawLine(string.Format("CRS_Low_{0}", index), index, High[index], index, Low[index], Colors.Gray, 1, LineStyle.Solid); ChartObjects.DrawLine(string.Format("CRS_Close_{0}", index), index, Open[index], index, Close[index], Colors.LightGray, 11, LineStyle.Solid); } SellLine1[index] = 6; SellLine2[index] = 8; BuyLine1[index] = -6; BuyLine2[index] = -8; }
private void LinearRegression(DataSeries series) { // Linear regresion double sum_x = 0, sum_x2 = 0, sum_y = 0, sum_xy = 0; int start = series.Count - Bars; int end = series.Count - 1; for (int i = start; i <= end; i++) { sum_x += 1.0 * i; sum_x2 += 1.0 * i * i; sum_y += series[i]; sum_xy += series[i] * i; } double a = (Bars * sum_xy - sum_x * sum_y) / (Bars * sum_x2 - sum_x * sum_x); double b = (sum_y - a * sum_x) / Bars; // Calculate maximum and standard devaitions double maxDeviation = 0; double sumDevation = 0; for (int i = start; i <= end; i++) { double price = a * i + b; maxDeviation = Math.Max(Math.Abs(series[i] - price), maxDeviation); sumDevation += Math.Pow(series[i] - price, 2.0); } double stdDeviation = Math.Sqrt(sumDevation / Bars); // draw in future end += 20; double pr1 = a * start + b; double pr2 = a * end + b; if (ShowCenter) { ChartObjects.DrawLine("center", start, pr1, end, pr2, color, LineThickness, LineStyle.Lines); } if (ShowChannel) { ChartObjects.DrawLine("top", start, pr1 + maxDeviation, end, pr2 + maxDeviation, color, LineThickness, LineStyle.Solid); ChartObjects.DrawLine("bottom", start, pr1 - maxDeviation, end, pr2 - maxDeviation, color, LineThickness, LineStyle.Solid); } if (ShowDeviantion) { ChartObjects.DrawLine("dev-top", start, pr1 + stdDeviation, end, pr2 + stdDeviation, color, LineThickness, LineStyle.DotsVeryRare); ChartObjects.DrawLine("dev-bottom", start, pr1 - stdDeviation, end, pr2 - stdDeviation, color, LineThickness, LineStyle.DotsVeryRare); } }
public override void Calculate(int index) { if (EnableTrendLines) { for (int i = 0; i < PreviousBars; i++) { if (wma.Result.Last(i) >= wma.Result.Last(i + 1)) { double high = double.MinValue; double offset = 0; for (int j = i; j < PreviousBars; j++) { if (MarketSeries.High.Last(j) > high) { high = MarketSeries.High.Last(j); offset = high - wma.Result.Last(j); } if (wma.Result.Last(j) <= wma.Result.Last(j + 1)) { ChartObjects.DrawLine("trend" + i, index - i, wma.Result.Last(i), index - j, wma.Result.Last(j), Colors.Green, 2, LineStyle.Solid); if (EnableTrendChannel) { //ChartObjects.DrawLine("trendhigh" + i, index - i, wma.Result.Last(i) + offset, index - j, wma.Result.Last(j) + offset, Colors.White, 1, LineStyle.Solid); ChartObjects.DrawLine("trendlow" + i, index - i, wma.Result.Last(i) - offset, index - j, wma.Result.Last(j) - offset, Colors.White, 1, LineStyle.DotsRare); } i = j; break; } } } else if (wma.Result.Last(i) <= wma.Result.Last(i + 1)) { double low = double.MaxValue; double offset = 0; for (int j = i; j < PreviousBars; j++) { if (MarketSeries.Low.Last(j) < low) { low = MarketSeries.Low.Last(j); offset = wma.Result.Last(j) - low; } if (wma.Result.Last(j) >= wma.Result.Last(j + 1)) { ChartObjects.DrawLine("trend" + i, index - i, wma.Result.Last(i), index - j, wma.Result.Last(j), Colors.Red, 2, LineStyle.Solid); if (EnableTrendChannel) { ChartObjects.DrawLine("trendhigh" + i, index - i, wma.Result.Last(i) + offset, index - j, wma.Result.Last(j) + offset, Colors.White, 1, LineStyle.DotsRare); //ChartObjects.DrawLine("trendlow" + i, index - i, wma.Result.Last(i) - offset, index - j, wma.Result.Last(j) - offset, Colors.White, 1, LineStyle.Solid); } i = j; break; } } } } } }
public override void Calculate(int index) { if (_incorrectColors) { var errorColor = _random.Next(2) == 0 ? Colors.Red : Colors.White; ChartObjects.DrawText("Error", "Incorrect colors", StaticPosition.Center, errorColor); return; } if ((Server.Time.Minute == 4 || Server.Time.Minute == 9 || Server.Time.Minute == 14 || Server.Time.Minute == 19 || Server.Time.Minute == 24 || Server.Time.Minute == 29 || Server.Time.Minute == 34 || Server.Time.Minute == 39 || Server.Time.Minute == 44 || Server.Time.Minute == 49 || Server.Time.Minute == 54 || Server.Time.Minute == 59) && Server.Time.Second > 55) { var open = MarketSeries.Open[index]; var high = MarketSeries.High[index]; var low = MarketSeries.Low[index]; var close = MarketSeries.Close[index]; var open1 = MarketSeries.Open[index - 1]; var high1 = MarketSeries.High[index - 1]; var low1 = MarketSeries.Low[index - 1]; var close1 = MarketSeries.Close[index - 1]; var open2 = MarketSeries.Open[index - 2]; var high2 = MarketSeries.High[index - 2]; var low2 = MarketSeries.Low[index - 2]; var close2 = MarketSeries.Close[index - 2]; var open3 = MarketSeries.Open[index - 3]; var high3 = MarketSeries.High[index - 3]; var low3 = MarketSeries.Low[index - 3]; var close3 = MarketSeries.Close[index - 3]; var open4 = MarketSeries.Open[index - 4]; var high4 = MarketSeries.High[index - 4]; var low4 = MarketSeries.Low[index - 4]; var close4 = MarketSeries.Close[index - 4]; Close = close; double Open; if (index > 0) { Open = open4; } else { Open = open4; } High = Math.Max(Math.Max(Math.Max(Math.Max(high, high1), high2), high3), high4); Low = Math.Min(Math.Min(Math.Min(Math.Min(low, low1), low2), low3), low4); var color = Open > Close ? _downColor : _upColor; ChartObjects.DrawLine("candle" + index, index, Open, index, Close, color, CandleWidth, LineStyle.Solid); ChartObjects.DrawLine("line" + index, index, High, index, Low, color, 1, LineStyle.Solid); _Open[index] = Open; _Close[index] = Close; } }
private void DrawTrendLine(string lineName, int startIndex, int endIndex, int index1, double value1, int index2, double value2) { double gradient = (value2 - value1) / (index2 - index1); double startValue = value1 + (startIndex - index1) * gradient; double endValue = value1 + (endIndex - index1) * gradient; ChartObjects.DrawLine(lineName, startIndex, startValue, endIndex, endValue, Colors.Gray); ChartObjects.DrawLine(lineName + "_red", index1, value1, index2, value2, Colors.Red); }
public void drawLines(int index, int[] values) { ChartObjects.DrawLine("topline", index - width, Symbol.Bid, index, Symbol.Bid, totalColor, 1, LineStyle.Solid); for (int i = 0; i < scores.Length + 2; i++) { ChartObjects.DrawLine("line" + i, index - i * width / 7, Symbol.Bid, index - i * width / 7, Symbol.Bid - height * Symbol.PipSize, totalColor, 1, LineStyle.Solid); } ChartObjects.DrawLine("bottomline", index - width, Symbol.Bid - height * Symbol.PipSize, index, Symbol.Bid - height * Symbol.PipSize, totalColor, 1, LineStyle.Solid); for (int i = 0; i < scores.Length; i++) { Colors color = Colors.Red; if (values[i] > 0) { color = Colors.Green; ChartObjects.DrawText(timeframes[i].ToString() + "Value", "+" + values[i], index - (i + 2) * width / 7 + width / 14, Symbol.Bid - height * Symbol.PipSize, VerticalAlignment.Top, HorizontalAlignment.Center, color); } else if (values[i] < 0) { color = Colors.Red; ChartObjects.DrawText(timeframes[i].ToString() + "Value", "" + values[i], index - (i + 2) * width / 7 + width / 14, Symbol.Bid - height * Symbol.PipSize, VerticalAlignment.Top, HorizontalAlignment.Center, color); } else { color = Colors.White; ChartObjects.DrawText(timeframes[i].ToString() + "Value", "" + values[i], index - (i + 2) * width / 7 + width / 14, Symbol.Bid - height * Symbol.PipSize, VerticalAlignment.Top, HorizontalAlignment.Center, color); } ChartObjects.DrawText(timeframes[i].ToString() + "Text", timeframes[i].ToString(), index - (i + 2) * width / 7 + width / 14, Symbol.Bid, VerticalAlignment.Bottom, HorizontalAlignment.Center, color); } ChartObjects.DrawText("ScoreText", "Score", index - 1 * width / 7 + width / 14, Symbol.Bid, VerticalAlignment.Bottom, HorizontalAlignment.Center, Colors.White); int sum = 0; foreach (int i in values) { sum += i; } totalColor = Colors.Red; if (sum >= threshold) { totalColor = Colors.Green; } else if (sum <= threshold * (-1)) { totalColor = Colors.Red; } else { totalColor = Colors.White; } ChartObjects.DrawText("ScoreValue", "" + sum, index - 1 * width / 7 + width / 14, Symbol.Bid - height * Symbol.PipSize, VerticalAlignment.Top, HorizontalAlignment.Center, totalColor); }
//---------------------------- public override void Calculate(int index) { if (VolumeBars && index > Lookback + 1) { double[] tempVolumeSeries = new double[Lookback]; for (int i = Lookback; i > 0; i--) { tempVolumeSeries[Lookback - i] = MarketSeries.TickVolume[(index - 1) - i]; } double LowerPerc = Percentile(tempVolumeSeries, PercentileLowerBound); double UpperPerc = Percentile(tempVolumeSeries, PercentileUpperBound); if (MarketSeries.TickVolume[index] >= LowerPerc && MarketSeries.TickVolume[index] < UpperPerc) { double x = PercentileLowerBound; for (int i = MinBarThickness; i < MaxBarThickness + 1; i++) { if (MarketSeries.TickVolume[index] >= Percentile(tempVolumeSeries, x)) { x += Stepsize; } else { BarThickness = i; break; } } } else if (MarketSeries.TickVolume[index] >= UpperPerc) { BarThickness = MaxBarThickness; } else { BarThickness = MinBarThickness; } } else { BarThickness = MinBarThickness; } ChartObjects.DrawLine(string.Format("Linie{0}", index), index, MarketSeries.High[index], index, MarketSeries.Low[index], (Colors)Enum.Parse(typeof(Colors), BarColor, true), BarThickness, LineStyle.Solid); // The drawing of the Current Price Marker if (IsLastBar && PriceMarker) { ChartObjects.DrawText("Triangle", Markers[MarkerType], index, MarketSeries.Close[index], VerticalAlignment.Center, HorizontalAlignment.Right, (Colors)Enum.Parse(typeof(Colors), MarkerColor, true)); } }
private void CalculatePivots(DateTime startTime, int startIndex, DateTime startTimeOfNextPeriod, int index) { var high = MarketSeries.High[startIndex]; var low = MarketSeries.Low[startIndex]; var close = MarketSeries.Close[startIndex]; var i = startIndex + 1; while (GetStartOfPeriod(MarketSeries.OpenTime[i]) == startTime && i < MarketSeries.Close.Count) { high = Math.Max(high, MarketSeries.High[i]); low = Math.Min(low, MarketSeries.Low[i]); close = MarketSeries.Close[i]; i++; } var pivotStartTime = startTimeOfNextPeriod; var pivotEndTime = GetEndOfPeriod(startTimeOfNextPeriod); var pivot = (high + low + close) / 3; var r1 = 2 * pivot - low; var s1 = 2 * pivot - high; var r2 = pivot + high - low; var s2 = pivot - high + low; var r3 = high + 2 * (pivot - low); var s3 = low - 2 * (high - pivot); ChartObjects.DrawLine("pivot " + startIndex, pivotStartTime, pivot, pivotEndTime, pivot, Colors.White); ChartObjects.DrawLine("r1 " + startIndex, pivotStartTime, r1, pivotEndTime, r1, Colors.Green); ChartObjects.DrawLine("r2 " + startIndex, pivotStartTime, r2, pivotEndTime, r2, Colors.Green); ChartObjects.DrawLine("r3 " + startIndex, pivotStartTime, r3, pivotEndTime, r3, Colors.Green); ChartObjects.DrawLine("s1 " + startIndex, pivotStartTime, s1, pivotEndTime, s1, Colors.Red); ChartObjects.DrawLine("s2 " + startIndex, pivotStartTime, s2, pivotEndTime, s2, Colors.Red); ChartObjects.DrawLine("s3 " + startIndex, pivotStartTime, s3, pivotEndTime, s3, Colors.Red); if (!ShowLabels) { return; } ChartObjects.DrawText("Lpivot " + startIndex, "P", index, pivot, vAlignment, hAlignment, pivotColor); ChartObjects.DrawText("Lr1 " + startIndex, "R1", index, r1, vAlignment, hAlignment, resistanceColor); ChartObjects.DrawText("Lr2 " + startIndex, "R2", index, r2, vAlignment, hAlignment, resistanceColor); ChartObjects.DrawText("Lr3 " + startIndex, "R3", index, r3, vAlignment, hAlignment, resistanceColor); ChartObjects.DrawText("Ls1 " + startIndex, "S1", index, s1, vAlignment, hAlignment, supportColor); ChartObjects.DrawText("Ls2 " + startIndex, "S2", index, s2, vAlignment, hAlignment, supportColor); ChartObjects.DrawText("Ls3 " + startIndex, "S3", index, s3, vAlignment, hAlignment, supportColor); }
public override void Calculate(int index) { if (_incorrectColors) { var errorColor = _random.Next(2) == 0 ? Colors.Red : Colors.White; ChartObjects.DrawText("Error", "Incorrect colors", StaticPosition.Center, errorColor); return; } var open = MarketSeries.Open[index]; var high = MarketSeries.High[index]; var low = MarketSeries.Low[index]; var close = MarketSeries.Close[index]; var haClose = (open + high + low + close) / 4; double haOpen; if (index > 0) { haOpen = (_haOpen[index - 1] + _haClose[index - 1]) / 2; } else { haOpen = (open + close) / 2; } var haHigh = Math.Max(Math.Max(high, haOpen), haClose); var haLow = Math.Min(Math.Min(low, haOpen), haClose); if (haOpen < haClose) { color = open > close ? _AboveDownColor : _AboveUpColor; } if (haOpen > haClose) { color = open > close ? _BelowDownColor : _BelowUpColor; } ChartObjects.DrawLine("candle" + index, index, open, index, close, color, CandleWidth, LineStyle.Solid); ChartObjects.DrawLine("line" + index, index, high, index, low, color, WickWidth, LineStyle.Solid); _haOpen[index] = haOpen; _haClose[index] = haClose; }
public override void Calculate(int index) { // Starting and ending bars int x1 = Source.Count - Period; int x2 = Source.Count - 1; // Linear regression parameters double sumX = 0; double sumX2 = 0; double sumY = 0; double sumXY = 0; for (int count = x1; count <= x2; count++) { sumX += count; sumX2 += count * count; sumY += Source[count]; sumXY += Source[count] * count; } double divisor = (Period * sumX2 - sumX * sumX); double slope = (Period * sumXY - sumX * sumY) / divisor; double intercept = (sumY - slope * sumX) / Period; // Distance to the regression line double deviation = 0; for (int count = x1; count <= x2; count++) { double regression = slope * count + intercept; deviation = Math.Max(Math.Abs(Source[count] - regression), deviation); } // Linear regression channel x2 += Extend; double y1 = slope * x1 + intercept; double y2 = slope * x2 + intercept; var color = y1 < y2 ? Colors.LimeGreen : Colors.Red; ChartObjects.DrawLine("Upper" + index, x1, y1 + deviation, x2, y2 + deviation, color, Thickness, LineStyle.Solid); ChartObjects.DrawLine("Lower" + index, x1, y1 - deviation, x2, y2 - deviation, color, Thickness, LineStyle.Solid); Diff[index] = y2 - y1; }
private void drawLine(List <int> segments) { ChartObjects.RemoveAllObjects(); int sz = segments.Count; for (int i = 0; i < sz - 1; i++) { int j0 = segments[i]; int j1 = segments[i + 1]; double a = stats[j1][j0].slope(); double b = stats[j1][j0].intercept(); ChartObjects.DrawLine("Segment-" + j0.ToString(), j0, a * j0 + b, j1, a * j1 + b, Colors.Aqua, 2, LineStyle.Solid); } }
private void DrawLine(DataSeries series, double price, int d, VerticalAlignment a) { int indexLast = GetIndexByPrice(series, price); if (indexLast != -1) { string l_name = string.Format("p_{0}", price); string t_name = string.Format("t_{0}", price); ChartObjects.DrawLine(l_name, MarketSeries.OpenTime[indexLast], price, MarketSeries.OpenTime.LastValue.AddYears(2), price, Colors.DarkGray, 1, LineStyle.LinesDots); if (ShowPrices) { ChartObjects.DrawText(t_name, string.Format("{0}", price), indexLast, price + d * Symbol.PipSize, a, HorizontalAlignment.Right, Colors.DarkGray); } } }
private void DrawTrendLine(string lineName, int startIndex, int endIndex, int index1, double value1, int index2, double value2, bool color_up_trend) { double gradient = (value2 - value1) / (index2 - index1); double startValue = value1 + (startIndex - index1) * gradient; double endValue = value1 + (endIndex - index1) * gradient; if (color_up_trend == true) { ChartObjects.DrawLine(lineName, index2, value2, endIndex, endValue, Colors.Red, 2, LineStyle.Solid); } else { ChartObjects.DrawLine(lineName, index2, value2, endIndex, endValue, Colors.Blue, 2, LineStyle.Solid); } }
public void lr(double[] xValues, double[] yValues, bool isPeak) { double rSquared, w, b; utils.LinearRegression(xValues, yValues, out rSquared, out b, out w); //Print("Line: y = ", w, "x + ", b); //Print("R-squared = ", rSquared); int o = 0; double sum = 0; foreach (double e in xValues) { var dist = utils.distanceFromPointToLine(xValues[o], yValues[o], w, b); sum += dist; o++; } double baseThreshold = 0.15; // base on XAU double threshold = baseThreshold / utils.FindLineThreshold(Bars.OpenPrices[0]); // XAU has it's value > 1000 if (sum - threshold <= 0) { if (!AllowBroken) { if (isBrokenTrend(w, b, (int)xValues[0], (int)xValues[2], isPeak, threshold * 10)) { return; } } //foreach (double e in xValues) //{ // int index = (int)xValues[y]; // Chart.DrawIcon("icon_" + xValues[0].ToString(), ChartIconType.Diamond, index, yValues[y], isPeak ? Color.DarkCyan : Color.Olive); //} ChartObjects.DrawLine("a" + xValues[0].ToString(), (int)xValues[0], yValues[0], (int)xValues[2], yValues[2], isPeak ? Colors.DarkCyan : Colors.Olive, 2); } }
void OnGbpUsdUpdated() { float sumBid = 0; float sumAsk = 0; _askNo = 0; _bidNo = 0; var index = MarketSeries.Close.Count - 1; for (int i = 0; i < 100; i++) { ChartObjects.RemoveObject(i.ToString() + "ask"); ChartObjects.RemoveObject(i.ToString() + "bid"); } foreach (var entry in GBPUSD.AskEntries) { sumAsk += entry.Volume; } foreach (var entry in GBPUSD.BidEntries) { sumBid += entry.Volume; } string s = ""; foreach (var entry in GBPUSD.AskEntries) { double val = entry.Volume / sumAsk; int len = Math.Max(1, (int)(lineLen * val)); ChartObjects.DrawLine(_askNo.ToString() + "ask", index + 1, entry.Price, index + len, entry.Price, Colors.Red, lineThickness); s += "\n ask " + len.ToString(); _askNo++; } foreach (var entry in GBPUSD.BidEntries) { double val = entry.Volume / sumBid; int len = Math.Max(1, (int)(lineLen * val)); ChartObjects.DrawLine(_bidNo.ToString() + "bid", index + 1, entry.Price, index + len, entry.Price, Colors.Blue, lineThickness); s += "\n bid " + len.ToString(); _bidNo++; } }
// ------------------------------------------------------ public override void Calculate(int index) { DateTime today = MarketSeries.OpenTime[index].Date; for (int i = 0; i < Boxes; i++) { DateTime startOfDay = today.AddDays(-i); DateTime endOfDay = today.AddDays(1 - i); var high = daily.High.Last(i); var high2 = daily.High.Last(i - 1); var high3 = daily.High.Last(i - 2); var low = daily.Low.Last(i); var low2 = daily.Low.Last(i - 1); var low3 = daily.Low.Last(i - 2); var median = ((low + high) / 2); // ----- Triple DailyHighLow ChartObjects.DrawLine("High" + i, startOfDay, high, endOfDay, high, dailyHLcolor, 1); ChartObjects.DrawLine("Low" + i, startOfDay, low, endOfDay, low, dailyHLcolor, 1); ChartObjects.DrawLine("pHigh" + i, endOfDay, high, endOfDay.AddDays(1), high, Colors.Green, 1, LineStyle.Lines); ChartObjects.DrawLine("pLow" + i, endOfDay, low, endOfDay.AddDays(1), low, Colors.Red, 1, LineStyle.Lines); ChartObjects.DrawLine("ppHigh" + i, endOfDay.AddDays(1), high, endOfDay.AddDays(2), high, Colors.Green, 1, LineStyle.DotsRare); ChartObjects.DrawLine("ppLow" + i, endOfDay.AddDays(1), low, endOfDay.AddDays(2), low, Colors.Red, 1, LineStyle.DotsRare); // ----- Triple Trendlines ChartObjects.DrawLine("DownTrend1" + i, startOfDay, high, endOfDay, low, Colors.Red, 1, LineStyle.Solid); ChartObjects.DrawLine("DownTrend2" + i, startOfDay, high, endOfDay.AddDays(1), low, Colors.Red, 1, LineStyle.Lines); ChartObjects.DrawLine("DownTrend3" + i, startOfDay, high, endOfDay.AddDays(2), low, Colors.Red, 1, LineStyle.DotsRare); ChartObjects.DrawLine("UpTrend1" + i, startOfDay, low, endOfDay, high, Colors.Green, 1, LineStyle.Solid); ChartObjects.DrawLine("UpTrend2" + i, startOfDay, low, endOfDay.AddDays(1), high, Colors.Green, 1, LineStyle.Lines); ChartObjects.DrawLine("UpTrend3" + i, startOfDay, low, endOfDay.AddDays(2), high, Colors.Green, 1, LineStyle.DotsRare); // ----- TurnLines ChartObjects.DrawLine("DownRC-Line1" + i, startOfDay, high, startOfDay.AddDays(2), low2, Colors.Blue, 1, LineStyle.Lines); ChartObjects.DrawLine("DownRC-Line2" + i, startOfDay, high, startOfDay.AddDays(3), low2, dailyHLcolor, 1, LineStyle.DotsRare); ChartObjects.DrawLine("DownRC-Line3" + i, startOfDay, high, endOfDay.AddDays(2), low3, Colors.White, 1, LineStyle.DotsRare); ChartObjects.DrawLine("UpRC-Line1" + i, startOfDay, low, startOfDay.AddDays(2), high2, Colors.Blue, 1, LineStyle.Lines); ChartObjects.DrawLine("UpRC-Line2" + i, startOfDay, low, startOfDay.AddDays(3), high2, dailyHLcolor, 1, LineStyle.DotsRare); ChartObjects.DrawLine("UpRC-Line3" + i, startOfDay, low, endOfDay.AddDays(2), high3, Colors.White, 1, LineStyle.DotsRare); // ----- MedianPriceLine ChartObjects.DrawLine("Median" + i, startOfDay, median, endOfDay, median, Colors.White, 1); } }
//----------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------- // DAILY HIGH LOW FUNCTION ---------------------------------------------------------------------- //----------------------------------------------------------------------------------------------- private void DailyHighLow_Main(int index) { DateTime today = MarketSeries.OpenTime[index].Date; DateTime tomorrow = today.AddDays(1); double high = MarketSeries.High.LastValue; double low = MarketSeries.Low.LastValue; for (int i = MarketSeries.Close.Count - 1; i > 0; i--) { if (MarketSeries.OpenTime[i].Date < today) { break; } high = Math.Max(high, MarketSeries.High[i]); low = Math.Min(low, MarketSeries.Low[i]); } ChartObjects.DrawLine("high " + today, today, high, tomorrow, high, Colors.Pink); ChartObjects.DrawLine("low " + today, today, low, tomorrow, low, Colors.Pink); }
//----------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------- // DAILY HIGH LOW FUNCTION ---------------------------------------------------------------------- //----------------------------------------------------------------------------------------------- private void HeikenAshi_Standard_Main(int index) { if (_incorrectColors) { var errorColor = _random.Next(2) == 0 ? Colors.Red : Colors.White; ChartObjects.DrawText("Error", "Incorrect colors", StaticPosition.Center, errorColor); return; } var open = MarketSeries.Open[index]; var high = MarketSeries.High[index]; var low = MarketSeries.Low[index]; var close = MarketSeries.Close[index]; haClose = (open + high + low + close) / 4; if (index > 0) { haOpen = (_haOpen[index - 1] + _haClose[index - 1]) / 2; } else { haOpen = (open + close) / 2; } haHigh = Math.Max(Math.Max(high, haOpen), haClose); haLow = Math.Min(Math.Min(low, haOpen), haClose); //var color = haOpen > haClose ? _downColor : _upColor; var haColor = haOpen > haClose ? _downColor : _upColor; ChartObjects.DrawLine("candle" + index, index, haOpen, index, haClose, haColor, CandleWidth, LineStyle.Solid); ChartObjects.DrawLine("line" + index, index, haHigh, index, haLow, haColor, 1, LineStyle.Solid); _haOpen[index] = haOpen; _haClose[index] = haClose; }
public override void Calculate(int index) { double haHigh; double haLow; Colors Color; if (index > 0 && !double.IsNaN(maOpen.Result[index - 1])) { haOpen[index] = (haOpen[index - 1] + haClose[index - 1]) / 2; haClose[index] = (maOpen.Result[index] + maClose.Result[index] + maHigh.Result[index] + maLow.Result[index]) / 4; haHigh = Math.Max(maHigh.Result[index], Math.Max(haOpen[index], haClose[index])); haLow = Math.Min(maLow.Result[index], Math.Min(haOpen[index], haClose[index])); Color = (haOpen[index] > haClose[index]) ? Colors.Red : Colors.Blue; ChartObjects.DrawLine("BarHA" + index, index, haOpen[index], index, haClose[index], Color, 5, LineStyle.Solid); ChartObjects.DrawLine("LineHA" + index, index, haHigh, index, haLow, Color, 1, LineStyle.Solid); } else if (!double.IsNaN(maOpen.Result[index])) { haOpen[index] = (maOpen.Result[index] + maClose.Result[index]) / 2; haClose[index] = (maOpen.Result[index] + maClose.Result[index] + maHigh.Result[index] + maLow.Result[index]) / 4; haHigh = maHigh.Result[index]; haLow = maLow.Result[index]; } }