2d visualization笔记(x3) dynamicdatadisplay(sl)(三)

<!-- 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>

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

namespace 
{
    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
        }
    }    
}