AIPlatform/aipdev/TaskConflictGroupBrowser.xaml.cs

using aipdev.ViewModel;
using AIPlatform.Protocol.Entities;
using AIPlatform.Protocol.LabelData;
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.Media;
using System.Windows.Media.Imaging;

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

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

        private int _totalPages { get; set; }

        private int _currentPage { get; set; }

        private bool _scrollDown { get; set; }

        private double _oldVerticalOffset { get; set; }

        private bool _stopLoading { get; set; }

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

        private List<GroupResultData> _groupResultDatas = new List<GroupResultData>();

        private long _testFolderId { get; set; }

        private long _testFolderGroupId { get; set; }

        public string PageName { get; set; }

        public bool IsHomePage { get; set; }

        public bool IsModalPage { get; set; }

        public TaskConflictGroupBrowser()
        {
            InitializeComponent();
            PageName = "TaskConflictGroupBrowser";
            IsHomePage = false;
            IsModalPage = true;
            TaskImages.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 (_currentPage < _totalPages)
                {
                    ContentManager.ShowLoading();
                    try
                    {
                        Task.Run(async () =>
                        {
                            await LoadImagesAsync(_currentPage);
                        });
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"加载文件夹图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                    finally
                    {
                        ContentManager.HideLoading();
                    }
                }
            }
        }

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

            #region 滚动条从上往下翻看，每次加载固定数量

            if (_scrollDown && verticalOffset == scrollableHeight && _currentPage < _totalPages - 1)
            {
                onBottom = true;
                verticalOffset = 2;
                _currentPage++;
            }

            #endregion 滚动条从上往下翻看，每次加载固定数量

            _oldVerticalOffset = verticalOffset;
            return onBottom;
        }

        public void Close()
        {
            ClearImages();
        }

        private async Task LoadImagesAsync(int page = 0)
        {
            var total = _groupResultDatas.Count;
            var num = page * _pageSize + _pageSize;
            var count = num > total ? total - page * _pageSize : _pageSize;
            var currGroupDatas = _groupResultDatas.GetRange(page * _pageSize, count);
            foreach (var currGroupData in currGroupDatas)
            {
                if (_stopLoading) return;

                #region 获取原始图像

                var isGetImageData = false;
                ArchivedImage currentarchivedImage = null;
                byte[] imageData = null;
                var index = currGroupData.GroupIndex;
                var taskConflictImage = _images.FirstOrDefault(x => x.Index == index);
                if (taskConflictImage == null)
                {
                    taskConflictImage = new FileViewModel
                    {
                        Index = index,
                        IsVideo = taskConflictImage.IsVideo,
                    };
                }
                if (taskConflictImage.PreviewImage == null)
                {
                    currentarchivedImage = await GetImageData(index);
                    if (currentarchivedImage == null)
                    {
                        break;
                    }
                    imageData = currentarchivedImage?.ImageData;
                    isGetImageData = true;
                }
                else
                {
                    break;
                }

                #endregion 获取原始图像

                #region 获取图片标注信息并标注

                var conclusions = new ObservableCollection<ConflictLabelConclusion>();
                var colorIndex = 0;
                var currFile = currGroupData.Files.FirstOrDefault(x => x.FileResultInfos.Count > 0);
                if (currFile != null)
                {
                    var annotator = currFile.Annotator;
                    var currResultInfo = currFile.FileResultInfos.FirstOrDefault(x => x.LabeledResult != null);
                    if (currResultInfo != null)
                    {
                        if (_stopLoading) return;

                        var imageContent = string.Empty;
                        var roiContent = string.Empty;
                        var labeledResult = currResultInfo.LabeledResult;
                        if (labeledResult != null)
                        {
                            foreach (var imageResult in labeledResult.ImageResults)
                            {
                                var currNum = imageResult.Index + 1;
                                imageContent += $"[图像标签-{currNum}]-{imageResult.Unit.Title}-{imageResult.Conclusion.Title}";
                                if (currNum < labeledResult.ImageResults.Count)
                                {
                                    imageContent += "\r\n";
                                }
                            }

                            foreach (var roi in labeledResult.Rois)
                            {
                                if (roi.Conclusion != null)
                                {
                                    var currNum = roi.Index + 1;
                                    roiContent += $"[ROI-{roi.Index + 1}]-{roi.Unit.Title}-{roi.Conclusion.Title}";
                                    if (currNum < labeledResult.Rois.Count)
                                    {
                                        roiContent += "\r\n";
                                    }
                                }
                            }

                            conclusions.Add(new ConflictLabelConclusion
                            {
                                Index = colorIndex,
                                Annotator = annotator,
                                ImageContent = imageContent,
                                RoiContent = roiContent,
                                LabeledResult = labeledResult,
                                IsRoi = labeledResult.Rois.Count > 0,
                            });
                            colorIndex += 1;
                        }

                        if (isGetImageData)
                        {
                            imageData = SkiaSharpHelper.GetMultiRectangelLabeledImageData(currentarchivedImage.ImageData, currentarchivedImage.Width, currentarchivedImage.Height, conclusions);
                            if (imageData != null)
                            {
                                var previewImage = new BitmapImage();
                                previewImage.BeginInit();
                                previewImage.StreamSource = new MemoryStream(imageData);
                                previewImage.EndInit();
                                previewImage.Freeze();
                                taskConflictImage.PreviewImage = previewImage;
                                Dispatcher.Invoke(() =>
                                {
                                    _images.Add(taskConflictImage);
                                });
                            }
                        }
                    }
                }

                #endregion 获取图片标注信息并标注
            }

            Dispatcher.Invoke(() =>
            {
                if (_scrollViewer == null)
                {
                    _scrollViewer = FindVisualChild<ScrollViewer>(TaskImages);
                    if (_scrollViewer != null)
                    {
                        _scrollViewer.ScrollToTop();
                        _scrollViewer.ScrollChanged += OnFolderImagesScrollChanged;
                    }
                }
            });
        }

        /// <summary>
        /// Get image according to the index
        /// </summary>
        /// <param name="imageIndex"></param>
        /// <returns></returns>
        private async Task<ArchivedImage> GetImageData(int imageIndex)
        {
            try
            {
                //获取developer folder image
                var developerFolderImage = await DeveloperManager.Shared.GetDeveloperFolderFilebyIndexAsync(_testFolderId, _testFolderGroupId, imageIndex);
                if (developerFolderImage == null)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"获取测试文件夹图像失败，Index：{imageIndex}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    return null;
                }
                var developerLabeledUltrasoundFile = await DeveloperManager.Shared.GetDeveloperLabeledUltrasoundFileAsync(developerFolderImage.DeveloperLabeledUltrasoundInfoList[0].DeveloperLabeledUltrasoundFileId);
                if (developerLabeledUltrasoundFile == null)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"获取测试文件夹标注图像失败，Index：{imageIndex}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    return null;
                }
                var currentarchivedImage = await DeveloperManager.Shared.GetArchivedImageAsync(developerLabeledUltrasoundFile.ArchivedImageId);
                if (currentarchivedImage == null)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"获取测试文件夹原始图像失败，Index：{imageIndex}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    return null;
                }
                return currentarchivedImage;
            }
            catch (Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow, $"获取原始图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                return null;
            }
        }

        private void ClearImages()
        {
            _scrollViewer ??= FindVisualChild<ScrollViewer>(TaskImages);
            if (_scrollViewer != null)
            {
                _scrollViewer.ScrollChanged -= OnFolderImagesScrollChanged;
            }
            _stopLoading = true;
            _scrollViewer = null;
            _images.Clear();
            _groupResultDatas.Clear();
            _testFolderId = 0;
            TaskName.Text = string.Empty;
            _currentPage = 0;
            _scrollDown = false;
            _oldVerticalOffset = 0;
            _totalPages = 0;
        }

        public async void OnShow(object arg)
        {
            ContentManager.ShowLoading();
            try
            {
                if (arg is TrainTaskEx task)
                {
                    _testFolderId = task.TestFolder.Id;
                    TaskName.Text = task.Name;
                    var content = await DeveloperManager.Shared.GetTestResultFromFileAsync(task.Id);
                    _groupResultDatas = await GetDeserializeGroupResult(content);
                    if (_groupResultDatas == null || _groupResultDatas.Count == 0)
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"没有可供查看的图像", "提示", MessageBoxButton.OK, MessageBoxImage.Information);
                        return;
                    }

                    var count = _groupResultDatas.Count;
                    _totalPages = count / _pageSize;
                    if (count % _pageSize != 0)
                    {
                        _totalPages++;
                    }
                    _stopLoading = false;
                    _ = Task.Run(async () =>
                      {
                          await LoadImagesAsync();
                      });
                }
                else
                {
                    throw new InvalidOperationException("无效的文件夹路径。");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow, $"加载文件夹图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                ContentManager.HideLoading();
            }
        }

        /// <summary>
        /// Deserialize the group content
        /// </summary>
        /// <param name="content"></param>
        /// <returns></returns>
        private async Task<List<GroupResultData>> GetDeserializeGroupResult(string content)
        {
            List<GroupResultData> groupResultData = await Task.Run(() =>
            {
                return Newtonsoft.Json.JsonConvert.DeserializeObject<List<GroupResultData>>(content);
            });
            return groupResultData;
        }

        public void OnHide()
        {
            ClearImages();
        }

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

            if (taskConflictImageEx != null)
            {
                var folderImageViewer = new TaskConflictGroupViewer(_groupResultDatas, _testFolderId, taskConflictImageEx.Index, 0) { Owner = Application.Current.MainWindow };
                folderImageViewer.ShowDialog();
            }
        }

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