Пример #1
0
        /// <summary>
        /// Adds to charts.
        /// </summary>
        /// <param name="rec">The record.</param>
        private void AddToCharts(SeismicRecordSpectrum rec)
        {
            var pen = new Pen();

            BindingOperations.SetBinding(pen, Pen.ThicknessProperty,
                                         new Binding("ChartPenThickness")
            {
                Source = ApplicationSettings.Current
            });

            var brush = new SolidColorBrush();

            BindingOperations.SetBinding(brush, SolidColorBrush.ColorProperty,
                                         new Binding("Color")
            {
                Source = rec
            });

            pen.Brush = brush;

            var a = new CustomObservableDataSource(rec.AccelerationSpectrum);

            rec.AccelerationSpectrum.CollectionChanged += (sender, e) => this.DispatcherInvoke(() =>
            {
                a.Collection.Clear();
                a.AppendMany(sender as FastObservableCollection <Point2D>);
            });


            a.SetXMapping(i => i.X);
            a.SetYMapping(i => i.Y);
            a.Record = rec;

            var aGr = AccelerationCharts.AddLineGraph(a, pen, new PenDescription());

            aGr.DataContext = rec;
            aGr.SetBinding(LineGraph.VisibilityProperty, new Binding("IsVisible")
            {
                Converter = new BoolToVisibilityConverter()
            });


            var v = new CustomObservableDataSource(rec.SpeedSpectrum);

            rec.SpeedSpectrum.CollectionChanged += (sender, e) => this.DispatcherInvoke(() =>
            {
                v.Collection.Clear();
                v.AppendMany(sender as FastObservableCollection <Point2D>);
            });


            v.SetXMapping(i => i.X);
            v.SetYMapping(i => i.Y);
            v.Record = rec;

            var vGr = VelocityCharts.AddLineGraph(v, pen, new PenDescription());

            vGr.DataContext = rec;
            vGr.SetBinding(LineGraph.VisibilityProperty, new Binding("IsVisible")
            {
                Converter = new BoolToVisibilityConverter()
            });

            var d = new CustomObservableDataSource(rec.DisplacementSpectrum);

            rec.DisplacementSpectrum.CollectionChanged += (sender, e) => this.DispatcherInvoke(() =>
            {
                d.Collection.Clear();
                d.AppendMany(sender as FastObservableCollection <Point2D>);
            });


            d.SetXMapping(i => i.X);
            d.SetYMapping(i => i.Y);
            d.Record = rec;

            var dGr = DisplacementCharts.AddLineGraph(d, pen, new PenDescription());

            dGr.DataContext = rec;
            dGr.SetBinding(LineGraph.VisibilityProperty, new Binding("IsVisible")
            {
                Converter = new BoolToVisibilityConverter()
            });
        }
Пример #2
0
        public void UpdateAverageAccelResponseLine()
        {
            var avgPts = new List <Point>();
            var maxPts = new List <Point>();

            var dt   = ApplicationSettings.Current.SpectrumsDt;
            var tmax = ApplicationSettings.Current.SpectrumsTMax;

            var m = tmax / dt;

            var recs = ApplicationSettings.Current.ActiveRecords.Select(i => i.AccelerationSpectrum.ToArray()).ToArray();

            for (var i = 0; i < m; i++)
            {
                var max = 0.0;
                var sum = 0.0;

                foreach (var rec in recs)
                {
                    sum += rec[i].Y;
                    max  = Math.Max(max, rec[i].Y);
                }

                avgPts.Add(new Point(i * dt, sum / recs.Length));
                maxPts.Add(new Point(i * dt, max));
            }



            var avgGr1 =
                AccelerationCharts.Children.Where(i => i is LineGraph)
                .Cast <LineGraph>()
                .FirstOrDefault(i => "avgaccel1".Equals(i.Tag));

            var avgGr2 =
                AccelerationCharts.Children.Where(i => i is LineGraph)
                .Cast <LineGraph>()
                .FirstOrDefault(i => "avgaccel2".Equals(i.Tag));


            var maxGr1 =
                AccelerationCharts.Children.Where(i => i is LineGraph)
                .Cast <LineGraph>()
                .FirstOrDefault(i => "maxaccel1".Equals(i.Tag));

            var maxGr2 =
                AccelerationCharts.Children.Where(i => i is LineGraph)
                .Cast <LineGraph>()
                .FirstOrDefault(i => "maxaccel2".Equals(i.Tag));



            if (avgGr1 == null)
            {
                {//for avgGr
                    var pen1 = new Pen(Brushes.Green, 4);
                    var pen2 = new Pen(Brushes.White, 2);

                    pen2.DashStyle = DashStyles.Dash;
                    pen1.DashCap   = pen1.DashCap = PenLineCap.Round;

                    var source = new ObservableDataSource <Point>();
                    {
                        avgGr1 = AccelerationCharts.AddLineGraph(source, pen1, null);
                        avgGr2 = AccelerationCharts.AddLineGraph(source, pen2, null);
                    }

                    avgGr1.Tag = "avgaccel1";
                    avgGr2.Tag = "avgaccel2";

                    avgGr1.ToolTip = avgGr2.ToolTip = "Average of all records";

                    Canvas.SetZIndex(avgGr1, 10001);
                    Canvas.SetZIndex(avgGr2, 10002);
                }


                {//for maxGr
                    var pen1 = new Pen(Brushes.Red, 4);
                    var pen2 = new Pen(Brushes.White, 2);

                    pen2.DashStyle = DashStyles.Dash;
                    pen1.DashCap   = pen1.DashCap = PenLineCap.Round;

                    var source = new ObservableDataSource <Point>();
                    {
                        maxGr1 = AccelerationCharts.AddLineGraph(source, pen1, null);
                        maxGr2 = AccelerationCharts.AddLineGraph(source, pen2, null);
                    }

                    maxGr1.Tag = "maxaccel1";
                    maxGr2.Tag = "maxaccel2";

                    maxGr1.ToolTip = maxGr2.ToolTip = "Maximum of all records";

                    Canvas.SetZIndex(maxGr1, 10003);
                    Canvas.SetZIndex(maxGr2, 10004);
                }

                StartBlinkForEver(avgGr2, maxGr2);
            }


            var avgSrc = avgGr1.DataSource as ObservableDataSource <Point>;
            var maxSrc = maxGr1.DataSource as ObservableDataSource <Point>;

            avgSrc.Collection.Clear();
            maxSrc.Collection.Clear();


            avgSrc.AppendMany(avgPts);
            maxSrc.AppendMany(maxPts);

            if (ApplicationSettings.Current.ActiveRecords.Count < 2)
            {
                stkLegends.Visibility =
                    avgGr1.Visibility = avgGr2.Visibility = maxGr1.Visibility = maxGr2.Visibility = Visibility.Collapsed;
            }
            else
            {
                if (stkLegends.Context.ChkChecked)
                {
                    stkLegends.Visibility             =
                        avgGr1.Visibility             =
                            avgGr2.Visibility         =
                                maxGr1.Visibility     =
                                    maxGr2.Visibility = Visibility.Visible;
                }
            }
        }