AIPractice/AIPractice.Labeller.Network/CaseImageView.xaml.cs

using System;
using System.Collections.Specialized;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shapes;


namespace AIPractice.Labeller
{
    /// <summary>
    /// Interaction logic for ImgCanvas.xaml
    /// </summary>
    public partial class CaseImageView : UserControl
    {
        private readonly Path _rulerPath;
        private readonly Grid _measuredValue;
        private readonly TextBlock _measuredValueText;

        private CaseImageViewModel _caseImageViewModel;
        private RoiViewModel _activeRoiViewModel;

        private double _currentScale = 1.0d;

        //private bool _isMeasuring;
        private bool _isDrawingRoi;
        //private Point _measureStartPoint;

        private Point _roiCurrentPosition;
        private Point _movingStartPosition;
        private Point _emptyPosition = new Point(0, 0);

        private TouchDevice _currentTouchDevice;

        public CaseImageView()
        {
            InitializeComponent();
            _rulerPath = new Path
            {
                Stroke = Brushes.Lime,
                StrokeThickness = 2
            };
            _measuredValueText = new TextBlock()
            {
                Foreground = Brushes.Lime,
                FontSize = 16,
                VerticalAlignment = VerticalAlignment.Center,
                HorizontalAlignment = HorizontalAlignment.Center,
                Margin = new Thickness(4,2,4,2),
            };
            _measuredValue = new Grid()
            {
                MinWidth = 48,
            };
            _measuredValue.Children.Add(new Border()
            {
                CornerRadius = new CornerRadius(4),
                BorderBrush = Brushes.DarkGray,
                BorderThickness = new Thickness(1),
                Background = Brushes.DarkGray,
                Opacity = 0.5,
            });
            _measuredValue.Children.Add(_measuredValueText);

            DataContextChanged += OnDataContextChanged;
            ControlGrid.SizeChanged += OnControlGridSizeChanged;
            ImageGrid.SizeChanged += OnRoiCanvasSizeChanged;

            ImageGrid.MouseLeftButtonDown += OnMouseLeftButtonDown;
            ImageGrid.MouseMove += OnMouseMove;
            ImageGrid.MouseLeftButtonUp += OnMouseLeftButtonUp;

            ImageGrid.TouchDown += OnTouchDown;
            ImageGrid.TouchMove += OnTouchMove;
            ImageGrid.TouchUp += OnTouchUp;
            ImageGrid.TouchLeave += OnTouchLeave;
        }

        private void OnTouchLeave(object sender, TouchEventArgs e)
        {
            e.Handled = true;
            if (_isDrawingRoi)
            {
                if (_caseImageViewModel.ActiveRoi != null)
                {
                    _caseImageViewModel.ActiveRoi.IsPasued = true;
                    if (_caseImageViewModel.ActiveRoi.ModifingStart)
                    {
                        _roiCurrentPosition = new Point(_caseImageViewModel.ActiveRoi.StartPoint.X * _caseImageViewModel.Transform.ScaleX, _caseImageViewModel.ActiveRoi.StartPoint.Y * _caseImageViewModel.Transform.ScaleY);
                    }
                    else
                    {
                        _roiCurrentPosition = new Point(_caseImageViewModel.ActiveRoi.LastPoint.X * _caseImageViewModel.Transform.ScaleX, _caseImageViewModel.ActiveRoi.LastPoint.Y * _caseImageViewModel.Transform.ScaleY);
                    }
                }
            }
            _currentTouchDevice = null;
            _movingStartPosition = _emptyPosition;
        }

        private void OnTouchDown(object sender, TouchEventArgs e)
        {
            e.Handled = true;
            var touchPoint = e.GetTouchPoint(ImageGrid);
            var position = touchPoint.Position;
            //DebugDownText.Text = $"Down Device:{touchPoint.TouchDevice.Id} Position:[{touchPoint.Position}]";
            if (_currentTouchDevice == null)
            {
                _currentTouchDevice = e.TouchDevice;
            }
            if (_currentTouchDevice == e.TouchDevice)
            {
                if (_caseImageViewModel != null)
                {
                    if (_caseImageViewModel.ActiveRoi == null)
                    {
                        var id = Guid.NewGuid().ToString("N").ToUpper();
                        var roiViewModel = new RoiViewModel(id, _caseImageViewModel.Transform) { ModifingStart = true };
                        if (_caseImageViewModel.Image != null)
                        {
                            roiViewModel.ParentWidth = _caseImageViewModel.Image.PixelWidth;
                            roiViewModel.ParentHeight = _caseImageViewModel.Image.PixelHeight;
                        }
                        using (roiViewModel.CreateUpdateTranscation())
                        {
                            var startPoint = new Point();
                            startPoint.X = position.X / _caseImageViewModel.Transform.ScaleX;
                            startPoint.Y = position.Y / _caseImageViewModel.Transform.ScaleY;
                            roiViewModel.Points.Add(startPoint);
                            _caseImageViewModel.AddRoi(roiViewModel);
                        }
                        roiViewModel.IsEditing = true;
                        _roiCurrentPosition = position;
                        _isDrawingRoi = true;
                    }
                    else
                    {
                        if (_caseImageViewModel.ActiveRoi.IsEditing)
                        {
                            _caseImageViewModel.ActiveRoi.IsPasued = false;
                            //DebugDownText.Text = $"Down Device:{touchPoint.TouchDevice.Id} Position:[{touchPoint.Position}] MoveStart:[{_movingStartPosition}]";
                        }
                    }
                }
                _movingStartPosition = position;
            }
        }

        private void OnTouchMove(object sender, TouchEventArgs e)
        {
            e.Handled = true;
            var touchPoint = e.GetTouchPoint(ImageGrid);
            //DebugMoveText.Text = $"Device:{touchPoint.TouchDevice.Id} Position:[{touchPoint.Position}] {Environment.NewLine} CurrentDeviceId:{_currentTouchDevice.Id} {Environment.NewLine} IsDrawingRoi:{_isDrawingRoi} {Environment.NewLine} RoiCurrentPosition:{_roiCurrentPosition} {Environment.NewLine} MovingStartPosition:{_movingStartPosition}";
            if (_currentTouchDevice == null)
            {
                _currentTouchDevice = e.TouchDevice;
            }
            if (e.TouchDevice == _currentTouchDevice)
            {
                if (_isDrawingRoi && _movingStartPosition != _emptyPosition)
                {
                    if (_caseImageViewModel.ActiveRoi != null)
                    {
                        var currentTouchPosition = touchPoint.Position;
                        var offset = currentTouchPosition - _movingStartPosition;
                        var roiPosition = new Point(_roiCurrentPosition.X + offset.X, _roiCurrentPosition.Y + offset.Y);
                        if (roiPosition.X > ImageGrid.ActualWidth)
                        {
                            roiPosition.X = ImageGrid.ActualWidth;
                        }
                        if (roiPosition.Y > ImageGrid.ActualHeight)
                        {
                            roiPosition.Y = ImageGrid.ActualHeight;
                        }
                        if (roiPosition.X < 0)
                        {
                            roiPosition.X = 0;
                        }
                        if (roiPosition.Y < 0)
                        {
                            roiPosition.Y = 0;
                        }
                        var roiPoint = new Point(roiPosition.X / _caseImageViewModel.Transform.ScaleX, roiPosition.Y / _caseImageViewModel.Transform.ScaleY);
                        if (_caseImageViewModel.ActiveRoi.ModifingStart)
                        {
                            _caseImageViewModel.ActiveRoi.StartPoint = roiPoint;
                            //DebugMoveText.Text = $"Move Device:{touchPoint.TouchDevice.Id} Position:[{touchPoint.Position}] OffSet:[{offset}] StartPoint:[{roiPoint}] IsDrawing:{_isDrawingRoi}";
                        }
                        else
                        {
                            var lastPoint = _caseImageViewModel.ActiveRoi.LastPoint;
                            var currentStoreRoiPoint = new System.Drawing.Point((int)roiPoint.X, (int)roiPoint.Y);
                            var lastStoreRoiPoint = new System.Drawing.Point((int)lastPoint.X, (int)lastPoint.Y);

                            if (_caseImageViewModel.ActiveRoi.Points.Count == 1 || currentStoreRoiPoint != lastStoreRoiPoint)
                            {
                                _caseImageViewModel.ActiveRoi.Points.Add(roiPoint);
                            }
                            var roiRect = _caseImageViewModel.ActiveRoi.RoiRect;
                            if (!_caseImageViewModel.ActiveRoi.IsPasued)
                            {
                                if (roiRect.Width > 8 && roiRect.Height > 8 && _caseImageViewModel.ActiveRoi.Points.Count > 8)
                                {
                                    var startPoint = _caseImageViewModel.ActiveRoi.StartPoint;
                                    lastPoint = _caseImageViewModel.ActiveRoi.LastPoint;
                                    var startPixelPoint = new Point(startPoint.X * _caseImageViewModel.Transform.ScaleX, startPoint.Y * _caseImageViewModel.Transform.ScaleY);
                                    var lastPixelPoint = new Point(lastPoint.X * _caseImageViewModel.Transform.ScaleX, lastPoint.Y * _caseImageViewModel.Transform.ScaleY);
                                    var vector = lastPixelPoint - startPixelPoint;
                                    if (vector.Length < 8)
                                    {
                                        _caseImageViewModel.ActiveRoi.Points.Add(startPoint);
                                        _caseImageViewModel.ActiveRoi.IsPasued = true;
                                        _isDrawingRoi = false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        private void OnTouchUp(object sender, TouchEventArgs e)
        {
            e.Handled = true;
            if (_isDrawingRoi)
            {
                if (_caseImageViewModel.ActiveRoi != null)
                {
                    _caseImageViewModel.ActiveRoi.IsPasued = true;
                    if (_caseImageViewModel.ActiveRoi.ModifingStart)
                    {
                        _roiCurrentPosition = new Point(_caseImageViewModel.ActiveRoi.StartPoint.X * _caseImageViewModel.Transform.ScaleX, _caseImageViewModel.ActiveRoi.StartPoint.Y * _caseImageViewModel.Transform.ScaleY);
                    }
                    else
                    {
                        _roiCurrentPosition = new Point(_caseImageViewModel.ActiveRoi.LastPoint.X * _caseImageViewModel.Transform.ScaleX, _caseImageViewModel.ActiveRoi.LastPoint.Y * _caseImageViewModel.Transform.ScaleY);
                    }
                }
            }
            if(e.TouchDevice == _currentTouchDevice)
            {
                _currentTouchDevice = null;
            }
            _movingStartPosition = _emptyPosition;
            //DebugDownText.Text = string.Empty;
            //DebugMoveText.Text = string.Empty;
        }



        private void OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            e.Handled = true;
            var position = e.GetPosition(ImageGrid);

            if (_caseImageViewModel != null)
            {
                if (_caseImageViewModel.ActiveRoi == null)
                {
                    var id = Guid.NewGuid().ToString("N").ToUpper();
                    var roiViewModel = new RoiViewModel(id, _caseImageViewModel.Transform) { ModifingStart = true };
                    if (_caseImageViewModel.Image != null)
                    {
                        roiViewModel.ParentWidth = _caseImageViewModel.Image.Width;
                        roiViewModel.ParentHeight = _caseImageViewModel.Image.Height;
                    }
                    using (roiViewModel.CreateUpdateTranscation())
                    {
                        var startPoint = new Point();
                        startPoint.X = position.X / _caseImageViewModel.Transform.ScaleX;
                        startPoint.Y = position.Y / _caseImageViewModel.Transform.ScaleY;
                        roiViewModel.Points.Add(startPoint);
                        _caseImageViewModel.AddRoi(roiViewModel);
                        //DebugDownText.Text = $"Down Device:{touchPoint.TouchDevice.Id} Position:[{touchPoint.Position}] StartPoint:[{startPoint} Transform:[{_caseImageViewModel.Transform.ScaleX}]";
                    }
                    roiViewModel.IsEditing = true;
                    _roiCurrentPosition = position;
                    _isDrawingRoi = true;
                }
                else
                {
                    if (_caseImageViewModel.ActiveRoi.IsEditing)
                    {
                        _caseImageViewModel.ActiveRoi.IsPasued = false;
                        //DebugDownText.Text = $"Down Device:{touchPoint.TouchDevice.Id} Position:[{touchPoint.Position}] MoveStart:[{_movingStartPosition}]";
                    }
                }
            }
            _movingStartPosition = position;
        }

        private void OnMouseMove(object sender, MouseEventArgs e)
        {
            e.Handled = true;
            if (_isDrawingRoi && _movingStartPosition != _emptyPosition)
            {
                if (_caseImageViewModel.ActiveRoi != null)
                {
                    var currentTouchPosition = e.GetPosition(ImageGrid);
                    var offset = currentTouchPosition - _movingStartPosition;
                    var roiPosition = new Point(_roiCurrentPosition.X + offset.X, _roiCurrentPosition.Y + offset.Y);
                    if(roiPosition.X > ImageGrid.ActualWidth)
                    {
                        roiPosition.X = ImageGrid.ActualWidth;
                    }
                    if (roiPosition.Y > ImageGrid.ActualHeight)
                    {
                        roiPosition.Y = ImageGrid.ActualHeight;
                    }
                    if (roiPosition.X < 0 || double.IsNaN(roiPosition.X))
                    {
                        roiPosition.X = 0;
                    }
                    if(roiPosition.Y < 0 || double.IsNaN(roiPosition.Y))
                    {
                        roiPosition.Y = 0;
                    }
                    var roiPoint = new Point(roiPosition.X / _caseImageViewModel.Transform.ScaleX, roiPosition.Y / _caseImageViewModel.Transform.ScaleY);
                    if (_caseImageViewModel.ActiveRoi.ModifingStart)
                    {
                        _caseImageViewModel.ActiveRoi.StartPoint = roiPoint;
                        //DebugMoveText.Text = $"Move Device:{touchPoint.TouchDevice.Id} Position:[{touchPoint.Position}] OffSet:[{offset}] StartPoint:[{roiPoint}] IsDrawing:{_isDrawingRoi}";
                    }
                    else
                    {
                        var lastPoint = _caseImageViewModel.ActiveRoi.LastPoint;
                        var currentStoreRoiPoint = new System.Drawing.Point((int)roiPoint.X, (int)roiPoint.Y);
                        var lastStoreRoiPoint = new System.Drawing.Point((int)lastPoint.X, (int)lastPoint.Y);

                        if (_caseImageViewModel.ActiveRoi.Points.Count == 1 || currentStoreRoiPoint != lastStoreRoiPoint)
                        {
                            _caseImageViewModel.ActiveRoi.Points.Add(roiPoint);
                        }
                        var roiRect = _caseImageViewModel.ActiveRoi.RoiRect;
                        if (!_caseImageViewModel.ActiveRoi.IsPasued)
                        {
                            if (roiRect.Width > 8 && roiRect.Height > 8 && _caseImageViewModel.ActiveRoi.Points.Count > 8)
                            {
                                var startPoint = _caseImageViewModel.ActiveRoi.StartPoint;
                                lastPoint = _caseImageViewModel.ActiveRoi.LastPoint;
                                var startPixelPoint = new Point(startPoint.X * _caseImageViewModel.Transform.ScaleX, startPoint.Y * _caseImageViewModel.Transform.ScaleY);
                                var lastPixelPoint = new Point(lastPoint.X * _caseImageViewModel.Transform.ScaleX, lastPoint.Y * _caseImageViewModel.Transform.ScaleY);
                                var vector = lastPixelPoint - startPixelPoint;
                                if (vector.Length < 8)
                                {
                                    _caseImageViewModel.ActiveRoi.Points.Add(startPoint);
                                    _caseImageViewModel.ActiveRoi.IsPasued = true;
                                    _isDrawingRoi = false;
                                }
                            }
                        }
                    }
                }
            }
        }


        private void OnMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            e.Handled = true;
            if (_isDrawingRoi)
            {
                if (_caseImageViewModel.ActiveRoi != null)
                {
                    _caseImageViewModel.ActiveRoi.IsPasued = true;
                    if (_caseImageViewModel.ActiveRoi.ModifingStart)
                    {
                        _roiCurrentPosition = new Point(_caseImageViewModel.ActiveRoi.StartPoint.X * _caseImageViewModel.Transform.ScaleX, _caseImageViewModel.ActiveRoi.StartPoint.Y * _caseImageViewModel.Transform.ScaleY);
                    }
                    else
                    {
                        _roiCurrentPosition = new Point(_caseImageViewModel.ActiveRoi.LastPoint.X * _caseImageViewModel.Transform.ScaleX, _caseImageViewModel.ActiveRoi.LastPoint.Y * _caseImageViewModel.Transform.ScaleY);
                    }
                }
            }
            _movingStartPosition = _emptyPosition;
            //DebugDownText.Text = string.Empty;
            //DebugMoveText.Text = string.Empty;
        }


        private void OnControlGridSizeChanged(object sender, SizeChangedEventArgs e)
        {
            ImageGrid.Width = double.NaN;
            ImageGrid.Height = double.NaN;
            CanvasScroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
            CanvasScroller.VerticalScrollBarVisibility = ScrollBarVisibility.Disabled;
            UpdateRoiTransform();
        }

        private void OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            if (_caseImageViewModel != null)
            {
                _caseImageViewModel.ImageChanged -= OnImageChanged;
                _caseImageViewModel.Rois.CollectionChanged -= OnRoisCollectionChanged;
                _caseImageViewModel.ActiveRoiChanged -= OnActiveRoiChanged;
            }
            _caseImageViewModel = e.NewValue as CaseImageViewModel;
            if (_caseImageViewModel != null)
            {
                _caseImageViewModel.ImageChanged += OnImageChanged;
                _caseImageViewModel.Rois.CollectionChanged += OnRoisCollectionChanged;
                _caseImageViewModel.ActiveRoiChanged += OnActiveRoiChanged;
            }
        }

        private void OnActiveRoiChanged(object sender, EventArgs e)
        {
            if(_activeRoiViewModel != null)
            {
                _activeRoiViewModel.IsPasuedChanged -= OnActiveRoiIsPasuedChanged;
            }
            UndoRoi.Visibility = Visibility.Collapsed;

            _activeRoiViewModel = _caseImageViewModel.ActiveRoi;

            if (_activeRoiViewModel != null)
            {
                //MeasureSwitch.IsChecked = false;
                _activeRoiViewModel.IsPasuedChanged += OnActiveRoiIsPasuedChanged;
                OnActiveRoiIsPasuedChanged(_activeRoiViewModel, EventArgs.Empty);
                TouchFinish.Visibility = Visibility.Visible;
                TouchDelete.Visibility = Visibility.Visible;
                _roiCurrentPosition = new Point(_caseImageViewModel.ActiveRoi.LastPoint.X * _caseImageViewModel.Transform.ScaleX, _caseImageViewModel.ActiveRoi.LastPoint.Y * _caseImageViewModel.Transform.ScaleY);
            }
            else
            {
                TouchFinish.Visibility = Visibility.Collapsed;
                TouchDelete.Visibility = Visibility.Collapsed;
            }
        }

        private void OnActiveRoiIsPasuedChanged(object sender, EventArgs e)
        {
            if(_activeRoiViewModel.IsEditing && !_activeRoiViewModel.IsPasued)
            {
                //_isDrawingRoi = true;
            }
            if(_activeRoiViewModel.IsPasued && _activeRoiViewModel.Points.Count > 1)
            {
                UndoRoi.Visibility = Visibility.Visible;
            }
            else
            {
                UndoRoi.Visibility = Visibility.Collapsed;
            }
        }

        private void OnRoisCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == NotifyCollectionChangedAction.Reset)
            {
                RoiCanvas.Children.Clear();
            }

            if (e.OldItems != null)
            {
                foreach (var oldItem in e.OldItems)
                {
                    RoiView roiViewToRemove = null;
                    foreach (var child in RoiCanvas.Children)
                    {
                        if (child is RoiView roiView)
                        {
                            if (roiView.DataContext == oldItem)
                            {
                                roiViewToRemove = roiView;
                            }
                        }
                    }

                    if (roiViewToRemove != null)
                    {
                        RoiCanvas.Children.Remove(roiViewToRemove);
                    }
                }
            }
            if (e.NewItems != null)
            {
                foreach (var newItem in e.NewItems)
                {
                    if (newItem is RoiViewModel roiViewModel)
                    {
                        var roiView = new RoiView();
                        roiView.DataContext = newItem;
                        RoiCanvas.Children.Add(roiView);
                    }
                }
            }
        }


        private void OnImageChanged(object sender, EventArgs e)
        {
            if (_caseImageViewModel != null)
            {
                if (_caseImageViewModel.Image != null)
                {
                    CanvasScroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
                    CanvasScroller.VerticalScrollBarVisibility = ScrollBarVisibility.Disabled;
                    ImageGrid.Width = double.NaN;
                    ImageGrid.Height = double.NaN;
                    UpdateRoiTransform();
                }

                if (_caseImageViewModel.CaseImage is ImportedCaseImage)
                {
                    ImageGrid.IsEnabled = false;
                }
                else
                {
                    ImageGrid.IsEnabled = true;
                }
            }
        }


        private void OnRoiCanvasSizeChanged(object sender, SizeChangedEventArgs e)
        {
            UpdateRoiTransform();
        }


        private void UpdateRoiTransform()
        {
            if (_caseImageViewModel != null)
            {
                if (_caseImageViewModel.Image != null)
                {
                    var imageWidth = _caseImageViewModel.Image.PixelWidth;
                    var imageHeight = _caseImageViewModel.Image.PixelHeight;
                    var canvasWidth = RoiCanvas.ActualWidth;
                    var canvasHeight = RoiCanvas.ActualHeight;
                    var scaleX = canvasWidth / imageWidth;
                    var scaleY = canvasHeight / imageHeight;
                    var newTransform = new ScaleTransform(scaleX, scaleY, 0, 0);
                    if (_caseImageViewModel.Transform != null)
                    {
                        var roiCurrentPoint = new Point(_roiCurrentPosition.X / _caseImageViewModel.Transform.ScaleX, _roiCurrentPosition.Y / _caseImageViewModel.Transform.ScaleY);
                        var movingStartPoint = new Point(_movingStartPosition.X / _caseImageViewModel.Transform.ScaleX, _movingStartPosition.Y / _caseImageViewModel.Transform.ScaleY);
                        _roiCurrentPosition.X = roiCurrentPoint.X * newTransform.ScaleX;
                        _roiCurrentPosition.Y = roiCurrentPoint.Y * newTransform.ScaleY;
                        _movingStartPosition.X = movingStartPoint.X * newTransform.ScaleX;
                        _movingStartPosition.Y = movingStartPoint.Y * newTransform.ScaleY;
                    }

                    _caseImageViewModel.Transform = newTransform;
                    _currentScale = imageWidth < imageHeight ? scaleX : scaleY;
                    CurrentScale.Text = $"缩放:{(int)(_currentScale * 100)}%";
                }
            }
        }


        //private void OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        //{
        //    if (_isMeasuring)
        //    {
        //        _rulerPath.Data = null;
        //        _rulerPath.InvalidateVisual();

        //        _measuredValueText.Text = "0 px";

        //        _measureStartPoint = e.GetPosition(ImageGrid);

        //        if (!RoiCanvas.Children.Contains(_rulerPath))
        //        {
        //            RoiCanvas.Children.Add(_rulerPath);
        //        }
        //        if (!RoiCanvas.Children.Contains(_measuredValue))
        //        {
        //            RoiCanvas.Children.Add(_measuredValue);
        //        }
        //    }
        //    else
        //    {
        //        if (_caseImageViewModel != null)
        //        {
        //            _isDrawingRoi = true;
        //            var id = Guid.NewGuid().ToString("N").ToUpper();
        //            var position = e.GetPosition(ImageGrid);
        //            var roiViewModel = new RoiViewModel(id, _caseImageViewModel.Transform);
        //            if (_caseImageViewModel.Image != null)
        //            {
        //                roiViewModel.ParentWidth = _caseImageViewModel.Image.Width;
        //                roiViewModel.ParentHeight = _caseImageViewModel.Image.Height;
        //            }
        //            using (roiViewModel.CreateUpdateTranscation())
        //            {
        //                var startPoint = new Point();
        //                startPoint.X = position.X / _caseImageViewModel.Transform.ScaleX;
        //                startPoint.Y = position.Y / _caseImageViewModel.Transform.ScaleY;
        //                roiViewModel.Points.Add(startPoint);
        //                _caseImageViewModel.AddRoi(roiViewModel);
        //            }
        //            roiViewModel.IsEditing = true;
        //        }
        //    }
        //}

        //private void OnMouseMove(object sender, MouseEventArgs e)
        //{
        //    if (_isMeasuring)
        //    {
        //        var currentPoint = e.GetPosition(ImageGrid);

        //        var line = new LineGeometry
        //        {
        //            StartPoint = _measureStartPoint,
        //            EndPoint = currentPoint
        //        };
        //        _rulerPath.Data = line;
        //        _rulerPath.InvalidateVisual();


        //        var vector1 = new Vector(_measureStartPoint.X / _caseImageViewModel.Transform.ScaleX,
        //            _measureStartPoint.Y / _caseImageViewModel.Transform.ScaleY);
        //        var vector2 = new Vector(currentPoint.X / _caseImageViewModel.Transform.ScaleX,
        //            currentPoint.Y / _caseImageViewModel.Transform.ScaleY);

        //        var length = Math.Abs((vector2 - vector1).Length);
        //        _measuredValueText.Text = $"{(int)length} px";

        //        var height = _measuredValue.ActualHeight;
        //        Canvas.SetLeft(_measuredValue, currentPoint.X);
        //        Canvas.SetTop(_measuredValue, currentPoint.Y - height - 2);
        //    }
        //    else if (_isDrawingRoi)
        //    {
        //        var currentPixelPoint = e.GetPosition(ImageGrid);
        //        var roiPoint = new Point(currentPixelPoint.X / _caseImageViewModel.Transform.ScaleX, currentPixelPoint.Y / _caseImageViewModel.Transform.ScaleY);
        //        var lastPoint = _caseImageViewModel.ActiveRoi.Points.Last();

        //        var currentStoreRoiPoint = new System.Drawing.Point((int)roiPoint.X, (int)roiPoint.Y);
        //        var lastStoreRoiPoint = new System.Drawing.Point((int)lastPoint.X, (int)lastPoint.Y);
        //        if (currentStoreRoiPoint != lastStoreRoiPoint)
        //        {
        //            _caseImageViewModel.ActiveRoi.Points.Add(roiPoint);
        //        }
        //        var roiRect = _caseImageViewModel.ActiveRoi.RoiRect;
        //        if (!_caseImageViewModel.ActiveRoi.IsPasued)
        //        {
        //            if (roiRect.Width > 8 && roiRect.Height > 8)
        //            {
        //                var startPoint = _caseImageViewModel.ActiveRoi.Points[0];
        //                var startPixelPoint = new Point(startPoint.X * _caseImageViewModel.Transform.ScaleX, startPoint.Y * _caseImageViewModel.Transform.ScaleY);
        //                var vector = currentPixelPoint - startPixelPoint;
        //                if (vector.Length < 8)
        //                {
        //                    var startScreenPosition = ImageGrid.PointToScreen(startPixelPoint);
        //                    SetCursorPos((int)startScreenPosition.X, (int)startScreenPosition.Y);
        //                }
        //            }
        //            if (roiPoint == _caseImageViewModel.ActiveRoi.Points[0])
        //            {
        //                _caseImageViewModel.ActiveRoi.IsPasued = true;
        //                _isDrawingRoi = false;
        //            }
        //        }
        //    }
        //}

        //private void OnMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        //{
        //    if (_isMeasuring)
        //    {
        //        RoiCanvas.Children.Remove(_measuredValue);
        //        RoiCanvas.Children.Remove(_rulerPath);
        //    }
        //    else if(_isDrawingRoi)
        //    {
        //        if(_caseImageViewModel.ActiveRoi != null)
        //        {
        //            _caseImageViewModel.ActiveRoi.IsPasued = true;
        //        }
        //        _isDrawingRoi = false;
        //    }
        //}

        //private void OnMeasureChecked(object sender, RoutedEventArgs e)
        //{
        //    if (_caseImageViewModel != null && _caseImageViewModel.ActiveRoi != null)
        //    {
        //        MeasureSwitch.IsChecked = false;
        //    }
        //    else
        //    {
        //        _isMeasuring = true;
        //    }
        //}

        //private void OnMeasureUnchecked(object sender, RoutedEventArgs e)
        //{
        //    _isMeasuring = false;
        //    RoiCanvas.Children.Remove(_measuredValue);
        //    RoiCanvas.Children.Remove(_rulerPath);
        //}

        private void OnImageGridMouseWheel(object sender, MouseWheelEventArgs e)
        {
            if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
            {
                e.Handled = true;
                var wheelPosition = e.GetPosition(ControlGrid);
                var step = e.Delta > 0 ? 5 : -5;
                if(step > 0)
                {
                    if (_currentScale >= 4)
                    {
                        return;
                    }
                }
                var increaseScale = (double)(step) / 100;
                var scale = increaseScale + _currentScale;
                if(scale > 4)
                {
                    scale = 4;
                }
                var newWidth = _caseImageViewModel.Image.PixelWidth * scale;
                var newHeight = _caseImageViewModel.Image.PixelHeight * scale;
                var ratio = newWidth / newHeight;

                if (ControlGrid.ActualWidth < ControlGrid.ActualHeight)
                {
                    if (newWidth < ControlGrid.ActualWidth)
                    {
                        newWidth = ControlGrid.ActualWidth;
                        newHeight = newWidth / ratio;
                        if (newHeight > ControlGrid.ActualHeight)
                        {
                            newHeight = ControlGrid.ActualHeight;
                            newWidth = newHeight * ratio;
                        }
                    }
                }
                else
                {
                    if (newHeight < ControlGrid.ActualHeight)
                    {
                        newHeight = ControlGrid.ActualHeight;
                        newWidth = newHeight * ratio;
                        if (newWidth > ControlGrid.ActualWidth)
                        {
                            newWidth = ControlGrid.ActualWidth;
                            newHeight = newWidth / ratio;
                        }
                    }
                }


                var newY = wheelPosition.Y / ImageGrid.ActualHeight * newHeight;

                ImageGrid.Width = newWidth;
                ImageGrid.Height = newHeight;

                //var increaseWidth = _caseImageViewModel.Image.Width * (_currentScale - 1);
                //var increaseHeight = _caseImageViewModel.Image.Height * increaseScale;

                var offsetX = 0;// CanvasScroller.HorizontalOffset +increaseWidth;
                var offsetY = 0;// CanvasScroller.VerticalOffset + wheelPosition.Y - increaseHeight;


                if (ControlGrid.ActualWidth < ImageGrid.ActualWidth)
                {
                    CanvasScroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Visible;
                    if (offsetX > 0)
                    {
                        CanvasScroller.ScrollToHorizontalOffset(offsetX);
                    }
                }
                else
                {
                    CanvasScroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
                }

                if (ControlGrid.ActualHeight < ImageGrid.ActualHeight)
                {
                    CanvasScroller.VerticalScrollBarVisibility = ScrollBarVisibility.Visible;
                    if (offsetY > 0)
                    {
                        CanvasScroller.ScrollToVerticalOffset(offsetY);
                    }
                }
                else
                {
                    CanvasScroller.VerticalScrollBarVisibility = ScrollBarVisibility.Disabled;
                }
            }
        }

        private void OnResetScaleClick(object sender, RoutedEventArgs e)
        {
            ImageGrid.Width = double.NaN;
            ImageGrid.Height = double.NaN;
            CanvasScroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
            CanvasScroller.VerticalScrollBarVisibility = ScrollBarVisibility.Disabled;
        }


        private void OnUndoRoiClick(object sender, RoutedEventArgs e)
        {
            if (_caseImageViewModel.ActiveRoi != null && _caseImageViewModel.ActiveRoi.Points.Count >= 7)
            {
                e.Handled = true;
                var lastPoint = _caseImageViewModel.ActiveRoi.LastPoint;
                _caseImageViewModel.ActiveRoi.Points.Remove(lastPoint);
                lastPoint = _caseImageViewModel.ActiveRoi.LastPoint;
                _caseImageViewModel.ActiveRoi.Points.Remove(lastPoint);
                lastPoint = _caseImageViewModel.ActiveRoi.LastPoint;
                _caseImageViewModel.ActiveRoi.Points.Remove(lastPoint);
                lastPoint = _caseImageViewModel.ActiveRoi.LastPoint;
                _caseImageViewModel.ActiveRoi.Points.Remove(lastPoint);
                lastPoint = _caseImageViewModel.ActiveRoi.LastPoint;
                _roiCurrentPosition = new Point(lastPoint.X * _caseImageViewModel.Transform.ScaleX, lastPoint.Y * _caseImageViewModel.Transform.ScaleY);
                _isDrawingRoi = true;
            }
        }

        private void OnTouchFinishClick(object sender, RoutedEventArgs e)
        {
            if(_caseImageViewModel.ActiveRoi != null)
            {
                if(_caseImageViewModel.ActiveRoi.ModifingStart)
                {
                    _caseImageViewModel.ActiveRoi.ModifingStart = false;
                }
                else
                {
                    _caseImageViewModel.ActiveRoi.Finish();
                }
            }
        }

        private void OnTouchDeleteClick(object sender, RoutedEventArgs e)
        {
            if (_caseImageViewModel.ActiveRoi != null)
            {
                _caseImageViewModel.ActiveRoi.Delete();
            }
        }

        private void OnZoomOutClick(object sender, RoutedEventArgs e)
        {
            if (_caseImageViewModel == null || _caseImageViewModel.Image == null) return;
            var step = -5;
            var increaseScale = (double)(step) / 100;
            var scale = increaseScale + _currentScale;
            var newWidth = _caseImageViewModel.Image.PixelWidth * scale;
            var newHeight = _caseImageViewModel.Image.PixelHeight * scale;
            var ratio = newWidth / newHeight;

            if (ControlGrid.ActualWidth < ControlGrid.ActualHeight)
            {
                if (newWidth < ControlGrid.ActualWidth)
                {
                    newWidth = ControlGrid.ActualWidth;
                    newHeight = newWidth / ratio;
                    if (newHeight > ControlGrid.ActualHeight)
                    {
                        newHeight = ControlGrid.ActualHeight;
                        newWidth = newHeight * ratio;
                    }
                }
            }
            else
            {
                if (newHeight < ControlGrid.ActualHeight)
                {
                    newHeight = ControlGrid.ActualHeight;
                    newWidth = newHeight * ratio;
                    if (newWidth > ControlGrid.ActualWidth)
                    {
                        newWidth = ControlGrid.ActualWidth;
                        newHeight = newWidth / ratio;
                    }
                }
            }

            ImageGrid.Width = newWidth;
            ImageGrid.Height = newHeight;

            if (ControlGrid.ActualWidth < ImageGrid.ActualWidth)
            {
                CanvasScroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Visible;
            }
            else
            {
                CanvasScroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
            }

            if (ControlGrid.ActualHeight < ImageGrid.ActualHeight)
            {
                CanvasScroller.VerticalScrollBarVisibility = ScrollBarVisibility.Visible;
            }
            else
            {
                CanvasScroller.VerticalScrollBarVisibility = ScrollBarVisibility.Disabled;
            }
        }

        private void OnZoomInClick(object sender, RoutedEventArgs e)
        {
            if(_caseImageViewModel == null || _caseImageViewModel.Image == null) return;
            if (_currentScale >= 4)
            {
                return;
            }
            var step = 5;
            var increaseScale = (double)(step) / 100;
            var scale = increaseScale + _currentScale;
            if(scale > 4)
            {
                scale = 4;
            }
            var newWidth = _caseImageViewModel.Image.PixelWidth * scale;
            var newHeight = _caseImageViewModel.Image.PixelHeight * scale;
            var ratio = newWidth / newHeight;

            ImageGrid.Width = newWidth;
            ImageGrid.Height = newHeight;

            if (ControlGrid.ActualWidth < ImageGrid.ActualWidth)
            {
                CanvasScroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Visible;
            }
            else
            {
                CanvasScroller.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
            }

            if (ControlGrid.ActualHeight < ImageGrid.ActualHeight)
            {
                CanvasScroller.VerticalScrollBarVisibility = ScrollBarVisibility.Visible;
            }
            else
            {
                CanvasScroller.VerticalScrollBarVisibility = ScrollBarVisibility.Disabled;
            }
        }
    }
}