Сохранение рисунка в WinRT

using System.Collections.Generic;

namespace WinRTTestApp
{
    public interface IGeometrySegment
    {
        void GetAllX(double y, IList<double> xCollection);
    }
}

using Windows.Foundation;
using System.Collections.Generic;

namespace WinRTTestApp
{
    public struct LineSegment : IGeometrySegment
    {
        readonly double a, b;         // as in x = ay + b
        readonly Point point1, point2;

        public LineSegment(Point point1, Point point2) : this()
        {
            this.point1 = point1;
            this.point2 = point2;

            b = point1.X - a * point1.Y;
            a = (point2.X - point1.X) / (point2.Y - point1.Y);
        }

        public void GetAllX(double y, IList<double> xCollection)
        {
            if ((point2.Y > point1.Y && y >= point1.Y && y < point2.Y) ||
                (point2.Y < point1.Y && y <= point1.Y && y > point2.Y))
            {
                xCollection.Add(a * y + b);
            }
        }
    }
}

using System;
using Windows.Foundation;
using System.Collections.Generic;

namespace WinRTTestApp
{
    public struct ArcSegment : IGeometrySegment
    {
        readonly double radius;
        readonly Point center, point1, point2;
        readonly double angle1, angle2;

        public ArcSegment(Point center, double radius,
                          Point point1, Point point2) : this()
        {
            this.point1 = point1;
            this.point2 = point2;
            this.center = center;
            this.radius = radius;
            this.angle1 = Math.Atan2(point1.Y - center.Y, point1.X - center.X);
            this.angle2 = Math.Atan2(point2.Y - center.Y, point2.X - center.X);
        }

        public void GetAllX(double y, IList<double> xCollection)
        {
            double sqrtArg = radius * radius - Math.Pow(y - center.Y, 2);

            if (sqrtArg >= 0)
            {
                double sqrt = Math.Sqrt(sqrtArg);
                TryY(y, center.X + sqrt, xCollection);
                TryY(y, center.X - sqrt, xCollection);
            }
        }

        private void TryY(double y, double x, IList<double> xCollection)
        {
            double angle = Math.Atan2(y - center.Y, x - center.X);

            if ((angle1 < angle2 && (angle1 <= angle && angle < angle2)) ||
                (angle1 > angle2 && (angle1 <= angle || angle < angle2)))
            {
                xCollection.Add((float)x);
            }
        }
    }
}

using System;
using Windows.Foundation;
using System.Collections.Generic;

namespace WinRTTestApp
{
    public struct RoundCappedLine : IGeometrySegment
    {
        LineSegment lineSegment2;
        ArcSegment arcSegment2;
        LineSegment lineSegment1;
        ArcSegment arcSegment1;

        public RoundCappedLine(Point point1, Point point2, double radius) : this()
        {
            Vector2 vector = new Vector2(point2 - new Vector2(point1));
            Vector2 normVect = vector;
            normVect = normVect.Normalized;

            Point pt1a = point1 + radius * new Vector2(normVect.Y, -normVect.X);
            Point pt2a = pt1a + vector;
            Point pt1b = point1 + radius * new Vector2(-normVect.Y, normVect.X);
            Point pt2b = pt1b + vector;

            lineSegment1 = new LineSegment(pt1a, pt2a);
            arcSegment1 = new ArcSegment(point2, radius, pt2a, pt2b);
            lineSegment2 = new LineSegment(pt2b, pt1b);
            arcSegment2 = new ArcSegment(point1, radius, pt1b, pt1a);
        }

        public void GetAllX(double y, IList<double> xCollection)
        {
            arcSegment1.GetAllX(y, xCollection);
            lineSegment1.GetAllX(y, xCollection);
            arcSegment2.GetAllX(y, xCollection);
            lineSegment2.GetAllX(y, xCollection);
        }
    }
}

using System;
using Windows.Foundation;
using System.Collections.Generic;

namespace WinRTTestApp
{
    public struct RoundCappedPath : IGeometrySegment
    {
        LineSegment lineSegment2;
        ArcSegment arcSegment2;
        LineSegment lineSegment1;
        ArcSegment arcSegment1;

        public RoundCappedPath(Point point1, Point point2, double radius1, double radius2) : this()
        {
            Point c0 = point1;
            Point c1 = point2;
            double r0 = radius1;
            double r1 = radius2;

            // Получение вектора из c1 в c0
            Vector2 vCenters = new Vector2(c0) - new Vector2(c1);

            // Получение длины и нормализованной версии
            double d = vCenters.Length;
            vCenters = vCenters.Normalized;

            // Создание точки фокуса F относительно c0
            double e = d * r0 / (r1 - r0);
            Point F = c0 + e * vCenters;

            // Определение угла и длины катетов
            double alpha = 180 * Math.Asin(r0 / e) / Math.PI;
            double leg0 = Math.Sqrt(e * e - r0 * r0);
            double leg1 = Math.Sqrt((e + d) * (e + d) - r1 * r1);

            // Векторы касательных
            Vector2 vRight = -vCenters.Rotate(alpha);
            Vector2 vLeft = -vCenters.Rotate(-alpha);

            // Определение точек касания
            Point t0R = F + leg0 * vRight;
            Point t0L = F + leg0 * vLeft;
            Point t1R = F + leg1 * vRight;
            Point t1L = F + leg1 * vLeft;

            lineSegment1 = new LineSegment(t1R, t0R);
            arcSegment1 = new ArcSegment(c0, r0, t0R, t0L);
            lineSegment2 = new LineSegment(t0L, t1L);
            arcSegment2 = new ArcSegment(c1, r1, t1L, t1R);
        }

        public void GetAllX(double y, IList<double> xCollection)
        {
            arcSegment1.GetAllX(y, xCollection);
            lineSegment1.GetAllX(y, xCollection);
            arcSegment2.GetAllX(y, xCollection);
            lineSegment2.GetAllX(y, xCollection);
        }
    }
}

using System;
using System.Linq;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Windows.Foundation;
using Windows.Graphics.Imaging;
using Windows.Storage;
using Windows.Storage.Pickers;
using Windows.Storage.Streams;
using Windows.UI;
using Windows.UI.Input;
using Windows.UI.Popups;
using Windows.UI.ViewManagement;
using Windows.UI.WebUI;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Media.Imaging;
using System.Runtime.InteropServices.WindowsRuntime;

namespace WinRTTestApp
{
    public sealed partial class MainPage : Page
    {
        // ...

        private bool RenderOnBitmap(Point point1, double radius1, Point point2, double radius2, Color color)
        {
            bool bitmapNeedsUpdate = false;

            // Определение линии между двумя точками
            IGeometrySegment geoseg = null;

            // Поправка на масштабирование изображения
            Point center1 = ScaleToBitmap(point1);
            Point center2 = ScaleToBitmap(point2);

            // Вычисление расстояния между точками
            double distance = Math.Sqrt(Math.Pow(center2.X - center1.X, 2) +
                                        Math.Pow(center2.Y - center1.Y, 2));

            // Определение правильного способа представления сегмента
            if (radius1 == radius2)
                geoseg = new RoundCappedLine(center1, center2, radius1);

            else if (radius1 < radius2 && radius1 + distance < radius2)
                geoseg = new RoundCappedLine(center1, center2, radius2);

            else if (radius2 < radius1 && radius2 + distance < radius1)
                geoseg = new RoundCappedLine(center1, center2, radius1);

            else if (radius1 < radius2)
                geoseg = new RoundCappedPath(center1, center2, radius1, radius2);

            else
                geoseg = new RoundCappedPath(center2, center1, radius2, radius1);

            // Определение минимальной и максимальной вертикальных координат
            int yMin = (int)Math.Min(center1.Y - radius1, center2.Y - radius2);
            int yMax = (int)Math.Max(center1.Y + radius1, center2.Y + radius2);

            yMin = Math.Max(0, Math.Min(bitmap.PixelHeight, yMin));
            yMax = Math.Max(0, Math.Min(bitmap.PixelHeight, yMax));

            // Перебор всех координат y, содержащих часть сегмента
            for (int y = yMin; y < yMax; y++)
            {
                // Получение диапазона координат в сегменте
                xCollection.Clear();
                geoseg.GetAllX(y, xCollection);

                if (xCollection.Count == 2)
                {
                    // Определение минимальной и максимальной горизонтальных координат
                    int xMin = (int)(Math.Min(xCollection[0], xCollection[1]) + 0.5f);
                    int xMax = (int)(Math.Max(xCollection[0], xCollection[1]) + 0.5f);

                    xMin = Math.Max(0, Math.Min(bitmap.PixelWidth, xMin));
                    xMax = Math.Max(0, Math.Min(bitmap.PixelWidth, xMax));

                    // Перебор значений X
                    for (int x = xMin; x < xMax; x++)
                    {
                        {
                            // Задание пиксела
                            int index = 4 * (y * bitmap.PixelWidth + x);
                            pixels[index + 0] = color.B;
                            pixels[index + 1] = color.G;
                            pixels[index + 2] = color.R;
                            pixels[index + 3] = 255;

                            bitmapNeedsUpdate = true;
                        }
                    }
                }
            }
            // Обновление растрового изображения
            if (bitmapNeedsUpdate)
            {
                // Определение начального индекса и количества пикселов
                int start = 4 * yMin * bitmap.PixelWidth;
                int count = 4 * (yMax - yMin) * bitmap.PixelWidth;

                pixelStream.Seek(start, SeekOrigin.Begin);
                pixelStream.Write(pixels, start, count);
                bitmap.Invalidate();
            }

            return bitmapNeedsUpdate;
        }

        private Point ScaleToBitmap(Point pt)
        {
            return new Point((pt.X - imageOffset.X) / imageScale,
                             (pt.Y - imageOffset.Y) / imageScale);
        }
    }
}

// ...

namespace WinRTTestApp
{
    public sealed partial class MainPage : Page
    {
        struct PointerInfo
        {
            public Brush Brush;
            public Point PreviousPoint;
            public double PreviousRadius;
        }

        Dictionary<uint, PointerInfo> pointerDictionary = new Dictionary<uint, PointerInfo>();
        List<double> xCollection = new List<double>();

        protected override void OnPointerPressed(PointerRoutedEventArgs e)
        {
            // Получение информации об аргументах события
            uint id = e.Pointer.PointerId;
            PointerPoint pointerPoint = e.GetCurrentPoint(this);

            // Создать объект PointerInfo
            PointerInfo pointerInfo = new PointerInfo
            {
                PreviousPoint = pointerPoint.Position,
                PreviousRadius = appSettings.Thickness * pointerPoint.Properties.Pressure,
                Brush = new SolidColorBrush(appSettings.Color)
            };

            // Включить в словарь
            pointerDictionary.Add(id, pointerInfo);

            // Захват указателя
            CapturePointer(e.Pointer);

            base.OnPointerPressed(e);
        }

        protected override void OnPointerMoved(PointerRoutedEventArgs e)
        {
            // Получение идентификатора из аргументов события
            uint id = e.Pointer.PointerId;

            // Если идентификатор находится в словаре, начинается цикл
            if (pointerDictionary.ContainsKey(id))
            {
                PointerInfo pointerInfo = pointerDictionary[id];

                foreach (PointerPoint pointerPoint in e.GetIntermediatePoints(this).Reverse())
                {
                    // Для каждой точки определяется новая позиция и сила нажатия
                    Point point = pointerPoint.Position;
                    double radius = appSettings.Thickness * pointerPoint.Properties.Pressure;

                    // Вывод и установка флага модификации
                    appSettings.IsImageModified =
                        RenderOnBitmap(pointerInfo.PreviousPoint, pointerInfo.PreviousRadius,
                                       point, radius,
                                       appSettings.Color);

                    // Обновить объект PointerInfo
                    pointerInfo.PreviousPoint = point;
                    pointerInfo.PreviousRadius = radius;
                }

                // Сохранить PointerInfo в словаре
                pointerDictionary[id] = pointerInfo;
            }
            base.OnPointerMoved(e);
        }

        protected override void OnPointerReleased(PointerRoutedEventArgs e)
        {
            // Получение информации из аргументов события
            uint id = e.Pointer.PointerId;

            // Если идентификатор хранится в словаре, удалить его
            if (pointerDictionary.ContainsKey(id))
                pointerDictionary.Remove(id);

            base.OnPointerReleased(e);
        }

        protected override void OnPointerCaptureLost(PointerRoutedEventArgs e)
        {
            // Получение информации из аргументов события
            uint id = e.Pointer.PointerId;

            // Если идентификатор хранится в словаре, удалить его
            if (pointerDictionary.ContainsKey(id))
                pointerDictionary.Remove(id);

            base.OnPointerCaptureLost(e);
        }

        private bool RenderOnBitmap(Point point1, double radius1, Point point2, double radius2, Color color)
        {
            // ...
        }

        private Point ScaleToBitmap(Point pt)
        {
            // ...
        }
        
        // ...
    }
}

<Page ...>

    <Grid Background="#FF1D1D1D">
        <Image Name="image" />

        <!-- Блокировка кнопок файлового ввода/вывода в состоянии Snapped -->
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup x:Name="ApplicationViewStates">
                <VisualState x:Name="FullScreenLandscape" />
                <VisualState x:Name="Filled" />
                <VisualState x:Name="FullScreenPortrait" />

                <VisualState x:Name="Snapped">
                    <Storyboard>
                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="fileButtons"
                                                   Storyboard.TargetProperty="Visibility">
                            <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed" />
                        </ObjectAnimationUsingKeyFrames>
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
    </Grid>

    <Page.BottomAppBar>
        <AppBar>
            <Grid>
                <StackPanel Orientation="Horizontal" 
                            HorizontalAlignment="Left">

                    <AppBarButton Label="Цвет" Icon="FontColor"
                            Name="colorbtn"
                            Click="colorbtn_Click" />

                    <AppBarButton Label="Толщина" Icon="Edit" Name="thicknessbtn"
                            Click="thicknessbtn_Click" />
                </StackPanel>

                <StackPanel Name="fileButtons"
                            Orientation="Horizontal" 
                            HorizontalAlignment="Right">

                    <AppBarButton Label="Открыть файл" Icon="OpenFile" Name="openbtn"
                            Click="openbtn_Click" />

                    <AppBarButton Label="Сохранить как" Icon="SaveLocal" Name="saveasbtn"
                            Click="saveasbtn_Click" />

                    <AppBarButton Label="Сохранить" Icon="Save" Name="savebtn"
                            Click="savebtn_Click" />

                    <AppBarButton Label="Добавить" Icon="Add" Name="addbtn"
                            Click="addbtn_Click" />
                </StackPanel>
            </Grid>
        </AppBar>
    </Page.BottomAppBar>
</Page>

// ...

namespace WinRTTestApp
{
    public sealed partial class MainPage : Page
    {
        // ...

        AppSettings appSettings = new AppSettings();
        double imageScale = 1;
        Point imageOffset = new Point();

        public MainPage()
        {
            this.InitializeComponent();

            SizeChanged += page_SizeChanged;
            Loaded += page_Loaded;
            Application.Current.Suspending += app_Suspending;
        }

        private void page_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            VisualStateManager.GoToState(this, ApplicationView.Value.ToString(), true);

            if (bitmap != null)
            {
                CalculateImageScaleAndOffset();
            }
        }

        private void CalculateImageScaleAndOffset()
        {
            imageScale = Math.Min(this.ActualWidth / bitmap.PixelWidth,
                                  this.ActualHeight / bitmap.PixelHeight);
            imageOffset = new Point((this.ActualWidth - imageScale * bitmap.PixelWidth) / 2,
                                    (this.ActualHeight - imageScale * bitmap.PixelHeight) / 2);
        }

        private async void page_Loaded(object sender, RoutedEventArgs e)
        {
            try
            {
                /* StorageFolder localFolder = ApplicationData.Current.LocalFolder;
                StorageFile storageFile = await localFolder.GetFileAsync("FingerPaint.png");
                await LoadBitmapFromFile(storageFile); */
            }
            catch
            {
                // Ошибки игнорируются
            }

            if (bitmap == null)
                await CreateNewBitmapAndPixelArray();
        }

        private async void app_Suspending(object sender, Windows.ApplicationModel.SuspendingEventArgs e)
        {
            // Сохранение конфигурации приложения
            appSettings.Save();

            // Сохранение текущего изображения
            Windows.ApplicationModel.SuspendingDeferral deferral = 
                e.SuspendingOperation.GetDeferral();

            try
            {
                StorageFolder localFolder = ApplicationData.Current.LocalFolder;
                StorageFile storageFile = await localFolder.CreateFileAsync("FingerPaint.png",
                                                        CreationCollisionOption.ReplaceExisting);
                await SaveBitmapToFile(storageFile);
            }
            catch
            {
                // Игнорировать ошибки
            }

            deferral.Complete();
        }

        // ...
    }
}

// ...

namespace WinRTTestApp
{
    public sealed partial class MainPage : Page
    {
        // ...

        private void colorbtn_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
        {
            // Добавим реализацию в следующей статье
            // DisplayDialog(sender, new ColorSettingDialog());
        }

        private void thicknessbtn_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
        {
            DisplayDialog(sender, new ThicknessSettingDialog());
        }

        private void DisplayDialog(object sender, FrameworkElement dialog)
        {
            dialog.DataContext = appSettings;

            Popup popup = new Popup
            {
                Child = dialog,
                IsLightDismissEnabled = true
            };

            dialog.SizeChanged += (dialogSender, dialogArgs) =>
            {
                // Определение местонахождения Button относительно экрана
                Button btn = sender as Button;
                Point pt = btn.TransformToVisual(null).TransformPoint(
                                                            new Point(btn.ActualWidth / 2,
                                                                      btn.ActualHeight / 2));

                popup.HorizontalOffset = Math.Max(24, pt.X - dialog.ActualWidth / 2);

                if (popup.HorizontalOffset + dialog.ActualWidth > this.ActualWidth)
                    popup.HorizontalOffset = this.ActualWidth - dialog.ActualWidth;

                popup.HorizontalOffset = Math.Max(0, popup.HorizontalOffset);

                popup.VerticalOffset = this.ActualHeight - dialog.ActualHeight
                                                         - this.BottomAppBar.ActualHeight - 24;
            };

            popup.Closed += (popupSender, popupArgs) =>
            {
                this.BottomAppBar.IsOpen = false;
            };

            popup.IsOpen = true;
        }
    }
}

<UserControl ...>

    <Grid>
        <Border Background="White" BorderBrush="Black"
                BorderThickness="3" Padding="32">

            <ListBox SelectedItem="{Binding Thickness, Mode=TwoWay}"
                     Width="150">
                <x:Double>2</x:Double>
                <x:Double>3</x:Double>
                <x:Double>4</x:Double>
                <x:Double>5</x:Double>
                <x:Double>6</x:Double>
                <x:Double>8</x:Double>
                <x:Double>10</x:Double>
                <x:Double>13</x:Double>
                <x:Double>16</x:Double>
                <x:Double>20</x:Double>
                <x:Double>25</x:Double>
                <x:Double>32</x:Double>
                <x:Double>40</x:Double>

                <ListBox.Foreground>
                    <SolidColorBrush Color="{Binding Color}" />
                </ListBox.Foreground>

                <ListBox.ItemContainerStyle>
                    <Style TargetType="ListBoxItem">
                        <Setter Property="Background" Value="Transparent" />
                        <Setter Property="Template">
                            <Setter.Value>
                                <ControlTemplate TargetType="ListBoxItem">
                                    <Grid>
                                        <VisualStateManager.VisualStateGroups>
                                            <VisualStateGroup x:Name="SelectionStates">
                                                <VisualState x:Name="Unselected">
                                                    <Storyboard>
                                                        <ObjectAnimationUsingKeyFrames 
                                                            Storyboard.TargetName="border"
                                                            Storyboard.TargetProperty="BorderBrush">
                                                            <DiscreteObjectKeyFrame 
                                                                            KeyTime="0" 
                                                                            Value="Transparent" />
                                                        </ObjectAnimationUsingKeyFrames>
                                                    </Storyboard>
                                                </VisualState>

                                                <VisualState x:Name="Selected" />
                                                <VisualState x:Name="SelectedUnfocused" />
                                                <VisualState x:Name="SelectedDisabled" />
                                                <VisualState x:Name="SelectedPointerOver" />
                                                <VisualState x:Name="SelectedPressed" />
                                            </VisualStateGroup>
                                        </VisualStateManager.VisualStateGroups>

                                        <Border Name="border"
                                                BorderBrush="Black"
                                                BorderThickness="1"
                                                Background="Transparent"
                                                Padding="12">

                                            <ContentPresenter Content="{TemplateBinding Content}" />

                                        </Border>
                                    </Grid>
                                </ControlTemplate>
                            </Setter.Value>
                        </Setter>
                    </Style>
                </ListBox.ItemContainerStyle>

                <ListBox.ItemTemplate>
                    <DataTemplate>
                        <Grid Height="{Binding}"
                              Width="120">
                            <Canvas VerticalAlignment="Center"
                                    HorizontalAlignment="Center">
                                <Polyline Points="-36 0 36 0"
                                  Stroke="{Binding RelativeSource={RelativeSource TemplatedParent}, 
                                                   Path=Foreground}"
                                  StrokeThickness="{Binding}"
                                  StrokeStartLineCap="Round"
                                  StrokeEndLineCap="Round" />
                            </Canvas>
                        </Grid>
                    </DataTemplate>
                </ListBox.ItemTemplate>
            </ListBox>
        </Border>
    </Grid>
</UserControl>