Example #1
0
        protected override void InitExample()
        {
            var xAxis = new SCINumericAxis {
                AutoRange = SCIAutoRange.Always
            };
            var leftAxis = new SCINumericAxis {
                AxisAlignment = SCIAxisAlignment.Left, AxisId = SCIAxisAlignment.Left.ToString()
            };
            var rightAxis = new SCINumericAxis {
                AxisAlignment = SCIAxisAlignment.Right, AxisId = SCIAxisAlignment.Right.ToString()
            };

            var initialColor        = UIColor.Blue;
            var selectedStrokeStyle = new SCISolidPenStyle(ColorUtil.White, 4f);
            var selectedPointMarker = new SCIEllipsePointMarker
            {
                Width       = 10,
                Height      = 10,
                FillStyle   = new SCISolidBrushStyle(0xFFFF00DC),
                StrokeStyle = new SCISolidPenStyle(ColorUtil.White, 1f)
            };

            using (Surface.SuspendUpdates())
            {
                Surface.XAxes.Add(xAxis);
                Surface.YAxes.Add(leftAxis);
                Surface.YAxes.Add(rightAxis);

                for (var i = 0; i < SeriesCount; i++)
                {
                    var alignment  = i % 2 == 0 ? SCIAxisAlignment.Left : SCIAxisAlignment.Right;
                    var dataSeries = GenerateDataSeries(alignment, i);

                    var rs = new SCIFastLineRenderableSeries
                    {
                        DataSeries          = dataSeries,
                        YAxisId             = alignment.ToString(),
                        StrokeStyle         = new SCISolidPenStyle(initialColor, 2f),
                        SelectedSeriesStyle = new SCILineSeriesStyle
                        {
                            StrokeStyle = selectedStrokeStyle,
                            PointMarker = selectedPointMarker,
                        }
                    };

                    var animation = new SCISweepRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOut);
                    animation.StartAfterDelay(0.3f);
                    rs.AddAnimation(animation);

                    // Colors are incremented for visual purposes only
                    var newR = initialColor.R() == 255 ? 255 : initialColor.R() + 5;
                    var newB = initialColor.B() == 0 ? 0 : initialColor.B() - 2;
                    initialColor = UIColor.FromRGB((byte)newR, initialColor.G(), (byte)newB);

                    Surface.RenderableSeries.Add(rs);
                }

                Surface.ChartModifiers.Add(new SCISeriesSelectionModifier());
            }
        }
        protected override void InitExample()
        {
            var xAxis = new SCIDateTimeAxis {
                GrowBy = new SCIDoubleRange(0.1, 0.1), TextFormatting = "dd/MM/YYYY"
            };
            var yAxis = new SCINumericAxis {
                GrowBy = new SCIDoubleRange(0.1, 0.1)
            };

            var dataSeries = new XyDataSeries <DateTime, double> {
                DataDistributionCalculator = new SCIUserDefinedDistributionCalculator()
            };
            var xyyDataSeries = new XyyDataSeries <DateTime, double> {
                DataDistributionCalculator = new SCIUserDefinedDistributionCalculator()
            };
            var xyyDataSeries1 = new XyyDataSeries <DateTime, double> {
                DataDistributionCalculator = new SCIUserDefinedDistributionCalculator()
            };
            var xyyDataSeries2 = new XyyDataSeries <DateTime, double> {
                DataDistributionCalculator = new SCIUserDefinedDistributionCalculator()
            };

            DataManager.Instance.GetFanData(10, result =>
            {
                dataSeries.Append(result.Date, result.ActualValue);
                xyyDataSeries.Append(result.Date, result.MaxValue, result.MinValue);
                xyyDataSeries1.Append(result.Date, result.Value1, result.Value4);
                xyyDataSeries2.Append(result.Date, result.Value2, result.Value3);
            });

            var dataRenderSeries = new SCIFastLineRenderableSeries
            {
                DataSeries  = dataSeries,
                StrokeStyle = new SCISolidPenStyle(UIColor.Red, 1.0f)
            };

            var animation = new SCIWaveRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOut);

            animation.StartAfterDelay(0.3f);
            dataRenderSeries.AddAnimation(animation);

            using (Surface.SuspendUpdates())
            {
                Surface.XAxes.Add(xAxis);
                Surface.YAxes.Add(yAxis);

                Surface.RenderableSeries.Add(createRenderableSeriesWith(xyyDataSeries));
                Surface.RenderableSeries.Add(createRenderableSeriesWith(xyyDataSeries1));
                Surface.RenderableSeries.Add(createRenderableSeriesWith(xyyDataSeries2));
                Surface.RenderableSeries.Add(dataRenderSeries);

                Surface.ChartModifiers = new SCIChartModifierCollection
                {
                    new SCIZoomPanModifier(),
                    new SCIPinchZoomModifier(),
                    new SCIZoomExtentsModifier()
                };
            }
        }
        protected override void InitExample()
        {
            var xAxis = new SCINumericAxis();
            var yAxis = new SCINumericAxis();

            var ds1 = new XyDataSeries <double, double> {
                SeriesName = "Curve A"
            };
            var ds2 = new XyDataSeries <double, double> {
                SeriesName = "Curve B"
            };
            var ds3 = new XyDataSeries <double, double> {
                SeriesName = "Curve C"
            };
            var ds4 = new XyDataSeries <double, double> {
                SeriesName = "Curve D"
            };

            var ds1Points = DataManager.Instance.GetStraightLine(4000, 1.0, 10);
            var ds2Points = DataManager.Instance.GetStraightLine(3000, 1.0, 10);
            var ds3Points = DataManager.Instance.GetStraightLine(2000, 1.0, 10);
            var ds4Points = DataManager.Instance.GetStraightLine(1000, 1.0, 10);

            ds1.Append(ds1Points.XData, ds1Points.YData);
            ds2.Append(ds2Points.XData, ds2Points.YData);
            ds3.Append(ds3Points.XData, ds3Points.YData);
            ds4.Append(ds4Points.XData, ds4Points.YData);

            var rs1 = new SCIFastLineRenderableSeries {
                DataSeries = ds1, StrokeStyle = new SCISolidPenStyle(0xFFFFFF00, 2f)
            };
            var rs2 = new SCIFastLineRenderableSeries {
                DataSeries = ds2, StrokeStyle = new SCISolidPenStyle(0xFF279B27, 2f)
            };
            var rs3 = new SCIFastLineRenderableSeries {
                DataSeries = ds3, StrokeStyle = new SCISolidPenStyle(0xFFFF1919, 2f)
            };
            var rs4 = new SCIFastLineRenderableSeries {
                DataSeries = ds4, IsVisible = false, StrokeStyle = new SCISolidPenStyle(0xFF1964FF, 2f)
            };

            using (Surface.SuspendUpdates())
            {
                Surface.XAxes.Add(xAxis);
                Surface.YAxes.Add(yAxis);
                Surface.RenderableSeries.Add(rs1);
                Surface.RenderableSeries.Add(rs2);
                Surface.RenderableSeries.Add(rs3);
                Surface.RenderableSeries.Add(rs4);
                Surface.ChartModifiers.Add(new SCILegendModifier {
                    SourceMode = SCISourceMode.AllSeries
                });

                rs1.AddAnimation(new SCISweepRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOut));
                rs2.AddAnimation(new SCISweepRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOut));
                rs3.AddAnimation(new SCISweepRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOut));
                rs4.AddAnimation(new SCISweepRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOut));
            }
        }
Example #4
0
        protected override void InitExample()
        {
            var xAxis = new SCIDateTimeAxis {
                GrowBy = new SCIDoubleRange(0.0, 0.1)
            };
            var yAxis = new SCINumericAxis {
                GrowBy = new SCIDoubleRange(0, 0.1)
            };

            var dataSeries      = new XyzDataSeries <DateTime, double, double>();
            var tradeDataSource = DataManager.Instance.GetTradeticks().ToArray();

            dataSeries.Append(
                tradeDataSource.Select(x => x.TradeDate).ToArray(),
                tradeDataSource.Select(x => x.TradePrice).ToArray(),
                tradeDataSource.Select(x => x.TradeSize).ToArray());

            var lineSeries = new SCIFastLineRenderableSeries
            {
                DataSeries  = dataSeries,
                StrokeStyle = new SCISolidPenStyle(0xFFFF3333, 1f)
            };

            var lineAnimation = new SCIScaleRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOutElastic);

            lineAnimation.StartAfterDelay(0.3f);
            lineSeries.AddAnimation(lineAnimation);

            var bubbleSeries = new SCIBubbleRenderableSeries
            {
                DataSeries = dataSeries,
                //Style = new SCIBubbleSeriesStyle { Detalization = 40,  },
                ZScaleFactor     = 1,
                AutoZRange       = false,
                BubbleBrushStyle = new SCISolidBrushStyle(0x50CCCCCC),
                StrokeStyle      = new SCISolidPenStyle(0x90CCCCCC, 2f)
            };

            var bubbleAnimation = new SCIScaleRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOutElastic);

            bubbleAnimation.StartAfterDelay(0.3f);
            bubbleSeries.AddAnimation(bubbleAnimation);

            using (Surface.SuspendUpdates())
            {
                Surface.XAxes.Add(xAxis);
                Surface.YAxes.Add(yAxis);
                Surface.RenderableSeries.Add(lineSeries);
                Surface.RenderableSeries.Add(bubbleSeries);

                Surface.ChartModifiers = new SCIChartModifierCollection
                {
                    new SCIZoomPanModifier(),
                    new SCIPinchZoomModifier(),
                    new SCIZoomExtentsModifier()
                };
            }
        }
        protected override void InitExample()
        {
            var xAxis = new SCINumericAxis {
                GrowBy = new SCIDoubleRange(0.1, 0.1), VisibleRange = new SCIDoubleRange(1.1, 2.7)
            };
            var yAxis = new SCINumericAxis {
                GrowBy = new SCIDoubleRange(0.1, 0.1)
            };

            var fourierSeries = DataManager.Instance.GetFourierSeries(1.0, 0.1);
            var dataSeries    = new XyDataSeries <double, double>();

            dataSeries.Append(fourierSeries.XData, fourierSeries.YData);

            var renderSeries = new SCIFastLineRenderableSeries {
                DataSeries = dataSeries, StrokeStyle = new SCISolidPenStyle(0xFF279B27, 2f)
            };

            var animation = new SCISweepRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOut);

            animation.StartAfterDelay(0.3f);

            renderSeries.AddAnimation(animation);

            using (Surface.SuspendUpdates())
            {
                Surface.XAxes.Add(xAxis);
                Surface.YAxes.Add(yAxis);
                Surface.RenderableSeries.Add(renderSeries);

                Surface.ChartModifiers = new SCIChartModifierCollection
                {
                    new SCIZoomPanModifier(),
                    new SCIPinchZoomModifier(),
                    new SCIZoomExtentsModifier()
                };
            }
        }
Example #6
0
        protected override void InitExample()
        {
            var xAxis = new SCINumericAxis();
            var yAxis = new SCINumericAxis();

            var fourierSeries = DataManager.Instance.GetFourierSeries(1.0, 0.1, 5.0, 5.15);

            var dataSeries0 = new HlDataSeries <double, double>();
            var dataSeries1 = new HlDataSeries <double, double>();

            FillDataSeries(dataSeries0, fourierSeries, 1.0);
            FillDataSeries(dataSeries1, fourierSeries, 1.3);

            const uint color = 0xFFC6E6FF;

            var strokeStyle = new SCISolidPenStyle(0xFFC6E6FF.ToColor(), 1f);

            var errorBars0 = new SCIFastErrorBarsRenderableSeries
            {
                DataSeries     = dataSeries0,
                StrokeStyle    = strokeStyle,
                ErrorDirection = SCIErrorBarDirection.Vertical,
                ErrorType      = SCIErrorBarType.Absolute
            };

            errorBars0.AddAnimation(new SCIScaleRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOutElastic));

            var lineSeries = new SCIFastLineRenderableSeries
            {
                DataSeries  = dataSeries0,
                StrokeStyle = strokeStyle,
                PointMarker = new SCIEllipsePointMarker
                {
                    FillStyle = new SCISolidBrushStyle(color),
                    Width     = 5,
                    Height    = 5
                }
            };

            lineSeries.AddAnimation(new SCIScaleRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOutElastic));

            var errorBars1 = new SCIFastErrorBarsRenderableSeries
            {
                DataSeries     = dataSeries1,
                StrokeStyle    = strokeStyle,
                DataPointWidth = 0.7f,
                ErrorDirection = SCIErrorBarDirection.Vertical,
                ErrorType      = SCIErrorBarType.Absolute
            };

            errorBars1.AddAnimation(new SCIScaleRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOutElastic));

            var scatterSeries = new SCIXyScatterRenderableSeries
            {
                DataSeries  = dataSeries1,
                PointMarker = new SCIEllipsePointMarker
                {
                    FillStyle   = new SCISolidBrushStyle(ColorUtil.Transparent),
                    StrokeStyle = strokeStyle,
                    Width       = 7,
                    Height      = 7
                }
            };

            scatterSeries.AddAnimation(new SCIScaleRenderableSeriesAnimation(3, SCIAnimationCurve.EaseOutElastic));

            using (Surface.SuspendUpdates())
            {
                Surface.XAxes.Add(xAxis);
                Surface.YAxes.Add(yAxis);
                Surface.RenderableSeries = new SCIRenderableSeriesCollection
                {
                    errorBars0,
                    lineSeries,
                    errorBars1,
                    scatterSeries
                };
                Surface.ChartModifiers = new SCIChartModifierCollection
                {
                    new SCIZoomPanModifier(),
                    new SCIPinchZoomModifier(),
                    new SCIZoomExtentsModifier()
                };
            }
        }