// Copyright © 2010-2011 Microsoft Corporation, All Rights Reserved.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Resources;

namespace ManyMarkersSample
{
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();

            var y = LoadData();
            var x = Enumerable.Range(0, y.Length).Select(p => (double)p).ToArray();

            markers.MarkersBatchSize = 750;
            markers.Plot(x, y);
        }

        private static double[] LoadData()
        {
            List<double> data = new List<double>(11000);
            StreamResourceInfo sri = Application.GetResourceStream(new Uri("r0001.csv", UriKind.Relative));
            using (var sr = new StreamReader(sri.Stream))
            {
                var s = sr.ReadLine();
                while ((s = sr.ReadLine()) != null)
                {
                    var d = double.Parse(s, CultureInfo.InvariantCulture);
                    data.Add(d);
                }
            }
            return data.ToArray();
        }
    }
}

System.Object
  System.Windows.DependencyObject
    System.Windows.UIElement
      System.Windows.FrameworkElement
        System.Windows.Controls.Panel
          Microsoft.Research.DynamicDataDisplay.PlotBase
            Microsoft.Research.DynamicDataDisplay.MarkerGraph
              Microsoft.Research.DynamicDataDisplay.BarGraph
              Microsoft.Research.DynamicDataDisplay.CartesianMarkerGraph
              Microsoft.Research.DynamicDataDisplay.VerticalIntervalGraph

class MarkerGraph
{
    public int MarkerBatchSize { get; set; } // Dep. prop.
    public int MaxSnapshotSize { get; set; } // Dep. prop.
    public long Plot(params object[] data);
    IObservable<RenderCompletion> RenderCompletion;
    …
}

// Copyright © 2010-2011 Microsoft Corporation, All Rights Reserved.

using System;
using System.Threading;
using System.Windows.Controls;
using System.Windows.Media;

namespace ConcurrentMarkerGraphSample
{
    public partial class MainPage : UserControl
    {
        private volatile bool isUnloaded;
        private Thread thread;
        private double phase;

        public MainPage()
        {
            InitializeComponent();

            markers.MarkersBatchSize = 300;

            // Start computation thread when page appears on the screen
            Loaded += (s, e) =>
            {
                thread = new Thread(ModelRun);
                isUnloaded = false;
                thread.Start();
            };

            // Stop computation thread when page is removed from the screen
            Unloaded += (s, e) =>
            {
                isUnloaded = true;
                thread.Join();
            };
        }

        private void ModelRun()
        {
            const int N = 1000;
            double[] y = new double[N];
            for (int i = 0; i < N; i++)
                y[i] = Math.Cos(i * Math.PI / 50);

            while (!isUnloaded) // Run until page is on the screen
            {
                // Data array is updated
                for (int i = 0; i < N; i++)
                {
                    y[i] = Math.Cos(i * Math.PI / 50 + phase);
                }
                phase += 0.1;

                // Render data only if marker graph is not renderind something.
                // This reduce flickering, but not guarantee that each interation of computations
                // will be rendered.
                if (!markers.IsBusy)
                {
                    // Do not forget to clone changing data before passing to plot
                    double[] data = (double[])y.Clone(); 

                    // MarkerGraph.Plot method is thread safe.
                    // Note: PlotY, PlotXY and other similar methods of derived 
                    // classes are not thread safe and required Dispatcher.BeginInvoke
                    markers.Plot(null, data, Colors.Red, 5.0);
                }
            }
        }
    }
}

System.Object
  System.Windows.DependencyObject
    System.Windows.UIElement
      System.Windows.FrameworkElement
        System.Windows.Controls.Panel
          Microsoft.Research.DynamicDataDisplay.PlotBase
            Microsoft.Research.DynamicDataDisplay.MarkerGraph
              Microsoft.Research.DynamicDataDisplay.BarGraph
              Microsoft.Research.DynamicDataDisplay.CartesianMarkerGraph
              Microsoft.Research.DynamicDataDisplay.VerticalIntervalGraph

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reactive.Subjects;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace Microsoft.Research.DynamicDataDisplay
{
    /// <summary>
    /// Base class for renderers, which can prepare its render results in a separate thread.
    /// </summary>
    public abstract class BackgroundBitmapRenderer : Plot
    {
        private delegate void RenderFunc(RenderResult r, RenderTaskState state);

        private Image outputImage;

        /// <summary>Cartesian coordinates of image currently on the screen.</summary>
        private DataRect imageCartesianRect;

        /// <summary>Size of image currently on the screen.</summary>
        private Size imageSize;

        private int maxTasks;

        private Queue<long> tasks = new Queue<long>();

        private List<RenderTaskState> runningTasks;

        private long nextID;

        private Size prevSize = new Size(double.NaN, double.NaN);

        private double prevScaleX = double.NaN;

        private double prevScaleY = double.NaN;

        private double prevOffsetX = double.NaN;

        private double prevOffsetY = double.NaN;

        private Subject<RenderCompletion> renderCompletion = new Subject<RenderCompletion>();

        /// <summary>
        /// Gets event which is occured when render task is finished
        /// </summary>
        public IObservable<RenderCompletion> RenderCompletion
        {
            get
            {
                return this.renderCompletion;
            }
        }

        /// <summary>
        /// Initializes new instance of <see cref="T:Microsoft.Research.DynamicDataDisplay.BackgroundBitmapRenderer" /> class, performing all basic preparings for inheriting classes.
        /// </summary>
        protected BackgroundBitmapRenderer()
        {
            this.maxTasks = Math.Max(1, Environment.get_ProcessorCount() - 1);
            this.runningTasks = new List<RenderTaskState>();
            this.outputImage = new Image();
            this.outputImage.set_Stretch(0);
            this.outputImage.set_VerticalAlignment(1);
            this.outputImage.set_HorizontalAlignment(1);
            base.get_Children().Add(this.outputImage);
            base.add_Unloaded(new RoutedEventHandler(this.BackgroundBitmapRendererUnloaded));
        }

        private void BackgroundBitmapRendererUnloaded(object sender, RoutedEventArgs e)
        {
            this.CancelAll();
        }

        /// <summary>
        /// Measures the size in layout required for child elements and determines a size for parent. 
        /// </summary>
        /// <param name="availableSize">The available size that this element can give to child elements. Infinity can be specified as a value to indicate that the element will size to whatever content is available.</param>
        /// <returns>The size that this element determines it needs during layout, based on its calculations of child element sizes.</returns>
        protected override Size MeasureOverride(Size availableSize)
        {
            availableSize = base.MeasureOverride(availableSize);
            this.outputImage.Measure(availableSize);
            if (this.prevSize != availableSize || this.prevOffsetX != this.masterField.OffsetX || this.prevOffsetY != this.masterField.OffsetY || this.prevScaleX != this.masterField.ScaleX || this.prevScaleY != this.masterField.ScaleY)
            {
                this.prevSize = availableSize;
                this.prevOffsetX = this.masterField.OffsetX;
                this.prevOffsetY = this.masterField.OffsetY;
                this.prevScaleX = this.masterField.ScaleX;
                this.prevScaleY = this.masterField.ScaleY;
                this.CancelAll();
                if (this.imageSize.get_Width() > 0.0 && this.imageSize.get_Height() > 0.0)
                {
                    Point point = new Point(base.LeftFromX(this.imageCartesianRect.XMin), base.TopFromY(this.imageCartesianRect.YMax));
                    Point point2 = new Point(base.LeftFromX(this.imageCartesianRect.XMax), base.TopFromY(this.imageCartesianRect.YMin));
                    Canvas.SetLeft(this.outputImage, point.get_X());
                    Canvas.SetTop(this.outputImage, point.get_Y());
                    UIElement arg_1BA_0 = this.outputImage;
                    ScaleTransform scaleTransform = new ScaleTransform();
                    scaleTransform.set_ScaleX((point2.get_X() - point.get_X()) / this.imageSize.get_Width());
                    scaleTransform.set_ScaleY((point2.get_Y() - point.get_Y()) / this.imageSize.get_Height());
                    arg_1BA_0.set_RenderTransform(scaleTransform);
                }
                this.QueueRenderTask();
            }
            return availableSize;
        }

        private void EnqueueTask(long id)
        {
            if (this.runningTasks.get_Count() >= this.maxTasks)
            {
                this.tasks.Enqueue(id);
                return;
            }
            Size screenSize = new Size(Math.Abs(base.LeftFromX(base.ActualPlotRect.XMax) - base.LeftFromX(base.ActualPlotRect.XMin)), Math.Abs(base.TopFromY(base.ActualPlotRect.YMax) - base.TopFromY(base.ActualPlotRect.YMin)));
            RenderTaskState renderTaskState = new RenderTaskState(base.ActualPlotRect, screenSize);
            renderTaskState.Id = id;
            renderTaskState.Bounds = this.ComputeBounds();
            this.runningTasks.Add(renderTaskState);
            if (!DesignerProperties.get_IsInDesignTool())
            {
                ThreadPool.QueueUserWorkItem(delegate(object s)
                {
                    RenderResult renderResult = this.RenderFrame((RenderTaskState)s);
                    base.get_Dispatcher().BeginInvoke(new BackgroundBitmapRenderer.RenderFunc(this.OnTaskCompleted), new object[]
                    {
                        renderResult,
                        s
                    });
                }, renderTaskState);
                return;
            }
            RenderResult r = this.RenderFrame(renderTaskState);
            this.OnTaskCompleted(r, renderTaskState);
        }

        /// <summary>
        /// Renders frame and returns it as a render result.
        /// </summary>
        /// <param name="state">Render task state for rendering frame.</param>
        /// <returns>Render result of rendered frame.</returns>
        protected virtual RenderResult RenderFrame(RenderTaskState state)
        {
            return null;
        }

        /// <summary>Creates new render task and puts it to queue.</summary>
        /// <returns>Async operation ID.</returns>
        protected long QueueRenderTask()
        {
            long num;
            this.nextID = (num = this.nextID) + 1L;
            long num2 = num;
            this.EnqueueTask(num2);
            return num2;
        }

        private void OnTaskCompleted(RenderResult r, RenderTaskState state)
        {
            if (r != null && !state.IsCanceled)
            {
                WriteableBitmap writeableBitmap = new WriteableBitmap((int)r.Output.get_Width(), (int)r.Output.get_Height());
                Array.Copy(r.Image, writeableBitmap.get_Pixels(), writeableBitmap.get_PixelHeight() * writeableBitmap.get_PixelWidth());
                writeableBitmap.Invalidate();
                this.outputImage.set_Source(writeableBitmap);
                Canvas.SetLeft(this.outputImage, r.Output.get_Left());
                Canvas.SetTop(this.outputImage, r.Output.get_Top());
                this.imageCartesianRect = r.Visible;
                this.imageSize = new Size(r.Output.get_Width(), r.Output.get_Height());
                this.outputImage.set_RenderTransform(null);
            }
            this.RaiseTaskCompletion(state.Id);
            this.runningTasks.Remove(state);
            while (this.tasks.get_Count() > 1)
            {
                long id = this.tasks.Dequeue();
                this.RaiseTaskCompletion(id);
            }
            if (this.tasks.get_Count() > 0 && this.runningTasks.get_Count() < this.maxTasks)
            {
                this.EnqueueTask(this.tasks.Dequeue());
            }
            base.InvalidateMeasure();
        }

        /// <summary>
        /// Cancel all tasks, which are in quere.
        /// </summary>
        public void CancelAll()
        {
            using (List<RenderTaskState>.Enumerator enumerator = this.runningTasks.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    RenderTaskState current = enumerator.get_Current();
                    current.Stop();
                }
            }
        }

        /// <summary>
        /// Raises RenderCompletion event when task with the specified id is finished
        /// </summary>
        /// <param name="id">ID of finished task</param>
        protected void RaiseTaskCompletion(long id)
        {
            this.renderCompletion.OnNext(new RenderCompletion
            {
                TaskId = id
            });
        }
    }
}

while (this.tasks.get_Count() > 1)
{
    long id = this.tasks.Dequeue();
    this.RaiseTaskCompletion(id);
}
if (this.tasks.get_Count() > 0 && this.runningTasks.get_Count() < this.maxTasks)
{
    this.EnqueueTask(this.tasks.Dequeue());
}

this.maxTasks = Math.Max(1, Environment.get_ProcessorCount() - 1);

public long Plot(double[,] data, double[] x, double[] y, double missingValue)
{
    HeatmapGraph.VerifyDimensions(data, x, y);
    lock (this.locker)
    {
        this.xArr = x;
        this.yArr = y;
        this.data = data;
        this.missingValue = missingValue;
        this.dataVersion += 1L;
    }
    this.InvalidateBounds();
    return base.QueueRenderTask();
}

private void PlotData()
{
    // HeatmapGraph objects prepare images to be drawn in a background thread. 
    // The Plot method cancels current incomplete images before starting a new one. 
    // This increases responsiveness of the UI but may result in loss of certain 
    // or even all of the frames.
    // The following code shows how to wait until a certain data is actually drawn.
    
    long id = heatmap.Plot(f, x, y); // receive a unique operation identifier
    heatmap.RenderCompletion // an observable of completed and cancelled operations
        .Where(rc => rc.TaskId == id) // filter out an operation with the known id
        .Subscribe(dummy => { renderComplete.Set(); }); // signal when the id is observed
}

<!-- Copyright © 2010-2011 Microsoft Corporation, All Rights Reserved.
 -->
<UserControl x:Class="DynamicHeatmapSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400"
    xmlns:d3="clr-namespace:Microsoft.Research.DynamicDataDisplay;assembly=DynamicDataDisplay.Silverlight">

    <Grid x:Name="LayoutRoot" Background="White">
        <d3:Chart>
            <d3:Chart.Title>
                <TextBlock FontSize="14" Margin="0,5,0,5">Background computations sample</TextBlock>
            </d3:Chart.Title>
            <d3:HeatmapGraph x:Name="heatmap" Palette="Yellow,Blue,Orange"/>
        </d3:Chart>
    </Grid>

</UserControl>

// Copyright © 2010-2011 Microsoft Corporation, All Rights Reserved.

using System;
using System.Reactive.Linq;
using System.Threading;
using System.Windows.Controls;

namespace DynamicHeatmapSample
{
    public partial class MainPage : UserControl
    {
        private volatile bool isUnloaded = false;
        private AutoResetEvent renderComplete = new AutoResetEvent(false);
        private Thread thread;
        private double phase = 0;

        const int N = 1000;
        const int M = 500;

        double[] x = new double[N + 1];
        double[] y = new double[M + 1];
        double[,] f = new double[N, M];

        public MainPage()
        {
            InitializeComponent();

            // Start computation thread when Page appears on the screen
            Loaded += (s, e) =>
            {
                thread = new Thread(ModelRun);
                isUnloaded = false;
                thread.Start();
            };

            // Stop computation thread when Page is removed from the screen
            Unloaded += (s, e) =>
            {
                isUnloaded = true;
                renderComplete.Set();
                thread.Join();
            };
        }

        private void ModelRun()
        {
            // Coordinate grid is constant
            for (int i = 0; i <= N; i++)
                x[i] = -Math.PI + 2 * i * Math.PI / N;

            for (int j = 0; j <= M; j++)
                y[j] = -Math.PI / 2 + j * Math.PI / M;

            while (!isUnloaded) // Run until page is on the screen
            {
                // Data array is updated
                for (int i = 0; i < N; i++)
                    for (int j = 0; j < M; j++)
                        f[i, j] = Math.Sqrt(x[i] * x[i] + y[j] * y[j]) * Math.Abs(Math.Cos(x[i] * x[i] + y[j] * y[j] + phase));
                phase += 0.1;

                // Uncomment next line to simulate delay in computations
                // Thread.Sleep(1000);

                // Plot the computed array.
                // The Plot method must be called from the UI dispatcher thread. 
                // Unlike Tutoral3 sample here we wait for each frame to be rendered.
                if (!isUnloaded)
                {
                    renderComplete.Reset();
                    Dispatcher.BeginInvoke(PlotData);
                    renderComplete.WaitOne();
                }
            }
        }

        private void PlotData()
        {
            // HeatmapGraph objects prepare images to be drawn in a background thread. 
            // The Plot method cancels current incomplete images before starting a new one. 
            // This increases responsiveness of the UI but may result in loss of certain 
            // or even all of the frames.
            // The following code shows how to wait until a certain data is actually drawn.
            
            long id = heatmap.Plot(f, x, y); // receive a unique operation identifier
            heatmap.RenderCompletion // an observable of completed and cancelled operations
                .Where(rc => rc.TaskId == id) // filter out an operation with the known id
                .Subscribe(dummy => { renderComplete.Set(); }); // signal when the id is observed
        }
    }    
}

<!-- Copyright © 2010-2011 Microsoft Corporation, All Rights Reserved.
 -->
<UserControl x:Class="Tutorial3.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:d3="clr-namespace:Microsoft.Research.DynamicDataDisplay;assembly=DynamicDataDisplay.Silverlight"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White">
        <d3:Chart>
            <d3:Chart.Title>
                <TextBlock HorizontalAlignment="Center" FontSize="14" Margin="0,5,0,5">Tutorial 3: Dynamic heatmap</TextBlock>
            </d3:Chart.Title>
            <d3:HeatmapGraph Name="heatmap" Palette="Blue,#00FF00,Red"/>
        </d3:Chart>
    </Grid>
</UserControl>

// Copyright © 2010-2011 Microsoft Corporation, All Rights Reserved.

using System;
using System.Threading;
using System.Windows.Controls;

namespace Tutorial3
{
    public partial class MainPage : UserControl
    {
        private volatile bool isUnloaded = false;
        private Thread thread;
        private double phase = 0;

        public MainPage()
        {
            InitializeComponent();

            // Start computation thread when page appears on the screen
            Loaded += (s, e) =>
            {
                thread = new Thread(ModelRun);
                isUnloaded = false;
                thread.Start();
            };

            // Stop computation thread when page is removed from the screen
            Unloaded += (s, e) =>
            {
                isUnloaded = true;
                thread.Join();
            };
        }

        /// <summary>Performs computations. Runs until isUnloaded became true.</summary>
        private void ModelRun()
        {
            const int N = 1000;
            const int M = 500;

            // 1D arrays for grid 
            double[] x = new double[N + 1];
            double[] y = new double[M + 1];

            // Size of data array here is one less than size of the grid.
            // HeatmapGraph will render in bitmap mode, when grid of size (N+1) x (M+1) 
            // defines N x M rectangular cells filled with solid color according to 
            // corresponding element of data array.
            double[,] f = new double[N, M]; 

            // Coordinate grid is constant and it is initialized once
            for (int i = 0; i <= N; i++)
                x[i] = -Math.PI + 2 * i * Math.PI / N;

            for (int j = 0; j <= M; j++)
                y[j] = -Math.PI / 2 + j * Math.PI / M;

            while (!isUnloaded) // Run until page is on the screen
            {
                // Compute next iteration and store it in data array
                for (int i = 0; i < N; i++)
                    for (int j = 0; j < M; j++)
                        f[i, j] = Math.Sqrt(x[i] * x[i] + y[j] * y[j])
                                  * Math.Abs(Math.Cos(x[i] * x[i] + y[j] * y[j] + phase));
                phase += 0.1;

                // Uncomment next line to simulate delay in computations
                // Thread.Sleep(1000);

                // Plot the computed array. 
                //
                // The Plot method must be called from the UI dispatcher thread. 
                // We pass a clone of the data array to the Plot method to prevent 
                // concurrent modification of the plotted data. 
                Dispatcher.BeginInvoke(
                    new Action<object>(data => heatmap.Plot((double[,])data, x, y)), f.Clone());
             }
        }
    }
}

public long Plot(double[,] data, double[] x, double[] y, double missingValue)
{
    HeatmapGraph.VerifyDimensions(data, x, y);
    lock (this.locker)
    {
        this.xArr = x;
        this.yArr = y;
        this.data = data;
        this.missingValue = missingValue;
        this.dataVersion += 1L;
    }
    this.InvalidateBounds();
    return base.QueueRenderTask();
}

/// <summary>
/// Base class for renderers, which can prepare its render results in a separate thread.
/// </summary>
public abstract class BackgroundBitmapRenderer : Plot
{
    // Microsoft.Research.DynamicDataDisplay.BackgroundBitmapRenderer
    /// <summary>Creates new render task and puts it to queue.</summary>
    /// <returns>Async operation ID.</returns>
    protected long QueueRenderTask()
    {
        long num;
        this.nextID = (num = this.nextID) + 1L;
        long num2 = num;
        this.EnqueueTask(num2);
        return num2;
    }
}

<!-- Copyright © 2010-2011 Microsoft Corporation, All Rights Reserved.
 -->
<UserControl x:Class="Tutorial1.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:d3="clr-namespace:Microsoft.Research.DynamicDataDisplay;assembly=DynamicDataDisplay.Silverlight"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White">        
        <!-- D3 markup starts here-->
        <d3:Chart BottomTitle="Sinc argument" LeftTitle="Sinc value">
            <d3:Chart.Title>
                <TextBlock HorizontalAlignment="Center" FontSize="14" Margin="0,5,0,5">Tutorial 1: Line graph</TextBlock>
            </d3:Chart.Title>
            <d3:LineGraph x:Name="linegraph" Description="Sinc graph" Stroke="Blue" StrokeThickness="3"/>
        </d3:Chart>        
    </Grid>
</UserControl>

// Copyright © 2010-2011 Microsoft Corporation, All Rights Reserved.

using System;
using System.Linq;
using System.Windows.Controls;

namespace Tutorial1
{
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();

            // Compute x array of 1001 points from 0 to 100 with 0.1 step
            var x = Enumerable.Range(0, 1001).Select(i => i / 10.0).ToArray();

            // Compute y array as sin(x)/x function defined on x grid
            var y = x.Select(v => Math.Abs(v) < 1e-10 ? 1 : Math.Sin(v) / v).ToArray();

            // Plot data 
            linegraph.Plot(x, y);
        }
    }
}

public class LineGraph : Plot 
{
    ...
    private Polyline polyline;

    /// <summary>
    /// Identifies <see cref="P:Microsoft.Research.DynamicDataDisplay.LineGraph.Points" /> dependecy property
    /// </summary>
    public new static readonly DependencyProperty PointsProperty = DependencyProperty.Register("Points", typeof(PointCollection), typeof(LineGraph), new PropertyMetadata(new PointCollection(), delegate(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        LineGraph lineGraph = (LineGraph)o;
        if (lineGraph != null)
        {
            Microsoft.Research.DynamicDataDisplay.Plot.SetPoints(lineGraph.polyline, (PointCollection)e.get_NewValue());
        }
    }));

    public void Plot(IEnumerable x, IEnumerable y)
    {
        ...
        PointCollection pointCollection = new PointCollection();
        IEnumerator enumerator = x.GetEnumerator();
        IEnumerator enumerator2 = y.GetEnumerator();
        ...
        this.Points = pointCollection;
    }

    /// <summary>
    /// Gets or sets line graph points.
    /// </summary>
    public PointCollection Points
    {
        get
        {
            return (PointCollection)base.GetValue(LineGraph.PointsProperty);
        }
        set
        {
            base.SetValue(LineGraph.PointsProperty, value);
        }
    }


}

namespace Simplest
{
	/// <summary>Interaction logic for simplest plot application</summary>
	public partial class MainWindow : Window
	{
		public MainWindow()
		{
			InitializeComponent();

			Loaded += new RoutedEventHandler(MainWindow_Loaded);
		}

		void MainWindow_Loaded(object sender, RoutedEventArgs e)
		{
			// Prepare data in arrays
			const int N = 1000;
			double[] x = new double[N];
			double[] y = new double[N];

			for (int i = 0; i < N; i++)
			{
				x[i] = i * 0.1;
				y[i] = Math.Sin(x[i]);
			}

			// Create data sources:
			var xDataSource = x.AsXDataSource();
			var yDataSource = y.AsYDataSource();

			CompositeDataSource compositeDataSource = xDataSource.Join(yDataSource);
			// adding graph to plotter
			plotter.AddLineGraph(compositeDataSource,
				Colors.Goldenrod,
				3,
				"zmapleaf");

			// Force evertyhing plotted to be visible
			plotter.FitToView();
		}
	}
}

public static LineGraph AddLineGraph(this Plotter2D plotter, IPointDataSource pointSource, Pen linePen, Description description)
{
	LineGraph graph = new LineGraph
	{
		DataSource = pointSource,
		LinePen = linePen
	};
	graph.Filters.Add(new InclinationFilter());
	graph.Filters.Add(new FrequencyFilter());
	//graph.Filters.Add(new CountFilter());
	plotter.Children.Add(graph);
	return graph;
}

System.Object
  System.Windows.Threading.DispatcherObject
    System.Windows.DependencyObject
      System.Windows.Media.Visual
        System.Windows.UIElement
          System.Windows.FrameworkElement
            Microsoft.Research.DynamicDataDisplay.PlotterElement
              Microsoft.Research.DynamicDataDisplay.ViewportElement2D
                Microsoft.Research.DynamicDataDisplay.PointsGraphBase
                  Microsoft.Research.DynamicDataDisplay.LineGraph

System.Object
  System.Windows.Threading.DispatcherObject
    System.Windows.DependencyObject
      System.Windows.Media.Visual
        System.Windows.UIElement
          System.Windows.FrameworkElement
            System.Windows.Controls.Control
              System.Windows.Controls.ContentControl
                Microsoft.Research.DynamicDataDisplay.Plotter
                  Microsoft.Research.DynamicDataDisplay.Plotter2D
                    Microsoft.Research.DynamicDataDisplay.ChartPlotter

filters.CollectionChanged += filters_CollectionChanged;

void filters_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
	filteredPoints = null;
	Update();
}

protected void Update()
{
	if (Viewport == null) return;

	UpdateCore();

	if (!beforeFirstUpdate)
	{
		updateCalled = true;
		InvalidateVisual();
	}
	beforeFirstUpdate = false;
}
protected virtual void UpdateCore() { }

private FakePointList filteredPoints;
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
	{...
	}
}

private bool shouldReRender = true;
private DrawingGroup graphContents;
protected sealed override void OnRender(DrawingContext drawingContext)
{
	if (Viewport == null) return;

	Rect output = Viewport.Output;
	if (output.Width == 0 || output.Height == 0) return;
	if (output.IsEmpty) return;
	if (Visibility != Visibility.Visible) return;

	if (shouldReRender || manualTranslate || renderTarget == RenderTo.Image || beforeFirstUpdate || updateCalled)
	{
		if (graphContents == null)
		{
			graphContents = new DrawingGroup();
		}
		if (beforeFirstUpdate)
		{
			Update();
		}

		using (DrawingContext context = graphContents.Open())
		{
			if (renderTarget == RenderTo.Screen)
			{
				RenderState state = CreateRenderState(Viewport.Visible, RenderTo.Screen);
				OnRenderCore(context, state);
			}
			else
			{
				// for future use
			}
		}
		updateCalled = false;
	}

	// thumbnail is not created, if
	// 1) CreateThumbnail is false
	// 2) this graph has IsLayer property, set to false
	if (ShouldCreateThumbnail)
	{
		RenderThumbnail();
	}

	if (!manualClip)
	{
		drawingContext.PushClip(new RectangleGeometry(output));
	}
	bool translate = !manualTranslate && IsTranslated;
	if (translate)
	{
		drawingContext.PushTransform(new TranslateTransform(offset.X, offset.Y));
	}

	drawingContext.DrawDrawing(graphContents);

	if (translate)
	{
		drawingContext.Pop();
	}
	if (!manualClip)
	{
		drawingContext.Pop();
	}
	shouldReRender = true;
}


protected abstract void OnRenderCore(DrawingContext dc, RenderState state);

protected override void OnRenderCore(DrawingContext dc, RenderState state)
{
	if (DataSource == null) return;

	if (filteredPoints.HasPoints)
	{
		StreamGeometry geometry = new StreamGeometry();
		using (StreamGeometryContext context = geometry.Open())
		{
			context.BeginFigure(filteredPoints.StartPoint, false, false);
			context.PolyLineTo(filteredPoints, true, true);
		}
		geometry.Freeze();

		const Brush brush = null;
		Pen pen = LinePen;

		bool isTranslated = IsTranslated;
		if (isTranslated)
		{
			dc.PushTransform(new TranslateTransform(Offset.X, Offset.Y));
		}
		dc.DrawGeometry(brush, pen, geometry);
		if (isTranslated)
		{
			dc.Pop();
		}
	}
}

private DataTransform dataTransform = null;
public DataTransform DataTransform
{
	get { return dataTransform; }
	set
	{
		if (dataTransform != value)
		{
			dataTransform = value;
			Update();
		}
	}
}

protected CoordinateTransform GetTransform()
{
	if (Plotter == null)
		return null;

	var transform = Plotter2D.Viewport.Transform;
	if (dataTransform != null)
		transform = transform.WithDataTransform(dataTransform);

	return transform;
}

	/// <summary>
	/// Base class for all data transforms.
	/// Defines methods to transform point from data coordinate system to viewport coordinates and vice versa.
	/// </summary>
	public abstract class DataTransform
	{
		/// <summary>
		/// Transforms the point in data coordinates to viewport coordinates.
		/// </summary>
		/// <param name="pt">The point in data coordinates.</param>
		/// <returns></returns>
		public abstract Point DataToViewport(Point pt);
		/// <summary>
		/// Transforms the point in viewport coordinates to data coordinates.
		/// </summary>
		/// <param name="pt">The point in viewport coordinates.</param>
		/// <returns></returns>
		public abstract Point ViewportToData(Point pt);

		private static readonly DataRect defaultDomain = DataRect.Empty;
		/// <summary>
		/// Gets the data domain.
		/// </summary>
		/// <value>The data domain.</value>
		public virtual DataRect DataDomain { get { return defaultDomain; } }
	}


namespace Microsoft.Research.DynamicDataDisplay
{
	/// <summary>
	/// A central class in 2d coordinate transformation in DynamicDataDisplay.
	/// Provides methods to transform point from one coordinate system to another.
	/// </summary>
	public sealed class CoordinateTransform
	{
		private CoordinateTransform(Rect visibleRect, Rect screenRect)
		{
			this.visibleRect = visibleRect;
			this.screenRect = screenRect;

			rxToScreen = screenRect.Width / visibleRect.Width;
			ryToScreen = screenRect.Height / visibleRect.Height;
			cxToScreen = visibleRect.Left * rxToScreen - screenRect.Left;
			cyToScreen = screenRect.Height + screenRect.Top + visibleRect.Top * ryToScreen;

			rxToData = visibleRect.Width / screenRect.Width;
			ryToData = visibleRect.Height / screenRect.Height;
			cxToData = screenRect.Left * rxToData - visibleRect.Left;
			cyToData = visibleRect.Height + visibleRect.Top + screenRect.Top * ryToData;
		}

		#region Coeffs
		double rxToScreen;
		double ryToScreen;
		double cxToScreen;
		double cyToScreen;

		double rxToData;
		double ryToData;
		double cxToData;
		double cyToData;
		#endregion

		#region Creation methods

		internal CoordinateTransform WithRects(Rect visibleRect, Rect screenRect)
		{
			CoordinateTransform copy = new CoordinateTransform(visibleRect, screenRect);
			copy.dataTransform = dataTransform;
			return copy;
		}

		/// <summary>
		/// Creates a new instance of CoordinateTransform with the given data transform.
		/// </summary>
		/// <param name="dataTransform">The data transform.</param>
		/// <returns></returns>
		public CoordinateTransform WithDataTransform(DataTransform dataTransform)
		{
			if (dataTransform == null)
				throw new ArgumentNullException("dataTransform");

			CoordinateTransform copy = new CoordinateTransform(visibleRect, screenRect);
			copy.dataTransform = dataTransform;
			return copy;
		}

		internal static CoordinateTransform CreateDefault()
		{
			CoordinateTransform transform = new CoordinateTransform(new Rect(0, 0, 1, 1), new Rect(0, 0, 1, 1));

			return transform;
		}

		#endregion

		#region Transform methods

		/// <summary>
		/// Transforms point from data coordinates to screen.
		/// </summary>
		/// <param name="dataPoint">The point in data coordinates.</param>
		/// <returns></returns>
		public Point DataToScreen(Point dataPoint)
		{
			Point viewportPoint = dataTransform.DataToViewport(dataPoint);

			Point screenPoint = new Point(viewportPoint.X * rxToScreen - cxToScreen,
				cyToScreen - viewportPoint.Y * ryToScreen);

			return screenPoint;
		}

		/// <summary>
		/// Transforms point from screen coordinates to data coordinates.
		/// </summary>
		/// <param name="screenPoint">The point in screen coordinates.</param>
		/// <returns></returns>
		public Point ScreenToData(Point screenPoint)
		{
			Point viewportPoint = new Point(screenPoint.X * rxToData - cxToData,
				cyToData - screenPoint.Y * ryToData);

			Point dataPoint = dataTransform.ViewportToData(viewportPoint);

			return dataPoint;
		}

		/// <summary>
		/// Transforms point from viewport coordinates to screen coordinates.
		/// </summary>
		/// <param name="viewportPoint">The point in viewport coordinates.</param>
		/// <returns></returns>
		public Point ViewportToScreen(Point viewportPoint)
		{
			Point screenPoint = new Point(viewportPoint.X * rxToScreen - cxToScreen,
				cyToScreen - viewportPoint.Y * ryToScreen);

			return screenPoint;
		}

		/// <summary>
		/// Transforms point from screen coordinates to viewport coordinates.
		/// </summary>
		/// <param name="screenPoint">The point in screen coordinates.</param>
		/// <returns></returns>
		public Point ScreenToViewport(Point screenPoint)
		{
			Point viewportPoint = new Point(screenPoint.X * rxToData - cxToData,
				cyToData - screenPoint.Y * ryToData);

			return viewportPoint;
		}

		#endregion

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Rect visibleRect;
		/// <summary>
		/// Gets the viewport rectangle.
		/// </summary>
		/// <value>The viewport rect.</value>
		public Rect ViewportRect
		{
			get { return visibleRect; }
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Rect screenRect;
		/// <summary>
		/// Gets the screen rectangle.
		/// </summary>
		/// <value>The screen rect.</value>
		public Rect ScreenRect
		{
			get { return screenRect; }
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private DataTransform dataTransform = DataTransforms.Identity;
		/// <summary>
		/// Gets the data transform.
		/// </summary>
		/// <value>The data transform.</value>
		public DataTransform DataTransform
		{
			get { return dataTransform; }
		}
	}
}

internal static CoordinateTransform CreateDefault()
{
	CoordinateTransform transform = new CoordinateTransform(new Rect(0, 0, 1, 1), new Rect(0, 0, 1, 1));

	return transform;
}