/// <summary>
/// To renew the indicator with numeric value.
/// </summary>
/// <param name="indicator">Indicator.</param>
/// <param name="value">Numeric value.</param>
/// <param name="isFinal">Is the value final (the indicator finally forms its value and will not be changed in this point of time anymore). Default is <see langword="true" />.</param>
/// <returns>The new value of the indicator.</returns>
public static IIndicatorValue Process(this IIndicator indicator, decimal value, bool isFinal = true)
{
return(indicator.Process(new DecimalIndicatorValue(indicator, value)
{
IsFinal = isFinal
}));
}
/// <summary>
/// To renew the indicator with numeric pair.
/// </summary>
/// <param name="indicator">Indicator.</param>
/// <param name="value">The pair of values.</param>
/// <param name="isFinal">If the pair final (the indicator finally forms its value and will not be changed in this point of time anymore). Default is <see langword="true" />.</param>
/// <returns>The new value of the indicator.</returns>
public static IIndicatorValue Process <TValue>(this IIndicator indicator, Tuple <TValue, TValue> value, bool isFinal = true)
{
return(indicator.Process(new PairIndicatorValue <TValue>(indicator, value)
{
IsFinal = isFinal
}));
}
private void Chart_OnSubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries series, IIndicator indicator)
{
_dataThreadActions.Add(() =>
{
var oldReset = Chart.DisableIndicatorReset;
try
{
Chart.DisableIndicatorReset = true;
indicator.Reset();
}
finally
{
Chart.DisableIndicatorReset = oldReset;
}
var chartData = new ChartDrawData();
foreach (var candle in _allCandles.CachedValues)
{
chartData.Group(candle.OpenTime).Add(element, indicator.Process(candle));
}
Chart.Reset(new[] { element });
Chart.Draw(chartData);
_indicators[element] = indicator;
});
}
public static IDataSeries CreateIndicatorSeries(string market, IIndicator indicator, Color color, Timeframe timeframe, IList <Candle> candles)
{
var series = new XyDataSeries <DateTime, double>();
var xvalues = new List <DateTime>();
var yvalues = new List <double>();
foreach (var candle in candles)
{
var signalAndValue = indicator.Process(candle);
DateTime time = new DateTime(candle.OpenTimeTicks, DateTimeKind.Utc);
if (indicator.IsFormed)
{
xvalues.Add(time);
yvalues.Add((double)signalAndValue.Value);
}
else
{
xvalues.Add(time);
yvalues.Add(double.NaN);
}
}
series.Append(xvalues, yvalues);
series.SeriesName = indicator.Name;
return(series);
}
private void Chart_SubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries series, IIndicator indicator)
{
var candles = _candles.TryGetValue(series.Security);
if (candles == null)
{
throw new InvalidOperationException("_candles == null");
}
var values = candles
.Select(candle =>
{
if (candle.State != CandleStates.Finished)
{
candle.State = CandleStates.Finished;
}
return(new RefPair <DateTimeOffset, IDictionary <IChartElement, object> >(candle.OpenTime, new Dictionary <IChartElement, object>
{
{ element, indicator.Process(candle) }
}));
})
.ToArray();
Chart.Draw(values);
}
public static List <SignalAndValue> ProcessIndicator(this IIndicator indicator, List <Candle> candles)
{
var ret = new List <SignalAndValue>();
foreach (var c in candles)
{
ret.Add(indicator.Process(c));
}
return(ret);
}
/// <summary>
/// Configures the first indicator to forward its output to the second indicator
/// </summary>
/// <param name="second">The indicator that receives data from the first</param>
/// <param name="first">The indicator that sends data via DataConsolidated even
/// to the second</param>
/// <param name="waitForFirstToReady">True to only send updates to the second if
/// first.IsReady returns true,false to alway send updates to second</param>
/// <returns>The reference to the second indicator to allow for method chaining
/// </returns>
public static IIndicator Of(this IIndicator second, IIndicator first, bool waitForFirstToReady)
{
first.OutputUpdated += (sender, consolidated) =>
{
// only send the data along if we're ready
if (!waitForFirstToReady || first.IsReady)
{
second.Process(consolidated);
}
};
return(second);
}
public static void SetChartViewModelIndicatorPaneData(IList <Candle> candles, ChartViewModel cvm, IIndicator indicator)
{
indicator.Reset();
var indicatorDataSeries = new XyDataSeries <DateTime, double>();
for (var i = 0; i < candles.Count; i++)
{
var time = new DateTime(candles[i].CloseTimeTicks, DateTimeKind.Utc).ToLocalTime();
var v = indicator.Process(candles[i]);
indicatorDataSeries.Append(time, v.IsFormed ? v.Value : float.NaN);
}
indicatorDataSeries.SeriesName = indicator.Name;
var indicatorPaneVm = cvm.ChartPaneViewModels.Count > 1 ? cvm.ChartPaneViewModels[1] : null;
if (indicatorPaneVm == null)
{
var indicatorPane = new ChartPaneViewModel(cvm, cvm.ViewportManager)
{
IsFirstChartPane = false,
IsLastChartPane = true,
YAxisTextFormatting = "0.0000"
};
indicatorPane.ChartSeriesViewModels.Add(new ChartSeriesViewModel(indicatorDataSeries, new FastLineRenderableSeries
{
AntiAliasing = false,
SeriesColor = Colors.DarkBlue,
StrokeThickness = 2
}));
cvm.ChartPaneViewModels.Add(indicatorPane);
}
else
{
indicatorPaneVm.ChartSeriesViewModels.Clear();
var fastLineRenderableSeries = new FastLineRenderableSeries
{
AntiAliasing = false,
SeriesColor = Colors.DarkBlue,
StrokeThickness = 2
};
indicatorPaneVm.ChartSeriesViewModels.Add(new ChartSeriesViewModel(indicatorDataSeries, fastLineRenderableSeries));
}
}
private void Chart_OnSubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries series, IIndicator indicator)
{
var chartData = new ChartDrawData();
foreach (var candle in _allCandles.Cache)
{
//if (candle.State != CandleStates.Finished)
// candle.State = CandleStates.Finished;
chartData.Group(candle.OpenTime).Add(element, indicator.Process(candle));
}
Chart.Draw(chartData);
_indicators.Add(element, indicator);
}
private void Chart_OnSubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries series, IIndicator indicator, ChartPanel chart)
{
var values = _allCandles
.Select(candle =>
{
if (candle.State != CandleStates.Finished)
candle.State = CandleStates.Finished;
return new RefPair<DateTimeOffset, IDictionary<IChartElement, object>>(candle.OpenTime, new Dictionary<IChartElement, object>
{
{ element, indicator.Process(candle) }
});
})
.ToArray();
chart.Draw(values);
}
private void Chart_OnSubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries series, IIndicator indicator)
{
var values = _allCandles.Cache
.Select(candle =>
{
if (candle.State != CandleStates.Finished)
{
candle.State = CandleStates.Finished;
}
return(new RefPair <DateTimeOffset, IDictionary <IChartElement, object> >(candle.OpenTime, new Dictionary <IChartElement, object>
{
{ element, indicator.Process(candle) }
}));
});
Chart.Draw(values);
}
private void Chart_OnSubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries series, IIndicator indicator)
{
_dataThreadActions.Add(() =>
{
var chartData = new ChartDrawData();
foreach (var candle in _allCandles.CachedValues)
{
chartData.Group(candle.OpenTime).Add(element, indicator.Process(candle));
}
Chart.Reset(new[] { element });
Chart.Draw(chartData);
_indicators[element] = indicator;
this.GuiAsync(() => CustomColors_Changed(null, null));
});
}
public static IDataSeries CreateIndicatorSeries(string market, IIndicator indicator, Color color, Timeframe timeframe, IList <Candle> candles)
{
var series = new XyDataSeries <DateTime, double>();
var xvalues = new List <DateTime>();
var yvalues = new List <double>();
foreach (var candle in candles)
{
var signalAndValue = indicator.Process(candle);
DateTime time;
lock (_utcTicksToLocalTimeLookup)
{
if (!_utcTicksToLocalTimeLookup.TryGetValue(candle.OpenTimeTicks, out time))
{
time = new DateTime(candle.OpenTimeTicks, DateTimeKind.Utc).ToLocalTime();
_utcTicksToLocalTimeLookup[candle.OpenTimeTicks] = time;
}
}
if (indicator.IsFormed)
{
lock (_utcTicksToLocalTimeLookup)
{
xvalues.Add(time);
yvalues.Add((double)signalAndValue.Value);
}
}
else
{
xvalues.Add(time);
yvalues.Add(double.NaN);
}
}
series.Append(xvalues, yvalues);
series.SeriesName = indicator.Name;
return(series);
}
/// <summary>
/// To renew the indicator with candle closing price <see cref="Candle.ClosePrice"/>.
/// </summary>
/// <param name="indicator">Indicator.</param>
/// <param name="candle">Candle.</param>
/// <returns>The new value of the indicator.</returns>
public static IIndicatorValue Process(this IIndicator indicator, Candle candle)
{
return(indicator.Process(new CandleIndicatorValue(indicator, candle)));
}
private void Chart_SubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries series, IIndicator indicator)
{
var candles = _candles.TryGetValue(series.Security);
if (candles == null)
throw new InvalidOperationException("_candles == null");
var values = candles
.Select(candle =>
{
if (candle.State != CandleStates.Finished)
candle.State = CandleStates.Finished;
return new RefPair<DateTimeOffset, IDictionary<IChartElement, object>>(candle.OpenTime, new Dictionary<IChartElement, object>
{
{ element, indicator.Process(candle) }
});
})
.ToArray();
Chart.Draw(values);
}
