Ejemplo n.º 1
0
        private void btnLoadData_Click(object sender, EventArgs e)
        {
            string itemCode = ItemCodeSet.GetItemCode(ItemCode.지수_국내_코스피200);

            var list = PPContext.Instance.ClientContext.GetSourceData(
                itemCode
                , Lib.Base.Enums.TimeIntervalEnum.Day
                , null
                , tbDT_E.Text
                , 120);

            int round = ItemCodeUtil.GetItemCodeRoundNum(itemCode);

            List <S_CandleItemData>  sourceDatas       = new List <S_CandleItemData>();
            List <T_AtomItemData>    transformedDatas  = new List <T_AtomItemData>();
            List <T_QuantumItemData> transformedDatas2 = new List <T_QuantumItemData>();

            foreach (var m in list)
            {
                S_CandleItemData sourceData = new S_CandleItemData(
                    itemCode
                    , (Single)Math.Round(m.OpenVal, round)
                    , (Single)Math.Round(m.HighVal, round)
                    , (Single)Math.Round(m.LowVal, round)
                    , (Single)Math.Round(m.CloseVal, round)
                    , m.Volume
                    , m.DT
                    );

                sourceDatas.Add(sourceData);
            }

            int itemsCnt = 7;

            for (int i = itemsCnt; i < sourceDatas.Count; i++)
            {
                T_AtomItemData transData = new T_AtomItemData(sourceDatas[i], sourceDatas.GetRange(i - itemsCnt, itemsCnt));
                transData.Transform();
                transformedDatas.Add(transData);
            }
            chartAT1.LoadData(itemCode, transformedDatas);


            itemsCnt = 7;
            for (int i = itemsCnt; i < sourceDatas.Count; i++)
            {
                T_QuantumItemData transData = new T_QuantumItemData(sourceDatas[i], sourceDatas.GetRange(i - itemsCnt, itemsCnt));
                transData.Transform();
                transformedDatas2.Add(transData);
            }
            chartQL1.LoadData(itemCode, transformedDatas2);
        }
Ejemplo n.º 2
0
        public override void View()
        {
            if (ChartData == null)
            {
                return;
            }

            foreach (T_AtomItemData item in ChartData)
            {
                int idx = chart.Series[0].Points.AddXY(item.DTime, item.HighPrice, item.LowPrice, item.OpenPrice, item.ClosePrice);
                chart.Series[1].Points.AddXY(item.DTime, item.QuantumHighPrice, item.QuantumLowPrice, item.OpenPrice, item.QuantumPrice);
                chart.Series[2].Points.AddXY(item.DTime, item.T_MassAvg);
                chart.Series[3].Points.AddXY(item.DTime, item.t_QuantumAvg);
                chart.Series[4].Points.AddXY(item.DTime, item.T_HighAvg);
                chart.Series[5].Points.AddXY(item.DTime, item.T_LowAvg);
                var dataPoint = chart.Series[1].Points[idx];

                if (idx > 0)
                {
                    T_AtomItemData bitem = ChartData[idx - 1];
                    if (bitem.PlusMinusType == PlusMinusTypeEnum.양)
                    {
                        if (bitem.QuantumPrice > item.ClosePrice)
                        {
                            chart.Series[1].Points[idx - 1].Label = "▼";
                        }
                        else if (bitem.QuantumPrice > item.LowPrice)
                        {
                            chart.Series[1].Points[idx - 1].Label = "▽";
                        }
                        else
                        {
                            chart.Series[1].Points[idx - 1].Label = "○";
                        }
                    }
                    if (bitem.PlusMinusType == PlusMinusTypeEnum.음)
                    {
                        if (bitem.QuantumPrice < item.ClosePrice)
                        {
                            chart.Series[1].Points[idx - 1].Label = "▲";
                        }
                        else if (bitem.QuantumPrice < item.HighPrice)
                        {
                            chart.Series[1].Points[idx - 1].Label = "△";
                        }
                        else
                        {
                            chart.Series[1].Points[idx - 1].Label = "○";
                        }
                    }
                }
            }
            chart.Series[1].Enabled = true;// IsShowCandle;

            double maxPrice1 = ChartData.Max(m => m.HighPrice);
            double minPrice1 = ChartData.Min(m => m.LowPrice);
            double maxPrice2 = ChartData.Max(m => m.QuantumHighPrice);
            double minPrice2 = ChartData.Min(m => m.QuantumLowPrice);
            double maxPrice  = maxPrice1 > maxPrice2 ? maxPrice1 : maxPrice2;
            double minPrice  = minPrice1 < minPrice2 ? minPrice1 : minPrice2;

            maxPrice = maxPrice + SpaceMaxMin;
            minPrice = minPrice - SpaceMaxMin;
            chart.ChartAreas[0].AxisY2.Maximum = maxPrice;
            chart.ChartAreas[0].AxisY2.Minimum = minPrice;
            SetScrollBar();
            SetTrackBar();
            DisplayView();

            IsLoaded = true;

            base.View();
        }
Ejemplo n.º 3
0
        public override void View()
        {
            if (ChartData == null)
            {
                return;
            }
            if (ChartDataSub == null)
            {
                return;
            }
            //foreach (T_AtomItemData item in ChartData)

            int diffCnt = ChartData.Count - ChartDataSub.Count;

            for (int i = 0; i < diffCnt; i++)
            {
                ChartData.RemoveAt(0);
            }

            diffCnt = ChartDataSub.Count - ChartData.Count;
            for (int i = 0; i < diffCnt; i++)
            {
                ChartDataSub.RemoveAt(0);
            }

            for (int i = 0; i < ChartData.Count; i++)
            {
                var item = ChartData[i];

                int idx = chart.Series[0].Points.AddXY(item.DTime, item.HighPrice, item.LowPrice, item.OpenPrice, item.ClosePrice);

                if (item.VirtualDepth == 2)
                {
                    chart.Series[1].Points.AddXY(item.DTime, double.NaN, double.NaN, double.NaN, double.NaN);
                    chart.Series[2].Points.AddXY(item.DTime, double.NaN, double.NaN, double.NaN, double.NaN);
                }
                else if (item.VirtualDepth == 1)
                {
                    chart.Series[1].Points.AddXY(item.DTime, item.VikalaPrice, item.VikalaPrice, item.ClosePrice, item.VikalaPrice);
                    chart.Series[2].Points.AddXY(item.DTime, item.QuantumPrice, item.QuantumPrice, item.OpenPrice, item.QuantumPrice);
                }
                else if (item.VirtualDepth == 0)
                {
                    chart.Series[1].Points.AddXY(item.DTime, item.VikalaPrice, item.VikalaPrice, item.ClosePrice, item.VikalaPrice);
                    chart.Series[2].Points.AddXY(item.DTime, item.QuantumPrice, item.QuantumPrice, item.OpenPrice, item.QuantumPrice);
                }

                if (IsShowVirtualDepth)
                {
                    var dataPoint = chart.Series[0].Points[idx];
                    if (item.VirtualDepth == 0)
                    {
                        if (item.PlusMinusType == PlusMinusTypeEnum.양)
                        {
                            SetDataPointColor(dataPoint, Color.Red, Color.Red, Color.Red, 2);
                        }
                        else if (item.PlusMinusType == PlusMinusTypeEnum.음)
                        {
                            SetDataPointColor(dataPoint, Color.Blue, Color.Blue, Color.Blue, 2);
                        }
                        else
                        {
                            SetDataPointColor(dataPoint, Color.Black, Color.Black, Color.Black, 2);
                        }

                        dataPoint.Label = "●";
                    }
                    else if (item.VirtualDepth == 1)
                    {
                        if (item.PlusMinusType == PlusMinusTypeEnum.양)
                        {
                            SetDataPointColor(dataPoint, Color.Red, Color.Red, Color.LightGray, 1);
                        }
                        else if (item.PlusMinusType == PlusMinusTypeEnum.음)
                        {
                            SetDataPointColor(dataPoint, Color.Blue, Color.Blue, Color.LightGray, 1);
                        }
                        else
                        {
                            SetDataPointColor(dataPoint, Color.Black, Color.Black, Color.LightGray, 1);
                        }
                    }
                    else if (item.VirtualDepth == 2)
                    {
                        if (item.PlusMinusType == PlusMinusTypeEnum.양)
                        {
                            SetDataPointColor(dataPoint, Color.Red, Color.Red, Color.White, 1);
                        }
                        else if (item.PlusMinusType == PlusMinusTypeEnum.음)
                        {
                            SetDataPointColor(dataPoint, Color.Blue, Color.Blue, Color.White, 1);
                        }
                        else
                        {
                            SetDataPointColor(dataPoint, Color.Black, Color.Black, Color.White, 1);
                        }
                    }
                }
                else
                {
                    var dataPoint = chart.Series[0].Points[idx];

                    if (item.PlusMinusType == PlusMinusTypeEnum.양 && item.YinAndYang == PlusMinusTypeEnum.양)
                    {
                        SetDataPointColor(dataPoint, Color.Red, Color.Red, Color.Red, 2);
                    }
                    else if (item.PlusMinusType == PlusMinusTypeEnum.음 && item.YinAndYang == PlusMinusTypeEnum.양)
                    {
                        SetDataPointColor(dataPoint, Color.Blue, Color.Blue, Color.Blue, 2);
                    }

                    else if (item.PlusMinusType == PlusMinusTypeEnum.양)
                    {
                        SetDataPointColor(dataPoint, Color.Red, Color.Red, Color.White, 2);
                    }
                    else if (item.PlusMinusType == PlusMinusTypeEnum.음)
                    {
                        SetDataPointColor(dataPoint, Color.Blue, Color.Blue, Color.White, 2);
                    }

                    else
                    {
                        SetDataPointColor(dataPoint, Color.Black, Color.Black, Color.White, 2);
                    }
                }

                var itemAvg = ChartDataSub[i];
                //빨강
                chart.Series[3].Points.AddXY(item.DTime, itemAvg.T_QuantumAvg);
                //주황
                chart.Series[4].Points.AddXY(item.DTime, itemAvg.T_MassAvg);
                //파랑
                chart.Series[5].Points.AddXY(item.DTime, itemAvg.T_VikalaAvg);
                //검정
                chart.Series[6].Points.AddXY(item.DTime, itemAvg.T_Avg);

                bool isSignal       = false;
                bool isUpPosition   = false;
                bool isDownPosition = false;

                if (itemAvg.HighPrice < itemAvg.T_MassAvg &&
                    itemAvg.HighPrice < itemAvg.T_QuantumAvg &&
                    itemAvg.HighPrice < itemAvg.T_VikalaAvg &&
                    itemAvg.HighPrice < itemAvg.T_TotalCenterAvg)
                {
                    isSignal       = true;
                    isDownPosition = true;
                }
                if (itemAvg.LowPrice > itemAvg.T_MassAvg &&
                    itemAvg.LowPrice > itemAvg.T_QuantumAvg &&
                    itemAvg.LowPrice > itemAvg.T_VikalaAvg &&
                    itemAvg.LowPrice > itemAvg.T_TotalCenterAvg)
                {
                    isSignal     = true;
                    isUpPosition = true;
                }

                if (idx > 0 && isSignal)
                {
                    T_AtomItemData bitem           = ChartDataSub[idx - 1];
                    bool           isUpPosition2   = false;
                    bool           isDownPosition2 = false;
                    if (bitem.HighPrice < bitem.T_MassAvg &&
                        bitem.HighPrice < bitem.T_QuantumAvg &&
                        bitem.HighPrice < bitem.T_VikalaAvg &&
                        bitem.HighPrice < bitem.T_TotalCenterAvg)
                    {
                        isDownPosition2 = true;
                    }
                    if (bitem.LowPrice > bitem.T_MassAvg &&
                        bitem.LowPrice > bitem.T_QuantumAvg &&
                        bitem.LowPrice > bitem.T_VikalaAvg &&
                        bitem.LowPrice > bitem.T_TotalCenterAvg)
                    {
                        isUpPosition2 = true;
                    }

                    if (bitem.PlusMinusType == PlusMinusTypeEnum.양 && isUpPosition && isUpPosition2)
                    {
                        bool isFirst  = false;
                        bool isSecond = false;
                        if (bitem.QuantumPrice > itemAvg.ClosePrice)
                        {
                            chart.Series[1].Points[idx - 1].Label = "▼";
                            isFirst = true;
                        }
                        if (bitem.VikalaPrice > itemAvg.ClosePrice)
                        {
                            chart.Series[2].Points[idx - 1].Label = "▼";
                            isSecond = true;
                        }

                        if (isFirst && isSecond)
                        {
                            chart.Series[1].Points[idx - 1].LabelForeColor     =
                                chart.Series[2].Points[idx - 1].LabelForeColor = Color.Blue;
                        }
                    }

                    if (bitem.PlusMinusType == PlusMinusTypeEnum.음 && isDownPosition && isDownPosition2)
                    {
                        bool isFirst  = false;
                        bool isSecond = false;
                        if (bitem.QuantumPrice < itemAvg.ClosePrice)
                        {
                            chart.Series[1].Points[idx - 1].Label = "▲";
                            isFirst = true;
                        }
                        if (bitem.VikalaPrice < itemAvg.ClosePrice)
                        {
                            chart.Series[2].Points[idx - 1].Label = "▲";
                            isSecond = true;
                        }

                        if (isFirst && isSecond)
                        {
                            chart.Series[1].Points[idx - 1].LabelForeColor     =
                                chart.Series[2].Points[idx - 1].LabelForeColor = Color.Red;
                        }
                    }
                }
            }

            SetTrackBar();
            SetScrollBar();

            DisplayView();

            IsLoaded = true;

            base.View();
        }
Ejemplo n.º 4
0
        private void btnLoadData_Click(object sender, EventArgs e)
        {
            TimeIntervalEnum timeInterval = TimeIntervalEnum.Day;

            if (radioButton1.Checked)
            {
                timeInterval = TimeIntervalEnum.Hour_01;
            }
            if (radioButton2.Checked)
            {
                timeInterval = TimeIntervalEnum.Hour_02;
            }
            if (radioButton3.Checked)
            {
                timeInterval = TimeIntervalEnum.Hour_03;
            }
            if (radioButton4.Checked)
            {
                timeInterval = TimeIntervalEnum.Day;
            }

            string itemCode = ItemCodeSet.GetItemCode(ItemCode.지수_국내_코스피200);
            var    list     = PPContext.Instance.ClientContext.GetSourceData(
                itemCode
                , timeInterval
                , null
                , tbDT_E.Text
                , 300);

            int round = ItemCodeUtil.GetItemCodeRoundNum(itemCode);

            List <S_CandleItemData> sourceDatas = new List <S_CandleItemData>();

            foreach (var m in list)
            {
                S_CandleItemData sourceData = new S_CandleItemData(
                    itemCode
                    , (Single)Math.Round(m.OpenVal, round)
                    , (Single)Math.Round(m.HighVal, round)
                    , (Single)Math.Round(m.LowVal, round)
                    , (Single)Math.Round(m.CloseVal, round)
                    , m.Volume
                    , m.DT
                    );

                sourceDatas.Add(sourceData);
            }

            int itemsCnt = 7;
            List <T_AtomItemData> transformedDatas = new List <T_AtomItemData>();

            for (int i = itemsCnt; i <= sourceDatas.Count; i++)
            {
                T_AtomItemData transData = new T_AtomItemData(sourceDatas[i - 1], sourceDatas.GetRange(i - itemsCnt, itemsCnt));
                transData.Transform();
                transformedDatas.Add(transData);
            }
            chartAT1.LoadData(itemCode, transformedDatas, timeInterval);


            List <S_CandleItemData> sourceDatas2 = new List <S_CandleItemData>();

            itemsCnt = 7;
            for (int i = itemsCnt; i < sourceDatas.Count; i++)
            {
                S_CandleItemData transData = new S_CandleItemData(itemCode, sourceDatas.GetRange(i - itemsCnt, itemsCnt));
                sourceDatas2.Add(transData);
            }
            itemsCnt = 7;
            List <T_AtomItemData> transformedDatas2 = new List <T_AtomItemData>();

            for (int i = itemsCnt; i <= sourceDatas2.Count; i++)
            {
                T_AtomItemData transData = new T_AtomItemData(sourceDatas2[i - 1], sourceDatas2.GetRange(i - itemsCnt, itemsCnt));
                transData.Transform();
                transformedDatas2.Add(transData);
            }
            chartAT2.LoadData(itemCode, transformedDatas2, timeInterval);
        }