private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
        {
            var pointsPerSlice = 65000;
            var sliceCount     = 10;

            var logBase        = 10;
            var slicePositions = new double[sliceCount];

            for (int i = 0; i < sliceCount; ++i)
            {
                slicePositions[i] = Math.Pow(logBase, i);
            }

            var dataSeries = new WaterfallDataSeries3D <double>(pointsPerSlice, slicePositions)
            {
                SeriesName = "Waterfall"
            };

            dataSeries.StartX = 10;
            dataSeries.StepX  = 1;

            FillDataSeries(dataSeries, sliceCount, pointsPerSlice);

            var resampleDataSeries = ResampleDataSeries(dataSeries, slicePositions);

            WaterfallSeries.DataSeries = resampleDataSeries;
        }
        private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
        {
            var pointsPerSlice = 100;
            var sliceCount     = 10;

            var slicePositions = new double[sliceCount];
            var dtNow          = DateTime.Now;

            for (int i = 0; i < sliceCount; ++i)
            {
                var date = dtNow.AddMinutes(10 * i).ToOADate();
                slicePositions[i] = date;
            }

            var dataSeries = new WaterfallDataSeries3D <double>(pointsPerSlice, slicePositions)
            {
                SeriesName = "Waterfall"
            };

            dataSeries.StartX = 10;
            dataSeries.StepX  = 1;

            FillDataSeries(dataSeries, sliceCount, pointsPerSlice);

            WaterfallSeries.DataSeries = dataSeries;
        }
        private void FillDataSeries(WaterfallDataSeries3D <double> dataSeries, int sliceCount, int pointsPerSlice)
        {
            var count = pointsPerSlice * 2;
            var re    = new double[count];
            var im    = new double[count];

            for (int sliceIndex = 0; sliceIndex < sliceCount; ++sliceIndex)
            {
                for (var i = 0; i < count; i++)
                {
                    re[i] = 2.0 * Math.Sin(2 * Math.PI * i / 20) +
                            5 * Math.Sin(2 * Math.PI * i / 10) +
                            2.0 * _random.NextDouble();
                    im[i] = -10;
                }

                _transform.run(re, im);

                var scaleCoef = Math.Pow(1.5, sliceIndex * 0.3) / Math.Pow(1.5, sliceCount * 0.3);
                for (var pointIndex = 0; pointIndex < pointsPerSlice; pointIndex++)
                {
                    var mag  = Math.Sqrt(re[pointIndex] * re[pointIndex] + im[pointIndex] * im[pointIndex]);
                    var yVal = _random.Next(10, 20) * Math.Log10(mag / pointsPerSlice);
                    yVal = (yVal <-25 || yVal> -5)
                        ? (yVal < -25) ? -25 : _random.Next(-6, -3)
                        : yVal;

                    dataSeries[sliceIndex, pointIndex] = -yVal * scaleCoef;
                }
            }
        }
        private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
        {
            var pointsPerSlice = 100;
            var sliceCount     = 20;

            var logBase        = 10;
            var slicePositions = new double[sliceCount];

            for (int i = 0; i < sliceCount; ++i)
            {
                slicePositions[i] = Math.Pow(logBase, i);
            }

            var dataSeries = new WaterfallDataSeries3D <double>(pointsPerSlice, slicePositions)
            {
                SeriesName = "Waterfall"
            };

            dataSeries.StartX = 10;
            dataSeries.StepX  = 1;

            _transform.init((uint)Math.Log(pointsPerSlice, 2));
            FillDataSeries(dataSeries, sliceCount, pointsPerSlice);

            WaterfallSeries.DataSeries = dataSeries;
        }
        private WaterfallDataSeries3D <double> ResampleDataSeries(WaterfallDataSeries3D <double> dataSeries, double[] slicePositions)
        {
            var pointsPerSlice = dataSeries.XSize;
            var sliceCount     = dataSeries.ZSize;

            var resamplerFactory = new PointResamplerFactory();

            var resamplingParams = new ResamplingParams
            {
                IsSortedData        = true,
                IsEvenlySpacedData  = true,
                IsCategoryData      = false,
                ContainsNaN         = false,
                ZeroLineY           = 0.0,
                PointRange          = new IndexRange(0, pointsPerSlice - 1),
                VisibleRange        = dataSeries.XRange,
                ViewportWidth       = Width > 0.0 ? (int)Width : 640,
                ResamplingPrecision = 1
            };

            var resampledSeriesesArray = new IPointSeries[sliceCount];
            var sliceAsXySeries        = new XyDataSeries <double>(pointsPerSlice);
            var sliceAsXySeriesYValues = sliceAsXySeries.YValues as ISciList <double>;

            sliceAsXySeriesYValues.SetCount(pointsPerSlice);

            var xValues   = new double[pointsPerSlice];
            var xRangeMin = (double)dataSeries.XRange.Min;
            var stepX     = dataSeries.StepX;

            for (int i = 0; i < pointsPerSlice; i++)
            {
                xValues[i] = xRangeMin + stepX * i;
            }

            // Init the XY series by first slice of the waterfall data series
            sliceAsXySeries.InsertRange(0, xValues, dataSeries.InternalArray[0]);
            resampledSeriesesArray[0] = sliceAsXySeries.ToPointSeries(resamplingParams, ResamplingMode.Auto, resamplerFactory, null);

            for (int i = 1; i < sliceCount; i++)
            {
                var curRow = dataSeries.GetRowAt(i);
                Array.Copy(curRow, sliceAsXySeriesYValues.ItemsArray, pointsPerSlice);

                resampledSeriesesArray[i] = sliceAsXySeries.ToPointSeries(resamplingParams, ResamplingMode.Auto, resamplerFactory, null);
            }

            var resampledPerPointsPerSlice = resampledSeriesesArray[0].Count;
            var resampledDataSeries        = new WaterfallDataSeries3D <double>(resampledPerPointsPerSlice, slicePositions);

            resampledDataSeries.StartX = dataSeries.StartX;
            resampledDataSeries.StepX  = dataSeries.StepX;
            for (int i = 0; i < sliceCount; i++)
            {
                resampledDataSeries.SetRowAt(i, resampledSeriesesArray[i].YValues.Items);
            }

            return(resampledDataSeries);
        }
 private void FillDataSeries(WaterfallDataSeries3D <double> dataSeries, int sliceCount, int pointsPerSlice)
 {
     for (int sliceIndex = 0; sliceIndex < sliceCount; ++sliceIndex)
     {
         var scaleCoef = Math.Pow(1.5, sliceIndex * 0.3) / Math.Pow(1.5, sliceCount * 0.3);
         for (var pointIndex = 0; pointIndex < pointsPerSlice; pointIndex++)
         {
             dataSeries[sliceIndex, pointIndex] = (Math.Sin(10 * Math.PI * pointIndex / pointsPerSlice) + 1.0) * scaleCoef;
         }
     }
 }
Example #7
0
        private static WaterfallDataSeries3D <double> GetWaterfallDataSeries()
        {
            var pointsPerSlice = 100;
            var sliceCount     = 20;

            var logBase        = 10;
            var slicePositions = new double[sliceCount];

            for (int i = 0; i < sliceCount; ++i)
            {
                slicePositions[i] = i;
            }

            var dataSeries = new WaterfallDataSeries3D <double>(pointsPerSlice, slicePositions);

            dataSeries.StartX = 10;
            dataSeries.StepX  = 1;

            _transform.init((uint)Math.Log(pointsPerSlice, 2));

            var count = pointsPerSlice * 2;
            var re    = new double[count];
            var im    = new double[count];

            for (int sliceIndex = 0; sliceIndex < sliceCount; ++sliceIndex)
            {
                for (var i = 0; i < count; i++)
                {
                    re[i] = 2.0 * Math.Sin(2 * Math.PI * i / 20) +
                            5 * Math.Sin(2 * Math.PI * i / 10) +
                            2.0 * _random.NextDouble();
                    im[i] = -10;
                }

                _transform.run(re, im);

                var scaleCoef = Math.Pow(1.5, sliceIndex * 0.3) / Math.Pow(1.5, sliceCount * 0.3);
                for (var pointIndex = 0; pointIndex < pointsPerSlice; pointIndex++)
                {
                    var mag  = Math.Sqrt(re[pointIndex] * re[pointIndex] + im[pointIndex] * im[pointIndex]);
                    var yVal = _random.Next(10, 20) * Math.Log10(mag / pointsPerSlice);
                    yVal = (yVal <-25 || yVal> -5)
                        ? (yVal < -25) ? -25 : _random.Next(-6, -3)
                        : yVal;

                    dataSeries[sliceIndex, pointIndex] = -yVal * scaleCoef;
                }
            }

            return(dataSeries);
        }
Example #8
0
        private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
        {
            // Initialize FFT
            _transform.init((uint)Math.Log(_pointsPerSlice, 2));
            _transformSize = _pointsPerSlice * 2;
            _real          = new double[_transformSize];
            _imaginary     = new double[_transformSize];

            // Initialize WaterfallDataSeries3D
            _waterfallDataSeries        = new WaterfallDataSeries3D <double>(_pointsPerSlice, _maxSliceCount);
            _waterfallDataSeries.StartX = 10;
            _waterfallDataSeries.StepX  = 1;

            _waterfallDataSeries.StartZ = 25;
            _waterfallDataSeries.StepZ  = 10;

            WaterfallSeries.DataSeries = _waterfallDataSeries;

            MeshSeries.DataSeries = (UniformGridDataSeries3D <double, double, double>)_waterfallDataSeries;
        }