Beispiel #1
0
        protected override void UpdateCore()
        {
            if (DataSource == null)
            {
                return;
            }
            if (Plotter == null)
            {
                return;
            }

            Rect output    = Viewport.Output;
            var  transform = GetTransform();

            if (filteredPoints == null || !(transform.DataTransform is IdentityTransform))
            {
                IEnumerable <Point> points = GetPoints();

                var bounds = BoundsHelper.GetViewportBounds(points, transform.DataTransform);
                Viewport2D.SetContentBounds(this, bounds);

                // getting new value of transform as it could change after calculating and setting content bounds.
                transform = GetTransform();
                List <Point> transformedPoints = transform.DataToScreenAsList(points);

                // Analysis and filtering of unnecessary points
                filteredPoints = new FakePointList(FilterPoints(transformedPoints),
                                                   output.Left, output.Right);

                if (ProvideVisiblePoints)
                {
                    List <Point> viewportPointsList = new List <Point>(transformedPoints.Count);
                    if (transform.DataTransform is IdentityTransform)
                    {
                        viewportPointsList.AddRange(points);
                    }
                    else
                    {
                        var viewportPoints = points.DataToViewport(transform.DataTransform);
                        viewportPointsList.AddRange(viewportPoints);
                    }

                    SetVisiblePoints(this, new ReadOnlyCollection <Point>(viewportPointsList));
                }

                Offset = new Vector();
            }
            else
            {
                double left  = output.Left;
                double right = output.Right;
                double shift = Offset.X;
                left  -= shift;
                right -= shift;

                filteredPoints.SetXBorders(left, right);
            }
        }
        protected override void UpdateCore()
        {
            if (DataSource == null || Viewport == null || Viewport.Output == new Rect(0, 0, 0, 0))
            {
                return;
            }

            if (path.Clip == null)
            {
                updateClippingRect();
            }

            Rect output    = Viewport.Output;
            var  transform = GetTransform();

            PerformanceCounter.startStopwatch("Updating linegraph core: Getting points");

            IEnumerable <Point> points = GetPoints();

            PerformanceCounter.stopStopwatch("Updating linegraph core: Getting points");
            PerformanceCounter.startStopwatch("Updating linegraph core: Getting Content bounds");

            ContentBounds = BoundsHelper.GetViewportBounds(points, transform.DataTransform);
            PerformanceCounter.stopStopwatch("Updating linegraph core: Getting Content bounds");

            List <Point> transformedPoints = transform.DataToScreen(points);

            PerformanceCounter.startStopwatch("Updating linegraph core: Creating fake points");
            filteredPoints = new FakePointList(FilterPoints(transformedPoints),
                                               output.Left, output.Right, output.Top, output.Bottom);
            PerformanceCounter.stopStopwatch("Updating linegraph core: Creating fake points");
            PerformanceCounter.startStopwatch("Updating linegraph core: adding segments");
            if (filteredPoints.Count != 0)
            {
                segments.Clear();

                for (int i = 0; i < filteredPoints.Count; i++)
                {
                    LineSegment segment = new LineSegment();
                    segment.Point = filteredPoints[i];
                    segments.Add(segment);
                }

                figure.StartPoint = filteredPoints.StartPoint;
                PerformanceCounter.stopStopwatch("Updating linegraph core: adding segments");
            }
        }
        protected override void UpdateCore()
        {
            if (DataSource == null)
            {
                return;
            }

            Rect output    = Viewport.Output;
            var  transform = GetTransform();

            if (filteredPoints == null || !(transform.DataTransform is IdentityTransform))
            {
                IEnumerable <Point> points = GetPoints();

                ContentBounds = BoundsHelper.GetViewportBounds(points, transform.DataTransform);

                transform = GetTransform();
                List <Point> transformedPoints = transform.DataToScreen(points);

                // Analysis and filtering of unnecessary points
                filteredPoints = new FakePointList(FilterPoints(transformedPoints),
                                                   output.Left, output.Right);

                Offset = new Vector();
            }
            else
            {
                double left  = output.Left;
                double right = output.Right;
                double shift = Offset.X;
                left  -= shift;
                right -= shift;

                filteredPoints.SetXBorders(left, right);
            }
        }
 void filters_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
 {
     filteredPoints = null;
     UpdateCore();
 }
Beispiel #5
0
        /*  FakePointList filteredMarkerPoints;//标记点在屏幕上显示的位置*/
        protected override void UpdateCore()
        {
            if (DataSource == null)
            {
                return;
            }
            if (Plotter == null)
            {
                return;
            }

            Rect output    = Viewport.Output;
            var  transform = GetTransform();

            if (filteredPoints == null || !(transform.DataTransform is IdentityTransform))
            {
                IEnumerable <Point> points = GetPoints();//实际值
                Point[]             ps     = points.ToArray <Point>();

                /* List<Point> ps=points.ToList<Point>();
                 * List<Point> pps = new List<Point>();
                 * if (myPointMarkers != null)
                 * {
                 *   foreach (MyPointMarker mp in myPointMarkers)
                 *   {
                 *       Point point = ps.Find(
                 *           delegate(Point p)
                 *           {
                 *               return p.X == mp.x;
                 *           });
                 *       pps.Add(point);
                 *   }
                 * }*/
                var bounds = BoundsHelper.GetViewportBounds(points, transform.DataTransform);
                Viewport2D.SetContentBounds(this, bounds);

                // getting new value of transform as it could change after calculating and setting content bounds.
                transform = GetTransform();
                List <Point> transformedPoints = transform.DataToScreenAsList(points);//屏幕上显示值
                /*List<Point> transformedMarkerPoints = transform.DataToScreenAsList(pps);*/
                // Analysis and filtering of unnecessary points,
                // 分析和过滤不必要的点
                filteredPoints = new FakePointList(FilterPoints(transformedPoints),
                                                   output.Left, output.Right);//过滤超出屏幕的点
                /*filteredMarkerPoints = new FakePointList(FilterPoints(transformedMarkerPoints), output.Left, output.Right);*/
                if (ProvideVisiblePoints)
                {
                    List <Point> viewportPointsList = new List <Point>(transformedPoints.Count);
                    if (transform.DataTransform is IdentityTransform)
                    {
                        viewportPointsList.AddRange(points);
                    }
                    else
                    {
                        var viewportPoints = points.DataToViewport(transform.DataTransform);
                        viewportPointsList.AddRange(viewportPoints);
                    }

                    SetVisiblePoints(this, new ReadOnlyCollection <Point>(viewportPointsList));
                }

                Offset = new Vector();
            }
            else
            {
                double left  = output.Left;
                double right = output.Right;
                double shift = Offset.X;
                left  -= shift;
                right -= shift;

                filteredPoints.SetXBorders(left, right);
            }
        }