public async Task Hide()
        {
            ((App)(App.Current)).BackRequested -= PhotoPreviewView_BackRequested;
            SizeChanged           -= PhotoPreviewView_SizeChanged;
            ImageRoot.SizeChanged -= ImageRoot_SizeChanged;

            IsVisible = false;

            var splitChar = _photo.IsLocal ? '\\' : '/';
            var filename  = (_photo.Uri.Split(splitChar).LastOrDefault()?.Split('.').FirstOrDefault() ?? "");

            var saveInkTask          = Inker.SaveInkToFile($"ink_{filename}.gif");
            var saveThumbnailTask    = InkHelpers.RenderImageWithInkToFileAsync(Inker, await _file.OpenReadAsync(), $"thumb_{filename}.jpg");
            var closingAnimationTask = Root.Scale(1.2f, 1.2f, (float)ActualWidth / 2, (float)ActualHeight / 2).Fade(0).StartAsync();

            await Task.WhenAll(saveInkTask, closingAnimationTask, saveThumbnailTask);

            _photo.InkUri       = saveInkTask.Result ?? _photo.InkUri;
            _photo.ThumbnailUri = saveThumbnailTask.Result ?? _photo.ThumbnailUri;


            Root.Visibility = Visibility.Collapsed;

            _canvasImage.Dispose();
            _canvasImage = null;

            _photo = null;
            _file  = null;

            ImageCanvas.Invalidate();

            FinishedHiding?.Invoke(this, null);

            _tags.Clear();
            _knownFaces.Clear();
            _facePanels.Clear();
            FaceCanvas.Children.Clear();

            if (Description != null)
            {
                Description.Text = "";
            }

            _effectsGenerator = null;

            FiltersButton.IsChecked = false;
            DetailsButton.IsChecked = false;
            InkButton.IsChecked     = false;
            Inker.InkPresenter.StrokeContainer.Clear();

            _photoInfoInitialized = false;

            if (EffectsView != null)
            {
                EffectsView.Visibility = Visibility.Collapsed;
                _effects.Clear();
            }
        }
        private async Task LoadEffects()
        {
            if (_effectsGenerator == null)
            {
                var stream = await _file.OpenReadAsync();

                _effectsGenerator = await EffectsGenerator.LoadImage(stream);
            }

            if (_effects.Count == 0)
            {
                foreach (var value in Enum.GetValues(typeof(EffectType)))
                {
                    _effects.Add((EffectType)value);
                }
            }
        }
        public static async Task <EffectsGenerator> LoadImage(IRandomAccessStream stream)
        {
            EffectsGenerator ef = new EffectsGenerator();

            ef._canvasDevice = new CanvasDevice();
            ef._canvasBitmap = await CanvasBitmap.LoadAsync(ef._canvasDevice, stream);

            var imgRect = new Rect();
            var width   = ef._canvasBitmap.Size.Width;
            var height  = ef._canvasBitmap.Size.Height;

            if (width > height)
            {
                imgRect.Width  = Math.Round(width * 150 / height);
                imgRect.Height = 150;
                imgRect.X      = -((imgRect.Width - imgRect.Height) / 2);
                imgRect.Y      = 0;
            }
            else if (height > width)
            {
                imgRect.Width  = 150;
                imgRect.Height = Math.Round(height * 150 / width);
                imgRect.X      = 0;
                imgRect.Y      = -((imgRect.Height - imgRect.Width) / 2);
            }
            else
            {
                imgRect.Width  = 150;
                imgRect.Height = 150;
                imgRect.X      = 0;
                imgRect.Y      = 0;
            }

            ef._imgRect = imgRect;

            ef._canvasRenderer = new CanvasRenderTarget(ef._canvasDevice, 150, 150, ef._canvasBitmap.Dpi);

            return(ef);
        }