From 47b8d60c529f5893419b37517fc53ff78520c079 Mon Sep 17 00:00:00 2001
From: Alek-ban <alek.kovkov124@gmail.com>
Date: Fri, 6 Feb 2026 17:19:57 +0300
Subject: [PATCH] feat: OpenCvImage

---
 GSS2.Test/ViewModels/MainViewModel.cs |  13 +-
 GSS2.Test/Views/MainView.axaml        |   9 +-
 GSS2.UI.Core/OpenCvImage.cs           | 275 ++++++++++++++++++++++++++
 3 files changed, 293 insertions(+), 4 deletions(-)
 create mode 100644 GSS2.UI.Core/OpenCvImage.cs

diff --git a/GSS2.Test/ViewModels/MainViewModel.cs b/GSS2.Test/ViewModels/MainViewModel.cs
index 5a0823e..6ace3be 100644
--- a/GSS2.Test/ViewModels/MainViewModel.cs
+++ b/GSS2.Test/ViewModels/MainViewModel.cs
@@ -1,5 +1,7 @@
 using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
 
+using GSS2.Core.Hardware;
 using GSS2.UI.Core.ViewModels;
 
 namespace GSS2.Test.ViewModels;
@@ -7,14 +9,23 @@ namespace GSS2.Test.ViewModels;
 public partial class MainViewModel : ViewModelBase
 {
     private readonly ILogger<MainViewModel> _logger;
+    private readonly CameraService _cameraService;
     [ObservableProperty] private CameraViewModel _cameraViewModel;
     [ObservableProperty] private ResourcesViewModel _resourcesViewModel;
+    [ObservableProperty] private OpenCvSharp.Mat? _image;
+    [ObservableProperty] private IRelayCommand _buttonClick;
 
-    public MainViewModel(ILogger<MainViewModel> logger, CameraViewModel cameraViewModel, ResourcesViewModel resourcesViewModel)
+    public MainViewModel(ILogger<MainViewModel> logger, CameraViewModel cameraViewModel, ResourcesViewModel resourcesViewModel, CameraService cameraService)
     {
         _logger = logger;
+        _cameraService = cameraService;
         CameraViewModel = cameraViewModel;
         ResourcesViewModel = resourcesViewModel;
+        ButtonClick = new RelayCommand(() =>
+        {
+            cameraService.CaptureImage(CancellationToken.None, 10).ContinueWith(image => Image = image.Result);
+        });
+
         _logger.LogInformation("{} initialized", nameof(MainViewModel));
     }
 }
\ No newline at end of file
diff --git a/GSS2.Test/Views/MainView.axaml b/GSS2.Test/Views/MainView.axaml
index 75b0bbb..3dc275f 100644
--- a/GSS2.Test/Views/MainView.axaml
+++ b/GSS2.Test/Views/MainView.axaml
@@ -3,10 +3,13 @@
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:local_vm="using:GSS2.Test.ViewModels"
              xmlns:core_vm="using:GSS2.UI.Core.ViewModels"
+             xmlns:core="using:GSS2.UI.Core"
              x:DataType="local_vm:MainViewModel"
              x:Class="GSS2.Test.Views.MainView">
-    <Grid RowDefinitions="*,*">
-        <ContentControl Grid.Row="0" VerticalAlignment="Stretch" HorizontalAlignment="Stretch" Content="{Binding CameraViewModel}" />
-        <ContentControl Grid.Row="1" VerticalAlignment="Stretch" HorizontalAlignment="Stretch" Content="{Binding ResourcesViewModel}" />
+    <Grid ColumnDefinitions="*,Auto">
+        <core:OpenCvImage Grid.Column="0" Image="{Binding Image}" />
+        <Button Grid.Column="1" Width="50" VerticalAlignment="Stretch" Command="{Binding ButtonClick}"/>
+        <!-- <ContentControl Grid.Row="0" VerticalAlignment="Stretch" HorizontalAlignment="Stretch" Content="{Binding CameraViewModel}" /> -->
+        <!-- <ContentControl Grid.Row="1" VerticalAlignment="Stretch" HorizontalAlignment="Stretch" Content="{Binding ResourcesViewModel}" /> -->
     </Grid>
 </UserControl>
\ No newline at end of file
diff --git a/GSS2.UI.Core/OpenCvImage.cs b/GSS2.UI.Core/OpenCvImage.cs
new file mode 100644
index 0000000..ca3d332
--- /dev/null
+++ b/GSS2.UI.Core/OpenCvImage.cs
@@ -0,0 +1,275 @@
+using Avalonia;
+using Avalonia.Media;
+using Avalonia.Input;
+using Avalonia.Controls;
+using Avalonia.Media.Imaging;
+
+using Mat = OpenCvSharp.Mat;
+using Cv2 = OpenCvSharp.Cv2;
+
+namespace GSS2.UI.Core;
+
+public class OpenCvImage : Control
+{
+    private class OpenCvBitmap : Bitmap
+    {
+        public OpenCvBitmap(Mat mat)
+        : base(
+            format: Avalonia.Platform.PixelFormat.Rgba8888,
+            alphaFormat: Avalonia.Platform.AlphaFormat.Unpremul,
+            data: mat.Data,
+            size: new PixelSize(mat.Width, mat.Height),
+            dpi: new Vector(96, 96),
+            stride: (mat.DataEnd - mat.DataStart).ToInt32() / mat.Rows
+        )
+        { }
+    }
+
+    private Point? _lastPosition = null;
+    private float _zoom = 1;
+    private float _panX = 0;
+    private float _panY = 0;
+    private OpenCvBitmap? _bitmap = null;
+
+    public static readonly StyledProperty<Color> BackgroundProperty = AvaloniaProperty.Register<OpenCvImage, Color>(nameof(Background), defaultValue: Colors.Transparent);
+    public Color Background
+    {
+        get => GetValue(BackgroundProperty);
+        set => SetValue(BackgroundProperty, value);
+    }
+    public static readonly StyledProperty<Stretch> StretchModeProperty = AvaloniaProperty.Register<OpenCvImage, Stretch>(nameof(StretchMode), defaultValue: Stretch.Uniform);
+    public Stretch StretchMode
+    {
+        get => GetValue(StretchModeProperty);
+        set => SetValue(StretchModeProperty, value);
+    }
+    public static readonly StyledProperty<TileMode> TileModeProperty = AvaloniaProperty.Register<OpenCvImage, TileMode>(nameof(TileMode), defaultValue: TileMode.None);
+    public TileMode TileMode
+    {
+        get => GetValue(TileModeProperty);
+        set => SetValue(TileModeProperty, value);
+    }
+    public static readonly StyledProperty<Mat?> ImageProperty = AvaloniaProperty.Register<OpenCvImage, Mat?>(nameof(Image), defaultValue: null);
+    public Mat? Image
+    {
+        get => GetValue(ImageProperty);
+        set => SetValue(ImageProperty, value);
+    }
+
+    public OpenCvImage()
+    : base()
+    { }
+
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        if (change.Property == ImageProperty)
+        {
+            _bitmap?.Dispose();
+            _bitmap = null;
+
+            if (Image is null)
+                return;
+
+            if (Image.Type() != OpenCvSharp.MatType.CV_8UC3 &&
+                Image.Type() != OpenCvSharp.MatType.CV_8UC4 &&
+                Image.Type() != OpenCvSharp.MatType.CV_16UC3 &&
+                Image.Type() != OpenCvSharp.MatType.CV_16UC4)
+                return;
+
+            var image = new Mat();
+            Image.CopyTo(image);
+
+            if (image.Type() == OpenCvSharp.MatType.CV_16UC3)
+                image.ConvertTo(image, OpenCvSharp.MatType.CV_8UC3, 1 / 256.0);
+            if (image.Type() == OpenCvSharp.MatType.CV_16UC4)
+                image.ConvertTo(image, OpenCvSharp.MatType.CV_8UC4, 1 / 256.0);
+
+            var channels = image.Split();
+            var alphaChannel = image.Channels() == 4 ? channels[4] : new Mat(Image.Size(), OpenCvSharp.MatType.CV_8UC1, new OpenCvSharp.Scalar(255));
+            Cv2.Merge([channels[2], channels[0], channels[1], alphaChannel], image);
+
+            _bitmap = new OpenCvBitmap(image);
+
+            InvalidateVisual();
+        }
+        base.OnPropertyChanged(change);
+    }
+
+    protected override void OnPointerWheelChanged(PointerWheelEventArgs ea)
+    {
+        if (ea.Pointer.Type == PointerType.Mouse)
+        {
+            var position = ea.GetPosition(this);
+
+            // Рассчитываем позицию в координатах изображения (до масштабирования)
+            var imageX = (position.X - Bounds.Width / 2 - _panX) / _zoom;
+            var imageY = (position.Y - Bounds.Height / 2 - _panY) / _zoom;
+
+            // Применяем масштаб
+            float zoomFactor = ea.Delta.Y > 0 ? 1.1f : 1 / 1.1f;
+            _zoom *= zoomFactor;
+            _zoom = Math.Clamp(_zoom, 1f, 10f);
+            _zoom = (float)Math.Round(_zoom, 2);
+
+            if (_zoom != 1f)
+            {
+                // Пересчитываем смещение так, чтобы указатель остался на месте
+                _panX = (float)(position.X - Bounds.Width / 2 - imageX * _zoom);
+                _panY = (float)(position.Y - Bounds.Height / 2 - imageY * _zoom);
+            }
+            else
+            {
+                // Если зум == 1, то возвращаем изображение к исходному смещению
+                _panX = 0f;
+                _panY = 0f;
+            }
+        }
+        else if (ea.Pointer.Type == PointerType.Touch)
+        {
+            Console.WriteLine(string.Format("PointerWheelChanged Type Touch {} {}", ea.GetPosition(this), ea.Delta));
+        }
+        base.OnPointerWheelChanged(ea);
+        InvalidateVisual();
+    }
+    protected override void OnPointerPressed(PointerPressedEventArgs ea)
+    {
+        if (ea.Pointer.Type == PointerType.Mouse)
+        {
+            if (ea.Properties.IsLeftButtonPressed)
+            {
+                if (ea.ClickCount == 2) // По двойному клику возвращаем изображение к смещение и зум к стандартным значениям
+                {
+                    _zoom = 1f;
+                    _panX = 0f;
+                    _panY = 0f;
+                }
+                else
+                    _lastPosition = ea.GetPosition(this);
+            }
+        }
+        else if (ea.Pointer.Type == PointerType.Touch)
+        {
+
+        }
+        base.OnPointerPressed(ea);
+        InvalidateVisual();
+    }
+    protected override void OnPointerReleased(PointerReleasedEventArgs ea)
+    {
+        if (ea.Pointer.Type == PointerType.Mouse)
+        {
+            if (!ea.Properties.IsLeftButtonPressed)
+                _lastPosition = null;
+        }
+        else if (ea.Pointer.Type == PointerType.Touch)
+        {
+
+        }
+        base.OnPointerReleased(ea);
+        InvalidateVisual();
+    }
+    protected override void OnPointerMoved(PointerEventArgs ea)
+    {
+        if (ea.Pointer.Type == PointerType.Mouse)
+        {
+            if (_lastPosition is null || _zoom == 1) // Если кнопка не нажата или зум == 1, то ничего не делаем
+            {
+                base.OnPointerMoved(ea);
+                return;
+            }
+            var position = ea.GetPosition(this);
+            _panX -= (float)(_lastPosition.Value.X - position.X);
+            _panY -= (float)(_lastPosition.Value.Y - position.Y);
+            _lastPosition = position;
+            base.OnPointerMoved(ea);
+        }
+        else if (ea.Pointer.Type == PointerType.Touch)
+        {
+
+        }
+        InvalidateVisual();
+    }
+
+    public override void Render(DrawingContext context)
+    {
+        context.FillRectangle(new SolidColorBrush(Background), new Rect(0, 0, Bounds.Width, Bounds.Height));
+        if (_bitmap is null)
+        {
+            base.Render(context);
+            return;
+        }
+
+        var (sx, sy) = ComputeStretchScale(StretchMode, _bitmap.PixelSize.Width, _bitmap.PixelSize.Height);
+        sx *= _zoom;
+        sy *= _zoom;
+
+        var drawWidth = _bitmap.PixelSize.Width * sx;
+        var drawHeight = _bitmap.PixelSize.Height * sy;
+        var destRect = new Rect((Bounds.Width - drawWidth) / 2 + _panX, (Bounds.Height - drawHeight) / 2 + _panY, drawWidth, drawHeight);
+
+        var srcRect = ComputeSourceRect(TileMode, _bitmap.PixelSize.Width, _bitmap.PixelSize.Height);
+
+        context.DrawImage(_bitmap, srcRect, destRect);
+
+        base.Render(context);
+    }
+
+    private (double sx, double sy) ComputeStretchScale(Stretch stretch, double imageWidth, double imageHeight)
+    {
+        double viewWidth = Bounds.Width;
+        double viewHeight = Bounds.Height;
+
+        var viewAspect = viewWidth / viewHeight;
+        var imageAspect = imageWidth / imageHeight;
+
+        switch (stretch)
+        {
+            case Stretch.None:
+                return (1, 1);
+            case Stretch.Fill:
+                return (viewWidth / imageWidth, viewHeight / imageHeight);
+            case Stretch.Uniform:
+                if (imageAspect > viewAspect)
+                {
+                    var s = viewWidth / imageWidth;
+                    return (s, s);
+                }
+                else
+                {
+                    var s = viewHeight / imageHeight;
+                    return (s, s);
+                }
+            case Stretch.UniformToFill:
+                if (imageAspect > viewAspect)
+                {
+                    var s = viewHeight / imageHeight;
+                    return (s, s);
+                }
+                else
+                {
+                    var s = viewWidth / imageWidth;
+                    return (s, s);
+                }
+            default:
+                return (1, 1);
+        }
+    }
+    private Rect ComputeSourceRect(TileMode mode, int imageWidth, int imageHeight)
+    {
+        switch (mode)
+        {
+            case TileMode.None:
+                return new Rect(0, 0, imageWidth, imageHeight);
+            case TileMode.Tile:
+                return new Rect(0, 0, imageWidth * 2, imageHeight * 2);
+            case TileMode.FlipX:
+                return new Rect(imageWidth, 0, -imageWidth, imageHeight);
+            case TileMode.FlipY:
+                return new Rect(0, imageHeight, imageWidth, -imageHeight);
+            case TileMode.FlipXY:
+                return new Rect(imageWidth, imageHeight, -imageWidth, -imageHeight);
+            default:
+                return new Rect(0, 0, imageWidth, imageHeight);
+        }
+    }
+}
\ No newline at end of file