using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using RealTimeGraphEx.Models;
using RealTimeGraphEx.DataSeries;
using RealTimeGraphEx.Controllers;
using System.Runtime.ExceptionServices;
namespace RealTimeGraphEx.FastGraphs
{
/// <summary>
/// Represents a real-time graph with a single scrollable line.
/// </summary>
public class RealTimeGraphExLineScroll : RealTimeGraphExBase
{
#region Protected Fields
protected ConcurrentpointsList graphPolygon;
protected int updateCounter;
#endregion
#region Cross Thread Fields
protected GraphController _graphController;
protected int _maxPoints;
protected double _scaleFactor;
protected Color _stroke;
protected Color _fill;
protected bool _fillGraph;
protected List<double> _markers;
#endregion
#region Properties
/// <summary>
/// Gets or sets the graph fill color.
/// </summary>
public Color Stroke
{
get { return (Color)GetValue(StrokeProperty); }
set { SetValue(StrokeProperty, value); }
}
public static readonly DependencyProperty StrokeProperty =
DependencyProperty.Register("Stroke", typeof(Color), typeof(RealTimeGraphExLineScroll), new PropertyMetadata(Colors.Black, new PropertyChangedCallback(CrossModelChanged)));
/// <summary>
/// Gets or sets the graph fill color.
/// </summary>
public Color Fill
{
get { return (Color)GetValue(FillProperty); }
set { SetValue(FillProperty, value); }
}
public static readonly DependencyProperty FillProperty =
DependencyProperty.Register("Fill", typeof(Color), typeof(RealTimeGraphExLineScroll), new PropertyMetadata(Colors.Gray, new PropertyChangedCallback(CrossModelChanged)));
/// <summary>
/// Gets or sets whether the graph will be rendered using the Fill color property.
/// </summary>
public bool FillGraph
{
get { return (bool)GetValue(FillGraphProperty); }
set { SetValue(FillGraphProperty, value); }
}
public static readonly DependencyProperty FillGraphProperty =
DependencyProperty.Register("FillGraph", typeof(bool), typeof(RealTimeGraphExLineScroll), new PropertyMetadata(false, new PropertyChangedCallback(CrossModelChanged)));
/// <summary>
/// Gets or sets the IDataSeries used to push data vectorsCollection to the graph.
/// </summary>
public GraphController Controller
{
get { return (GraphController)GetValue(ControllerProperty); }
set { SetValue(ControllerProperty, value); }
}
public static readonly DependencyProperty ControllerProperty =
DependencyProperty.Register("Controller", typeof(GraphController), typeof(RealTimeGraphExLineScroll), new PropertyMetadata(null, new PropertyChangedCallback(GraphControllerChanged)));
private static void GraphControllerChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var control = d as RealTimeGraphExLineScroll;
if (control.Controller != null)
{
control.Controller.RegisterMethods(control.ClearGraph, control.StartPushThread, control.SetPaused, control.ChangeRenderMode, control.OnPushMarker);
control._graphController = control.Controller;
}
}
#endregion
#region Constructors
public RealTimeGraphExLineScroll()
: base()
{
graphPolygon = new ConcurrentpointsList();
_markers = new List<double>();
}
#endregion
#region Override Methods
protected override void OnSizeChanged(object sender, SizeChangedEventArgs e)
{
OnSetCrossThreadFields();
}
protected override void OnSetCrossThreadFields()
{
base.OnSetCrossThreadFields();
this.Dispatcher.Invoke(() =>
{
_maxPoints = MaxPoints;
_scaleFactor = _width / _maxPoints;
_graphController = Controller;
_stroke = Stroke;
_fillGraph = FillGraph;
_fill = Fill;
}, DispatcherPriority.Send);
}
protected override void OnClearGraph()
{
base.OnClearGraph();
_graphController.dataSeries.ClearPoints();
graphPolygon.Clear();
}
protected internal override void OnRenderGraph()
{
if (_graphController != null && _graphController.dataSeries.Points != null && _graphController.dataSeries.Points.Count > 0 && _width > 1 && _height > 1)
{
var points = _graphController.dataSeries.Points.GetAndClearAllPoints();
if (_useAutoRange && points.Count > 0)
{
Dispatcher.Invoke(() =>
{
Maximum = points.Concat(graphPolygon.GetPoints()).Max();
Minimum = points.Concat(graphPolygon.GetPoints()).Min();
});
}
if (!_isPaused)
{
for (int i = 0; i < points.Count; i++)
{
double value = points[i];
NormalizeValue(ref value);
graphPolygon.Add(value);
xValueCounter += _scaleFactor;
}
if (graphPolygon.Count > _maxPoints + 1)
{
xValueCounter -= (_scaleFactor * (graphPolygon.Count - (_maxPoints + 1)));
graphPolygon.RemoveFromStart(graphPolygon.Count - (_maxPoints + 1));
}
}
updateCounter++;
if (updateCounter >= 1)
{
updateCounter = 0;
if (!_disableRendering)
{
WriteableBitmap bmp = BitmapFactory.New((int)_mainWidth, (int)_mainHeight);
bmp.Clear(Colors.Transparent);
OnDrawVisuals(bmp);
bmp.Freeze();
img.Dispatcher.BeginInvoke(new Action(() =>
{
img.Source = bmp;
}), System.Windows.Threading.DispatcherPriority.Send);
}
}
}
}
protected override void OnZoomingComplete(Point transformOrigin, double scaleX, double scaleY)
{
base.OnZoomingComplete(transformOrigin, scaleX, scaleY);
}
#endregion
#region Virtual Methods
protected virtual void OnPushMarker()
{
}
/// <summary>
/// Calculate the scaling factor for the current graph width.
/// </summary>
/// <returns></returns>
protected virtual double GetPolygonScaleFactor()
{
return _width / (graphPolygon.Count - 1);
}
/// <summary>
/// Draw the actual polygon on the image.
/// </summary>
/// <param name="bmp"></param>
[HandleProcessCorruptedStateExceptions]
protected virtual void OnDrawVisuals(WriteableBitmap bmp)
{
Color stroke = _graphController.dataSeries.GetStrokeColor() != null ? _graphController.dataSeries.GetStrokeColor().Value : _stroke;
Color fill = _graphController.dataSeries.GetFillColor() != null ? _graphController.dataSeries.GetFillColor().Value : _fill;
double scale = GetPolygonScaleFactor();
OnBeforeRenderingVisuals(bmp, scale);
if (_fillGraph) //Fill Graph
{
bmp.FillPolygon(graphPolygon.ToPolygonPointsFill(_offSetX, _offSetY, _mainWidth, _mainHeight, scale, ConvertYToImageYFliped), fill);
}
DrawPolyline(bmp, graphPolygon.ToPolygonPoints(_offSetX, _offSetY, scale, ConvertYToImageYFliped), stroke);
OnAfterRenderingVisuals(bmp, scale);
}
#endregion
}
}
