AIPlatform_6787/aipdev/FolderQuestionedImageViewer.xaml.cs

using AIPlatform.Protocol.Entities;
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.Imaging;
using static System.Windows.Forms.AxHost;

namespace aipdev
{
    /// <summary>
    /// Interaction logic for FolderQuestionedImageViewer.xaml
    /// </summary>
    public partial class FolderQuestionedImageViewer : Window
    {
        private long _folderId;
        private int _index;
        private LabeledUltrasoundFile _labeledUltrasoundFile;
        private readonly IList<long> _lstUltrasoundFileId;
        private readonly IList<long> _lstLatestLabeledUltrasoundFileId;
        private readonly ObservableCollection<LabelConclusion> _conclusions = new ObservableCollection<LabelConclusion>();
        private readonly ObservableCollection<ReviewerInfo> _reviewerInfos = new ObservableCollection<ReviewerInfo>();
        private readonly ObservableCollection<LabelerItem> _labelerItems = new ObservableCollection<LabelerItem>();
        private readonly ObservableCollection<LabeledUltrasoundFileInfoModel> _relabeledInfos = new ObservableCollection<LabeledUltrasoundFileInfoModel>();
        private List<LabeledUltrasoundFileInfo> _labeledUltrasoundFileInfos;

        public FolderQuestionedImageViewer(long folderId, int index, LabeledUltrasoundFile labeledUltrasoundImage, IList<long> lstFileId, IList<long> lstLabeledFileId)
        {
            InitializeComponent();
            _folderId = folderId;
            _index = index;
            _labeledUltrasoundFile = labeledUltrasoundImage;
            _lstUltrasoundFileId = lstFileId;
            _lstLatestLabeledUltrasoundFileId = lstLabeledFileId;
            Conclusions.ItemsSource = _conclusions;
            LabelerList.ItemsSource = _labelerItems;
            ReviewInfoList.ItemsSource = _reviewerInfos;
            RelabelInfoList.ItemsSource = _relabeledInfos;
            Loaded += OnLoaded;
        }

        private async Task LoadLabelerAsync()
        {
            try
            {
                _labelerItems.Clear();
                _labeledUltrasoundFileInfos = new List<LabeledUltrasoundFileInfo>();
                LabelerItem labelerItem = null;
                _labeledUltrasoundFileInfos = await DeveloperManager.Shared.GetLabeledFileInfosAsync(_folderId, _labeledUltrasoundFile.UltrasoundFileId);
                foreach (var item in _labeledUltrasoundFileInfos)
                {
                    var state = item.LabeledUltrasoundFile.DeveloperItem.QuestionedState;
                    _labelerItems.Add(new LabelerItem
                    {
                        Labeler = item.LabeledUltrasoundFile.Labeler,
                        LabeledUltrasoundFileId = item.LabeledUltrasoundFile.Id,
                        IsQuestioned = item.HasQuestioned,
                        IsQuestionedFinished = item.LabeledUltrasoundFile.SourceLabeledUltrasoundFileId > 0,
                    });
                    labelerItem = _labelerItems.FirstOrDefault(x => x.LabeledUltrasoundFileId == _labeledUltrasoundFile.Id);
                }
                LabelerList.SelectedItem = labelerItem;
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, $"加载标注人员失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void LoadImage()
        {
            try
            {
                _conclusions.Clear();
                _reviewerInfos.Clear();
                _relabeledInfos.Clear();
                var fileInfo = _labeledUltrasoundFileInfos.FirstOrDefault(x => x.LabeledUltrasoundFile.Id == _labeledUltrasoundFile.Id);
                var reviewerInfos = fileInfo.ReviewerInfos;
                var imageData = fileInfo.ImageData;
                foreach (var item in fileInfo.LabelConclusions)
                {
                    _conclusions.Add(item);
                }

                #region 历史结果

                if (fileInfo.RelabeledInfos != null && fileInfo.RelabeledInfos.Count > 0)
                {
                    for (int i = 0; i < fileInfo.RelabeledInfos.Count; i++)
                    {
                        var item = fileInfo.RelabeledInfos[i];
                        var devItem = item.LabeledUltrasoundFile.DeveloperItem;
                        var info = new LabeledUltrasoundFileInfoModel
                        {
                            LabeledResultHeader = $"标注结果{i + 1}",
                            Labeler = item.Labeler,
                            LabeledUltrasoundFile = item.LabeledUltrasoundFile,
                            ImageData = item.ImageData,
                            LabelConclusions = item.LabelConclusions,
                            ReviewerInfos = item.ReviewerInfos,
                            HasReviewedResult = item.ReviewerInfos != null,
                            ReviewedResultHeader = $"审核结果{i + 1}",
                            HasDeveloperItem = devItem.Id > 0,
                            DeveloperItemHeader = $"状态{i + 1}",
                            QuestionedState = "质疑：",
                            ConfirmedState = "确认：",
                        };
                        switch (devItem.QuestionedState)
                        {
                            case QuestionedState.None:
                                info.QuestionedState += "无";
                                break;
                            case QuestionedState.PendingAssigned:
                                info.QuestionedState += "待分配";
                                break;
                            case QuestionedState.Assigned:
                                info.QuestionedState += "已分配";
                                break;
                            case QuestionedState.Completed:
                                info.QuestionedState += "已完成";
                                break;
                            default:
                                break;
                        }
                        switch (devItem.ConfirmedState)
                        {
                            case ConfirmedState.None:
                                info.ConfirmedState += "无";
                                break;
                            case ConfirmedState.Accepted:
                                info.ConfirmedState += "接受";
                                break;
                            case ConfirmedState.Abandoned:
                                info.ConfirmedState += "弃用";
                                break;
                            default:
                                break;
                        }
                        _relabeledInfos.Add(info);
                    }
                }

                #endregion

                _labeledUltrasoundFile = fileInfo.LabeledUltrasoundFile;
                ImageNameTextBox.Text = $"名称：{_labeledUltrasoundFile.Source.FileName}";
                ImageIdTextBox.Text = $"Id：{_labeledUltrasoundFile.Id}";
                ImageIndex.Visibility = Visibility.Collapsed;
                ImageIndex.Text = string.Empty;

                #region 质疑状态 & 确认状态

                btnWithdrawalQuestioned.Visibility = Visibility.Collapsed;
                btnAccepted.Visibility = Visibility.Collapsed;
                btnAbandoned.Visibility = Visibility.Collapsed;
                switch (_labeledUltrasoundFile.DeveloperItem.QuestionedState)
                {
                    case QuestionedState.None:
                        txtQuestionedState.Text = "无";
                        break;
                    case QuestionedState.PendingAssigned:
                        txtQuestionedState.Text = "待分配";
                        if (_labeledUltrasoundFile.DeveloperItem.Id == DeveloperManager.Shared.Session.AccountId)
                        {
                            btnWithdrawalQuestioned.Visibility = Visibility.Visible;
                        }
                        break;
                    case QuestionedState.Assigned:
                        txtQuestionedState.Text = "已分配";
                        break;
                    case QuestionedState.Completed:
                        txtQuestionedState.Text = "已完成";
                        if (_labeledUltrasoundFile.SourceLabeledUltrasoundFileId > 0 && _labeledUltrasoundFile.DeveloperItem.Id == DeveloperManager.Shared.Session.AccountId)
                        {
                            btnAccepted.Visibility = Visibility.Visible;
                            btnAbandoned.Visibility = Visibility.Visible;
                        }
                        break;
                    default:
                        break;
                }

                switch (_labeledUltrasoundFile.DeveloperItem.ConfirmedState)
                {
                    case ConfirmedState.None:
                        txtConfirmedState.Text = "无";
                        if (_labeledUltrasoundFile.SourceLabeledUltrasoundFileId > 0)
                        {
                            btnAccepted.Visibility = Visibility.Visible;
                            btnAbandoned.Visibility = Visibility.Visible;
                        }
                        break;
                    case ConfirmedState.Accepted:
                        txtConfirmedState.Text = "接受";
                        if (_labeledUltrasoundFile.SourceLabeledUltrasoundFileId > 0)
                        {
                            btnAbandoned.Visibility = Visibility.Visible;
                        }
                        break;
                    case ConfirmedState.Abandoned:
                        txtConfirmedState.Text = "弃用";
                        if (_labeledUltrasoundFile.SourceLabeledUltrasoundFileId > 0)
                        {
                            btnAccepted.Visibility = Visibility.Visible;
                        }
                        break;
                    default:
                        break;
                }

                #endregion

                #region imageData         
                if (imageData != null)
                {
                    var bitmapImage = new BitmapImage();
                    bitmapImage.BeginInit();
                    bitmapImage.StreamSource = new MemoryStream(imageData);
                    bitmapImage.EndInit();
                    Image.Source = bitmapImage;
                }
                #endregion

                #region reviewedResult
                if (reviewerInfos != null && reviewerInfos.Count > 0)
                {
                    foreach (var item in reviewerInfos)
                    {
                        _reviewerInfos.Add(new ReviewerInfo
                        {
                            Reviewer = item.Reviewer,
                            IsPassed = item.IsPassed,
                            Results = item.Results,
                        });
                    }
                }
                #endregion

                ReviewInfoGroup.Visibility = _reviewerInfos.Count > 0 ? Visibility.Visible : Visibility.Collapsed;
                RelabelInfoGroup.Visibility = _relabeledInfos.Count > 0 ? Visibility.Visible : Visibility.Collapsed;
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, $"加载图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                PreviousImage.IsEnabled = _index > 0;
                NextImage.IsEnabled = _index < _lstUltrasoundFileId.Count - 1;
            }
        }

        private async void OnLoaded(object sender, RoutedEventArgs e)
        {
            try
            {
                Waiting.StartWaiting();
                await LoadLabelerAsync();
                LoadImage();
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, $"加载图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                Waiting.StopWaiting();
            }
        }

        private async void OnPreviousImageClick(object sender, RoutedEventArgs e)
        {
            try
            {
                Waiting.StartWaiting();

                var index = _lstUltrasoundFileId.IndexOf(_labeledUltrasoundFile.UltrasoundFileId);
                _index = index - 1;
                var labeledImageId = _lstLatestLabeledUltrasoundFileId[_index];
                _labeledUltrasoundFile = await DeveloperManager.Shared.GetLabeledUltrasoundFileAsync(labeledImageId);

                await LoadLabelerAsync();
                LoadImage();
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, $"加载上一张图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                Waiting.StopWaiting();
            }
        }

        private async void OnNextImageClick(object sender, RoutedEventArgs e)
        {
            try
            {
                Waiting.StartWaiting();

                var index = _lstUltrasoundFileId.IndexOf(_labeledUltrasoundFile.UltrasoundFileId);
                _index = index + 1;
                var labeledImageId = _lstLatestLabeledUltrasoundFileId[_index];
                _labeledUltrasoundFile = await DeveloperManager.Shared.GetLabeledUltrasoundFileAsync(labeledImageId);

                await LoadLabelerAsync();
                LoadImage();
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, $"加载下一张图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                Waiting.StopWaiting();
            }
        }

        private async void OnLabelerMouseLeftButtonDownAsync(object sender, MouseButtonEventArgs e)
        {
            try
            {
                if (e.OriginalSource as FrameworkElement == null)
                {
                    return;
                }
                if (e.OriginalSource as Border == null && e.OriginalSource as TextBlock == null)
                {
                    return;
                }
                Waiting.StartWaiting();

                var labelerItem = (e.OriginalSource as FrameworkElement).DataContext as LabelerItem;
                _labeledUltrasoundFile = await DeveloperManager.Shared.GetLabeledUltrasoundFileAsync(labelerItem.LabeledUltrasoundFileId);

                LoadImage();
            }
            catch (Exception ex)
            {
                Waiting.StopWaiting();
                MessageBox.Show(this, $"切换标注人员失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                Waiting.StopWaiting();
            }
        }

        private void OnRelabelResultClick(object sender, RoutedEventArgs e)
        {
            try
            {
                Waiting.StartWaiting();
                var button = (Button)sender;
                var dataContext = button.DataContext;
                if (dataContext is LabeledUltrasoundFileInfoModel relabeledInfo)
                {
                    var imageData = relabeledInfo.ImageData;
                    if (imageData != null)
                    {
                        var bitmapImage = new BitmapImage();
                        bitmapImage.BeginInit();
                        bitmapImage.StreamSource = new MemoryStream(imageData);
                        bitmapImage.EndInit();
                        Image.Source = bitmapImage;
                    }
                    foreach (var item in _relabeledInfos)
                    {
                        item.IsSelected = false;
                        if (item == relabeledInfo)
                        {
                            item.IsSelected = true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, $"加载历史图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                Waiting.StopWaiting();
            }
        }

        private async void OnWithdrawalQuestionedFileClick(object sender, RoutedEventArgs e)
        {
            var result = MessageBox.Show(Application.Current.MainWindow, "确认撤销质疑该标注人员图像吗？", "质疑", MessageBoxButton.YesNo, MessageBoxImage.Question);
            if (result == MessageBoxResult.Yes)
            {
                try
                {
                    Waiting.StartWaiting();
                    await DeveloperManager.Shared.WithdrawalQuestionedDeveloperFolderFileAsync(_labeledUltrasoundFile.Id, _labeledUltrasoundFile.UltrasoundFileId, _labeledUltrasoundFile.ImageCaseId, _labeledUltrasoundFile.Labeler);
                    _labeledUltrasoundFile.DeveloperItem.QuestionedState = QuestionedState.None;
                    txtQuestionedState.Text = "无";
                    btnWithdrawalQuestioned.Visibility = Visibility.Collapsed;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"撤销质疑图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                }
                finally
                {
                    Waiting.StopWaiting();
                }
            }
        }

        private async void OnAcceptedFileClick(object sender, RoutedEventArgs e)
        {
            var result = MessageBox.Show(Application.Current.MainWindow, "确认接受该标注人员图像吗？", "质疑", MessageBoxButton.YesNo, MessageBoxImage.Question);
            if (result == MessageBoxResult.Yes)
            {
                try
                {
                    Waiting.StartWaiting();
                    await DeveloperManager.Shared.UpdateQuestionedDeveloperFolderFileConfirmedStateAsync(_labeledUltrasoundFile.Id, _labeledUltrasoundFile.SourceLabeledUltrasoundFileId, ConfirmedState.Accepted);
                    _labeledUltrasoundFile.DeveloperItem.ConfirmedState = ConfirmedState.Accepted;
                    txtConfirmedState.Text = "接受";
                    btnAccepted.Visibility = Visibility.Collapsed;
                    btnAbandoned.Visibility = Visibility.Visible;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"接受图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                }
                finally
                {
                    Waiting.StopWaiting();
                }
            }
        }

        private async void OnAbandonedFileClick(object sender, RoutedEventArgs e)
        {
            var result = MessageBox.Show(Application.Current.MainWindow, "确认弃用该标注人员图像吗？", "质疑", MessageBoxButton.YesNo, MessageBoxImage.Question);
            if (result == MessageBoxResult.Yes)
            {
                try
                {
                    Waiting.StartWaiting();
                    await DeveloperManager.Shared.UpdateQuestionedDeveloperFolderFileConfirmedStateAsync(_labeledUltrasoundFile.Id, _labeledUltrasoundFile.SourceLabeledUltrasoundFileId, ConfirmedState.Abandoned);
                    _labeledUltrasoundFile.DeveloperItem.ConfirmedState = ConfirmedState.Abandoned;
                    txtConfirmedState.Text = "弃用";
                    btnAccepted.Visibility = Visibility.Visible;
                    btnAbandoned.Visibility = Visibility.Collapsed;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"弃用图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                }
                finally
                {
                    Waiting.StopWaiting();
                }
            }
        }
    }
}