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