AIPlatform/aipdev/FolderQuestionedImageBrowser.xaml.cs

using AIPlatform.Protocol.Model;
using AIPlatform.Protocol.Utilities;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace aipdev
{
    /// <summary>
    /// Interaction logic for FolderQuestionedImageBrowser.xaml
    /// </summary>
    public partial class FolderQuestionedImageBrowser : UserControl, IContentPage
    {
        private ScrollViewer _scrollViewer;

        private string _keyword;

        private int _pageSize { get; set; } = 45;

        private int _totalPages { get; set; }

        private int _preloadedPage { get; set; }

        private bool _scrollDown { get; set; }

        private bool _isLoadPreviousImages { get; set; }

        private bool _isLoadNextImages { get; set; }

        private double _oldVerticalOffset { get; set; }

        private int _browseImageIndex { get; set; }

        private int _browsePage { get; set; }

        private int _imageCount { get; set; }

        private int _groupCount { get; set; }

        private ImageFolderExtend _folder;

        private readonly ObservableCollection<FolderImageEx> _images = new ObservableCollection<FolderImageEx>();

        public string PageName { get; set; }

        public bool IsHomePage { get; set; }

        public bool IsModalPage { get; set; }

        private bool _stopLoading { get; set; }

        private bool _isPendingConfirmed { get; set; }

        public FolderQuestionedImageBrowser()
        {
            InitializeComponent();
            PageName = "FolderQuestionedImageBrowser";
            IsHomePage = false;
            IsModalPage = true;
            FolderImages.ItemsSource = _images;
        }

        private T FindVisualChild<T>(DependencyObject element) where T : class
        {
            try
            {
                while (element != null)
                {
                    if (element is T)
                        return element as T;
                    element = VisualTreeHelper.GetChild(element, 0);
                }
            }
            catch (Exception)
            {
                //DoNothing
            }

            return null;
        }

        private void OnFolderImagesScrollChanged(object sender, ScrollChangedEventArgs e)
        {
            var scrollViewer = (ScrollViewer)sender;
            if (IsOnScrollViewBottom(scrollViewer))
            {
                if (_preloadedPage < _totalPages)
                {
                    try
                    {
                        Task.Run(async () =>
                        {
                            await LoadImagesAsync(_preloadedPage).ConfigureAwait(false);
                        });
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"加载文件夹图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                }
            }
        }

        private bool IsOnScrollViewBottom(ScrollViewer view)
        {
            var onBottom = false;
            var verticalOffset = view.VerticalOffset;
            var scrollableHeight = view.ScrollableHeight;
            var extentHeight = view.ExtentHeight;
            _scrollDown = verticalOffset >= _oldVerticalOffset;

            #region 滚动条从上往下翻看，加载之面页数

            if (_scrollDown && verticalOffset / extentHeight > 0.7 && _stopLoading && _preloadedPage < _totalPages - 1)
            {
                _isLoadNextImages = true;
                _isLoadPreviousImages = false;
                onBottom = true;
                verticalOffset = 2;
                _preloadedPage++;
            }

            #endregion 滚动条从上往下翻看，加载之面页数

            #region 有上一次的浏览记录时，滚动条从下往上翻看，加载之前页数

            else if (_browsePage > 0 && !_scrollDown && verticalOffset / extentHeight < 0.3 && _stopLoading && _preloadedPage > 0)
            {
                _isLoadPreviousImages = true;
                _isLoadNextImages = false;
                onBottom = true;
                verticalOffset = scrollableHeight;
                _preloadedPage--;
            }

            #endregion 有上一次的浏览记录时，滚动条从下往上翻看，加载之前页数

            _oldVerticalOffset = verticalOffset;
            return onBottom;
        }

        public void Close()
        {
            ClearImages();
        }

        private string GetConclusions(List<LabelConclusion> labelConclusions, ref string trimmingConclusions)
        {
            var conclusions = string.Empty;
            for (int i = 0; i < labelConclusions.Count; i++)
            {
                var item = labelConclusions[i];
                conclusions += $"{item.Title} {item.Content}";
                if (i < labelConclusions.Count - 1)
                    conclusions += Environment.NewLine;

                if (i < 5)
                {
                    trimmingConclusions = conclusions;
                }
                else if (i == 5)
                {
                    trimmingConclusions += "......";
                }
            }
            return conclusions;
        }

        private async Task LoadImagesAsync(int page = 0)
        {
            try
            {
                Dispatcher.Invoke(() =>
                {
                    ContentManager.ShowLoading();
                });
                _stopLoading = false;
                if (_folder is ImageFolderExtend imageFolder)
                {
                    var labeledFileInfos = await DeveloperManager.Shared.GetLatestLabeledFileInfosAsync(imageFolder.Id, _keyword, true, _isPendingConfirmed, page, _pageSize);
                    if (_isLoadPreviousImages)
                    {
                        labeledFileInfos = labeledFileInfos.OrderByDescending(x => x).ToList();
                    }
                    foreach (var fileInfo in labeledFileInfos)
                    {
                        var labeledUltrasoundFile = fileInfo.LabeledUltrasoundFile;
                        if (_images.Any(x => x.LabeledUltrasoundFile.Id == labeledUltrasoundFile.Id))
                        {
                            continue;
                        }
                        var previewImage = new BitmapImage();
                        previewImage.BeginInit();
                        previewImage.StreamSource = new MemoryStream(fileInfo.ImageData);
                        previewImage.EndInit();
                        previewImage.Freeze();
                        var trimmingConclusions = string.Empty;
                        var conclusions = GetConclusions(fileInfo.LabelConclusions, ref trimmingConclusions);
                        var folderImageEx = new FolderImageEx(labeledUltrasoundFile, previewImage, false, fileInfo.LabeledResult, conclusions, trimmingConclusions, page, imageFolder.Id, fileInfo.HasQuestioned);
                        if (_stopLoading)
                        {
                            break;
                        }
                        if (_isLoadPreviousImages)
                        {
                            Dispatcher.Invoke(() =>
                            {
                                _images.Insert(0, folderImageEx);
                            });
                        }
                        else
                        {
                            Dispatcher.Invoke(() =>
                            {
                                _images.Add(folderImageEx);
                            });
                        }
                    }
                }
                _stopLoading = true;

                Dispatcher.Invoke(() =>
                {
                    if (_scrollViewer == null)
                    {
                        _scrollViewer = FindVisualChild<ScrollViewer>(FolderImages);
                        if (_scrollViewer != null)
                        {
                            if (_browseImageIndex == 0)
                            {
                                _scrollViewer.ScrollToTop();
                            }
                            else
                            {
                                var rowHeight = _scrollViewer.ExtentHeight / Math.Ceiling((double)_images.Count / 3);
                                var count = _browseImageIndex % _pageSize;
                                var verticalOffset = Math.Floor((double)count / 3) * rowHeight;
                                _scrollViewer.ScrollToVerticalOffset(verticalOffset);
                            }
                            _scrollViewer.ScrollChanged += OnFolderImagesScrollChanged;
                        }
                    }
                    else if (_isLoadPreviousImages)
                    {
                        var rowHeight = _scrollViewer.ExtentHeight / Math.Ceiling((double)_images.Count / 3);
                        var verticalOffset = _pageSize / 3 * rowHeight + _scrollViewer.VerticalOffset;
                        _scrollViewer.ScrollToVerticalOffset(verticalOffset);
                    }
                });
            }
            catch (Exception ex)
            {
                Dispatcher.Invoke(() =>
                {
                    MessageBox.Show(Application.Current.MainWindow, $"加载文件夹图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                });
            }
            finally
            {
                Dispatcher.Invoke(() =>
                {
                    ContentManager.HideLoading();
                });
            }
        }

        private void ClearImages()
        {
            Reset();

            _folder = null;
            FolderName.Text = string.Empty;
            FolderName.ToolTip = string.Empty;
            _keyword = txtFileName.Text = string.Empty;
            _totalPages = 0;
            _imageCount = 0;
            _groupCount = 0;
            chbIsConfirmed.IsChecked = false;
            _isPendingConfirmed = false;
        }

        public async void OnShow(object arg)
        {
            try
            {
                if (arg is ImageFolderExtend imageFolder)
                {
                    _folder = imageFolder;
                    FolderName.Text = _folder.Name;
                    FolderName.ToolTip = _folder.Name;
                    _imageCount = _folder.ImageCount;
                    _groupCount = _folder.GroupCount;
                    _totalPages = (int)Math.Ceiling((double)_groupCount / _pageSize);

                    await LoadImagesAsync(_preloadedPage).ConfigureAwait(false);
                }
                else
                {
                    throw new InvalidOperationException("无效的文件夹路径。");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow, $"加载文件夹图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        public void OnHide()
        {
            ClearImages();
        }

        private async void OnImageClick(object sender, RoutedEventArgs e)
        {
            FolderImageEx folderImageEx = null;
            if (sender is MenuItem menuItem)
            {
                folderImageEx = (FolderImageEx)menuItem.DataContext;
            }
            else if (sender is Button button)
            {
                folderImageEx = (FolderImageEx)button.DataContext;
            }

            if (folderImageEx != null)
            {
                if (folderImageEx.LabeledUltrasoundFile != null)
                {
                    var lstFileId = _images.Select(x => x.LabeledUltrasoundFile.UltrasoundFileId).ToList();
                    var lstLabeledFileId = _images.Select(x => x.LabeledUltrasoundFile.Id).ToList();
                    var index = lstFileId.IndexOf(folderImageEx.LabeledUltrasoundFile.UltrasoundFileId);
                    var folderImageViewer = new FolderQuestionedImageViewer(folderImageEx.SourceFolderId, index, folderImageEx.LabeledUltrasoundFile, lstFileId, lstLabeledFileId) { Owner = Application.Current.MainWindow };
                    folderImageViewer.ShowDialog();
                }
            }
        }

        private void OnCloseClick(object sender, RoutedEventArgs e)
        {
            ClearImages();
            this.Hide();
        }

        private void OnSearchFiles(object sender, RoutedEventArgs e)
        {
            _keyword = txtFileName.Text;
            Reset();
            Task.Run(async () =>
            {
                await LoadImagesAsync().ConfigureAwait(false);
            });
        }

        private void Reset()
        {
            _scrollViewer ??= FindVisualChild<ScrollViewer>(FolderImages);
            if (_scrollViewer != null)
            {
                //#region 保存历史查看位置
                //if (_folder is DeveloperImageFolder developerImageFolder)
                //{
                //    try
                //    {
                //        var rowHeight = _scrollViewer.ExtentHeight / Math.Ceiling((double)_images.Count / 3);
                //        var currRows = Math.Ceiling(_scrollViewer.VerticalOffset / rowHeight);
                //        _browseImageIndex = (int)currRows * 3;
                //        _browsePage = _images[_browseImageIndex].Page;
                //        await DeveloperManager.Shared.UpdateDeveloperFolderBrowseHistoricalInfo(_folder.Id, _browseImageIndex, _browsePage);
                //    }
                //    catch (Exception ex)
                //    {
                //        MessageBox.Show(Application.Current.MainWindow, $"保存文件夹浏览记录失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                //    }
                //}
                //#endregion

                _scrollViewer.ScrollChanged -= OnFolderImagesScrollChanged;
            }
            _stopLoading = true;
            _scrollViewer = null;
            _images.Clear();
            _preloadedPage = 0;
            _isLoadPreviousImages = false;
            _isLoadNextImages = false;
            _scrollDown = false;
            _oldVerticalOffset = 0;
            _browseImageIndex = 0;
            _browsePage = 0;
        }

        private void OnClearAndSearchFiles(object sender, RoutedEventArgs e)
        {
            _keyword = txtFileName.Text = string.Empty;
            OnSearchFiles(sender, e);
        }

        private void txtFileName_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                OnSearchFiles(sender, e);
            }
        }

        private async void OnSuspectedMislabelingFileClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folderImageEx = (FolderImageEx)menuItem.DataContext;
            try
            {
                CopyImageWindow copyImageWindow;
                if (folderImageEx.DeveloperFolderFile != null)
                {
                    copyImageWindow = new CopyImageWindow(folderImageEx.DeveloperFolderFile.ImageCategoryId) { Owner = Application.Current.MainWindow };
                }
                else
                {
                    copyImageWindow = new CopyImageWindow(folderImageEx.LabeledUltrasoundFile.ImageCategoryId) { Owner = Application.Current.MainWindow };
                }
                copyImageWindow.ShowDialog();
                var selectedFolder = copyImageWindow.SelectedFolder;
                if (selectedFolder != null)
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.ShowLoading();
                    });
                    try
                    {
                        if (folderImageEx.DeveloperFolderFile != null)
                        {
                            await DeveloperManager.Shared.CopyDeveloperFolderGroupAsync(selectedFolder.Id, folderImageEx.SourceFolderId, folderImageEx.DeveloperFolderFile.UltrasoundGroupId);
                        }
                        else
                        {
                            await DeveloperManager.Shared.CopyFolderGroupAsync(selectedFolder.Id, folderImageEx.SourceFolderId, folderImageEx.LabeledUltrasoundFile.UltrasoundGroupId);
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"复制图片失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                    finally
                    {
                        Dispatcher.Invoke(() =>
                        {
                            ContentManager.HideLoading();
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow, $"获取文件夹列表失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void OnConfirmedFilesClick(object sender, RoutedEventArgs e)
        {
            _isPendingConfirmed = (bool)chbIsConfirmed.IsChecked;
            OnSearchFiles(sender, e);
        }
    }
}