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];
}
}
