/// <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); }