private void btnOpen_Click(object sender, EventArgs e) { if (btnOpen.Text.Equals("OPEN")) { var devices = Lepton.CCI.GetDevices(); try { for (int i = 0; i < devices.Count; i++) { if (devices[i].Name.Equals("PureThermal (fw:v1.3.0)")) { var device = devices[i]; //device.Open().vid.SetVideoOutputFormat(Lepton.CCI.Vid.VideoOutputFormat.RAW14); //device.Open().sys.SetTelemetryEnableState(Lepton.CCI.Sys.TelemetryEnableState.TELEMETRY_ENABLED); //device.Open().oem.SetVideoOutputFormat(Lepton.CCI.Oem.VideoOutputFormat.RAW14); lepton = device.Open(); //lepton.oem.SetVideoOutputSource(CCI.Oem.VideoOutputSource.RAW); BTN_GET_SETTING.Enabled = true; btnOpen.Enabled = false; MessageBox.Show("Device Opened"); } } if (btnOpen.Enabled == true) { MessageBox.Show("Please Check Device", "System Message"); } } catch (Exception) { MessageBox.Show("Please Connect Camera"); } } }
public override void GetAll(IIndicatorValues Ind) { int period = (int)this.IndicatorParameters.List[0]; int smoothingPeriod = (int)this.IndicatorParameters.List[1]; decimal thresholdValue = (decimal)this.IndicatorParameters.List[2]; if (!Ind.CCI(period, smoothingPeriod, thresholdValue).IsPopulated) { int oldCurrentBar = Ind.Bar.CurrentBar; for (int i = 1; i <= Ind.Bar.MaxBar; i++) { Ind.Bar.CurrentBar = i; object prototype = null; if (i == 1) { prototype = new CCI(thresholdValue); } else { prototype = (CCI)Ind.CCI(period, smoothingPeriod, thresholdValue)[1].Clone(); } Get(ref prototype, Ind); Ind.CCI(period, smoothingPeriod, thresholdValue)[0] = (CCI)prototype; Ind.CCI(period, smoothingPeriod, thresholdValue).IsPopulated = true; // set here so instance is guaranteed to exits } Ind.Bar.CurrentBar = oldCurrentBar; } }
public override Advice GetActionForBuckets(List <TradeBucket> tradeBuckets) { Advice advice = new Advice(); advice.AlgorithmName = Name; advice.Confidence = 0; advice.Group = Group; advice.Time = tradeBuckets[tradeBuckets.Count - 1].Time; List <TradeBucket> buckets = tradeBuckets; CCI rsi = new CCI(); TIOutput output = rsi.GetCurrentValue(buckets); advice.Price = buckets[buckets.Count - 1].Close; advice.Confidence = (decimal)output.Value; if (output.Value > 190) { advice.Action = TradeAction.Sell; } else if (output.Value < -200) { advice.Action = TradeAction.Buy; } else { advice.Action = TradeAction.Hold; } return(advice); }
static void Main(string[] args) { Console.ForegroundColor = ConsoleColor.Gray; //Console.ResetColor() is not working :( Console.CancelKeyPress += Console_CancelKeyPress; var ticker = string.Empty; string indicator = string.Empty; HandleArgs(args, ref ticker, ref indicator); Console.WriteLine($"Fetching trade data for {ticker.ToUpper()}..."); //on the next version, it's gonna be an interface RSI RSITrades = null; CCI CCITrades = null; BollingerBands BBandTrades = null; var bfxReader = new Core.Exchanges.Bitfinex.TickerReader(); TickerHandler tickerHndl = null; //getting the 14 last minutes history var hist = new Core.Exchanges.Bitfinex.TickerCandlesReader(); if (indicator.ToUpper() == "RSI") { RSICalc(out RSITrades, bfxReader, out tickerHndl, hist); } else if (indicator.ToUpper() == "CCI") { CCICalc(out CCITrades, bfxReader, out tickerHndl, hist); } else if (indicator.ToUpper() == "BBANDS") { BBandCalc(out BBandTrades, bfxReader, out tickerHndl, hist); } else { Console.WriteLine("Invalid Parameter"); return; } tickerHndl.OnError += tickerHndl_OnError; bfxReader.Enabled = true; Task.Run(async() => { await bfxReader.Start(ticker.ToUpper()); }); while (enabled) { ; } Console.ForegroundColor = ConsoleColor.Gray; Console.WriteLine($"Program ended."); }
public TickerHandler(IExchangeTickerReader tickerReader, CCI trades) { _tickerReader = tickerReader; _tickerReader.PoolingInterval = Consts.PoolingInterval; _tickerReader.TickerReady += _tickerReader_TickerReady; _tickerReader.OnError += _tickerReader_OnError; _cci = trades; _cci.IndicatorReady += _cci_IndicatorReady; }
protected override void OnStart() { _macd = Indicators.MacdHistogram(LongCycle, ShortCycle, Period); _emaFast = Indicators.ExponentialMovingAverage(Price, FastPeriods); _adx = Indicators.GetIndicator <ADXR>(Source, interval); _cci = Indicators.GetIndicator <CCI>(CCI_period); _heiken = Indicators.GetIndicator <HeikenAshi2>(1); _emasignal = Indicators.GetIndicator <ExponentialSignal>(EMAPeriod); }
public void CCI() { CCI cci = new CCI(); cci.Load(OhlcList); SingleDoubleSerie serie = cci.Calculate(); Assert.IsNotNull(serie); Assert.IsTrue(serie.Values.Count > 0); }
public void CCI() { CCI cci = new CCI(); cci.Load(csvPath); SingleDoubleSerie serie = cci.Calculate(); Assert.NotNull(serie); Assert.True(serie.Values.Count > 0); }
public void CCI() { CCI cci = new CCI(); cci.Load(Directory.GetCurrentDirectory() + "\\table.csv"); SingleDoubleSerie serie = cci.Calculate(); Assert.IsNotNull(serie); Assert.IsTrue(serie.Values.Count > 0); }
protected override void OnStart() { _botName = ToString(); _instanceLabel = string.Format("{0}-{1}-{2}-{3}-{4}", _botName, _botVersion, Symbol.Code, TimeFrame.ToString(), GlobalTimeFrame.ToString()); tendency = Indicators.GetIndicator <CandlestickTendencyII>(GlobalTimeFrame, MinimumGlobalCandleSize); _macd = Indicators.MacdHistogram(LongCycle, ShortCycle, Period); _emaFast = Indicators.ExponentialMovingAverage(Price, FastPeriods); _adx = Indicators.GetIndicator <ADXR>(Source, interval); _cci = Indicators.GetIndicator <CCI>(CCI_period); _heiken = Indicators.GetIndicator <HeikenAshi2>(1); }
protected override string GetPresentDetail(IOutputInstant Instant, IIndicatorValues Data, IndicatorParameters IndicatorParameters) { CCI cci = Data.CCI(IndicatorParameters)[Instant.ExposureDate]; if (cci != null) { return(String.Format("{0}|{1}|{2}|{3}|{4}|{5}|{6}|", cci.Value, (int)cci.Trendiness, cci.Trendiness, (int)cci.Direction, cci.Direction, (int)cci.Oscillation, cci.Oscillation)); } else { return(String.Format("{0}|{1}|{2}|{3}|{4}|{5}|{6}|", "", "", "", "", "", "", "")); } }
private static void CCICalc(out CCI CCITrades, Core.Exchanges.Bitfinex.TickerReader bfxReader, out TickerHandler tickerHndl, Core.Exchanges.Bitfinex.TickerCandlesReader hist) { CCITrades = new CCI(); tickerHndl = new TickerHandler(bfxReader, CCITrades); tickerHndl.CCIReady += tickerHndl_CCI_IndicatorReady; var lista = hist.GetHistory("BTCUSD", Core.Exchanges.Bitfinex.Common.CandleInterval1Min, 22); foreach (Ticker t in lista) { CCITrades.Add(t.UtcDateTime, t.high, t.low, t.last_price); } }
public ThoseFourIndicators(BarItemType barType) { this.barType = barType; this.identityCode = string.Format("{0}({1})", IDENTITY_CODE, barType.Code); cci = new CCI(barType, 14); stoch = new Stochastics(barType, 14, 2, 2); macd = new MACD(barType, 8, 40, 8); adx = new ADX(barType, 14); Register(cci, stoch, macd, adx); }
protected override void OnStart() { label = "Bladerunner Major CCI Heiken" + " " + Symbol.Code + " " + TimeFrame.ToString() + " / " + GlobalTimeFrame.ToString(); tendency = Indicators.GetIndicator <CandlestickTendencyII>(GlobalTimeFrame, MinimumGlobalCandleSize); index = MarketSeries.Close.Count - 1; _macd = Indicators.MacdHistogram(LongCycle, ShortCycle, Period); _emaFast = Indicators.ExponentialMovingAverage(Price, FastPeriods); _adx = Indicators.GetIndicator <ADXR>(Source, interval); _cci = Indicators.GetIndicator <CCI>(CCI_period); _heiken = Indicators.GetIndicator <HeikenAshi2>(1); Positions.Opened += PositionsOnOpened; Positions.Closed += PositionsOnClosed; }
protected override void OnStart() { _instanceLabel = "Heiken CCI Adxr" + " " + Symbol.Code + " " + TimeFrame.ToString(); _macd = Indicators.MacdHistogram(LongCycle, ShortCycle, Period); _emaFast = Indicators.ExponentialMovingAverage(Price, FastPeriods); _adx = Indicators.GetIndicator <ADXR>(Source, interval); _cci = Indicators.GetIndicator <CCI>(CCI_period); _heiken = Indicators.GetIndicator <HeikenAshi2>(1); index = MarketSeries.Close.Count - 1; Positions.Opened += PositionsOnOpened; Positions.Closed += PositionsOnClosed; }
public ReversalGenesis(int n) : base(n) { T3 = new AdaptiveSmoothing(n); T32 = new AdaptiveSmoothing(5 * n); CCI = new CCI(n); WILLR = new WilliamsR(n); Gann = new GannHiLo(n); KST = new KST(); CH = new Chaikin(); BB = new BollingerBands(n); UO = new UltimateOscillator(n, 2 * n, 3 * n); }
public Task <SignalStrength> ProcessSignalAsync(TimePeriod timePeriod, CandleDto[] candles) { var cmo = new CMO().Calculate(candles, 9); var cci = new CCI().Calculate(candles, 20); var mfi = new MFI().Calculate(candles, 14); var cmoUnit = TraderUtils.NormaliseAndClamp(cmo.First(), -50, 50); var cciUnit = TraderUtils.NormaliseAndClamp(cci.First(), -100, 100); var mfiUnit = TraderUtils.NormaliseAndClamp(mfi.First(), 10, 80); var avg = (cmoUnit + cciUnit + mfiUnit) / 3; return(Task.FromResult(TraderUtils.ToSignalStrength(avg))); }
public Genesis(int n) : base(n) { T3 = new AdaptiveSmoothing(n); T32 = new AdaptiveSmoothing(5 * n); CCI = new CCI(n); WILLR = new WilliamsR(n); Gann = new GannHiLo(n); KST = new KST(); CH = new Chaikin(); BB = new BollingerBands(); QChannel = new QSPolyChannel(); FI = new ForceIndex(30); PFE = new PFE(150); RWI = new RWI(30); AC = new AC(10); }
protected override void OnStateChange() { if (State == State.SetDefaults) { Description = @"Enter the description for your new custom Strategy here."; Name = "StrategyAddIndicatorsToSamePanel"; Calculate = Calculate.OnBarClose; } else if (State == State.DataLoaded) { CCI1 = CCI(14); CCI2 = CCI(30); AddChartIndicator(CCI1); AddChartIndicator(CCI2); CCI1.Panel = 1; CCI2.Panel = 1; } }
public MTSuperTrendSeries(Bars bars, int CCIPeriod, double ATRMultiple, int ATRPeriod, string description) : base(bars, description) { base.FirstValidValue = Math.Max(CCIPeriod, ATRPeriod * 3); for (int bar = FirstValidValue; bar < bars.Count; bar++) { double Value = 0; if (CCI.Series(bars, CCIPeriod)[bar] >= 0) { Value = Math.Max(base[bar - 1], bars.Low[bar] - ATRMultiple * ATR.Series(bars, ATRPeriod)[bar]); } else { Value = Math.Min(base[bar - 1], bars.High[bar] + ATRMultiple * ATR.Series(bars, ATRPeriod)[bar]); } base[bar] = Value; } }
public double[] CalculateCCI(IEnumerable <Quote> quotes, int period) { var listOhlc = quotes.Select( x => new Ohlc { Date = x.Date, Close = x.Close, AdjClose = x.Close, High = x.High, Low = x.Low, Open = x.Open, Volume = x.Volume }).ToList(); var cci = new CCI(period, 0.015); cci.Load(listOhlc); var result = cci.Calculate(); return(result.Values.Select(x => x.GetValueOrDefault()).ToArray()); }
public InSyncIndex(Bars bars, string description) : base(bars, description) { base.FirstValidValue = 20; if (bars.Count < 20) { return; } DataSeries BOLInSLB = StdDev.Series(bars.Close, 20, StdDevCalculation.Sample) * 2; BOLInSLB = Community.Indicators.FastSMA.Series(bars.Close, 20) - BOLInSLB; DataSeries BOLInSUB = StdDev.Series(bars.Close, 20, StdDevCalculation.Sample) * 2; BOLInSUB = Community.Indicators.FastSMA.Series(bars.Close, 20) + BOLInSUB; DataSeries BOLInS2 = BOLInSUB - BOLInSLB; BOLInS2 = (bars.Close - BOLInSLB) / BOLInS2; EMV emv = EMV.Series(bars, 13); DataSeries EMVSer = Community.Indicators.FastSMA.Series(emv, 10); DataSeries EMVInS2 = EMVSer - Community.Indicators.FastSMA.Series(EMVSer, 10); DataSeries MACDSer = Community.Indicators.FastSMA.Series(MACD.Series(bars.Close), 10); DataSeries MACDInS2 = MACD.Series(bars.Close) - MACDSer; int Period = 18; DataSeries DPOSeries = bars.Close - (Community.Indicators.FastSMA.Series(bars.Close, Period) >> ((Period / 2) + 1)); DataSeries PDOSer = Community.Indicators.FastSMA.Series(DPOSeries, 10); DataSeries PDOInS2 = DPOSeries - PDOSer; DataSeries ROCSer = EMA.Series(ROC.Series(bars.Close, 10), 10, EMACalculation.Modern); DataSeries ROCInS2 = ROC.Series(bars.Close, 10) - ROCSer; DataSeries BOLInSLL = bars.Close * 0; DataSeries CCInS = bars.Close * 0; DataSeries EMVInSB = bars.Close * 0; DataSeries EMVInSS = bars.Close * 0; DataSeries MACDInSB = bars.Close * 0; DataSeries MACDInSS = bars.Close * 0; DataSeries MFIInS = bars.Close * 0; DataSeries PDOInSB = bars.Close * 0; DataSeries PDOInSS = bars.Close * 0; DataSeries ROCInSB = bars.Close * 0; DataSeries ROCInSS = bars.Close * 0; DataSeries RSIInS = bars.Close * 0; DataSeries STODInS = bars.Close * 0; DataSeries STOKInS = bars.Close * 0; for (int bar = base.FirstValidValue; bar < bars.Count; bar++) { if (BOLInS2[bar] < 0.05) { BOLInSLL[bar] = -5; } else if (BOLInS2[bar] > 0.95) { BOLInSLL[bar] = +5; } if (CCI.Series(bars, 14)[bar] > +100) { CCInS[bar] = +5; } else if (CCI.Series(bars, 14)[bar] < -100) { CCInS[bar] = -5; } if ((EMVInS2[bar] < 0) & (EMVSer[bar] < 0)) { EMVInSB[bar] = -5; } if ((EMVInS2[bar] > 0) & (EMVSer[bar] > 0)) { EMVInSS[bar] = +5; } if ((MACDInS2[bar] < 0) & (MACDSer[bar] < 0)) { MACDInSB[bar] = -5; } if ((MACDInS2[bar] > 0) & (MACDSer[bar] > 0)) { MACDInSS[bar] = +5; } if (MFI.Series(bars, 20)[bar] > 80) { MFIInS[bar] = +5; } else if (MFI.Series(bars, 20)[bar] < 20) { MFIInS[bar] = -5; } if ((PDOInS2[bar] < 0) & (PDOSer[bar] < 0)) { PDOInSB[bar] = -5; } if ((PDOInS2[bar] > 0) & (PDOSer[bar] > 0)) { PDOInSS[bar] = +5; } if ((ROCInS2[bar] < 0) & (ROCSer[bar] < 0)) { ROCInSB[bar] = -5; } if ((ROCInS2[bar] > 0) & (ROCSer[bar] > 0)) { ROCInSS[bar] = +5; } if (RSI.Series(bars.Close, 14)[bar] > 70) { RSIInS[bar] = +5; } else if (RSI.Series(bars.Close, 14)[bar] < 30) { RSIInS[bar] = -5; } if (StochD.Series(bars, 14, 3)[bar] > 80) { STODInS[bar] = +5; } else if (StochD.Series(bars, 14, 3)[bar] < 20) { STODInS[bar] = -5; } if (StochK.Series(bars, 14)[bar] > 80) { STOKInS[bar] = +5; } else if (StochK.Series(bars, 14)[bar] < 20) { STOKInS[bar] = -5; } base[bar] = 50 + CCInS[bar] + BOLInSLL[bar] + RSIInS[bar] + STODInS[bar] + MFIInS[bar] + EMVInSB[bar] + EMVInSS[bar] + ROCInSS[bar] + ROCInSB[bar] + STOKInS[bar] + MACDInSS[bar] + MACDInSB[bar] + PDOInSS[bar - 10] + PDOInSB[bar - 10]; } }
public void CheckInitStatus(object obj, System.Timers.ElapsedEventArgs e) { if (!Initializing) { lock (this) { if (!Initialized && initCdlStatus == DataInitStatus.Initialized && initRtdStatus == DataInitStatus.Initialized && initSigStatus == DataInitStatus.Initialized ) { Initializing = true; if( handler !=null ) handler.IsProcessing = false; if (initRtdStatus == DataInitStatus.Initialized) { Console.WriteLine(" LatesRtds count ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + LatesRtds.Count); LogUtil.Info(" LatesRtds count ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + LatesRtds.Count); if (LatesRtds.Count > 0) { if (dataCache.DataUnits.ContainsKey(CurrentTInterval)) { dataCache.DataUnits[CurrentTInterval].AddRange(LatesRtds); } else { dataCache.DataUnits.Add(CurrentTInterval, LatesRtds); } Console.WriteLine(" dataCache.DataUnits[CurrentTInterval].Count ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + dataCache.DataUnits[CurrentTInterval].Count); LogUtil.Info(" dataCache.DataUnits[CurrentTInterval].Count ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + dataCache.DataUnits[CurrentTInterval].Count); } } RealTimeData[] rtds = null; lock (dataCache.RealTimeDatas) { if (dataCache.RealTimeDatas.Count > 0) { rtds = new RealTimeData[dataCache.RealTimeDatas.Count]; dataCache.RealTimeDatas.CopyTo(rtds); dataCache.RealTimeDatas.Clear(); } } if (dataCache.DataUnits[CurrentTInterval].Count > 0) { List<BarData> datas = dataCache.DataUnits[CurrentTInterval]; BarData lastBar = dataCache.DataUnits[CurrentTInterval][datas.Count - 1]; dataCache.RefreshCurrentTime(currentTInterval, lastBar.DateTime); IntervalData data = new IntervalData(lastBar.Open, lastBar.Close, lastBar.Low, lastBar.High); dataCache.InitCurrentData(currentTInterval, data); Console.WriteLine(" Last BAR ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + lastBar ); LogUtil.Info(" Last BAR ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + lastBar); if (rtds != null && rtds.Length > 0) { Console.WriteLine(" dataCache.RealTimeDatas. count ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + rtds.Length); LogUtil.Info(" dataCache.RealTimeDatas. count ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + rtds.Length); Console.WriteLine(lastBar); if (lastBar.IsCompleted) { foreach (RealTimeData rtd in rtds) { dataCache.UpdateDataSource(rtd); } } else { bool isCompleted = false; double max = lastBar.High; double min = lastBar.Low; List<double> prices = new List<double>(); prices.Add(lastBar.Open); prices.Add(lastBar.Close); prices.Add(lastBar.Low); prices.Add(lastBar.High); for (int k = 0; k < rtds.Length; k++) { RealTimeData rtd = rtds[k]; Console.WriteLine(" RealTimeData ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + rtd); LogUtil.Info(" RealTimeData ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + rtd); if (rtd.dateTime.CompareTo(lastBar.DateTime) < 0) continue; if (rtd.dateTime.Subtract(AppConst.AppTimeSpans[CurrentTInterval]) < lastBar.DateTime) { foreach (double price in rtd.datas) { prices.Add(price); max = Math.Max(max, price); min = Math.Min(min, price); } if (k == rtds.Length - 1 && prices.Count > 0) { lastBar.Close = prices[prices.Count - 1]; lastBar.High = max; lastBar.Low = min; IntervalData newdata = new IntervalData(lastBar.Open, lastBar.Close, lastBar.Low, lastBar.High); dataCache.InitCurrentData(currentTInterval, newdata); dataCache.DataUnits[CurrentTInterval][datas.Count - 1] = lastBar; } } else if (rtd.dateTime.Subtract(AppConst.AppTimeSpans[CurrentTInterval]) >= lastBar.DateTime) { if (!isCompleted) { if (prices != null && prices.Count > 0) { lastBar.Close = prices[prices.Count - 1]; lastBar.High = max; lastBar.Low = min; prices.Clear(); } lastBar.IsCompleted = true; dataCache.DataUnits[CurrentTInterval][datas.Count - 1] = lastBar; IntervalData newdata = new IntervalData(lastBar.Open, lastBar.Close, lastBar.Low, lastBar.High); dataCache.InitCurrentData(currentTInterval, newdata); isCompleted = true; dataCache.UpdateDataSource(rtd); } else { dataCache.UpdateDataSource(rtd); } } } } } SAR sar = new SAR(symbol.ToString(), currentTInterval); RSI rsi = new RSI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),6); RSI rsi2 = new RSI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),42); RSI rsi3 = new RSI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),14); RSI rsi4 = new RSI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),22); CR cr = new CR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval))); ARBR arbr = new ARBR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 26); ARBR arbr2 = new ARBR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),42); CCI cci = new CCI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 14); //CCI cci2 = new CCI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 42); CCI cci2 = new CCI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 24); CCI cci3 = new CCI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 42); WR wr=new WR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),14); WR wr2 = new WR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 24); LWR lwr=new LWR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 14, 3, 3); BOLL boll = new BOLL(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 20); for (int i = 0; i < datas.Count; i++) { BarData bar = datas[i]; if (bar.IsCompleted) { sar.handleFullCandle(ref bar); rsi.handleFullCandle(ref bar, true, 1); rsi2.handleFullCandle(ref bar, true,2); rsi3.handleFullCandle(ref bar, true,3); rsi4.handleFullCandle(ref bar, true,4); cr.handleFullCandle(ref bar); arbr.handleFullCandle(ref bar, 1); arbr2.handleFullCandle(ref bar,2); cci.handleFullCandle(ref bar,1); cci2.handleFullCandle(ref bar,2); cci3.handleFullCandle(ref bar, 3); wr.handleFullCandle(ref bar, 1); wr2.handleFullCandle(ref bar,2); lwr.handleFullCandle(ref bar, 0); boll.handleFullCandle(ref bar, 0); datas[i] = bar; } } dataCache.SARs[currentTInterval] = sar; dataCache.RISs[currentTInterval] = rsi; dataCache.RISs2[currentTInterval] = rsi2; dataCache.RISs3[currentTInterval] = rsi3; dataCache.RISs4[currentTInterval] = rsi4; dataCache.CRs[currentTInterval] = cr; dataCache.ARBRs[currentTInterval] = arbr; dataCache.ARBRs2[currentTInterval] = arbr2; dataCache.CCIs[currentTInterval] = cci; dataCache.CCIs2[currentTInterval] = cci2; dataCache.CCIs3[currentTInterval] = cci3; dataCache.WRs[currentTInterval] = wr; dataCache.WRs2[currentTInterval] = wr2; dataCache.LWRs[currentTInterval] = lwr; dataCache.BOLLs[currentTInterval] = boll; List<Signal> signalList = dataCache.SignalUnits[currentTInterval]; LogUtil.Info(" SignalList count ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + signalList.Count); if (signalList.Count > 0) { Signal[] signals = new Signal[signalList.Count]; signalList.CopyTo(signals, 0); Array.Sort(signals); Array.Reverse(signals); DateTime currentTime = dataCache.CurrentTimes[currentTInterval]; int startIndex = 0; foreach (Signal signal in signals) { DateTime actTime = signal.ActTime; for (int i = startIndex; i < dataCache.DataUnits[currentTInterval].Count; i++) { bool isUpdate = false; List<CandleSignal> sigList = new List<CandleSignal>(); BarData candle = dataCache.DataUnits[currentTInterval][i]; if (actTime.CompareTo(candle.DateTime) > 0) { continue; } else if (actTime.CompareTo(candle.DateTime) == 0) { startIndex = i; isUpdate = true; LogUtil.Info(" Signal " + signal ); LogUtil.Info(" Candle " + candle); // LogUtil.Info(" bf1st " + dataCache.DataUnits[currentTInterval][i-1]); //LogUtil.Info(" bf2nd " + dataCache.DataUnits[currentTInterval][i-2]); CandleSignal cs = new CandleSignal(signal, 1); sigList.Add(cs); } if (signal.GainTip!=0 && signal.GainTipPrice > 0 && candle.DateTime.CompareTo(signal.GainTipTime) == 0) { CandleSignal cs = new CandleSignal(signal, 2); sigList.Add(cs); isUpdate = true; } if (signal.StopLoss != 0 && signal.StopLossBidPrice > 0 && candle.DateTime.CompareTo(signal.StopLossTime) == 0) { CandleSignal cs = new CandleSignal(signal, 3); sigList.Add(cs); isUpdate = true; } if (signal.StopGain != 0 && signal.StopGainPrice > 0 && candle.DateTime.CompareTo(signal.StopGainTime) == 0) { CandleSignal cs = new CandleSignal(signal, 4); sigList.Add(cs); isUpdate = true; } if (isUpdate) { if (candle.SignalList != null) candle.SignalList.AddRange(sigList); else candle.SignalList = sigList; candle.RefreshExValues(); dataCache.DataUnits[currentTInterval][i] = candle; } } List<CandleSignal> sList = new List<CandleSignal>(); if (signal.ActTime.CompareTo(currentTime) <= 0) { if (signal.ActTime.CompareTo(currentTime) == 0) { CandleSignal cs = new CandleSignal(signal, 1); sList.Add(cs); } if (signal.GainTipPrice > 0 && signal.GainTipTime.CompareTo(currentTime) == 0) { CandleSignal cs = new CandleSignal(signal, 2); sList.Add(cs); } if (signal.StopLossBidPrice > 0 && signal.StopLossTime.CompareTo(currentTime) == 0) { CandleSignal cs = new CandleSignal(signal, 3); sList.Add(cs); } if (signal.StopGainPrice > 0 && signal.StopGainTime.CompareTo(currentTime) == 0) { CandleSignal cs = new CandleSignal(signal, 4); sList.Add(cs); } dataCache.CurrentDatas[currentTInterval].SignalList.AddRange(sList); } } } Console.WriteLine(" LAST ###### "+lastBar); LogUtil.Info(" LAST ###### " + lastBar); dataCache.RefreshDataUnits(datas); } //dataCache.Start(); if (AppContext.IsLoading) { AppContext.IsFirstProviderInit = true; isAddCandle = true; Initialized = true; Initializing = false; ProviderHelper.CleanInitDirs(this); } else { isAddCandle = true; Initialized = true; Process(null, null); timerInit.Stop(); timerAuto.Start(); Initializing = false; ProviderHelper.CleanInitDirs(this); Console.WriteLine(" End Now ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; " + DateTime.Now.ToLongTimeString()); } } } } }
public CCISeries(C1FlexChart chart, string plotAreaName) : base() { Chart = chart; Chart.BeginUpdate(); AxisY.TitleStyle = new ChartStyle(); AxisY.TitleStyle.FontWeight = FontWeights.Bold; AxisY.Position = C1.Chart.Position.Right; AxisY.PlotAreaName = plotAreaName; AxisY.Title = "CCI"; AxisY.Labels = false; AxisY.MajorTickMarks = AxisY.MinorTickMarks = C1.Chart.TickMark.None; CCI series = new CCI(); series.ChartType = C1.Chart.Finance.FinancialChartType.Line; series.Style = new C1.WPF.Chart.ChartStyle(); series.Style.Stroke = new SolidColorBrush(Color.FromArgb(255, 51, 103, 214)); series.Style.Fill = new SolidColorBrush(Color.FromArgb(128, 66, 133, 244)); series.Style.StrokeThickness = 1; series.BindingX = "Date"; series.Binding = "High,Low,Close"; series.AxisY = AxisY; Chart.Series.Add(series); ThresholdSeries overBought = new ThresholdSeries(); overBought.ChartType = C1.Chart.Finance.FinancialChartType.Line; overBought.Style = new C1.WPF.Chart.ChartStyle(); overBought.Style.Stroke = new SolidColorBrush(ViewModel.IndicatorPalettes.StockGreen); overBought.Style.StrokeThickness = 1; overBought.AxisY = AxisY; Chart.Series.Add(overBought); ThresholdSeries overSold = new ThresholdSeries(); overSold.ChartType = C1.Chart.Finance.FinancialChartType.Line; overSold.Style = new C1.WPF.Chart.ChartStyle(); overSold.Style.Stroke = new SolidColorBrush(ViewModel.IndicatorPalettes.StockRed); overSold.Style.StrokeThickness = 1; overSold.AxisY = AxisY; Chart.Series.Add(overSold); Utilities.Helper.BindingSettingsParams(chart, series, typeof(CCI), "Commodity Channel Index (CCI)", new Data.PropertyParam[] { new Data.PropertyParam("Period", typeof(int)), new Data.PropertyParam("Style.Stroke", typeof(Brush)), }, () => { this.OnSettingParamsChanged(); } ); Utilities.Helper.BindingSettingsParams(chart, overBought, typeof(ThresholdSeries), "Commodity Channel Index (CCI)", new Data.PropertyParam[] { new Data.PropertyParam("ZonesVisibility", typeof(bool)), new Data.PropertyParam("Threshold", typeof(int), "OverBought"), }, () => { this.OnSettingParamsChanged(); } ); Utilities.Helper.BindingSettingsParams(chart, overSold, typeof(ThresholdSeries), "Commodity Channel Index (CCI)", new Data.PropertyParam[] { new Data.PropertyParam("ZonesVisibility", typeof(bool)), new Data.PropertyParam("Threshold", typeof(int), "OverSold"), }, () => { this.OnSettingParamsChanged(); } ); overBought.OnThesholdChanged += (o, e) => { this.OnSettingParamsChanged(); }; overSold.OnThesholdChanged += (o, e) => { this.OnSettingParamsChanged(); }; //binding series color to axis title. Binding binding = new Binding("Stroke"); binding.Source = series.Style; BindingOperations.SetBinding(AxisY.TitleStyle, ChartStyle.StrokeProperty, binding); Chart.EndUpdate(); this.Series = new FinancialSeries[] { series, overBought, overSold }; }