ImageView.cs

Go to the documentation of this file.

using AForge;
using AForge.Imaging.Filters;
using BioLib;
using CSScripting;
using Gtk;
using OpenSlideGTK;
using OpenTK.Mathematics;
using OpenTK.Windowing.Common;
using OpenTK.Windowing.Desktop;
using OpenTK.Windowing.GraphicsLibraryFramework;
using SkiaSharp;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Application = System.Windows.Forms.Application;
using Bitmap = AForge.Bitmap;
using Image = System.Drawing.Image;
using Keys = System.Windows.Forms.Keys;
using PointF = AForge.PointF;
using Rectangle = AForge.Rectangle;
using RectangleD = AForge.RectangleD;
using RectangleF = AForge.RectangleF;
using SizeF = AForge.SizeF;
 
namespace BioImager
{
 
    public partial class ImageView : UserControl, IDisposable
    {
        GLWindow window;
        SlideGLArea gl = new SlideGLArea();
        SlideRenderer slideRenderer;
        public ImageView(BioImage im, bool OpenWithOpenSlide = true)
        {
            string file = im.ID.Replace("\\", "/");
            InitializeComponent();
            bool useGpuTiles = im.Resolutions.Count > 1;
            BioLib.SlideSourceBase.UseGPU = useGpuTiles;
            OpenSlideGTK.SlideSourceBase.useGPU = useGpuTiles;
            viewpanel.Paint += Viewpanel_Paint;
            AttachViewerInput(viewpanel);
 
            if (im.isPyramidal)
            {
                gl.Size = new System.Drawing.Size(800, 600);
                if (im.openSlideImage != null && OpenWithOpenSlide)
                {
                    Initialize(im.file, im);
                }
                else
                    Initialize(im.file, im);
                hScrollBar.Visible = true;
                vScrollBar.Visible = true;
            }
            else
            {
                hScrollBar.Visible = false;
                vScrollBar.Visible = false;
                Tools.selectBoxSize = GetSelectBoxSize();
            }
            App.viewer = this;
            serie = im.series;
            gl.Dock = DockStyle.Fill;
            viewpanel.Controls.Add(gl);
            AttachViewerInput(gl);
            InitializeOverview();
            Dock = DockStyle.Fill;
            AddImage(im);
            UpdateRenderSurfaceMode();
            App.viewer = this;
            if (file == "" || file == null)
                return;
            InitGUI();
            MouseWheel += new System.Windows.Forms.MouseEventHandler(ImageView_MouseWheel);
            zBar.MouseWheel += new System.Windows.Forms.MouseEventHandler(ZTrackBar_MouseWheel);
            cBar.MouseWheel += new System.Windows.Forms.MouseEventHandler(CTrackBar_MouseWheel);
            tBar.MouseWheel += new System.Windows.Forms.MouseEventHandler(TimeTrackBar_MouseWheel);
            //We set the trackbar event to handled so that it only scrolls one tick not the default multiple.
            zBar.MouseWheel += (sender, e) => ((HandledMouseEventArgs)e).Handled = true;
            tBar.MouseWheel += (sender, e) => ((HandledMouseEventArgs)e).Handled = true;
            cBar.MouseWheel += (sender, e) => ((HandledMouseEventArgs)e).Handled = true;
            this.SizeChanged += ImageView_SizeChanged;
            this.KeyDown += ImageView_KeyDown;
            this.KeyPress += ImageView_KeyPress;
            this.KeyUp += ImageView_KeyUp;
            TimeFps = 60;
            ZFps = 60;
            CFps = 1;
            resolutions = im.Resolutions;
            if (im.isPyramidal)
            {
                // Keep the renderer bound to the currently selected pyramidal source.
                if (im.OpenSlideBase != null)
                {
                    if (slideRenderer == null)
                        slideRenderer = new SlideRenderer(gl);
                    if (!slideRenderer.IsSource(im.OpenSlideBase))
                        slideRenderer.SetSource(im.OpenSlideBase);
                }
                else if (im.SlideBase != null)
                {
                    if (slideRenderer == null)
                        slideRenderer = new SlideRenderer(gl);
                    if (!slideRenderer.IsSource(im.SlideBase))
                        slideRenderer.SetSource(im.SlideBase);
                }
            }
            InitGL();
            update = true;
            InitPreview();
            GoToImage();
            UpdateImages();
            Mode = ViewMode.Filtered;
            UpdateView();
 
        }
        public ImageView()
        {
            InitializeComponent();
            viewpanel.Paint += Viewpanel_Paint;
            AttachViewerInput(viewpanel);
            InitGL();
            AttachViewerInput(gl);
            InitializeOverview();
            Dock = DockStyle.Fill;
            App.viewer = this;
            InitGUI();
            //Buf = image.GetBufByCoord(GetCoordinate());
            MouseWheel += new System.Windows.Forms.MouseEventHandler(ImageView_MouseWheel);
            zBar.MouseWheel += new System.Windows.Forms.MouseEventHandler(ZTrackBar_MouseWheel);
            cBar.MouseWheel += new System.Windows.Forms.MouseEventHandler(CTrackBar_MouseWheel);
            tBar.MouseWheel += new System.Windows.Forms.MouseEventHandler(TimeTrackBar_MouseWheel);
            this.SizeChanged += ImageView_SizeChanged;
            //We set the trackbar event to handled so that it only scrolls one tick not the default multiple.
            zBar.MouseWheel += (sender, e) => ((HandledMouseEventArgs)e).Handled = true;
            tBar.MouseWheel += (sender, e) => ((HandledMouseEventArgs)e).Handled = true;
            cBar.MouseWheel += (sender, e) => ((HandledMouseEventArgs)e).Handled = true;
            TimeFps = 60;
            ZFps = 60;
            CFps = 1;
            update = true;
            UpdateImages();
            GoToImage();
            UpdateView();
        }
        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            const int WM_KEYDOWN = 0x0100;
            const int WM_KEYUP = 0x0101;
            const int WM_CHAR = 0x0102;
 
            switch (msg.Msg)
            {
                case WM_KEYDOWN:
                    ImageView_KeyDown(this, new KeyEventArgs(keyData));
                    break;
 
                case WM_KEYUP:
                    ImageView_KeyUp(this, new KeyEventArgs(keyData));
                    break;
 
                case WM_CHAR:
                    char ch = (char)msg.WParam;
                    ImageView_KeyPress(this, new System.Windows.Forms.KeyPressEventArgs(ch));
                    break;
            }
 
            return base.ProcessCmdKey(ref msg, keyData);
        }
 
        private void ImageView_SizeChanged(object? sender, EventArgs e)
        {
            if (SelectedImage != null)
                if (UsesSlideRenderer(SelectedImage))
                    SelectedImage.PyramidalSize = new AForge.Size(gl.Width, gl.Height);
            if (centerOnNextResize && SelectedImage != null && ViewWidth > 1 && ViewHeight > 1)
            {
                centerOnNextResize = false;
                GoToImage(SelectedIndex);
            }
            UpdateOverviewVisibility();
        }
 
        private void InitGL()
        {
            var gameWindowSettings = new GameWindowSettings()
            {
                UpdateFrequency = 60,
            };
            NativeWindowSettings nativeSettings;
 
            nativeSettings = new NativeWindowSettings()
            {
                ClientSize = new Vector2i(600, 400),
                Location = new Vector2i(0, 0),
                Title = "OpenGL Context",
                StartVisible = false,  // Window starts hidden
                API = ContextAPI.OpenGL,
                Profile = ContextProfile.Core,
                APIVersion = new Version(3, 3)
            };
            window = new GLWindow(gameWindowSettings, nativeSettings);
            GLFWProvider.SetErrorCallback((error, description) =>
            {
                Console.WriteLine($"BioImager GLFW Error {error}: {description}");
            });
        }
 
        private void BringRenderSurfacesToFront()
        {
            if (gl.Parent == viewpanel)
                gl.BringToFront();
            if (overviewPanel != null && overviewPanel.Parent == viewpanel)
                overviewPanel.BringToFront();
        }
 
        private void AttachViewerInput(Control surface)
        {
            surface.MouseDown += pictureBox_MouseDown;
            surface.MouseMove += rgbPictureBox_MouseMove;
            surface.MouseUp += pictureBox_MouseUp;
            surface.MouseDoubleClick += pictureBox_MouseDoubleClick;
            surface.MouseWheel += ImageView_MouseWheel;
            surface.MouseEnter += (sender, e) => surface.Focus();
        }
 
        ~ImageView()
        {
 
        }
        public struct Layer
        {
            public double Resolution
            {
                get; set;
            }
            public bool Enabled { get; set; }
            public Layer(double d)
            {
                Enabled = true;
                Resolution = d;
            }
            public Layer(double d, bool enabled)
            {
                Enabled = enabled;
                Resolution = d;
            }
        }
 
        public List<Layer> Layers = new List<Layer>();
        private Layers layersTool = new Layers();
        private bool IsLayerEnabled(double d)
        {
            foreach (Layer item in Layers)
            {
                if (d == item.Resolution && item.Enabled)
                    return true;
            }
            return false;
        }
        List<System.Drawing.Bitmap> Bitmaps = new List<System.Drawing.Bitmap>();
        List<Resolution> resolutions = new List<Resolution>();
        public static List<ROI> selectedAnnotations = new List<ROI>();
        private static int selectedIndex = 0;
        public static BioImage SelectedImage
        {
            get
            {
                if (App.viewer != null)
                {
                    if (App.viewer.Images.Count > 0)
                        return App.viewer.Images[selectedIndex];
                    else
                        return null;
                }
                else
                    return null;
            }
            set
            {
                if (App.viewer != null)
                {
                    if (App.viewer.Images.Count > 0)
                        App.viewer.Images[selectedIndex] = value;
                    else
                        App.viewer.AddImage(value);
                }
            }
        }
        public static Bitmap SelectedBuffer
        {
            get
            {
                int ind = SelectedImage.Coords[SelectedImage.Coordinate.Z, SelectedImage.Coordinate.C, SelectedImage.Coordinate.T];
                return SelectedImage.Buffers[ind];
            }
        }
        public static PointD mouseDown;
        public static bool down;
        public static PointD mouseUp;
        public static bool up;
        public static bool Ctrl
        {
            get
            {
                return Win32.GetKeyState(Keys.LControlKey);
            }
        }
        private bool x1State = false;
        private bool x2State = false;
        public static MouseButtons mouseUpButtons;
        public static MouseButtons mouseDownButtons;
        private PointD pd;
        public static bool showBounds = true;
        public static bool showText = true;
        public Image Buf = null;
        public bool init = false;
        private bool update = false;
        public List<BioImage> Images = new List<BioImage>();
        private bool centerOnNextResize;
        private void Render(System.Drawing.Graphics canvas)
        {
            try
            {
                DrawOverlay(canvas);
                System.Drawing.Rectangle rf = new System.Drawing.Rectangle((int)canvas.Clip.GetBounds(canvas).X, (int)canvas.Clip.GetBounds(canvas).Y,
                   (int)canvas.Clip.GetBounds(canvas).Width, (int)canvas.Clip.GetBounds(canvas).Height);
                // Plugin rendering hook
                Plugins.Render(this, new PaintEventArgs(canvas, rf));
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Annotation render error: {ex.Message}");
            }
        }
 
        private void RefreshPyramidalOverlayTexture()
        {
            if (SelectedImage == null || !SelectedImage.isPyramidal || gl == null)
                return;
            if (gl.Width <= 0 || gl.Height <= 0)
                return;
 
            using System.Drawing.Bitmap overlay = new System.Drawing.Bitmap(gl.Width, gl.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
            using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(overlay))
            {
                g.Clear(System.Drawing.Color.Transparent);
                Render(g);
            }
 
            gl.SetOverlayBitmap(overlay);
        }
 
        private void BindSlideRendererSource(BioImage image)
        {
            if (image == null || !UsesSlideRenderer(image))
                return;
 
            if (slideRenderer == null)
                slideRenderer = new SlideRenderer(gl);
 
            if (image.OpenSlideBase != null)
            {
                if (!slideRenderer.IsSource(image.OpenSlideBase))
                    slideRenderer.SetSource(image.OpenSlideBase);
            }
            else if (image.SlideBase != null)
            {
                if (!slideRenderer.IsSource(image.SlideBase))
                    slideRenderer.SetSource(image.SlideBase);
            }
        }
 
        private static bool UsesSlideRenderer(BioImage image)
        {
            return image != null && (image.isPyramidal || image.SlideBase != null || image.OpenSlideBase != null);
        }
 
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int SelectedIndex
        {
            get;
            set
            {
                if (value >= 0 && value < Images.Count)
                {
                    App.viewer = this;
                    field = value;
                    selectedIndex = field;
                    InitGUI();
                    if (UsesSlideRenderer(Images[field]))
                        BindSlideRendererSource(Images[field]);
                }
            }
        } = 0;
        public Tools tools { get { return App.tools; } }
        public string filepath = "";
        public int serie = 0;
        public int minSizeX = 50;
        public int minSizeY = 20;
        public bool loopZ = true;
        public bool loopT = true;
        public bool loopC = true;
        private AForge.Rectangle overview;
        public Rectangle OverView
        {
            get { return overview; }
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool ShowStage { get; set; }
        private double pxWmicron = 0.004;
        private double pxHmicron = 0.004;
        AForge.SizeF scale = new AForge.SizeF(1, 1);
        private bool initializingCoordinates;
        public void SetCoordinate(int z, int c, int t)
        {
            if (IsDisposed)
                return;
 
            if (InvokeRequired)
            {
                BeginInvoke(new MethodInvoker(() => SetCoordinate(z, c, t)));
                return;
            }
 
            if (SelectedImage == null)
                return;
 
            int targetZ = Math.Clamp(z, zBar.Minimum, zBar.Maximum);
            int targetC = Math.Clamp(c, cBar.Minimum, cBar.Maximum);
            int targetT = Math.Clamp(t, tBar.Minimum, tBar.Maximum);
 
            initializingCoordinates = true;
            if (zBar.Value != targetZ)
                zBar.Value = targetZ;
            if (cBar.Value != targetC)
                cBar.Value = targetC;
            if (tBar.Value != targetT)
                tBar.Value = targetT;
            initializingCoordinates = false;
            SelectedImage.Coordinate = new ZCT(targetZ, targetC, targetT);
            UpdateView();
        }
        public ZCT GetCoordinate()
        {
            if (SelectedImage != null)
                return SelectedImage.Coordinate;
            else
                return new ZCT();
        }
        public void AddImage(BioImage im)
        {
            ZCT initialCoordinate = new ZCT(im.Coordinate.Z, im.Coordinate.C, im.Coordinate.T);
            Images.Add(im);
            SelectedIndex = Images.Count - 1;
            centerOnNextResize = true;
            bool c = false;
            foreach (var item in Layers)
            {
                if (item.Resolution == im.PhysicalSizeX)
                    c = true;
            }
            if (!c)
                Layers.Add(new Layer(im.PhysicalSizeX));
            if (im.isPyramidal)
            {
                hScrollBar.Visible = true;
                vScrollBar.Visible = true;
            }
            else
            {
                hScrollBar.Visible = false;
                vScrollBar.Visible = false;
                Tools.selectBoxSize = GetSelectBoxSize();
            }
            InitGUI();
            SetCoordinate(initialCoordinate.Z, initialCoordinate.C, initialCoordinate.T);
            UpdateImages();
 
            GoToImage(Images.Count - 1);
            QueueInitialCenterAfterLayout(Images.Count - 1);
        }
 
        private void QueueInitialCenterAfterLayout(int imageIndex)
        {
            if (!IsHandleCreated)
                return;
            BeginInvoke(new System.Action(() =>
            {
                if (IsDisposed || !centerOnNextResize || imageIndex >= Images.Count)
                    return;
                centerOnNextResize = false;
                GoToImage(imageIndex);
            }));
        }
 
        private static int GetPreviewLevel(BioImage image)
        {
            if (image == null || image.Resolutions.Count == 0)
                return 0;
 
            int nativeLevelCount = image.PyramidNativeLevelCount > 0
                ? Math.Min(image.PyramidNativeLevelCount, image.Resolutions.Count)
                : image.Resolutions.Count;
            return Math.Max(0, nativeLevelCount - 1);
        }
        private bool showControls = true;
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool ShowControls
        {
            get => showControls;
            set
            {
                showControls = value;
                trackBarPanel.Visible = value;
                hideControlsToolStripMenuItem1.Text = value ? "Hide Controls" : "Show Controls";
                showControlsToolStripMenuItem.Text = value ? "Hide Controls" : "Show Controls";
                PerformLayout();
                UpdateView();
            }
        }
        private bool showStatus = true;
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool ShowStatus
        {
            get => showStatus;
            set
            {
                showStatus = value;
                statusPanel.Visible = value;
                hideControlsToolStripMenuItem.Text = value ? "Hide Status" : "Show Status";
                PerformLayout();
                UpdateView();
            }
        }
 
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public double PxWmicron
        {
            get
            {
                return pxWmicron;
            }
            set
            {
                pxWmicron = value;
            }
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public double PxHmicron
        {
            get
            {
                return pxHmicron;
            }
            set
            {
                pxHmicron = value;
            }
        }
        public enum ViewMode
        {
            Raw,
            Filtered,
            RGBImage,
            Emission,
        }
        private ViewMode viewMode = ViewMode.Filtered;
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ViewMode Mode
        {
            get
            {
                return viewMode;
            }
            set
            {
                viewMode = value;
                //If view mode is changed we update.
                update = true;
                UpdateImages();
                App.tabsView.UpdateViewMode(viewMode);
                UpdateView();
                UpdateOverlay();
                if (viewMode == ViewMode.RGBImage)
                {
                cBar.Value = 0;
                rgbBoxsPanel.BringToFront();
                cBar.SendToBack();
                cLabel.SendToBack();
                BringRenderSurfacesToFront();
                }
                else
                if (viewMode == ViewMode.Filtered)
                {
                rgbBoxsPanel.SendToBack();
                cBar.BringToFront();
                cLabel.BringToFront();
                BringRenderSurfacesToFront();
                }
                else
                if (viewMode == ViewMode.Raw)
                {
                rgbBoxsPanel.SendToBack();
                cBar.BringToFront();
                cLabel.BringToFront();
                BringRenderSurfacesToFront();
                }
                else
                {
                cBar.Value = 0;
                rgbBoxsPanel.BringToFront();
                cBar.SendToBack();
                cLabel.SendToBack();
                BringRenderSurfacesToFront();
                }
            }
        }
        public string Path
        {
            get
            {
                return filepath;
            }
        }
        public Channel RChannel
        {
            get
            {
                return SelectedImage.Channels[SelectedImage.rgbChannels[0]];
            }
        }
        public Channel GChannel
        {
            get
            {
                return SelectedImage.Channels[SelectedImage.rgbChannels[1]];
            }
        }
        public Channel BChannel
        {
            get
            {
                return SelectedImage.Channels[SelectedImage.rgbChannels[2]];
            }
        }
        PointD origin = new PointD(0, 0);
        bool hardwareAcceleration = true;
        public bool OpenSlide
        {
            get { if (SelectedImage.SlideBase == null) return true; else return false; }
        }
        public int? MacroResolution { get { return SelectedImage.MacroResolution; } }
        public int? LabelResolution { get { return SelectedImage.LabelResolution; } }
        public int ViewWidth
        {
            get
            {
                if (SelectedImage != null && !SelectedImage.isPyramidal && viewpanel != null && viewpanel.ClientSize.Width > 1)
                    return viewpanel.ClientSize.Width;
                return gl.Width;
            }
        }
        public int ViewHeight
        {
            get
            {
                if (SelectedImage != null && !SelectedImage.isPyramidal && viewpanel != null && viewpanel.ClientSize.Height > 1)
                    return viewpanel.ClientSize.Height;
                return gl.Height;
            }
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public PointD Origin
        {
            get { return origin; }
            set
            {
                origin = value;
                update = true;
                UpdateView();
            }
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public PointD PyramidalOrigin
        {
            get
            {
                if (SelectedImage != null)
                    return SelectedImage.PyramidalOrigin;
                else
                    return new PointD(0, 0);
            }
            set
            {
                SelectedImage.PyramidalOrigin = value;
            }
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public double Resolution
        {
            get
            {
                if (SelectedImage == null)
                    return 1;
                return SelectedImage.Resolution;
            }
            set
            {
                SelectedImage.Resolution = value;
                if (SelectedImage.Type == BioImage.ImageType.well)
                    SelectedImage.Level = (int)value;
            }
        }
 
        public int Level
        {
            get
            {
                if (SelectedImage != null)
                    return SelectedImage.Level;
                else
                    return 0;
            }
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public new AForge.SizeF Scale
        {
            get
            {
                return scale;
            }
            set
            {
                scale = value;
                update = true;
                UpdateView();
                Tools.selectBoxSize = GetSelectBoxSize();
            }
        }
        public ContextMenuStrip ViewContextMenu
        {
            get
            {
                return contextMenuStrip;
            }
        }
        private readonly bool[] rgbEnabled = { true, true, true };
        private bool initializingRgbSelectors;
        private BioImage rgbSelectorImage;
 
        private int[] SelectedRgbChannels(BioImage image) => Enumerable.Range(0, 3)
            .Select(i => rgbEnabled[i] ? image.rgbChannels[i] : -1).ToArray();
 
        public void UpdateRGBChannels()
        {
            if (SelectedImage == null) return;
            System.Windows.Forms.ComboBox[] boxes = { channelBoxR, channelBoxG, channelBoxB };
            for (int i = 0; i < boxes.Length; i++)
            {
                rgbEnabled[i] = boxes[i].SelectedIndex > 0;
                if (rgbEnabled[i]) SelectedImage.rgbChannels[i] = boxes[i].SelectedIndex - 1;
            }
        }
 
        private bool timeEnabled = false;
        private int zfps;
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int ZFps
        {
            get
            {
                return zfps;
            }
            set
            {
                zfps = value;
                float f = value;
                zTimer.Interval = (int)Math.Floor(1000 / f);
            }
        }
        private int timefps;
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int TimeFps
        {
            get
            {
                return timefps;
            }
            set
            {
                timefps = value;
                float f = value;
                timelineTimer.Interval = (int)Math.Floor(1000 / f);
            }
        }
        private int cfps;
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int CFps
        {
            get
            {
                return cfps;
            }
            set
            {
                cfps = value;
                float f = value;
                cTimer.Interval = (int)Math.Floor(1000 / f);
            }
        }
        public void InitGUI()
        {
            if (SelectedImage == null)
                return;
            ZCT coordinate = new ZCT(SelectedImage.Coordinate.Z, SelectedImage.Coordinate.C, SelectedImage.Coordinate.T);
            initializingCoordinates = true;
            ZarrChannelView.InitializeChannels(SelectedImage);
            zBar.Maximum = Math.Max(0, SelectedImage.SizeZ - 1);
            if (!SelectedImage.IsZarrSource && SelectedImage.Buffers.Count > 0 && SelectedImage.Buffers[0].RGBChannelsCount == 3)
                cBar.Maximum = 0;
            else
                cBar.Maximum = Math.Max(0, SelectedImage.SizeC - 1);
            if (SelectedImage.SizeT > 1)
            {
                tBar.Maximum = Math.Max(0, SelectedImage.SizeT - 1);
                tBar.Enabled = true;
                timeEnabled = true;
            }
            else
            {
                tBar.Enabled = false;
                timeEnabled = false;
                tBar.Maximum = Math.Max(0, SelectedImage.SizeT - 1);
            }
            //rgbPictureBox.Image = image.plane.GetBitmap();
            //we clear the channel comboboxes incase we have channels from previous loaded image.
            bool sameImage = ReferenceEquals(rgbSelectorImage, SelectedImage);
            rgbSelectorImage = SelectedImage;
            bool[] previousEnabled = (bool[])rgbEnabled.Clone();
            int[] previousChannels = (int[])SelectedImage.rgbChannels.Clone();
            initializingRgbSelectors = true;
            channelBoxR.Items.Clear();
            channelBoxG.Items.Clear();
            channelBoxB.Items.Clear();
 
            channelBoxR.Items.Add("");
            channelBoxG.Items.Add("");
            channelBoxB.Items.Add("");
            foreach (Channel ch in SelectedImage.Channels)
            {
                channelBoxR.Items.Add(ch);
                channelBoxG.Items.Add(ch);
                channelBoxB.Items.Add(ch);
            }
            System.Windows.Forms.ComboBox[] rgbBoxes = { channelBoxR, channelBoxG, channelBoxB };
            int count = SelectedImage.Channels.Count;
            for (int i = 0; i < rgbBoxes.Length; i++)
                rgbBoxes[i].SelectedIndex = count == 0 || (sameImage && !previousEnabled[i]) ? 0 :
                    (sameImage ? Math.Clamp(previousChannels[i], 0, count - 1) : (i < count ? i : 0)) + 1;
            initializingRgbSelectors = false;
            zBar.Value = Math.Clamp(coordinate.Z, zBar.Minimum, zBar.Maximum);
            cBar.Value = Math.Clamp(coordinate.C, cBar.Minimum, cBar.Maximum);
            tBar.Value = Math.Clamp(coordinate.T, tBar.Minimum, tBar.Maximum);
            SelectedImage.Coordinate = new ZCT(zBar.Value, cBar.Value, tBar.Value);
            initializingCoordinates = false;
            UpdateRGBChannels();
 
            init = true;
        }
        public void UpdateSelectBoxSize(float size)
        {
            ROI.selectBoxSize = size;
            UpdateToolSelectBoxSize();
        }
 
        private const float MinSelectBoxScreenSize = 8f;
        private const float MinSelectionHitScreenSize = 8f;
 
        private float GetSelectBoxSize()
        {
            return GetSelectBoxSizeForScreenPixels(MinSelectBoxScreenSize);
        }
 
        private float GetSelectBoxSizeForScreenPixels(float minScreenSize)
        {
            if (SelectedImage != null && SelectedImage.isPyramidal)
            {
                float logicalSize = Math.Max(ROI.selectBoxSize, minScreenSize);
                double resolution = Resolution;
                if (resolution <= 0 || double.IsNaN(resolution) || double.IsInfinity(resolution))
                    resolution = 1;
                return (float)(logicalSize * resolution);
            }
 
            float zoom = Math.Abs(Scale.Width);
            if (zoom <= 0 || float.IsNaN(zoom) || float.IsInfinity(zoom))
                zoom = 1f;
 
            double pixelSize = Math.Min(PxWmicron, PxHmicron);
            if (pixelSize <= 0 || double.IsNaN(pixelSize) || double.IsInfinity(pixelSize))
                pixelSize = 1;
 
            float screenSize = Math.Max(ROI.selectBoxSize, minScreenSize);
            return (float)(screenSize / (zoom * pixelSize));
        }
 
        private void UpdateToolSelectBoxSize()
        {
            Tools.selectBoxSize = GetSelectBoxSize();
        }
        public void UpdateOverlay()
        {
            UpdateToolSelectBoxSize();
            if (SelectedImage != null && UsesSlideRenderer(SelectedImage))
            {
                RefreshPyramidalOverlayTexture();
                gl.Invalidate();
                overviewPanel.Invalidate();
            }
            else
                viewpanel.Invalidate();
        }
        public void UpdateStatus()
        {
            BioImage image = OverviewSelectedImage;
            if (image == null)
                return;
            string res = image.Type == BioImage.ImageType.well
                ? $"Well:{image.Level}"
                : image.isPyramidal ? $"Res.:{image.Resolution:G4} Level:{image.Level}" : "";
            string pixelFormat = image.Buffers.Count > 0
                ? image.Buffers[0].PixelFormat.ToString()
                : image.Resolutions.Count > 0
                    ? image.Resolutions[Math.Clamp(image.Level, 0, image.Resolutions.Count - 1)].PixelFormat.ToString()
                    : "";
            string position = image.isPyramidal
                ? $"({image.PyramidalOrigin.X:0.##}, {image.PyramidalOrigin.Y:0.##})"
                : $"({-Origin.X:0.##}, {-Origin.Y:0.##})";
            string location = $"({image.Volume.Location.X:0.##}, {image.Volume.Location.Y:0.##})";
            string plane = $"{zBar.Value + 1}/{zBar.Maximum + 1}";
            if (Mode != ViewMode.RGBImage)
                plane += $", {cBar.Value + 1}/{cBar.Maximum + 1}";
            if (timeEnabled)
                plane += $", {tBar.Value + 1}/{tBar.Maximum + 1}";
            statusLabel.Text = $"{plane}, {mousePoint}{mouseColor}, {pixelFormat}, Origin: {position}, {location} {res}";
        }
        public void UpdateView(bool refreshImages = true)
        {
            UpdateStatus();
            update = true;
            UpdateToolSelectBoxSize();
            if (refreshImages)
                UpdateImages();
            UpdateRenderSurfaceMode();
            UpdateScrollBars();
            overviewPanel.Invalidate();
            if (SelectedImage != null && UsesSlideRenderer(SelectedImage))
            {
                RefreshPyramidalOverlayTexture();
                gl.Invalidate();
                overviewPanel.Invalidate();
            }
            else
                viewpanel.Invalidate();
        }
        /*
        public void RenderFrame()
        {
            if (!update)
                return;
            drawing = true;
            if (dBitmaps.Count != Images.Count)
                UpdateImages();
            if (HardwareAcceleration && sk != null)
            {
                Plugins.Render(this, sk);
                sk.BeginDraw();
                sk.RenderTarget2D.Clear(new RawColor4(1.0f, 1.0f, 1.0f, 1.0f));
                RectangleF rg = ToScreenRect(PointD.MinX, PointD.MinY, PointD.MaxX - PointD.MinX, PointD.MaxY - PointD.MinY);
                //dx.RenderTarget2D.Transform = SharpDX.Matrix3x2.Rotation((float)Math.PI);
                SharpDX.Direct2D1.SolidColorBrush pen = new SharpDX.Direct2D1.SolidColorBrush(sk.RenderTarget2D, new RawColor4(1.0f, 0.0f, 0.0f, 1.0f));
                SharpDX.Direct2D1.SolidColorBrush red = new SharpDX.Direct2D1.SolidColorBrush(sk.RenderTarget2D, new RawColor4(1.0f, 0.0f, 0.0f, 1.0f));
                SharpDX.Direct2D1.SolidColorBrush green = new SharpDX.Direct2D1.SolidColorBrush(sk.RenderTarget2D, new RawColor4(0.0f, 1.0f, 0.0f, 1.0f));
                SharpDX.Direct2D1.SolidColorBrush mag = new SharpDX.Direct2D1.SolidColorBrush(sk.RenderTarget2D, new RawColor4(1.0f, 0.0f, 1.0f, 1.0f));
                SharpDX.Direct2D1.SolidColorBrush blue = new SharpDX.Direct2D1.SolidColorBrush(sk.RenderTarget2D, new RawColor4(0.0f, 0.0f, 1.0f, 1.0f));
                SharpDX.Direct2D1.SolidColorBrush b = new SharpDX.Direct2D1.SolidColorBrush(sk.RenderTarget2D, new RawColor4(1.0f, 1.0f, 0.0f, 1.0f));
                SharpDX.Direct2D1.SolidColorBrush gray = new SharpDX.Direct2D1.SolidColorBrush(sk.RenderTarget2D, new RawColor4(0.5f, 0.5f, 0.5f, 1.0f));
 
                sk.RenderTarget2D.FillRectangle(ToSKRect(rg.X, rg.Y, rg.Width, rg.Height), gray);
                for (int x = 0; x < Images.Count; x++)
                {
                    if (!IsLayerEnabled(Images[x].PhysicalSizeX) && !Images[x].isPyramidal)
                        continue;
                    RectangleF r = ToScreenRect(Images[x].Volume.Location.X, Images[x].Volume.Location.Y, Images[x].Volume.Width, Images[x].Volume.Height);
                    double w = ToViewW(ViewWidth);
                    double h = ToViewH(ViewHeight);
                    RectangleF rge = new RectangleF((float)((-Origin.X) - (w / 2)), (float)((-Origin.Y) - (h / 2)), (float)(Math.Abs(w)), (float)(Math.Abs(h)));
                    RectangleF rec = new RectangleF((float)Images[x].Volume.Location.X, (float)Images[x].Volume.Location.Y, (float)Images[x].Volume.Width, (float)Images[x].Volume.Height);
                    //if (rge.IntersectsWith(rec))
                    sk.RenderTarget2D.DrawBitmap(dBitmaps[x], ToSKRect(r.X, r.Y, r.Width, r.Height), 1.0f, SharpDX.Direct2D1.BitmapInterpolationMode.Linear);
                    if (x == selectedIndex)
                        sk.RenderTarget2D.DrawRectangle(ToSKRect(r.X, r.Y, r.Width, r.Height), blue);
                }
                bool bounds = showBounds;
                bool labels = showText;
                foreach (BioImage bi in Images)
                {
                    if (!IsLayerEnabled(bi.PhysicalSizeX) && !bi.isPyramidal)
                        continue;
                    foreach (ROI an in bi.Annotations)
                    {
                        if (an.type == ROI.Type.Polygon || an.type == ROI.Type.Freeform || an.type == ROI.Type.Polyline)
                        {
                            if (zBar.Value != an.coord.Z || tBar.Value != an.coord.T)
                                continue;
                        }
                        else if (zBar.Value != an.coord.Z || cBar.Value != an.coord.C || tBar.Value != an.coord.T)
                            continue;
                        float w = Math.Abs(Scale.Width);
                        Font fo = new Font(new FontFamily(an.family), (float)((an.strokeWidth / w) * an.fontSize));
                        PointF pc = new PointF((float)(an.BoundingBox.X + (an.BoundingBox.W / 2)), (float)(an.BoundingBox.Y + (an.BoundingBox.H / 2)));
                        float width = (float)an.strokeWidth / w;
                        if (width <= 0)
                            width = 1;
                        sk.RenderTarget2D.StrokeWidth = width;
                        if (an.Selected)
                            b.Color = new RawColor4(1.0f, 0.0f, 1.0f, 1.0f);
                        else
                            b.Color = new RawColor4((float)an.strokeColor.R / 255f, (float)an.strokeColor.G / 255f, (float)an.strokeColor.B / 255f, 1.0f);
                        if (an.type == ROI.Type.Point)
                        {
                            PointD pf = ToScreenSpace(an.Points[0]);
                            SharpDX.Direct2D1.Ellipse dot = new SharpDX.Direct2D1.Ellipse(new RawVector2((float)pf.X, (float)pf.Y), 2f, 2f);
                            sk.RenderTarget2D.FillEllipse(dot, b);
                            RectangleF[] rfs = ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize));
                            for (int i = 0; i < rfs.Length; i++)
                            {
                                sk.RenderTarget2D.DrawRectangle(ToSKRect(rfs[i].X, rfs[i].Y, rfs[i].Width, rfs[i].Height), red);
                            }
                        }
                        else
                        if (an.type == ROI.Type.Line)
                        {
                            PointD pf = ToScreenSpace(an.GetPoint(0));
                            PointD pf2 = ToScreenSpace(an.GetPoint(1));
                            sk.RenderTarget2D.DrawLine(new RawVector2((float)pf.X, (float)pf.Y), new RawVector2((float)pf2.X, (float)pf2.Y), b);
                            RectangleF[] rfs = ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize));
                            for (int i = 0; i < rfs.Length; i++)
                            {
                                sk.RenderTarget2D.DrawRectangle(ToSKRect(rfs[i].X, rfs[i].Y, rfs[i].Width, rfs[i].Height), red);
                            }
                        }
                        else
                        if (an.type == ROI.Type.Rectangle && an.BoundingBox.W > 0 && an.BoundingBox.H > 0)
                        {
                            RectangleF rec = ToScreenSpace(an.BoundingBox);
                            sk.RenderTarget2D.DrawRectangle(ToSKRect(rec.X, rec.Y, rec.Width, rec.Height), red);
                            RectangleF[] rfs = ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize));
                            for (int i = 0; i < rfs.Length; i++)
                            {
                                sk.RenderTarget2D.DrawRectangle(ToSKRect(rfs[i].X, rfs[i].Y, rfs[i].Width, rfs[i].Height), red);
                            }
                        }
                        else
                        if (an.type == ROI.Type.Ellipse)
                        {
                            RectangleF r = ToScreenSpace(an.BoundingBox);
                            RectangleF[] rfs = ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize));
                            RawRectangleF rf = ToSKRect(rfs[0].X, rfs[0].Y, rfs[0].Width, rfs[0].Height);
                            SharpDX.Direct2D1.Ellipse e = new SharpDX.Direct2D1.Ellipse(new RawVector2(rf.Left + (Math.Abs(r.Width) / 2) - (rfs[0].Width / 2), rf.Top + (Math.Abs(r.Height) / 2) - (rfs[0].Height / 2)), -r.Width / 2, -r.Height / 2);
                            sk.RenderTarget2D.DrawEllipse(e, b);
                            for (int i = 0; i < rfs.Length; i++)
                            {
                                sk.RenderTarget2D.DrawRectangle(ToSKRect(rfs[i].X, rfs[i].Y, rfs[i].Width, rfs[i].Height), red);
                            }
                        }
                        else
                        if (an.type == ROI.Type.Polygon && an.closed)
                        {
                            RawVector2 pf;
                            RawVector2 pf2;
                            for (int i = 0; i < an.Points.Count - 1; i++)
                            {
                                pf = new RawVector2((float)ToScreenSpace(an.GetPoint(i).X, an.GetPoint(i).Y).X, (float)ToScreenSpace(an.GetPoint(i).X, an.GetPoint(i).Y).Y);
                                pf2 = new RawVector2((float)ToScreenSpace(an.GetPoint(i + 1).X, an.GetPoint(i + 1).Y).X, (float)ToScreenSpace(an.GetPoint(i + 1).X, an.GetPoint(i + 1).Y).Y);
                                sk.RenderTarget2D.DrawLine(pf, pf2, b);
                            }
                            pf = new RawVector2((float)ToScreenSpace(an.GetPoint(0)).X, (float)ToScreenSpace(an.GetPoint(0)).Y);
                            pf2 = new RawVector2((float)ToScreenSpace(an.GetPoint(an.Points.Count - 1)).X, (float)ToScreenSpace(an.GetPoint(an.Points.Count - 1)).Y);
                            sk.RenderTarget2D.DrawLine(pf, pf2, b);
 
                            RectangleF[] rfs = ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize));
                            for (int i = 0; i < rfs.Length; i++)
                            {
                                sk.RenderTarget2D.DrawRectangle(ToSKRect(rfs[i].X, rfs[i].Y, rfs[i].Width, rfs[i].Height), red);
                            }
                        }
                        else
                        if ((an.type == ROI.Type.Polygon && !an.closed) || an.type == ROI.Type.Polyline)
                        {
                            RawVector2 pf;
                            RawVector2 pf2;
                            for (int i = 0; i < an.Points.Count - 1; i++)
                            {
                                pf = new RawVector2((float)ToScreenSpace(an.GetPoint(i).X, an.GetPoint(i).Y).X, (float)ToScreenSpace(an.GetPoint(i).X, an.GetPoint(i).Y).Y);
                                pf2 = new RawVector2((float)ToScreenSpace(an.GetPoint(i + 1).X, an.GetPoint(i + 1).Y).X, (float)ToScreenSpace(an.GetPoint(i + 1).X, an.GetPoint(i + 1).Y).Y);
                                sk.RenderTarget2D.DrawLine(pf, pf2, b);
                                sk.RenderTarget2D.DrawLine(pf, pf2, b);
                            }
 
                            RectangleF[] rfs = ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize));
                            for (int i = 0; i < rfs.Length; i++)
                            {
                                sk.RenderTarget2D.DrawRectangle(ToSKRect(rfs[i].X, rfs[i].Y, rfs[i].Width, rfs[i].Height), red);
                            }
 
                        }
                        else
                        if (an.type == ROI.Type.Freeform && an.closed)
                        {
                            RawVector2 pf;
                            RawVector2 pf2;
                            for (int i = 0; i < an.Points.Count - 1; i++)
                            {
                                pf = new RawVector2((float)ToScreenSpace(an.GetPoint(i).X, an.GetPoint(i).Y).X, (float)ToScreenSpace(an.GetPoint(i).X, an.GetPoint(i).Y).Y);
                                pf2 = new RawVector2((float)ToScreenSpace(an.GetPoint(i + 1).X, an.GetPoint(i + 1).Y).X, (float)ToScreenSpace(an.GetPoint(i + 1).X, an.GetPoint(i + 1).Y).Y);
                                sk.RenderTarget2D.DrawLine(pf, pf2, b);
                                sk.RenderTarget2D.DrawLine(pf, pf2, b);
                            }
                            pf = new RawVector2((float)ToScreenSpace(an.GetPoint(0)).X, (float)ToScreenSpace(an.GetPoint(0)).Y);
                            pf2 = new RawVector2((float)ToScreenSpace(an.GetPoint(an.Points.Count - 1)).X, (float)ToScreenSpace(an.GetPoint(an.Points.Count - 1)).Y);
                            sk.RenderTarget2D.DrawLine(pf, pf2, b);
                            if (an.Selected)
                            {
                                RectangleF[] rfs = ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize));
                                for (int i = 0; i < rfs.Length; i++)
                                {
                                    sk.RenderTarget2D.DrawRectangle(ToSKRect(rfs[i].X, rfs[i].Y, rfs[i].Width, rfs[i].Height), red);
                                }
                            }
                        }
                        else
                        if (an.type == ROI.Type.Freeform && !an.closed)
                        {
                            RawVector2 pf;
                            RawVector2 pf2;
                            for (int i = 0; i < an.Points.Count - 1; i++)
                            {
                                pf = new RawVector2((float)ToScreenSpace(an.GetPoint(i).X, an.GetPoint(i).Y).X, (float)ToScreenSpace(an.GetPoint(i).X, an.GetPoint(i).Y).Y);
                                pf2 = new RawVector2((float)ToScreenSpace(an.GetPoint(i + 1).X, an.GetPoint(i + 1).Y).X, (float)ToScreenSpace(an.GetPoint(i + 1).X, an.GetPoint(i + 1).Y).Y);
                                sk.RenderTarget2D.DrawLine(pf, pf2, b);
                            }
                            if (an.Selected)
                            {
                                RectangleF[] rfs = ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize));
                                for (int i = 0; i < rfs.Length; i++)
                                {
                                    sk.RenderTarget2D.DrawRectangle(ToSKRect(rfs[i].X, rfs[i].Y, rfs[i].Width, rfs[i].Height), red);
                                }
                            }
                        }
                        if (an.type == ROI.Type.Label)
                        {
                            using Font labelFont = GetScaledLabelFont(an, (float)w);
                            System.Drawing.Size textSize = System.Windows.Forms.TextRenderer.MeasureText(an.Text ?? string.Empty, labelFont);
                            System.Drawing.RectangleF rec = GetLabelScreenRect(an);
                            float tx = rec.X + ((rec.Width - textSize.Width) / 2f);
                            float ty = rec.Y + ((rec.Height - textSize.Height) / 2f);
                            RawRectangleF r = ToSKRect(tx, ty, textSize.Width, textSize.Height);
                            SharpDX.DirectWrite.TextFormat tex = new SharpDX.DirectWrite.TextFormat(sk.FactoryDWrite, an.family.ToString(), an.fontSize);
                            sk.RenderTarget2D.DrawText(an.Text ?? string.Empty, tex, r, b);
                            tex.Dispose();
                            sk.RenderTarget2D.DrawRectangle(ToSKRect(rec.X, rec.Y, rec.Width, rec.Height), red);
                        }
                        if (labels)
                        {
                            if (an.Text != null && an.type != ROI.Type.Label)
                            {
                                System.Drawing.Size s = TextRenderer.MeasureText(an.Text, new Font(an.family, an.fontSize));
                                //Lets draw the text of this ROI in the middle of the ROI.
                                float fw = ((float)an.BoundingBox.X + ((float)an.BoundingBox.W / 2)) - ((float)s.Width / 2);
                                float fh = ((float)an.BoundingBox.Y + ((float)an.BoundingBox.H / 2)) - ((float)s.Height / 2);
                                RawRectangleF r = ToSKRect(fw, fh, s.Width, s.Height);
                                SharpDX.DirectWrite.TextFormat tex = new SharpDX.DirectWrite.TextFormat(sk.FactoryDWrite, an.family.ToString(), an.fontSize);
                                sk.RenderTarget2D.DrawText(an.Text, tex, r, b);
                                tex.Dispose();
                            }
                        }
                        if (bounds)
                        {
                            if (an.type == ROI.Type.Point)
                            {
                                PointD pt = ToScreenSpace(an.Points[0]);
                                SharpDX.Direct2D1.Ellipse dot = new SharpDX.Direct2D1.Ellipse(new RawVector2((float)pt.X, (float)pt.Y), 2f, 2f);
                                sk.RenderTarget2D.FillEllipse(dot, green);
                            }
                            else if (an.type == ROI.Type.Label)
                            {
                                System.Drawing.RectangleF rec = GetLabelScreenRect(an);
                                sk.RenderTarget2D.DrawRectangle(ToSKRect(rec.X, rec.Y, rec.Width, rec.Height), green);
                            }
                            else
                            {
                                RectangleF r = ToScreenSpace(an.BoundingBox);
                                sk.RenderTarget2D.DrawRectangle(ToSKRect(r.X, r.Y, r.Width, r.Height), green);
                            }
                        }
                        if (an.Selected)
                        {
                            if (an.type == ROI.Type.Point)
                            {
                                PointD pt = ToScreenSpace(an.Points[0]);
                                SharpDX.Direct2D1.Ellipse dot = new SharpDX.Direct2D1.Ellipse(new RawVector2((float)pt.X, (float)pt.Y), 2f, 2f);
                                sk.RenderTarget2D.FillEllipse(dot, mag);
                                continue;
                            }
                            else if (an.type == ROI.Type.Label)
                            {
                                System.Drawing.RectangleF rec = GetLabelScreenRect(an);
                                sk.RenderTarget2D.DrawRectangle(ToSKRect(rec.X, rec.Y, rec.Width, rec.Height), mag);
                                continue;
                            }
 
                            //Lets draw the selected bounding box.
                            RectangleF r = ToScreenSpace(an.BoundingBox);
                            sk.RenderTarget2D.DrawRectangle(ToSKRect(r.X, r.Y, r.Width, r.Height), mag);
 
                            //Lets draw the selectBoxes.
                            List<RectangleD> rects = new List<RectangleD>();
                            RectangleD[] sels = an.GetSelectBoxes(Tools.selectBoxSize);
                            for (int i = 0; i < an.selectedPoints.Count; i++)
                            {
                                if (an.selectedPoints[i] < an.GetPointCount())
                                {
                                    rects.Add(sels[an.selectedPoints[i]]);
                                }
                            }
                            if (rects.Count > 0)
                            {
                                for (int i = 0; i < rects.Count; i++)
                                {
                                    RectangleF ri = ToScreenSpace(rects[i]);
                                    sk.RenderTarget2D.DrawRectangle(ToSKRect(ri.X, ri.Y, ri.Width, ri.Height), blue);
                                }
                            }
                            rects.Clear();
                        }
 
                    }
                }
                if (ShowStage)
                {
                    AForge.RectangleD re = Microscope.GetViewRectangle(false);
                    RectangleF vr = ToScreenRect(re.X, re.Y, re.W, re.H);
                    RawRectangleF rr = ToSKRect(vr.X, vr.Y, vr.Width, vr.Height);
                    sk.RenderTarget2D.DrawRectangle(rr, red);
                }
 
                if(Tools.currentTool!=null)
                if (Tools.currentTool.type == Tools.Tool.Type.rectSel || Tools.currentTool.type == Tools.Tool.Type.rect)// && Modifiers == ModifierType.Button1Mask)
                {
                    var recd = ToScreenRect(Tools.currentTool.Rectangle.X, Tools.currentTool.Rectangle.Y, Tools.currentTool.Rectangle.W, Tools.currentTool.Rectangle.H);
                    sk.RenderTarget2D.DrawRectangle(ToSKRect((float)recd.X, (float)recd.Y, (float)recd.Width, (float)recd.Height), blue);
                }
                pen.Dispose();
                red.Dispose();
                mag.Dispose();
                green.Dispose();
                blue.Dispose();
                gray.Dispose();
                b.Dispose();
                sk.EndDraw();
            }
            drawing = false;
        }
        */
        public void UpdateViewLegacy(bool refresh)
        {
            UpdateStatus();
            update = refresh;
            if (update)
            {
                gl.Invalidate();
                overviewPanel.Invalidate();
            }
        }
        bool updating = false;
        private int zarrRgbRequest;
        public async void UpdateImages(bool updatePyramidal = true)
        {
            if (SelectedImage == null)
                return;
            App.channelsTool?.RefreshHistogram();
            UpdateRenderSurfaceMode();
            if (UsesSlideRenderer(SelectedImage))
            {
                InitPreview();
                if (!updatePyramidal || gl.Width <= 1 || gl.Height <= 1)
                    return;
                SelectedImage.PyramidalOrigin = PyramidalOrigin;
                SelectedImage.PyramidalSize = new AForge.Size(gl.Width, gl.Height);
 
                // Use the new renderer - no more ReadPixels!
                BindSlideRendererSource(SelectedImage);
                try
                {
                    BioImage? directZarr = null;
                    int[]? directZarrChannels = null;
                    if (SelectedImage.IsZarrSource)
                    {
                        if (Mode == ViewMode.RGBImage)
                        {
                            directZarr = SelectedImage;
                            directZarrChannels = SelectedRgbChannels(SelectedImage);
                        }
                        else if (Mode == ViewMode.Filtered)
                        {
                            // Use the same direct, coordinate-aware Zarr reader as
                            // RGB mode. Repeating the selected channel produces the
                            // expected grayscale Filtered view and avoids the legacy
                            // buffered plane path that could remain stuck on Z=0.
                            int channel = Math.Clamp(GetCoordinate().C, 0,
                                Math.Max(0, SelectedImage.SizeC - 1));
                            directZarr = SelectedImage;
                            directZarrChannels = new[] { channel, channel, channel };
                        }
                    }
 
                    await slideRenderer.UpdateViewAsync(
                        PyramidalOrigin,
                        gl.Width,
                        gl.Height,
                        Resolution,
                        GetCoordinate(),
                        directZarr,
                        Mode == ViewMode.RGBImage ? SelectedRgbChannels(SelectedImage) : directZarrChannels
                    );
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Trace.WriteLine($"Could not update slide view: {ex}");
                }
                RefreshPyramidalOverlayTexture();
                UpdateScrollBars();
                // Pyramidal images are drawn from tiles, not the full-plane buffers below.
                return;
            }
 
            if (SelectedImage.IsZarrSource &&
                (Mode == ViewMode.RGBImage || Mode == ViewMode.Filtered) &&
                Images.Count == 1 && SelectedImage.levels?.Count > 0)
            {
                var image = SelectedImage;
                var requestedMode = Mode;
                int request = ++zarrRgbRequest;
                int width = image.Buffers[0].SizeX, height = image.Buffers[0].SizeY;
                try
                {
                    int[] channels;
                    if (requestedMode == ViewMode.RGBImage)
                    {
                        channels = SelectedRgbChannels(image);
                    }
                    else
                    {
                        int channel = Math.Clamp(GetCoordinate().C, 0,
                            Math.Max(0, image.SizeC - 1));
                        channels = new[] { channel, channel, channel };
                    }
 
                    byte[] rgba = await ZarrChannelView.ReadRgbTileAsync(image, 0, 0, 0, width, height,
                        GetCoordinate(), channels);
                    if (request != zarrRgbRequest || SelectedImage != image || Mode != requestedMode)
                        return;
                    var frame = new System.Drawing.Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
                    var data = frame.LockBits(new System.Drawing.Rectangle(0, 0, width, height),
                        System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
                    try
                    {
                        for (int i = 0; i < rgba.Length; i += 4)
                            (rgba[i], rgba[i + 2]) = (rgba[i + 2], rgba[i]);
                        for (int row = 0; row < height; row++)
                            Marshal.Copy(rgba, row * width * 4, IntPtr.Add(data.Scan0, row * data.Stride), width * 4);
                    }
                    finally { frame.UnlockBits(data); }
                    foreach (var old in Bitmaps) old?.Dispose();
                    Bitmaps.Clear();
                    Bitmaps.Add(frame);
                    update = true;
                    UpdateRegularOverview();
                    InvalidateView();
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Trace.WriteLine($"Could not render Zarr RGB channels: {ex.Message}");
                }
                return;
            }
 
            // AForge's filters copy from unmanaged pixel pointers. Missing or disposed
            // buffers have a null pointer, so keep the last frame until pixels are available.
            foreach (BioImage image in Images)
            {
                int index = image.GetFrameIndex(zBar.Value, cBar.Value, tBar.Value);
                bool unavailable = index < 0 || index >= image.Buffers.Count;
                if (!unavailable)
                {
                    var buffers = Mode == ViewMode.Filtered || Mode == ViewMode.Raw
                        ? new[] { image.Buffers[index] }
                        : image.Buffers.AsEnumerable();
                    unavailable = buffers.Any(buffer =>
                        buffer == null || buffer.Bytes == null || buffer.Bytes.Length == 0);
                }
                if (unavailable)
                {
                    System.Diagnostics.Trace.WriteLine($"Image pixels are unavailable: {image.ID}");
                    return;
                }
            }
            for (int i = 0; i < Bitmaps.Count; i++)
            {
                Bitmaps[i].Dispose();
                Bitmaps[i] = null;
            }
            Bitmaps.Clear();
            if (zBar.Maximum != SelectedImage.SizeZ - 1 || tBar.Maximum != SelectedImage.SizeT - 1)
            {
                InitGUI();
            }
 
            int bi = 0;
            foreach (BioImage b in Images)
            {
                if (b.isPyramidal)
                    b.PyramidalOrigin = PyramidalOrigin;
                b.PyramidalSize = new AForge.Size(gl.Width, gl.Height);
                ZCT coords = new ZCT(zBar.Value, cBar.Value, tBar.Value);
                Bitmap bitmap = null;
 
                int index = b.Coords[zBar.Value, cBar.Value, tBar.Value];
                if (Mode == ViewMode.Filtered)
                {
                    bitmap = b.GetFiltered(coords, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                }
                else if (Mode == ViewMode.RGBImage)
                {
                    if (b.Buffers[0].RGBChannelsCount == 1)
                    {
                        var planes = new Bitmap[3];
                        for (int color = 0; color < 3; color++)
                        {
                            int channel = Math.Clamp(b.rgbChannels[color], 0, b.SizeC - 1);
                            planes[2 - color] = b.Buffers[b.GetFrameIndex(coords.Z, channel, coords.T)];
                        }
                        bitmap = Bitmap.GetRGBBitmap(planes, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                    }
                    else
                        bitmap = b.GetRGBBitmap(coords, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                }
                else if (Mode == ViewMode.Raw)
                {
                    bitmap = (Bitmap)b.Buffers[index].GetImageRGBA();
                }
                else
                {
                    bitmap = b.GetEmission(coords, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                }
                var display = ToSysBitmap(bitmap);
                if (Mode == ViewMode.RGBImage)
                    MaskRgbComponents(display, rgbEnabled);
                Bitmaps.Add(display);
                bi++;
            }
            UpdateRegularOverview();
            update = true;
            InvalidateView();
        }
 
        private void UpdateRenderSurfaceMode()
        {
            if (SelectedImage == null)
            {
                hScrollBar.Visible = false;
                vScrollBar.Visible = false;
                PerformLayout();
                if (overviewPanel != null)
                    overviewPanel.Visible = false;
                return;
            }
 
            if (UsesSlideRenderer(SelectedImage))
            {
                if (gl.Parent != viewpanel)
                    viewpanel.Controls.Add(gl);
                if (!gl.Visible)
                    gl.Visible = true;
                BringRenderSurfacesToFront();
            }
            else
            {
                if (gl.Visible)
                    gl.Visible = false;
                if (gl.Parent == viewpanel)
                    viewpanel.Controls.Remove(gl);
                gl.ClearOverlayBitmap();
            }
            hScrollBar.Visible = UsesSlideRenderer(SelectedImage);
            vScrollBar.Visible = UsesSlideRenderer(SelectedImage);
            PerformLayout();
            UpdateOverviewVisibility();
        }
        bool drawing = false;
        public void RemoveImage(int i)
        {
            do
            {
                System.Threading.Thread.Sleep(50);
                Application.DoEvents();
            } while (drawing || updating);
            Images[i].Dispose();
            Images.RemoveAt(i);
            UpdateImages();
        }
        public void RemoveImages()
        {
            do
            {
                Thread.Sleep(50);
                Application.DoEvents();
            } while (drawing || updating);
            for (int i = 0; i < Images.Count; i++)
            {
                Images[i].Dispose();
            }
            Images.Clear();
            UpdateImages();
        }
        Bitmap bitmap;
        public void UpdateImage()
        {
            UpdateImages();
        }
        private void channelBoxR_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (initializingRgbSelectors || SelectedImage == null || channelBoxR.SelectedIndex == -1)
                return;
            rgbEnabled[0] = channelBoxR.SelectedIndex > 0;
            if (rgbEnabled[0]) SelectedImage.rgbChannels[0] = channelBoxR.SelectedIndex - 1;
            update = true;
            UpdateView();
        }
        private void channelBoxG_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (initializingRgbSelectors || SelectedImage == null || channelBoxG.SelectedIndex == -1)
                return;
            rgbEnabled[1] = channelBoxG.SelectedIndex > 0;
            if (rgbEnabled[1]) SelectedImage.rgbChannels[1] = channelBoxG.SelectedIndex - 1;
            update = true;
            UpdateView();
        }
        private void channelBoxB_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (initializingRgbSelectors || SelectedImage == null || channelBoxB.SelectedIndex == -1)
                return;
            rgbEnabled[2] = channelBoxB.SelectedIndex > 0;
            if (rgbEnabled[2]) SelectedImage.rgbChannels[2] = channelBoxB.SelectedIndex - 1;
            update = true;
            UpdateView();
        }
        private void showControlsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ShowControls = !ShowControls;
        }
        private void playZToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (playZToolStripMenuItem.Checked)
            {
                //We stop
                playZToolStripMenuItem.Checked = false;
                stopZToolStripMenuItem.Checked = true;
                zTimer.Stop();
            }
            else
            {
                //We start
                playZToolStripMenuItem.Checked = true;
                stopZToolStripMenuItem.Checked = false;
                zTimer.Start();
            }
        }
        private void stopZToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (stopZToolStripMenuItem.Checked)
            {
                //We start
                playZToolStripMenuItem.Checked = true;
                stopZToolStripMenuItem.Checked = false;
                zTimer.Start();
 
            }
            else
            {
                //We stop
                playZToolStripMenuItem.Checked = false;
                stopZToolStripMenuItem.Checked = true;
                zTimer.Stop();
            }
        }
        private void playTimeToolStripMenu_Click(object sender, EventArgs e)
        {
            if (playTimeToolStripMenu.Checked)
            {
                //We stop
                playTimeToolStripMenu.Checked = false;
                stopTimeToolStripMenu.Checked = true;
                timelineTimer.Stop();
            }
            else
            {
                //We start
                playTimeToolStripMenu.Checked = true;
                stopTimeToolStripMenu.Checked = false;
                timelineTimer.Start();
            }
        }
        private void stopTimeToolStripMenu_Click(object sender, EventArgs e)
        {
            playTimeToolStripMenu.Checked = false;
            stopTimeToolStripMenu.Checked = true;
            timelineTimer.Stop();
        }
        private void playCToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (playCToolStripMenuItem.Checked)
            {
                //We stop
                playCToolStripMenuItem.Checked = false;
                stopCToolStripMenuItem.Checked = true;
                cTimer.Stop();
            }
            else
            {
                //We start
                playCToolStripMenuItem.Checked = true;
                stopCToolStripMenuItem.Checked = false;
                cTimer.Start();
            }
        }
        private void stopCToolStripMenuItem_Click(object sender, EventArgs e)
        {
            stopCToolStripMenuItem.Checked = false;
            playCToolStripMenuItem.Checked = true;
            cTimer.Stop();
        }
        private string mousePoint = "";
        private string mouseColor = "";
        private void playSpeedToolStripMenuItem_Click(object sender, EventArgs e)
        {
            PlaySpeed sp = null;
            if (Mode == ViewMode.RGBImage)
                sp = new PlaySpeed(timeEnabled, false, ZFps, TimeFps, CFps);
            else
                sp = new PlaySpeed(timeEnabled, true, ZFps, TimeFps, CFps);
            if (sp.ShowDialog() != DialogResult.OK)
                return;
            zTimer.Interval = sp.TimePlayspeed;
            cTimer.Interval = sp.CPlayspeed;
            timelineTimer.Interval = sp.TimePlayspeed;
        }
        private void playSpeedToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            PlaySpeed sp = null;
            if (Mode == ViewMode.RGBImage)
                sp = new PlaySpeed(timeEnabled, false, ZFps, TimeFps, CFps);
            else
                sp = new PlaySpeed(timeEnabled, true, ZFps, TimeFps, CFps);
            if (sp.ShowDialog() != DialogResult.OK)
                return;
            zTimer.Interval = sp.TimePlayspeed;
            cTimer.Interval = sp.CPlayspeed;
            timelineTimer.Interval = sp.TimePlayspeed;
        }
        private void CPlaySpeedToolStripMenuItem_Click(object sender, EventArgs e)
        {
            PlaySpeed sp = null;
            if (Mode == ViewMode.RGBImage)
                sp = new PlaySpeed(timeEnabled, false, ZFps, TimeFps, CFps);
            else
                sp = new PlaySpeed(timeEnabled, true, ZFps, TimeFps, CFps);
            if (sp.ShowDialog() != DialogResult.OK)
                return;
            zTimer.Interval = sp.TimePlayspeed;
            cTimer.Interval = sp.CPlayspeed;
            timelineTimer.Interval = sp.TimePlayspeed;
        }
        public void GetRange()
        {
            RangeTool t;
            if (Mode == ViewMode.Filtered)
                t = new RangeTool(timeEnabled, true, zBar.Minimum, zBar.Maximum, tBar.Minimum, tBar.Maximum, cBar.Minimum, cBar.Maximum);
            else
                t = new RangeTool(timeEnabled, false, zBar.Minimum, zBar.Maximum, tBar.Minimum, tBar.Maximum, cBar.Minimum, cBar.Maximum);
            if (t.ShowDialog() != DialogResult.OK)
                return;
            zBar.Minimum = t.ZMin;
            zBar.Maximum = t.ZMax;
            tBar.Minimum = t.TimeMin;
            tBar.Maximum = t.TimeMax;
            cBar.Minimum = t.CMin;
            cBar.Maximum = t.CMax;
        }
        private void setValueRangeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            GetRange();
        }
        private void setValueRangeToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            GetRange();
        }
        private void setCValueRangeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            GetRange();
        }
        private void ImageView_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e is HandledMouseEventArgs handled && handled.Handled)
                return;
            var source = sender as System.Windows.Forms.Control ?? this;
            System.Drawing.Point cursor = source.Parent == viewpanel
                ? new System.Drawing.Point(source.Left + e.X, source.Top + e.Y)
                : viewpanel.PointToClient(source.PointToScreen(e.Location));
            if (e.Delta == 0 || !viewpanel.ClientRectangle.Contains(cursor) || Images.Count == 0)
                return;
 
            App.viewer = this;
            Plugins.ScrollEvent(sender, e);
            if (e is HandledMouseEventArgs wheel)
            {
                if (wheel.Handled)
                    return;
                // Prevent a canvas event from bubbling up and zooming a second time.
                wheel.Handled = true;
            }
 
            const double minZoom = 0.000001;
            const double maxZoom = 1000000;
            double factor = Math.Pow(1.2, e.Delta / 120.0);
            PointD anchor = ImageToViewSpace(cursor.X, cursor.Y);
            if (SelectedImage.isPyramidal)
            {
                // Resolution is world units per screen pixel, so zooming in reduces it.
                Resolution = Math.Clamp(Resolution / factor, minZoom, maxZoom);
                PyramidalOrigin = new PointD(anchor.X - cursor.X * Resolution,
                    anchor.Y - cursor.Y * Resolution);
                Tools.selectBoxSize = (float)(ROI.selectBoxSize * Resolution);
                UpdateImages();
            }
            else
            {
                // Clamp the common factor to preserve the X/Y scale ratio.
                factor = Math.Clamp(factor,
                    minZoom / Math.Min(Scale.Width, Scale.Height),
                    maxZoom / Math.Max(Scale.Width, Scale.Height));
                Scale = new SizeF((float)(Scale.Width * factor), (float)(Scale.Height * factor));
                PointD shifted = ImageToViewSpace(cursor.X, cursor.Y);
                Origin = new PointD(Origin.X + shifted.X - anchor.X, Origin.Y + shifted.Y - anchor.Y);
            }
            UpdateView();
        }
 
        private void ZoomPyramidalAt(System.Drawing.Point mouseLocation, double zoomFactor)
        {
            if (SelectedImage == null || !SelectedImage.isPyramidal)
                return;
 
            double oldResolution = Resolution;
            double oldOriginX = PyramidalOrigin.X;
            double oldOriginY = PyramidalOrigin.Y;
            double newResolution = oldResolution * zoomFactor;
            if (newResolution <= 0 || Math.Abs(newResolution - oldResolution) < double.Epsilon)
                return;
 
            // PyramidalOrigin is stored in world units. Convert the cursor anchor
            // into the same space before changing resolution.
            double worldX = oldOriginX + (mouseLocation.X * oldResolution);
            double worldY = oldOriginY + (mouseLocation.Y * oldResolution);
 
            SelectedImage.Resolution = newResolution;
 
            var schema = SelectedImage.OpenSlideBase != null
                ? (BruTile.ITileSchema)SelectedImage.OpenSlideBase.Schema
                : SelectedImage.SlideBase.Schema;
 
            double newOriginX = worldX - (mouseLocation.X * Resolution);
            double newOriginY = worldY - (mouseLocation.Y * Resolution);
 
            double maxX = schema != null ? schema.Extent.MaxX : newOriginX;
            double maxY = schema != null ? -schema.Extent.MinY : newOriginY;
 
            PyramidalOrigin = new PointD(
                Math.Max(0, Math.Min(newOriginX, maxX)),
                Math.Max(0, Math.Min(newOriginY, maxY)));
 
            UpdateView();
        }
 
        private void ZTrackBar_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Delta > 0)
            {
                if (zBar.Value + 1 <= zBar.Maximum)
                    zBar.Value += 1;
            }
            else
            {
                if (zBar.Value - 1 >= zBar.Minimum)
                    zBar.Value -= 1;
            }
 
        }
        private void TimeTrackBar_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (!timeEnabled)
                return;
            if (e.Delta > 0)
            {
                if (tBar.Value + 1 <= tBar.Maximum)
                    tBar.Value += 1;
            }
            else
            {
                if (tBar.Value - 1 >= tBar.Minimum)
                    tBar.Value -= 1;
            }
        }
        private void CTrackBar_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Delta > 0)
            {
                if (cBar.Value + 1 <= cBar.Maximum)
                    cBar.Value += 1;
            }
            else
            {
                if (cBar.Value - 1 >= cBar.Minimum)
                    cBar.Value -= 1;
            }
        }
 
        private void cTimer_Tick(object sender, EventArgs e)
        {
            if (playCToolStripMenuItem.Checked)
            {
                if (cBar.Maximum >= cBar.Value + 1)
                    cBar.Value++;
                else
                {
                    if (loopC)
                        cBar.Value = cBar.Minimum;
                }
            }
        }
        private void zTimer_Tick(object sender, EventArgs e)
        {
            if (playZToolStripMenuItem.Checked)
            {
                if (zBar.Maximum >= zBar.Value + 1)
                    zBar.Value++;
                else
                {
                    if (loopZ)
                        zBar.Value = zBar.Minimum;
                }
            }
        }
        private void timer_Tick(object sender, EventArgs e)
        {
            if (playTimeToolStripMenu.Checked)
            {
                if (tBar.Maximum >= tBar.Value + 1)
                    tBar.Value++;
                else
                {
                    if (loopT)
                        tBar.Value = tBar.Minimum;
                }
            }
        }
        private void zBar_ValueChanged(object sender, EventArgs e)
        {
            if (initializingCoordinates || SelectedImage == null)
                return;
            SelectedImage.Coordinate = new ZCT(zBar.Value, SelectedImage.Coordinate.C, SelectedImage.Coordinate.T);
            update = true;
            UpdateView();
        }
        private void timeBar_ValueChanged(object sender, EventArgs e)
        {
            if (initializingCoordinates || SelectedImage == null)
                return;
            SelectedImage.Coordinate = new ZCT(SelectedImage.Coordinate.Z, SelectedImage.Coordinate.C, tBar.Value);
            update = true;
            UpdateView();
        }
        private void cBar_ValueChanged(object sender, EventArgs e)
        {
            if (initializingCoordinates || SelectedImage == null)
                return;
            SelectedImage.Coordinate = new ZCT(SelectedImage.Coordinate.Z, cBar.Value, SelectedImage.Coordinate.T);
            update = true;
            UpdateView();
        }
 
        private void loopTimeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            loopT = loopTimeToolStripMenuItem.Checked;
        }
        private void loopZToolStripMenuItem_Click(object sender, EventArgs e)
        {
            loopZ = loopZToolStripMenuItem.Checked;
        }
        private void loopCToolStripMenuItem_Click(object sender, EventArgs e)
        {
            loopC = loopCToolStripMenuItem.Checked;
        }
 
        public bool showRROIs = true;
        public bool showGROIs = true;
        public bool showBROIs = true;
 
        private List<ROI> annotationsR = new List<ROI>();
        public List<ROI> AnnotationsR
        {
            get
            {
                if (SelectedImage == null)
                    return new List<ROI>();
                return SelectedImage.Annotations.Where(an =>
                    an != null &&
                    an.coord.Z == SelectedImage.Coordinate.Z &&
                    an.coord.T == SelectedImage.Coordinate.T &&
                    (an.type == ROI.Type.Polygon || an.type == ROI.Type.Freeform || an.type == ROI.Type.Polyline || an.coord.C == RChannel.Index)).ToList();
            }
        }
        private List<ROI> annotationsG = new List<ROI>();
        public List<ROI> AnnotationsG
        {
            get
            {
                if (SelectedImage == null)
                    return new List<ROI>();
                return SelectedImage.Annotations.Where(an =>
                    an != null &&
                    an.coord.Z == SelectedImage.Coordinate.Z &&
                    an.coord.T == SelectedImage.Coordinate.T &&
                    (an.type == ROI.Type.Polygon || an.type == ROI.Type.Freeform || an.type == ROI.Type.Polyline || an.coord.C == GChannel.Index)).ToList();
            }
        }
        private List<ROI> annotationsB = new List<ROI>();
        public List<ROI> AnnotationsB
        {
            get
            {
                if (SelectedImage == null)
                    return new List<ROI>();
                return SelectedImage.Annotations.Where(an =>
                    an != null &&
                    an.coord.Z == SelectedImage.Coordinate.Z &&
                    an.coord.T == SelectedImage.Coordinate.T &&
                    (an.type == ROI.Type.Polygon || an.type == ROI.Type.Freeform || an.type == ROI.Type.Polyline || an.coord.C == BChannel.Index)).ToList();
            }
        }
        public List<ROI> AnnotationsRGB
        {
            get
            {
                if (SelectedImage == null)
                    return null;
                List<ROI> ans = new List<ROI>();
                if (Mode == ViewMode.RGBImage)
                {
                    if (showRROIs)
                        ans.AddRange(AnnotationsR);
                    if (showGROIs)
                        ans.AddRange(AnnotationsG);
                    if (showBROIs)
                        ans.AddRange(AnnotationsB);
                }
                else
                {
                    ans.AddRange(SelectedImage.Annotations.Where(an =>
                        an != null &&
                        an.coord.Z == SelectedImage.Coordinate.Z &&
                        an.coord.T == SelectedImage.Coordinate.T &&
                        (an.type == ROI.Type.Polygon || an.type == ROI.Type.Freeform || an.type == ROI.Type.Polyline || an.coord.C == SelectedImage.Coordinate.C)));
                }
                return ans;
            }
        }
        private System.Drawing.Point ToPoint(AForge.Point p)
        {
            return new System.Drawing.Point((int)p.X, (int)p.Y);
        }
        private System.Drawing.PointF ToPointF(PointD p)
        {
            return new System.Drawing.PointF((float)p.X, (float)p.Y);
        }
        private void DrawOverlay(System.Drawing.Graphics g)
        {
            if (SelectedImage == null)
                return;
            System.Drawing.Pen pen = null;
            System.Drawing.Pen red = null;
            System.Drawing.Pen green = null;
            System.Drawing.Pen mag = null;
            System.Drawing.Pen blue = null;
            Brush b = null;
            bool bounds = showBounds;
            bool labels = showText;
            ZCT cor = GetCoordinate();
            foreach (BioImage bi in Images)
            {
                if (!IsLayerEnabled(bi.PhysicalSizeX) && !bi.isPyramidal)
                    continue;
                foreach (ROI an in bi.Annotations)
                {
                    if (an.type == ROI.Type.Polygon || an.type == ROI.Type.Freeform || an.type == ROI.Type.Polyline)
                    {
                        if (zBar.Value != an.coord.Z || tBar.Value != an.coord.T)
                            continue;
                    }
                    else if (Mode == ViewMode.RGBImage)
                    {
                        if (!showRROIs && an.coord.C == 0)
                            continue;
                        if (!showGROIs && an.coord.C == 1)
                            continue;
                        if (!showBROIs && an.coord.C == 2)
                            continue;
                    }
                    else if (zBar.Value != an.coord.Z || cBar.Value != an.coord.C || tBar.Value != an.coord.T)
                        continue;
                    float w = Math.Abs(Scale.Width);
                    pen = new System.Drawing.Pen(new SolidBrush(System.Drawing.Color.FromArgb(an.strokeColor.R, an.strokeColor.G, an.strokeColor.B)), (float)an.strokeWidth / w);
                    red = new System.Drawing.Pen(Brushes.Red, (float)an.strokeWidth / w);
                    mag = new System.Drawing.Pen(Brushes.Magenta, (float)an.strokeWidth / w);
                    green = new System.Drawing.Pen(Brushes.Green, (float)an.strokeWidth / w);
                    blue = new System.Drawing.Pen(Brushes.Blue, (float)an.strokeWidth / w);
                    Font fo = new Font(an.family, (float)(an.strokeWidth / w) * an.fontSize);
                    if (an.Selected)
                    {
                        b = new SolidBrush(System.Drawing.Color.Magenta);
                    }
                    else
                        b = new SolidBrush(System.Drawing.Color.FromArgb(an.strokeColor.R, an.strokeColor.G, an.strokeColor.B));
                    PointF pc = new PointF((float)(an.BoundingBox.X + (an.BoundingBox.W / 2)), (float)(an.BoundingBox.Y + (an.BoundingBox.H / 2)));
                    float width = (float)ToViewSizeW(ROI.selectBoxSize / w);
                    if (SelectedImage.isPyramidal)
                    {
                        width = (float)(ROI.selectBoxSize * Resolution);
                    }
                    if (an.type == ROI.Type.Point)
                    {
                        PointD pt = ToScreenSpace(an.Points[0]);
                        g.FillEllipse(b, (float)pt.X - 2f, (float)pt.Y - 2f, 4f, 4f);
                        foreach (var item in ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize)))
                        {
                            g.DrawRectangle(red, new System.Drawing.RectangleF((float)item.X, (float)item.Y, (float)item.W, (float)item.H));
                        }
                    }
                    else
                    if (an.type == ROI.Type.Line)
                    {
                        g.DrawLine(pen, ToPointF(ToScreenSpace(an.Points[0])), ToPointF(ToScreenSpace(an.GetPoint(1))));
                        foreach (var item in ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize)))
                        {
                            g.DrawRectangle(red, new System.Drawing.RectangleF((float)item.X, (float)item.Y, (float)item.W, (float)item.H));
                        }
                    }
                    else
                    if (an.type == ROI.Type.Rectangle && an.BoundingBox.W > 0 && an.BoundingBox.H > 0)
                    {
                        RectangleD rec = ToScreenSpace(an.BoundingBox);
                        g.DrawRectangle(pen, new System.Drawing.RectangleF((float)rec.X, (float)rec.Y, (float)rec.W, (float)rec.H));
                        foreach (var item in ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize)))
                        {
                            g.DrawRectangle(red, new System.Drawing.RectangleF((float)item.X, (float)item.Y, (float)item.W, (float)item.H));
                        }
                    }
                    else
                    if (an.type == ROI.Type.Ellipse)
                    {
                        RectangleD rec = ToScreenSpace(an.BoundingBox);
                        g.DrawEllipse(pen, (float)rec.X, (float)rec.Y, (float)rec.W, (float)rec.H);
                        foreach (var item in ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize)))
                        {
                            g.DrawRectangle(red, new System.Drawing.RectangleF((float)item.X, (float)item.Y, (float)item.W, (float)item.H));
                        }
                    }
                    else
                    if (an.type == ROI.Type.Polygon && an.closed)
                    {
                        if (an.Points.Count > 1)
                        {
                            System.Drawing.PointF[] pts = new System.Drawing.PointF[an.Points.Count];
                            for (int i = 0; i < an.Points.Count; i++)
                            {
                                var p = ToScreenSpace(an.Points[i].X, an.Points[i].Y);
                                pts[i] = new System.Drawing.PointF((float)p.X, (float)p.Y);
                            }
                            g.DrawLines(pen, pts);
                            g.DrawLine(pen, pts[pts.Length - 1], pts[0]);
                        }
                        foreach (var item in ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize)))
                        {
                            g.DrawRectangle(red, new System.Drawing.RectangleF((float)item.X, (float)item.Y, (float)item.W, (float)item.H));
                        }
                    }
                    else
                    if (an.type == ROI.Type.Polygon && !an.closed)
                    {
                        if (an.Points.Count > 1)
                        {
                            System.Drawing.PointF[] pts = new System.Drawing.PointF[an.Points.Count];
                            for (int i = 0; i < an.Points.Count; i++)
                            {
                                var p = ToScreenSpace(an.Points[i].X, an.Points[i].Y);
                                pts[i] = new System.Drawing.PointF((float)p.X, (float)p.Y);
                            }
                            g.DrawLines(pen, pts);
                        }
                        foreach (var item in ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize)))
                        {
                            g.DrawRectangle(red, new System.Drawing.RectangleF((float)item.X, (float)item.Y, (float)item.W, (float)item.H));
                        }
                    }
                    else
                    if (an.type == ROI.Type.Polyline)
                    {
                        if (an.Points.Count > 1)
                        {
                            System.Drawing.PointF[] pts = new System.Drawing.PointF[an.Points.Count];
                            for (int i = 0; i < an.Points.Count; i++)
                            {
                                var p = ToScreenSpace(an.Points[i].X, an.Points[i].Y);
                                pts[i] = new System.Drawing.PointF((float)p.X, (float)p.Y);
                            }
                            g.DrawLines(pen, pts);
                        }
                        foreach (var item in ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize)))
                        {
                            g.DrawRectangle(red, new System.Drawing.RectangleF((float)item.X, (float)item.Y, (float)item.W, (float)item.H));
                        }
                    }
 
                    else
                    if (an.type == ROI.Type.Freeform && an.closed)
                    {
                        if (an.Points.Count > 1)
                        {
                            System.Drawing.PointF[] pts = new System.Drawing.PointF[an.Points.Count];
                            for (int i = 0; i < an.Points.Count; i++)
                            {
                                var p = ToScreenSpace(an.Points[i].X, an.Points[i].Y);
                                pts[i] = new System.Drawing.PointF((float)p.X, (float)p.Y);
                            }
                            g.DrawLines(pen, pts);
                            g.DrawLine(pen, pts[pts.Length - 1], pts[0]);
                        }
                        if (an.Selected)
                        {
                            foreach (var item in ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize)))
                            {
                                g.DrawRectangle(red, new System.Drawing.RectangleF((float)item.X, (float)item.Y, (float)item.W, (float)item.H));
                            }
                        }
                    }
                    else
                    if (an.type == ROI.Type.Freeform && !an.closed)
                    {
                        if (an.Points.Count > 1)
                        {
                            System.Drawing.PointF[] pts = new System.Drawing.PointF[an.Points.Count];
                            for (int i = 0; i < an.Points.Count; i++)
                            {
                                var p = ToScreenSpace(an.Points[i].X, an.Points[i].Y);
                                pts[i] = new System.Drawing.PointF((float)p.X, (float)p.Y);
                            }
                            g.DrawLines(pen, pts);
                        }
                        if (an.Selected)
                        {
                            foreach (var item in ToScreenSpace(an.GetSelectBoxes(Tools.selectBoxSize)))
                            {
                                g.DrawRectangle(red, new System.Drawing.RectangleF((float)item.X, (float)item.Y, (float)item.W, (float)item.H));
                            }
                        }
                    }
                    if (an.type == ROI.Type.Label)
                    {
                        System.Drawing.RectangleF rec = GetLabelScreenRect(an);
                        using Font labelFont = GetScaledLabelFont(an, w);
                        System.Drawing.Size textSize = System.Windows.Forms.TextRenderer.MeasureText(an.Text ?? string.Empty, labelFont);
                        float tx = rec.X + ((rec.Width - textSize.Width) / 2f);
                        float ty = rec.Y + ((rec.Height - textSize.Height) / 2f);
                        g.DrawString(an.Text ?? string.Empty, labelFont, b, tx, ty);
                        g.DrawRectangle(red, rec.X, rec.Y, rec.Width, rec.Height);
                    }
                    if (labels)
                    {
                        if (an.type == ROI.Type.Label)
                            continue;
                        System.Drawing.SizeF s = System.Windows.Forms.TextRenderer.MeasureText(an.Text, new Font(an.family, an.fontSize));
                        //Lets draw the text of this ROI in the middle of the RO
                        float fw = ((float)an.BoundingBox.X + ((float)an.BoundingBox.W / 2)) - ((float)s.Width / 2);
                        float fh = ((float)an.BoundingBox.Y + ((float)an.BoundingBox.H / 2)) - ((float)s.Height / 2);
                        var v = ToScreenSpace(new PointF(fw, fh));
                        g.DrawString(an.Text, fo, b, v.X, v.Y);
                    }
                    if (bounds)
                    {
                        if (an.type == ROI.Type.Point)
                        {
                            var pv = ToScreenSpace(an.Points[0]);
                            g.FillEllipse(Brushes.Green, (float)pv.X - 2f, (float)pv.Y - 2f, 4f, 4f);
                        }
                        else if (an.type == ROI.Type.Label)
                        {
                            System.Drawing.RectangleF rec = GetLabelScreenRect(an);
                            g.DrawRectangle(green, rec.X, rec.Y, rec.Width, rec.Height);
                        }
                        else
                        {
                            var rb = ToScreenSpace(an.BoundingBox);
                            g.DrawRectangles(green, new System.Drawing.RectangleF[1] { new System.Drawing.RectangleF((float)rb.X, (float)rb.Y, (float)rb.W, (float)rb.H) });
                        }
                    }
                    if (an.Selected)
                    {
                        if (an.type == ROI.Type.Point)
                        {
                            var pv = ToScreenSpace(an.Points[0]);
                            g.FillEllipse(Brushes.Magenta, (float)pv.X - 2f, (float)pv.Y - 2f, 4f, 4f);
                            continue;
                        }
                        else if (an.type == ROI.Type.Label)
                        {
                            System.Drawing.RectangleF rec = GetLabelScreenRect(an);
                            g.DrawRectangle(mag, rec.X, rec.Y, rec.Width, rec.Height);
                            continue;
                        }
 
                        //Lets draw the bounding box.
                        var rb = ToScreenSpace(an.BoundingBox);
                        g.DrawRectangles(mag, new System.Drawing.RectangleF[1] { new System.Drawing.RectangleF((float)rb.X, (float)rb.Y, (float)rb.W, (float)rb.H) });
                        //Lets draw the selectBoxes.
                        List<RectangleD> rects = new List<RectangleD>();
                        RectangleD[] sels = an.GetSelectBoxes(Tools.selectBoxSize);
                        for (int i = 0; i < an.selectedPoints.Count; i++)
                        {
                            if (an.selectedPoints[i] < an.GetPointCount())
                            {
                                rects.Add(sels[an.selectedPoints[i]]);
                            }
                        }
                        for (int i = 0; i < rects.Count; i++)
                        {
                            var va = ToScreenSpace(rects.ToArray());
                            g.DrawRectangle(blue, new System.Drawing.RectangleF((float)va[0].X, (float)va[0].Y, (float)va[0].W, (float)va[0].H));
                        }
 
                        rects.Clear();
                        //Lets draw the text of this ROI in the middle of the ROI
                    if (an.type == ROI.Type.Label)
                        continue;
                    System.Drawing.Size s = System.Windows.Forms.TextRenderer.MeasureText(an.Text, new Font(an.family, an.fontSize));
                    float fw = ((float)an.BoundingBox.X + ((float)an.BoundingBox.W / 2)) - ((float)s.Width / 2);
                    float fh = ((float)an.BoundingBox.Y + ((float)an.BoundingBox.H / 2)) - ((float)s.Height / 2);
                    var vv = ToScreenSpace(new PointF(fw, fh));
                    g.DrawString(an.Text, fo, b, vv.X, vv.Y);
                }
                if (Tools.currentTool != null && Tools.currentTool.type == Tools.Tool.Type.rectSel)
                {
                    RectangleD sel = Tools.currentTool.Rectangle;
                    if (sel.W != 0 || sel.H != 0)
                    {
                        double x = Math.Min(sel.X, sel.X + sel.W);
                        double y = Math.Min(sel.Y, sel.Y + sel.H);
                        double selW = Math.Abs(sel.W);
                        double selH = Math.Abs(sel.H);
                        RectangleD normalized = new RectangleD(x, y, selW, selH);
                        RectangleD rec = ToScreenSpace(normalized);
                        g.DrawRectangle(blue, new System.Drawing.RectangleF((float)rec.X, (float)rec.Y, (float)rec.W, (float)rec.H));
                    }
                }
                    pen.Dispose();
                    red.Dispose();
                    mag.Dispose();
                    green.Dispose();
                    blue.Dispose();
                    b.Dispose();
                }
            }
        }
        AForge.SizeF dSize = new AForge.SizeF(1, 1);
        public void DrawView(System.Drawing.Graphics g)
        {
            try
            {
                drawing = true;
                if (SelectedImage == null)
                    return;
                if (UsesSlideRenderer(SelectedImage))
                {
                    UpdateImages();
                    return;
                }
                g.TranslateTransform(ViewWidth / 2, ViewHeight / 2);
                if (Scale.Width == 0 || float.IsInfinity(Scale.Width))
                    Scale = new SizeF(1, 1);
                g.ScaleTransform(Scale.Width, Scale.Height);
                if (Bitmaps.Count == 0)
                    return;
                System.Drawing.RectangleF[] rf = new System.Drawing.RectangleF[1];
                System.Drawing.Pen blue = new System.Drawing.Pen(Brushes.Blue, 1 / Scale.Width);
                int i = 0;
                foreach (BioImage im in Images)
                {
                    if (!IsLayerEnabled(im.PhysicalSizeX) && !im.isPyramidal)
                        continue;
                    RectangleD r = ToScreenRect(im.Volume.Location.X, im.Volume.Location.Y, im.Volume.Width, im.Volume.Height);
                    double w = ToViewW(ViewWidth);
                    double h = ToViewH(ViewHeight);
                    RectangleF rg = new RectangleF((float)((-Origin.X) - (w / 2)), (float)((-Origin.Y) - (h / 2)), (float)(w), (float)(h));
                    RectangleF rec = new RectangleF((float)im.Volume.Location.X, (float)im.Volume.Location.Y, (float)im.Volume.Width, (float)im.Volume.Height);
                    if (SelectedImage.isPyramidal)
                    {
                        var tr = g.Transform;
                        g.ResetTransform();
                        g.DrawImage(Bitmaps[i], 0, 0);
                        g.Transform = tr;
                    }
                    else
                    if (rg.IntersectsWith(rec))
                    {
                        g.DrawImage(Bitmaps[i], (float)r.X, (float)r.Y, (float)r.W, (float)r.H);
                    }
                    if (i == SelectedIndex && !SelectedImage.isPyramidal)
                    {
                        rf[0] = new System.Drawing.RectangleF((float)r.X, (float)r.Y, (float)r.W, (float)r.H);
                        g.DrawRectangles(blue, rf);
                    }
                    i++;
                }
                if (ShowStage)
                {
                    RectangleD d = Microscope.GetViewRectangle(false);
                    RectangleF[] rfs = new RectangleF[1] { new RectangleF((float)d.X, (float)d.Y, (float)d.W, (float)d.H) };
                    var v = ToScreenSpace(rfs);
                    System.Drawing.Pen red = new System.Drawing.Pen(Brushes.Red, 1 / Scale.Width);
                    g.DrawRectangle(red, v[0].X, v[0].Y, v[0].Width, v[0].Height);
                }
                blue.Dispose();
                update = false;
                drawing = false;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
        private void pictureBox_Paint(object sender, PaintEventArgs e)
        {
            update = true;
            //
            BringRenderSurfacesToFront();
            //Render(gl.CreateGraphics());
            DrawView(gl.CreateGraphics());
            Plugins.Paint(sender, e);
        }
 
        private void Viewpanel_Paint(object sender, PaintEventArgs e)
        {
            if (SelectedImage == null)
                return;
            if (UsesSlideRenderer(SelectedImage))
            {
                return;
            }
            DrawView(e.Graphics);
            DrawOverlay(e.Graphics);
            Render(e.Graphics);
        }
 
        public double GetScale()
        {
            return GetSelectionBoxHitSize();
        }
 
        public double GetSelectionBoxHitSize()
        {
            return GetSelectBoxSizeForScreenPixels(MinSelectionHitScreenSize);
        }
        private System.Drawing.Bitmap ToSysBitmap(Bitmap bm)
        {
            if (bm == null)
                return null;
            if (bm.PixelFormat == AForge.PixelFormat.Format16bppGrayScale)
            {
                var grayResult = new System.Drawing.Bitmap(
                    bm.Width,
                    bm.Height,
                    System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                int min = int.MaxValue;
                int max = int.MinValue;
                for (int y = 0; y < bm.Height; y++)
                {
                    for (int x = 0; x < bm.Width; x++)
                    {
                        int value = (int)bm.GetValue(x, y, 0);
                        if (value < min)
                            min = value;
                        if (value > max)
                            max = value;
                    }
                }
                if (max <= min)
                    max = min + 1;
 
                var grayRect = new System.Drawing.Rectangle(0, 0, bm.Width, bm.Height);
                var grayData = grayResult.LockBits(grayRect, System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                try
                {
                    int dstStride = Math.Abs(grayData.Stride);
                    unsafe
                    {
                        for (int y = 0; y < bm.Height; y++)
                        {
                            byte* dstRow = (byte*)grayData.Scan0 + (y * dstStride);
                            for (int x = 0; x < bm.Width; x++)
                            {
                                byte value = (byte)(((int)bm.GetValue(x, y, 0) - min) * 255 / (max - min));
                                int offset = x * 3;
                                dstRow[offset] = value;
                                dstRow[offset + 1] = value;
                                dstRow[offset + 2] = value;
                            }
                        }
                    }
                }
                finally
                {
                    grayResult.UnlockBits(grayData);
                }
 
                return grayResult;
            }
 
            var rgba = bm.GetImageRGBA();
            var result = new System.Drawing.Bitmap(
                bm.Width,
                bm.Height,
                System.Drawing.Imaging.PixelFormat.Format32bppArgb);
 
            var rect = new System.Drawing.Rectangle(0, 0, bm.Width, bm.Height);
            var data = result.LockBits(rect, System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
            try
            {
                int bytes = bm.Width * bm.Height * 4;
                byte[] buffer = new byte[bytes];
                Marshal.Copy(rgba.Data, buffer, 0, bytes);
                Marshal.Copy(buffer, 0, data.Scan0, bytes);
            }
            finally
            {
                result.UnlockBits(data);
            }
 
            return result;
        }
 
        PointD mouseD = new PointD(0, 0);
        PointD prevMove = new PointD();
        private PointD GetStatusPoint(PointD p)
        {
            if (SelectedImage != null && SelectedImage.isPyramidal && Resolution != 0)
                return new PointD(p.X / Resolution, p.Y / Resolution);
            return p;
        }
        private void UpdateMouseStatus(PointD p)
        {
            if (SelectedImage == null)
                return;
 
            PointD displayPoint = GetStatusPoint(p);
            PointD samplePoint = SelectedImage.isPyramidal
                ? new PointD((p.X / Resolution) - PyramidalOrigin.X, (p.Y / Resolution) - PyramidalOrigin.Y)
                : p;
 
            mousePoint = "(" + (int)displayPoint.X + ", " + (int)displayPoint.Y + ")";
            mouseColor = "";
 
            AForge.Point s = SelectedImage.isPyramidal
                ? new AForge.Point(
                    Math.Max(1, SelectedImage.Resolutions[Math.Clamp(SelectedImage.Level, 0, SelectedImage.Resolutions.Count - 1)].SizeX),
                    Math.Max(1, SelectedImage.Resolutions[Math.Clamp(SelectedImage.Level, 0, SelectedImage.Resolutions.Count - 1)].SizeY))
                : new AForge.Point(SelectedImage.SizeX, SelectedImage.SizeY);
            if (samplePoint.X < 0 || samplePoint.Y < 0 || samplePoint.X >= s.X || samplePoint.Y >= s.Y)
                return;
 
            int zc = SelectedImage.Coordinate.Z;
            int cc = SelectedImage.Coordinate.C;
            int tc = SelectedImage.Coordinate.T;
            if (SelectedImage.isPyramidal &&
                SelectedImage.Resolutions.Count > 0 &&
                SelectedImage.Resolutions[Math.Clamp(SelectedImage.Level, 0, SelectedImage.Resolutions.Count - 1)].PixelFormat == AForge.PixelFormat.Format16bppGrayScale)
            {
                try
                {
                    int frameIndex = SelectedImage.GetFrameIndex(zc, cc, tc);
                    int level = Math.Clamp(SelectedImage.Level, 0, SelectedImage.Resolutions.Count - 1);
                    int sx = (int)Math.Floor(samplePoint.X);
                    int sy = (int)Math.Floor(samplePoint.Y);
                    byte[] raw = SelectedImage.GetTileBytesRaw(frameIndex, level, sx, sy, 1, 1, SelectedImage.Coordinate)
                        .GetAwaiter()
                        .GetResult();
                    if (raw != null && raw.Length >= 2)
                    {
                        ushort value = (ushort)(raw[0] | (raw[1] << 8));
                        mouseColor = ", " + value;
                        return;
                    }
                }
                catch
                {
                    // Fall back to the generic buffer-backed path below.
                }
            }
            if (SelectedImage.isPyramidal)
            {
                try
                {
                    int frameIndex = SelectedImage.GetFrameIndex(zc, cc, tc);
                    int level = Math.Clamp(SelectedImage.Level, 0, SelectedImage.Resolutions.Count - 1);
                    int sx = (int)Math.Floor(samplePoint.X);
                    int sy = (int)Math.Floor(samplePoint.Y);
                    using Bitmap rawTile = SelectedImage.GetTile(frameIndex, level, sx, sy, 1, 1, SelectedImage.Coordinate, true)
                        .GetAwaiter()
                        .GetResult();
                    if (rawTile != null)
                    {
                        switch (rawTile.PixelFormat)
                        {
                            case AForge.PixelFormat.Format8bppIndexed:
                                mouseColor = ", " + (int)rawTile.GetValue(0, 0, 0);
                                return;
                            case AForge.PixelFormat.Format16bppGrayScale:
                                mouseColor = ", " + (int)rawTile.GetValue(0, 0, 0);
                                return;
                            case AForge.PixelFormat.Format24bppRgb:
                            case AForge.PixelFormat.Format32bppArgb:
                            case AForge.PixelFormat.Format32bppRgb:
                            case AForge.PixelFormat.Format32bppPArgb:
                                {
                                    int b = (int)rawTile.GetValue(0, 0, 0);
                                    int g = (int)rawTile.GetValue(0, 0, 1);
                                    int r = (int)rawTile.GetValue(0, 0, 2);
                                    mouseColor = ", " + r + "," + g + "," + b;
                                    return;
                                }
                            case AForge.PixelFormat.Format48bppRgb:
                                {
                                    int b = (int)rawTile.GetValue(0, 0, 0);
                                    int g = (int)rawTile.GetValue(0, 0, 1);
                                    int r = (int)rawTile.GetValue(0, 0, 2);
                                    mouseColor = ", " + r + "," + g + "," + b;
                                    return;
                                }
                        }
                    }
                }
                catch
                {
                    // Fall back to the generic buffer-backed path below.
                }
            }
            if (SelectedImage.isRGB)
            {
                int r = (int)SelectedImage.GetValueRGB(zc, RChannel.Index, tc, (int)samplePoint.X, (int)samplePoint.Y, 0);
                int g = (int)SelectedImage.GetValueRGB(zc, GChannel.Index, tc, (int)samplePoint.X, (int)samplePoint.Y, 1);
                int b = (int)SelectedImage.GetValueRGB(zc, BChannel.Index, tc, (int)samplePoint.X, (int)samplePoint.Y, 2);
                mouseColor = ", " + r + "," + g + "," + b;
            }
            else
            {
                int r = (int)SelectedImage.GetValueRGB(zc, 0, tc, (int)samplePoint.X, (int)samplePoint.Y, 0);
                mouseColor = ", " + r;
            }
        }
        private void rgbPictureBox_MouseMove(object sender, MouseEventArgs e)
        {
            App.viewer = this;
            PointD p = ImageToViewSpace(e.Location.X, e.Location.Y);
            tools.ToolMove(p, e.Button);
            mouseMove = p;
            MouseMoveInt = new PointD(e.X, e.Y);
            if (SelectedImage == null)
                return;
            UpdateMouseStatus(p);
            if (e.Button == MouseButtons.XButton1 && !x1State && !Ctrl && Mode != ViewMode.RGBImage)
            {
                if (cBar.Value < cBar.Maximum)
                    cBar.Value++;
                x1State = true;
            }
            else if (e.Button == MouseButtons.XButton1 && !x1State && Ctrl)
            {
                if (tBar.Value < tBar.Maximum)
                    tBar.Value++;
                x1State = true;
            }
            if (e.Button != MouseButtons.XButton1)
                x1State = false;
 
            if (e.Button == MouseButtons.XButton2 && !x2State && !Ctrl && Mode != ViewMode.RGBImage)
            {
                if (cBar.Value > cBar.Minimum)
                    cBar.Value--;
                x2State = true;
            }
            else if (e.Button == MouseButtons.XButton2 && !x2State && Ctrl)
            {
                if (tBar.Value > tBar.Minimum)
                    tBar.Value--;
                x2State = true;
            }
            if (e.Button != MouseButtons.XButton2)
                x2State = false;
 
            if (Tools.currentTool.type == Tools.Tool.Type.move && e.Button == MouseButtons.Left)
            {
                foreach (ROI an in selectedAnnotations)
                {
                    if (an.selectedPoints.Count > 0 && an.selectedPoints.Count < an.GetPointCount())
                    {
                        if (an.type == ROI.Type.Rectangle || an.type == ROI.Type.Ellipse)
                        {
                            RectangleD d = an.BoundingBox;
                            if (an.selectedPoints[0] == 0)
                            {
                                double dw = d.X - p.X;
                                double dh = d.Y - p.Y;
                                d.X = p.X;
                                d.Y = p.Y;
                                d.W += dw;
                                d.H += dh;
                            }
                            else
                            if (an.selectedPoints[0] == 1)
                            {
                                double dw = p.X - (d.W + d.X);
                                double dh = d.Y - p.Y;
                                d.W += dw;
                                d.H += dh;
                                d.Y -= dh;
                            }
                            else
                            if (an.selectedPoints[0] == 2)
                            {
                                double dw = d.X - p.X;
                                double dh = p.Y - (d.Y + d.H);
                                d.W += dw;
                                d.H += dh;
                                d.X -= dw;
                            }
                            else
                            if (an.selectedPoints[0] == 3)
                            {
                                double dw = d.X - p.X;
                                double dh = d.Y - p.Y;
                                d.W = p.X - an.X;
                                d.H = p.Y - an.Y;
                            }
                            an.BoundingBox = d;
                            an.Validate();
                        }
                        else
                        {
                            PointD pod = new PointD(p.X - pd.X, p.Y - pd.Y);
                            for (int i = 0; i < an.selectedPoints.Count; i++)
                            {
                                PointD poid = an.GetPoint(an.selectedPoints[i]);
                                an.UpdatePoint(new PointD(poid.X + pod.X, poid.Y + pod.Y), an.selectedPoints[i]);
                            }
                            an.UpdateBoundingBox();
                        }
                    }
                    else
                    {
                        PointD pod = new PointD(p.X - pd.X, p.Y - pd.Y);
                        for (int i = 0; i < an.GetPointCount(); i++)
                        {
                            PointD poid = an.Points[i];
                            an.UpdatePoint(new PointD(poid.X + pod.X, poid.Y + pod.Y), i);
                        }
                        an.UpdateBoundingBox();
                    }
                }
                UpdateOverlay();
            }
 
            if (Tools.currentTool != null)
            if (Tools.currentTool.type == Tools.Tool.Type.pencil && e.Button == MouseButtons.Left)
            {
                    PointD pencilIp = SelectedImage.ToImageSpace(p);
                    Tools.Tool tool = Tools.currentTool;
                    Graphics.Graphics g = Graphics.Graphics.FromImage(SelectedBuffer);
                    Graphics.Pen pen = new Graphics.Pen(Tools.DrawColor, (int)Tools.StrokeWidth, ImageView.SelectedImage.bitsPerPixel);
                    g.FillEllipse(new Rectangle((int)pencilIp.X, (int)pencilIp.Y, (int)Tools.StrokeWidth, (int)Tools.StrokeWidth), pen.color);
                    UpdateImage();
                }
 
            UpdateStatus();
            prevMove = p;
            pd = p;
        }
        private void pictureBox_MouseUp(object sender, MouseEventArgs e)
        {
            PointD p = ImageToViewSpace(e.Location.X, e.Location.Y);
            mouseUpButtons = e.Button;
            mouseDownButtons = MouseButtons.None;
            MouseUpInt = new PointD(e.X, e.Y);
            mouseUp = p;
            down = false;
            up = true;
            if (SelectedImage == null)
                return;
            App.viewer = this;
            tools.ToolUp(p, e.Button);
        }
        private void pictureBox_MouseDown(object sender, MouseEventArgs e)
        {
            App.viewer = this;
            MouseDownInt = new PointD(e.X, e.Y);
            mouseDownButtons = e.Button;
            mouseUpButtons = MouseButtons.None;
            PointD p = ImageToViewSpace(e.Location.X, e.Location.Y);
            pd = new PointD(p.X, p.Y);
            mouseDown = pd;
            mouseD = new PointD(e.Location.X, e.Location.Y);
            down = true;
            up = false;
            if (SelectedImage == null)
                return;
            tools.BringToFront();
            int ind = 0;
            foreach (BioImage b in Images)
            {
                RectangleD r = new RectangleD(b.Volume.Location.X, b.Volume.Location.Y, b.Volume.Width, b.Volume.Height);
                if (r.IntersectsWith(p))
                {
                    b.selected = true;
                    SelectedIndex = ind;
                }
                else
                    b.selected = false;
                ind++;
            }
            if (!Ctrl && e.Button == MouseButtons.Left && Tools.currentTool.type != Tools.Tool.Type.rectSel)
            {
                foreach (ROI item in selectedAnnotations)
                {
                    if (item.Selected)
                        item.selectedPoints.Clear();
                }
                selectedAnnotations.Clear();
            }
 
            if (Tools.currentTool.type == Tools.Tool.Type.move && e.Button == MouseButtons.Left)
            {
                float width = (float)GetSelectionBoxHitSize();
                float height = (float)GetSelectionBoxHitSize();
                foreach (BioImage bi in Images)
                {
                    foreach (ROI an in bi.Annotations)
                    {
                        if (an.GetSelectBound(width, height).IntersectsWith(new RectangleD(p.X, p.Y, 1, 1)))
                        {
                            selectedAnnotations.Add(an);
                            an.Selected = true;
                            RectangleD[] sels = an.GetSelectBoxes(Tools.selectBoxSize);
                            double hitSize = GetSelectionBoxHitSize();
                            RectangleD r = new RectangleD(p.X - hitSize / 2, p.Y - hitSize / 2, hitSize, hitSize);
                            for (int i = 0; i < sels.Length; i++)
                            {
                                if (sels[i].IntersectsWith(r))
                                {
                                    an.selectedPoints.Add(i);
                                }
                            }
                        }
                        else
                            if (!Ctrl)
                            an.Selected = false;
                    }
                }
                UpdateOverlay();
            }
 
            if (e.Button == MouseButtons.Left)
            {
                UpdateMouseStatus(p);
            }
            UpdateStatus();
            tools.ToolDown(mouseDown, e.Button);
        }
        private void pictureBox_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (SelectedImage == null)
                return;
            App.viewer = this;
            PointD p = ToViewSpace(e.Location.X, e.Location.Y);
            tools.ToolDown(p, e.Button);
            if (e.Button != MouseButtons.XButton1 && e.Button != MouseButtons.XButton2)
                Origin = new PointD(-p.X, -p.Y);
        }
        private void deleteROIToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (SelectedImage == null)
                return;
            foreach (ROI item in AnnotationsRGB)
            {
                if (item.Selected && (item.selectedPoints.Count == 0 || item.selectedPoints.Count == item.GetPointCount() || item.type == ROI.Type.Ellipse || item.type == ROI.Type.Rectangle))
                {
                    SelectedImage.Annotations.Remove(item);
                }
                else
                {
                    if ((item.type == ROI.Type.Polygon || item.type == ROI.Type.Freeform || item.type == ROI.Type.Polyline) && item.selectedPoints.Count > 0)
                    {
                        item.RemovePoints(item.selectedPoints.ToArray());
 
                    }
                    item.selectedPoints.Clear();
                }
            }
            UpdateOverlay();
        }
        private void setTextSelectionToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (SelectedImage == null)
                return;
            foreach (ROI item in AnnotationsRGB)
            {
                if (item.Selected)
                {
                    TextInput input = new TextInput(item.Text);
                    if (input.ShowDialog() != DialogResult.OK)
                        return;
                    item.Text = input.TextValue;
                    item.family = input.font.FontFamily.Name;
                    item.fontSize = input.font.Size;
                    item.strokeColor = AForge.Color.FromArgb(input.color.R, input.color.G, input.color.B);
                    UpdateOverlay();
                }
            }
        }
 
        private void copyViewToClipboardToolStripMenuItem_Click(object sender, EventArgs e)
        {
            System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(ViewWidth, ViewHeight);
            using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(bmp))
            {
                DrawView(g);
                DrawOverlay(g);
            }
            System.Windows.Forms.Clipboard.SetImage(bmp);
        }
        List<ROI> copys = new List<ROI>();
 
        public void CopySelection()
        {
            copys.Clear();
            string s = "";
            foreach (ROI item in AnnotationsRGB)
            {
                if (item.Selected)
                {
                    copys.Add(item);
                    s += BioImage.ROIToString(item);
                }
            }
            System.Windows.Forms.Clipboard.SetText(s);
        }
        public void PasteSelection()
        {
            string[] sts = System.Windows.Forms.Clipboard.GetText().Split(BioImage.NewLine);
            foreach (string line in sts)
            {
                if (line.Length > 8)
                {
                    ROI an = BioImage.StringToROI(line);
                    //We set the coordinates of the ROI's we are pasting
                    an.coord = GetCoordinate();
                    SelectedImage.Annotations.Add(an);
                }
            }
            UpdateOverlay();
        }
        private void copyROIToolStripMenuItem_Click(object sender, EventArgs e)
        {
            CopySelection();
        }
 
        private void pasteROIToolStripMenuItem_Click(object sender, EventArgs e)
        {
            PasteSelection();
        }
 
        private void hideControlsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (ShowControls)
                ShowControls = false;
            else
                ShowControls = true;
        }
 
        private void showControlToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (ShowControls)
                ShowControls = false;
            else
                ShowControls = true;
        }
 
        private void HideStatusMenuItem_Click(object sender, EventArgs e)
        {
            ShowStatus = !ShowStatus;
        }
        private void rGBToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Mode = ViewMode.RGBImage;
        }
 
        private void filteredToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Mode = ViewMode.Filtered;
        }
 
        private void rawToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Mode = ViewMode.Raw;
        }
        public PointD ImageToViewSpace(double x, double y)
        {
            if (SelectedImage == null)
                return ToViewSpace(x, y);
            if (SelectedImage.isPyramidal)
            {
                return new PointD(PyramidalOrigin.X + (x * Resolution), PyramidalOrigin.Y + (y * Resolution));
            }
            else
                return ToViewSpace(x, y);
        }
        public PointF ToViewSpace(PointF p)
        {
            PointD d = ToViewSpace(p.X, p.Y);
            return new PointF((float)d.X, (float)d.Y);
        }
        public PointD ToViewSpace(PointD p)
        {
            return ToViewSpace(p.X, p.Y); ;
        }
        public PointD ToViewSpace(double x, double y)
        {
            if (SelectedImage != null)
                if (SelectedImage.isPyramidal)
                {
                    return new PointD((x - PyramidalOrigin.X) / Resolution, (y - PyramidalOrigin.Y) / Resolution);
                }
            double dx, dy;
            dx = (ToViewSizeW(x - (ViewWidth / 2)) / Scale.Width) - Origin.X;
            dy = (ToViewSizeH(y - (ViewHeight / 2)) / Scale.Height) - Origin.Y;
            return new PointD(dx, dy);
        }
        private double ToViewSizeW(double d)
        {
            if (SelectedImage != null)
                if (SelectedImage.isPyramidal)
                {
                    return d / Resolution;
                }
            double x = (double)(d / PxWmicron);
            return x;
        }
        public double ToViewSizeH(double d)
        {
            if (SelectedImage != null)
                if (SelectedImage.isPyramidal)
                {
                    return d / Resolution;
                }
            double y = (double)(d / PxHmicron);
            return y;
        }
        public double ToViewW(double d)
        {
            double x = (double)(d / PxWmicron) / scale.Width;
            return x;
        }
        public double ToViewH(double d)
        {
            double y = (double)(d / PxHmicron) / scale.Height;
            return y;
        }
        public PointD ToScreenSpace(double x, double y)
        {
            if (SelectedImage != null && SelectedImage.isPyramidal)
            {
                return new PointD((x - PyramidalOrigin.X) / Resolution, (y - PyramidalOrigin.Y) / Resolution);
            }
            double fx = ToScreenScaleW(Origin.X + x);
            double fy = ToScreenScaleH(Origin.Y + y);
            return new PointD(fx, fy);
        }
        public PointD ToScreenSpace(PointD p)
        {
            return ToScreenSpace(p.X, p.Y);
        }
        public PointF ToScreenSpace(PointF p)
        {
            PointD pd = ToScreenSpace(p.X, p.Y);
            return new PointF((float)pd.X, (float)pd.Y);
        }
        public PointF[] ToScreenSpace(PointF[] p)
        {
            PointF[] pf = new PointF[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                pf[i] = ToScreenSpace(p[i]);
            }
            return pf;
        }
        private Font GetLabelFont(ROI an)
        {
            string family = string.IsNullOrWhiteSpace(an?.family) ? SystemFonts.DefaultFont.FontFamily.Name : an.family;
            float size = an != null && an.fontSize > 0 ? an.fontSize : SystemFonts.DefaultFont.Size;
            try
            {
                return new Font(family, size);
            }
            catch
            {
                return new Font(SystemFonts.DefaultFont.FontFamily, SystemFonts.DefaultFont.Size);
            }
        }
        private Font GetScaledLabelFont(ROI an, float zoomScale)
        {
            string family = string.IsNullOrWhiteSpace(an?.family) ? SystemFonts.DefaultFont.FontFamily.Name : an.family;
            float baseSize = an != null && an.fontSize > 0 ? an.fontSize : SystemFonts.DefaultFont.Size;
            float scale = Math.Max(0.0001f, zoomScale);
            try
            {
                return new Font(family, baseSize / scale);
            }
            catch
            {
                return new Font(SystemFonts.DefaultFont.FontFamily, SystemFonts.DefaultFont.Size / scale);
            }
        }
        private System.Drawing.RectangleF GetLabelScreenRect(ROI an)
        {
            if (an == null)
                return System.Drawing.RectangleF.Empty;
            AForge.RectangleD rect = ToScreenSpace(an.BoundingBox);
            return new System.Drawing.RectangleF((float)rect.X, (float)rect.Y, (float)rect.W, (float)rect.H);
        }
        public PointF ToScreenSpace(Point3D p)
        {
            PointD pd = ToScreenSpace(p.X, p.Y);
            return new PointF((float)pd.X, (float)pd.Y);
        }
        public float ToScreenScaleW(double x)
        {
            return (float)(x * PxWmicron);
        }
        public float ToScreenScaleH(double y)
        {
            return (float)(y * PxHmicron);
        }
        public PointF ToScreenScale(PointD p)
        {
            float x = ToScreenScaleW((float)p.X);
            float y = ToScreenScaleH((float)p.Y);
            return new PointF(x, y);
        }
        public RectangleD ToScreenRect(double x, double y, double w, double h)
        {
            if (SelectedImage == null)
            {
                PointD pf;
                pf = ToScreenSpace(x, y);
                return new RectangleD(pf.X, pf.Y, ToScreenScaleW(w), ToScreenScaleH(h));
            }
            if (SelectedImage.isPyramidal)
            {
                PointD d = ToScreenSpace(x, y);
                double dw = ToViewSizeW(w);
                double dh = ToViewSizeH(h);
                return new RectangleD(d.X, d.Y, dw, dh);
            }
            else
            {
                PointD pf = ToScreenSpace(x, y);
                return new RectangleD(pf.X, pf.Y, ToScreenScaleW(w), ToScreenScaleH(h));
            }
        }
        public SKRect ToSKRect(double x, double y, double w, double h)
        {
            double xd = gl.Width / 2;
            double yd = gl.Height / 2;
            return new SKRect((float)(xd - x), (float)(yd - y), (float)(xd - (x + w)), (float)(yd - (y + h)));
        }
        public RectangleD ToScreenSpace(RectangleD p)
        {
            return ToScreenRect(p.X, p.Y, p.W, p.H);
        }
        public RectangleD ToScreenSpace(RectangleF p)
        {
            return ToScreenRect(p.X, p.Y, p.Width, p.Height);
        }
        public RectangleD[] ToScreenSpace(RectangleD[] p)
        {
            RectangleD[] rs = new RectangleD[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                rs[i] = ToScreenSpace(p[i]);
            }
            return rs;
        }
        public RectangleF[] ToScreenSpace(RectangleF[] p)
        {
            RectangleF[] rs = new RectangleF[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                rs[i] = ToScreenSpace(p[i]).ToRectangleF();
            }
            return rs;
        }
        public PointF[] ToScreenSpace(PointD[] p)
        {
            PointF[] rs = new PointF[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                PointD pd = ToScreenSpace(p[i]);
                rs[i] = new PointF((float)pd.X, (float)pd.Y);
            }
            return rs;
        }
        public float ToScreenW(double x)
        {
            return (float)(x * PxWmicron);
        }
        public float ToScreenH(double y)
        {
            return (float)(y * PxHmicron);
        }
        public void ImageView_KeyDown(object sender, KeyEventArgs e)
        {
            double moveAmount = 5 * Scale.Width;
            Plugins.KeyDownEvent(sender, e);
            if (e.KeyCode == Keys.C && e.Control)
            {
                CopySelection();
                return;
            }
            if (e.KeyCode == Keys.V && e.Control)
            {
                PasteSelection();
                return;
            }
            if (e.KeyCode == Keys.Subtract || e.KeyCode == Keys.NumPad7)
            {
                if (SelectedImage.isPyramidal)
                    ZoomPyramidalAt(new System.Drawing.Point(ViewWidth / 2, ViewHeight / 2), 0.9);
                else
                    Scale = new SizeF(Scale.Width - 0.1f, Scale.Height - 0.1f);
                if (!SelectedImage.isPyramidal)
                    UpdateView();
            }
            if (e.KeyCode == Keys.Add || e.KeyCode == Keys.NumPad9)
            {
                if (SelectedImage.isPyramidal)
                    ZoomPyramidalAt(new System.Drawing.Point(ViewWidth / 2, ViewHeight / 2), 1.1);
                else
                    Scale = new SizeF(Scale.Width + 0.1f, Scale.Height + 0.1f);
                if (!SelectedImage.isPyramidal)
                    UpdateView();
            }
            if (e.KeyCode == Keys.W || e.KeyCode == Keys.NumPad8)
            {
                if (SelectedImage.isPyramidal)
                    PyramidalOrigin = new PointD(PyramidalOrigin.X, PyramidalOrigin.Y - moveAmount);
                else
                    Origin = new PointD(Origin.X, Origin.Y + moveAmount);
                UpdateView();
            }
            if (e.KeyCode == Keys.S || e.KeyCode == Keys.NumPad2)
            {
                if (SelectedImage.isPyramidal)
                    PyramidalOrigin = new PointD(PyramidalOrigin.X, PyramidalOrigin.Y + moveAmount);
                else
                    Origin = new PointD(Origin.X, Origin.Y - moveAmount);
                UpdateView();
            }
            if (e.KeyCode == Keys.A || e.KeyCode == Keys.NumPad4)
            {
                if (SelectedImage.isPyramidal)
                    PyramidalOrigin = new PointD(PyramidalOrigin.X - moveAmount, PyramidalOrigin.Y);
                else
                    Origin = new PointD(Origin.X + moveAmount, Origin.Y);
                UpdateView();
            }
            if (e.KeyCode == Keys.D || e.KeyCode == Keys.NumPad6)
            {
                if (SelectedImage.isPyramidal)
                    PyramidalOrigin = new PointD(PyramidalOrigin.X + moveAmount, PyramidalOrigin.Y);
                else
                    Origin = new PointD(Origin.X - moveAmount, Origin.Y);
                UpdateView();
            }
        }
        private void ImageView_KeyUp(object sender, KeyEventArgs e)
        {
            Plugins.KeyUpEvent(sender, e);
        }
        private void ImageView_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
        {
            Plugins.KeyPressEvent(sender, e);
        }
        public void GoToImage()
        {
            GoToImage(SelectedIndex);
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public PointD PyramidalOriginTransformed
        {
            get { return new PointD(PyramidalOrigin.X * Resolution, PyramidalOrigin.Y * Resolution); }
            set { PyramidalOrigin = new PointD(value.X / Resolution, value.Y / Resolution); }
        }
        PointD mouseDownInt = new PointD(0, 0);
        PointD mouseUpInt = new PointD(0, 0);
        PointD mouseMoveInt = new PointD(0, 0);
        PointD mouseMove = new PointD(0, 0);
        /* A property that returns the value of the mouseDownInt variable. */
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public PointD MouseDownInt
        {
            get { return mouseDownInt; }
            set { mouseDownInt = value; }
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public PointD MouseUpInt
        {
            get { return mouseUpInt; }
            set { mouseUpInt = value; }
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public PointD MouseMoveInt
        {
            get { return mouseMoveInt; }
            set { mouseMoveInt = value; }
        }
 
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool ShowMasks { get; set; } = true;
 
        public void GoToImage(int i)
        {
            if (i < 0 || Images.Count <= i)
                return;
            App.viewer = this;
            if (SelectedIndex != i)
                SelectedIndex = i;
            BioImage image = Images[i];
            int viewportWidth = GetEffectiveViewWidth();
            int viewportHeight = GetEffectiveViewHeight();
            if (UsesSlideRenderer(image))
            {
                CenterPyramidalImage(image, viewportWidth, viewportHeight);
                UpdateView();
                return;
            }
 
            double dx = image.Volume.Width / 2;
            double dy = image.Volume.Height / 2;
            origin = new PointD(-(image.Volume.Location.X + dx), -(image.Volume.Location.Y + dy));
            double screenWidth = Math.Abs(ToScreenScaleW(image.Volume.Width));
            double screenHeight = Math.Abs(ToScreenScaleH(image.Volume.Height));
            double wx = screenWidth > 0 ? viewportWidth / screenWidth : 1;
            double wy = screenHeight > 0 ? viewportHeight / screenHeight : 1;
            double fitScale = Math.Min(wx, wy);
            if (fitScale <= 0 || double.IsNaN(fitScale) || double.IsInfinity(fitScale))
                fitScale = 1;
            scale = new SizeF((float)fitScale, (float)fitScale);
            update = true;
            UpdateView();
        }
 
        private int GetEffectiveViewWidth()
        {
            int width = ViewWidth;
            if (width <= 1)
                width = viewpanel?.ClientSize.Width ?? Width;
            if (width <= 1)
                width = Width;
            return Math.Max(1, width);
        }
 
        private int GetEffectiveViewHeight()
        {
            int height = ViewHeight;
            if (height <= 1)
                height = viewpanel?.ClientSize.Height ?? Height;
            if (height <= 1)
                height = Height;
            return Math.Max(1, height);
        }
 
        private void CenterPyramidalImage(BioImage image, int viewportWidth, int viewportHeight)
        {
            if (!TryGetPyramidalWorldBounds(image, out double minX, out double minY, out double maxX, out double maxY))
                return;
 
            double worldWidth = maxX - minX;
            double worldHeight = maxY - minY;
            if (worldWidth <= 0 || worldHeight <= 0)
                return;
 
            double fitResolution = Math.Max(worldWidth / viewportWidth, worldHeight / viewportHeight) * 1.02;
            if (fitResolution <= 0 || double.IsNaN(fitResolution) || double.IsInfinity(fitResolution))
                fitResolution = image.Resolution > 0 ? image.Resolution : 1;
 
            image.Resolution = fitResolution;
            double viewportWorldWidth = viewportWidth * fitResolution;
            double viewportWorldHeight = viewportHeight * fitResolution;
            double centerX = minX + (worldWidth / 2);
            double centerY = minY + (worldHeight / 2);
 
            image.PyramidalOrigin = new PointD(
                centerX - (viewportWorldWidth / 2),
                -(centerY + (viewportWorldHeight / 2)));
        }
 
        private void CenterPyramidalOrigin(BioImage image, int viewportWidth, int viewportHeight)
        {
            if (viewportWidth <= 1 || viewportHeight <= 1)
                return;
            if (!TryGetPyramidalWorldBounds(image, out double minX, out double minY, out double maxX, out double maxY))
                return;
 
            double worldWidth = maxX - minX;
            double worldHeight = maxY - minY;
            if (worldWidth <= 0 || worldHeight <= 0)
                return;
 
            double visibleWidth = viewportWidth * Math.Max(image.Resolution, 1e-9);
            double visibleHeight = viewportHeight * Math.Max(image.Resolution, 1e-9);
            double centerX = minX + (worldWidth / 2.0);
            double centerY = minY + (worldHeight / 2.0);
 
            image.PyramidalOrigin = new PointD(
                centerX - (visibleWidth / 2.0),
                -(centerY + (visibleHeight / 2.0)));
        }
 
        private bool TryGetPyramidalWorldBounds(BioImage image, out double minX, out double minY, out double maxX, out double maxY)
        {
            minX = minY = maxX = maxY = 0;
            BruTile.ITileSchema schema = null;
            if (image.OpenSlideBase != null)
                schema = image.OpenSlideBase.Schema;
            else if (image.SlideBase != null)
                schema = image.SlideBase.Schema;
 
            if (schema != null)
            {
                minX = schema.Extent.MinX;
                minY = schema.Extent.MinY;
                maxX = schema.Extent.MaxX;
                maxY = schema.Extent.MaxY;
                return maxX > minX && maxY > minY;
            }
 
            if (image.Resolutions.Count == 0)
                return false;
 
            double unitsPerPixel = image.GetUnitPerPixel(0);
            if (unitsPerPixel <= 0 || double.IsNaN(unitsPerPixel) || double.IsInfinity(unitsPerPixel))
                unitsPerPixel = 1;
 
            minX = 0;
            maxX = image.Resolutions[0].SizeX * unitsPerPixel;
            maxY = 0;
            minY = -(image.Resolutions[0].SizeY * unitsPerPixel);
            return maxX > minX && maxY > minY;
        }
 
        private void goToImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            GoToImage();
        }
        private void goToToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            Origin = new PointD(mouseDown.X, mouseDown.Y);
        }
        private void goToImageToolStripMenuItem_DropDownOpening(object sender, EventArgs e)
        {
            ToolStripMenuItem item = (ToolStripMenuItem)sender;
            item.DropDownItems.Clear();
            for (int i = 0; i < Images.Count; i++)
            {
                BioImage im = Images[i];
                ToolStripMenuItem it = new ToolStripMenuItem();
                it.Text = $"{i}: {im.filename}";
                it.Tag = i;
                item.DropDownItems.Add(it);
            }
        }
        private void goToImageToolStripMenuItem_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            if (e.ClickedItem.Tag is int index && index >= 0 && index < Images.Count)
            {
                GoToImage(index);
                return;
            }
        }
        public new void Dispose()
        {
            foreach (var bitmap in Bitmaps)
                bitmap?.Dispose();
            Bitmaps.Clear();
            base.Dispose();
        }
 
        private void goToToolStripMenuItem_Click_1(object sender, EventArgs e)
        {
            Microscope.Stage.SetPosition(mouseDown.X, mouseDown.Y);
        }
 
        private void drawToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Graphics.Graphics g = Graphics.Graphics.FromImage(SelectedBuffer);
            foreach (ROI item in AnnotationsRGB)
            {
                Graphics.Pen p = new Graphics.Pen(Tools.DrawColor, (int)Tools.StrokeWidth, SelectedBuffer.BitsPerPixel);
                g.pen = p;
                if (item.Selected)
                {
                    if (item.type == ROI.Type.Point)
                    {
                        PointD pt = SelectedImage.ToImageSpace(item.Points[0]);
                        g.FillEllipse(new RectangleF((float)pt.X - 2f, (float)pt.Y - 2f, 4f, 4f), p.color);
                    }
                    else
                    if (item.type == ROI.Type.Line)
                    {
                        g.DrawLine(new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(0)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(0)).Y), new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(1)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(1)).Y));
                    }
                    else
                    if (item.type == ROI.Type.Rectangle)
                    {
                        g.DrawRectangle(SelectedImage.ToImageSpace(item.BoundingBox));
                    }
                    else
                    if (item.type == ROI.Type.Ellipse)
                    {
                        g.DrawEllipse(SelectedImage.ToImageSpace(item.BoundingBox));
                    }
                    else
                    if (item.type == ROI.Type.Freeform || item.type == ROI.Type.Polygon || item.type == ROI.Type.Polyline)
                    {
                        if (item.closed)
                        {
                            for (int i = 0; i < item.GetPointCount() - 1; i++)
                            {
                                g.DrawLine(new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(i)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(i)).Y), new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(i + 1)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(i + 1)).Y));
                            }
                            g.DrawLine(new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(0)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(0)).Y), new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(item.GetPointCount() - 1)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(item.GetPointCount() - 1)).Y));
 
                        }
                        else
                        {
                            for (int i = 0; i < item.GetPointCount() - 1; i++)
                            {
                                g.DrawLine(new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(i)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(i)).Y), new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(i + 1)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(i + 1)).Y));
                            }
                        }
                    }
                }
            }
            update = true;
            UpdateImage();
        }
 
        private void fillToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Graphics.Graphics g = Graphics.Graphics.FromImage(SelectedBuffer);
            foreach (ROI item in AnnotationsRGB)
            {
                Graphics.Pen p = new Graphics.Pen(Tools.DrawColor, (int)Tools.StrokeWidth, SelectedBuffer.BitsPerPixel);
                if (item.Selected)
                {
                    if (item.type == ROI.Type.Point)
                    {
                        PointD pt = SelectedImage.ToImageSpace(item.Points[0]);
                        g.FillEllipse(new RectangleF((float)pt.X - 2f, (float)pt.Y - 2f, 4f, 4f), p.color);
                    }
                    else
                    if (item.type == ROI.Type.Line)
                    {
                        g.DrawLine(new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(0)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(0)).Y), new PointF((float)SelectedImage.ToImageSpace(item.GetPoint(1)).X, (float)SelectedImage.ToImageSpace(item.GetPoint(1)).Y));
                    }
                    else
                    if (item.type == ROI.Type.Rectangle)
                    {
                        g.FillRectangle(SelectedImage.ToImageSpace(item.BoundingBox), p.color);
                    }
                    else
                    if (item.type == ROI.Type.Ellipse)
                    {
                        g.FillEllipse(SelectedImage.ToImageSpace(item.BoundingBox), p.color);
                    }
                    else
                    if (item.type == ROI.Type.Freeform || item.type == ROI.Type.Polygon || item.type == ROI.Type.Polyline)
                    {
                        g.FillPolygon(SelectedImage.ToImageSpace(item.GetPointsF()), SelectedImage.ToImageSpace(item.BoundingBox), p.color);
                    }
                }
            }
            update = true;
            UpdateImage();
        }
 
        public void GoToStage()
        {
            RectangleD d = Microscope.GetViewRectangle(false);
            double dx = d.W / 2;
            double dy = d.H / 2;
            Origin = new PointD(-(d.X + dx), -(d.Y + dy));
            double wx, wy;
            wx = Math.Abs(ViewWidth / ToScreenScaleW(d.W));
            wy = Math.Abs(ViewHeight / ToScreenScaleH(d.H));
            scale.Width = (float)wy;
            scale.Height = (float)wy;
            update = true;
            UpdateView();
        }
        public void MoveStageToImage()
        {
            if (SelectedImage == null)
                return;
            Microscope.Stage.SetPosition(SelectedImage.Volume.Location.X, SelectedImage.Volume.Location.Y);
            update = true;
            UpdateView();
        }
        public void MoveStageToImage(int i)
        {
            update = true;
            Microscope.Stage.SetPosition(Images[i].Volume.Location.X, Images[i].Volume.Location.Y);
            UpdateView();
        }
        private void goToStageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            update = true;
            GoToStage();
        }
        private void moveStageToImageToolStripMenuItem_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            int i = 0;
            foreach (var item in Images)
            {
                if (item.ID.Contains(e.ClickedItem.Text))
                {
                    MoveStageToImage(i);
                    return;
                }
                i++;
            }
        }
 
        private void moveStageToImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            MoveStageToImage();
        }
        private void layersToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (layersTool == null)
                layersTool = new Layers();
            layersTool.Show();
        }
        private void pictureBox_SizeChanged(object sender, EventArgs e)
        {
            if (ViewWidth < 2 || ViewHeight < 2) return;
            if (SelectedImage.isPyramidal)
            {
                if (SelectedImage.isPyramidal)
                    UpdateImages();
            }
        }
        private void contextMenuStrip_Opening(object sender, CancelEventArgs e)
        {
            App.viewer = this;
            if (App.tabsView != null)
                Function.Initialize();
        }
        private void hideOverviewToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (hideOverViewToolStripMenuItem.Text == "Hide Overview")
            {
                ShowOverview = false;
                hideOverViewToolStripMenuItem.Text = "Show Overview";
            }
            else
            {
                ShowOverview = true;
                hideOverViewToolStripMenuItem.Text = "Hide Overview";
            }
            UpdateOverviewVisibility();
        }
        private void removeImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            RemoveImage(SelectedIndex);
        }
 
        private void removeImagesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            RemoveImages();
        }
        #region OpenSlide
        private OpenSlideBase _openSlideBase;
        private SlideBase _slideBase;
 
        private void Initialize(string file, BioImage bm)
        {
            if (bm.Type != BioImage.ImageType.pyramidal)
                return;
            if (bm.OpenSlideBase == null)
            {
                _slideBase = bm.SlideBase;
                slideRenderer = new SlideRenderer(gl);
                slideRenderer.SetSource(_slideBase);
            }
            else
            {
                _openSlideBase = bm.OpenSlideBase;
                slideRenderer = new SlideRenderer(gl);
                slideRenderer.SetSource(_openSlideBase);
            }
        }
 
        #endregion
 
        private sealed class BufferedViewPanel : Panel
        {
            public BufferedViewPanel()
            {
                SetStyle(ControlStyles.UserPaint |
                         ControlStyles.AllPaintingInWmPaint |
                         ControlStyles.OptimizedDoubleBuffer |
                         ControlStyles.ResizeRedraw, true);
            }
        }
 
    }
}