vStationURM/Tools/VidTool/MainWindow.xaml.cs

using System;
using System.Drawing;
using System.IO;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Forms;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using Vinno.vCloud.Common.Vid2;
using Vinno.vCloud.Common.Vid2.Visuals;
using System.Drawing.Imaging;
using SkiaSharp;
using Vinno.vCloud.Common.Vid2.Codec;

namespace VidTool
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private VinnoImageData _opendVinnoImageData;
        private int _currentIndex;
        private readonly DispatcherTimer _playTimer;

        public MainWindow()
        {
            InitializeComponent();
            _playTimer = new DispatcherTimer();
            _playTimer.Tick += PlayTimerOnTick;
            PlayButton.IsEnabled = false;
            PauseButton.IsEnabled = false;
            NextButton.IsEnabled = false;
            PreviousButton.IsEnabled = false;
        }


        private void OnEncodeClick(object sender, RoutedEventArgs e)
        {
            var dialog = new FolderBrowserDialog();
            if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                var foldPath = dialog.SelectedPath;
                var files = Directory.GetFiles(foldPath, "*.bmp");
                if (files.Length > 0)
                {
                    var encoder = new VinnoImageEncoder(0.8f, 0.8f);
                    var filePath = Path.Combine(foldPath, "test.vid");
                    var imageData = new VinnoImageData(filePath, OperationMode.Create);
                    var probe = new VinnoProbe("G1-4PX", VinnoProbeType.Sector, new VinnoApplication("Adult1", string.Empty, "Adult1", "CARD", false), 30);
                    imageData.AddProbe(probe);
                    foreach (var file in files)
                    {
                        var bmp = new Bitmap(file);
                        using (var stream = new MemoryStream())
                        {
                            bmp.Save(stream, ImageFormat.Jpeg);
                            var skipBitMap = SKBitmap.Decode(stream);
                            var image = encoder.Encode(skipBitMap);
                            bmp.Dispose();
                            var visual = new Vinno2DVisual();
                            visual.Modes.Add(new VinnoMode("HAR", "HAR", VinnoModeType.Tissue));
                            visual.ActiveModeType = VinnoModeType.Tissue;
                            var physicalCoordinateInfo = new VinnoConvexTissuePhysicalCoordinate(15.99, 0, 80, 0, 0.11);
                            var logicalCoordinateInfo = new VinnoLogicalCoordinate(true, false, new VinnoRect(-12.04, -0.025, 24.08, 16.02), VinnoUnit.cm, VinnoUnit.cm);
                            visual.PhysicalCoordinates.Add(VinnoVisualAreaType.Tissue, physicalCoordinateInfo);
                            visual.LogicalCoordinates.Add(VinnoVisualAreaType.Tissue, logicalCoordinateInfo);
                            image.Visuals.Add(visual);
                            imageData.AddImage(image);
                            skipBitMap.Dispose();
                        }
                           
                    }
                    imageData.Dispose();
                    System.Windows.MessageBox.Show("Encode finished.");
                }
            }

        }

        private BitmapSource BitmapToBitmapSource(byte[] bytes)
        {
            var bitmapImage = new BitmapImage();
            bitmapImage.BeginInit();
            bitmapImage.StreamSource = new MemoryStream(bytes);
            bitmapImage.EndInit();
            return bitmapImage;
        }


        private void Play(int index)
        {
            if (_opendVinnoImageData != null)
            {
                if (index > _opendVinnoImageData.ImageCount - 1)
                {
                    index = 0;
                }
                if (index < 0)
                {
                    index = 0;
                }

                var vinnoImage = _opendVinnoImageData.GetImage(index);
                DisplayImage.Source = BitmapToBitmapSource(vinnoImage.ImageData);

                Properties.Items.Clear();

                var probeNameNode = new TreeViewItem { Header = $"Name: {_opendVinnoImageData.Probe.Name}" };
                var probeTypeNode = new TreeViewItem { Header = $"Type: {_opendVinnoImageData.Probe.Type}" };
                var probeApplicationNode = new TreeViewItem { Header = $"Application: {_opendVinnoImageData.Probe.Application.ApplicationCategoryName}-{_opendVinnoImageData.Probe.Application.ApplicationName}" };
                var frameRateNode = new TreeViewItem { Header = $"Framerate: {_opendVinnoImageData.Probe.FrameRate}" };
                var probeNode = new TreeViewItem { Header = "Probe" };
                probeNode.Items.Add(probeNameNode);
                probeNode.Items.Add(probeTypeNode);
                probeNode.Items.Add(probeApplicationNode);
                probeNode.Items.Add(frameRateNode);
                probeNode.IsExpanded = true;

                var indexNode = new TreeViewItem { Header = $"Index: {vinnoImage.Index}" };
                var widthNode = new TreeViewItem { Header = $"Width: {vinnoImage.Width}" };
                var heightNode = new TreeViewItem { Header = $"Height: {vinnoImage.Height}" };
                var visualsNode = new TreeViewItem { Header = "Visuals" };
                foreach (var visual in vinnoImage.Visuals)
                {
                    var visualNode = new TreeViewItem { Header = $"Visual - {visual.Indicator}" };
                    var displayModeNode = new TreeViewItem { Header = $"DisplayMode: {visual.DisplayMode}" };
                    var activeModeNode = new TreeViewItem { Header = $"ActiveModeType: {visual.ActiveModeType}" };
                    var modesNode = new TreeViewItem() { Header = "Modes" };
                    foreach (var mode in visual.Modes)
                    {
                        var modeNameNode = new TreeViewItem { Header = $"ActiveModeType: {mode.DisplayName}" };
                        var modeTypeNode = new TreeViewItem { Header = $"Type: {mode.Type}" };
                        modesNode.Items.Add(modeNameNode);
                        modesNode.Items.Add(modeTypeNode);
                    }
                    modesNode.IsExpanded = true;
                    visualNode.Items.Add(displayModeNode);
                    visualNode.Items.Add(activeModeNode);
                    visualNode.Items.Add(modesNode);

                    if (visual is Vinno2DVisual v2D)
                    {
                        var physicalCoordinatesNode = new TreeViewItem() { Header = "PhysicalCoordinates" };
                        foreach (var physicalCoordinate in v2D.PhysicalCoordinates)
                        {
                            var physicalCoordinateNode = new TreeViewItem { Header = physicalCoordinate.Key };
                            var physicalCoordinateProperties = physicalCoordinate.Value.GetType().GetProperties();
                            foreach (var physicalCoordinateProperty in physicalCoordinateProperties)
                            {
                                var header =
                                    $"{physicalCoordinateProperty.Name}: {physicalCoordinateProperty.GetValue(physicalCoordinate.Value)}";
                                physicalCoordinateNode.Items.Add(new TreeViewItem { Header = header });

                            }
                            physicalCoordinateNode.IsExpanded = true;
                            physicalCoordinatesNode.Items.Add(physicalCoordinateNode);
                        }
                        physicalCoordinatesNode.IsExpanded = true;
                        visualNode.Items.Add(physicalCoordinatesNode);

                        var logicalCoordinatesNode = new TreeViewItem() { Header = "LogicalCoordinates" };
                        foreach (var logicalCoordinate in v2D.LogicalCoordinates)
                        {
                            var logicalCoordinateNode = new TreeViewItem { Header = logicalCoordinate.Key };
                            var logicalCoordinateProperties = logicalCoordinate.Value.GetType().GetProperties();
                            foreach (var logicalCoordinateProperty in logicalCoordinateProperties)
                            {
                                var header =
                                    $"{logicalCoordinateProperty.Name}: {logicalCoordinateProperty.GetValue(logicalCoordinate.Value)}";
                                logicalCoordinateNode.Items.Add(new TreeViewItem { Header = header });

                            }
                            logicalCoordinateNode.IsExpanded = true;
                            logicalCoordinatesNode.Items.Add(logicalCoordinateNode);
                        }
                        logicalCoordinatesNode.IsExpanded = true;
                        visualNode.Items.Add(logicalCoordinatesNode);
                    }
                    else
                    {
                        var v3d = (Vinno3DVisual)visual;
                        var tissue3DAreasNode = new TreeViewItem() { Header = "Tissue3DAreas" };
                        foreach (var tissue3DArea in v3d.Tissue3DAreas)
                        {
                            var tissue3DAreaNode = new TreeViewItem { Header = tissue3DArea.Indicator };
                            tissue3DAreaNode.Items.Add(new TreeViewItem()
                            {
                                Header = $"Indicator: {tissue3DArea.Indicator}"
                            });
                            tissue3DAreaNode.Items.Add(new TreeViewItem()
                            {
                                Header = $"GlobalOffset: {tissue3DArea.GlobalOffset}"
                            });
                            tissue3DAreaNode.Items.Add(new TreeViewItem()
                            {
                                Header = $"CmPerPixel: {tissue3DArea.CmPerPixel}"
                            });
                            tissue3DAreaNode.Items.Add(new TreeViewItem()
                            {
                                Header = $"Bounds: {tissue3DArea.Bounds}"
                            });
                            tissue3DAreaNode.IsExpanded = true;
                            tissue3DAreasNode.Items.Add(tissue3DAreaNode);
                        }
                        tissue3DAreasNode.IsExpanded = true;
                        visualNode.Items.Add(tissue3DAreasNode);
                    }

                    visualNode.IsExpanded = true;
                    visualsNode.Items.Add(visualNode);
                }
                visualsNode.IsExpanded = true;

                var imageNode = new TreeViewItem { Header = "Image" };
                imageNode.Items.Add(indexNode);
                imageNode.Items.Add(widthNode);
                imageNode.Items.Add(heightNode);
                imageNode.Items.Add(visualsNode);
                imageNode.IsExpanded = true;

                Properties.Items.Add(probeNode);
                Properties.Items.Add(imageNode);

                _currentIndex = index;
                PlaySlider.Value = _currentIndex;
                if (Math.Abs(_currentIndex % _opendVinnoImageData.Probe.FrameRate) < 0.001)
                {
                    GC.Collect();
                }
            }
        }

        private void OnDecodeClick(object sender, RoutedEventArgs e)
        {
            var dialog = new OpenFileDialog { Filter = "*.vid|*.vid" };
            if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                _playTimer.Stop();
                _opendVinnoImageData?.Dispose();
                _opendVinnoImageData = new VinnoImageData(dialog.FileName, OperationMode.Open);
                PlaySlider.Minimum = 0;
                PlaySlider.Maximum = _opendVinnoImageData.ImageCount - 1;
                Max.Text = (_opendVinnoImageData.ImageCount - 1).ToString();
                Play(0);
                PlayButton.IsEnabled = true;
                PauseButton.IsEnabled = false;
                NextButton.IsEnabled = true;
                PreviousButton.IsEnabled = true;
            }

        }

        private void OnNextClick(object sender, RoutedEventArgs e)
        {
            OnPauseClick(this, null);
            Play(_currentIndex + 1);
        }

        private void OnPreviousClick(object sender, RoutedEventArgs e)
        {
            OnPauseClick(this, null);
            Play(_currentIndex - 1);
        }

        private void OnPlaySliderValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            var index = (int)e.NewValue;
            Play(index);
        }

        private void PlayTimerOnTick(object sender, EventArgs eventArgs)
        {
            Play(_currentIndex + 1);
        }

        private void OnPlayClick(object sender, RoutedEventArgs e)
        {
            if (_opendVinnoImageData != null)
            {
                _playTimer.Interval = TimeSpan.FromMilliseconds(1000 / _opendVinnoImageData.Probe.FrameRate);
                _playTimer.Start();
                PlayButton.IsEnabled = false;
                PauseButton.IsEnabled = true;
            }
        }

        private void OnPauseClick(object sender, RoutedEventArgs e)
        {
            _playTimer.Stop();
            PlayButton.IsEnabled = true;
            PauseButton.IsEnabled = false;
        }
    }
}