ImageView.cs

using AForge;
using AForge.Imaging.Filters;
using Bio;
using BruTile;
using Gdk;
using Gtk;
using OpenSlideGTK;
using OpenTK.Mathematics;
using OpenTK.Windowing.Common;
using OpenTK.Windowing.Desktop;
using SkiaSharp;
using SkiaSharp.Views.Gtk;
using System.Linq;
using System.Threading;
using ZarrNET.Core.Nodes;
using Color = AForge.Color;
using PointD = AForge.PointD;
using PointF = AForge.PointF;
using Rectangle = AForge.Rectangle;
using SizeF = AForge.SizeF;
using ZCT = AForge.ZCT;
 
namespace BioGTK
{
    public class ImageView : Gtk.Window
    {
        #region Properties
 
        private Builder _builder;
        public List<BioImage> Images = new List<BioImage>();
        private bool _updatingCoordinate = false;
        //public List<SKImage> SKImages = new List<SKImage>();
        public void SetCoordinate(int z, int c, int t)
        {
            if (SelectedImage == null)
                return;
            if (_updatingCoordinate)
                return;
 
            ZCT previousCoordinate = SelectedImage.Coordinate;
            _updatingCoordinate = true;
            try
            {
                if (z > SelectedImage.SizeZ - 1 && SelectedImage.Type == BioImage.ImageType.well)
                    zBar.Value = zBar.Adjustment.Upper;
                else
                    zBar.Value = z;
                if (c > SelectedImage.SizeC - 1)
                    cBar.Value = cBar.Adjustment.Upper;
                else
                    cBar.Value = c;
                if (t > SelectedImage.SizeT - 1)
                    tBar.Value = tBar.Adjustment.Upper;
                else
                    tBar.Value = t;
 
                if (SelectedImage.Type == BioImage.ImageType.well)
                    SelectedImage.Coordinate = new ZCT(0, (int)cBar.Value, (int)tBar.Value);
                else
                    SelectedImage.Coordinate = new ZCT((int)zBar.Value, (int)cBar.Value, (int)tBar.Value);
            }
            finally
            {
                _updatingCoordinate = false;
            }
 
            bool coordinateChanged = SelectedImage.Coordinate != previousCoordinate;
            if (coordinateChanged)
                App.channelsTool?.RefreshStatisticsForCoordinate(SelectedImage, SelectedImage.Coordinate);
            if (SelectedImage.isPyramidal && coordinateChanged)
            {
                PreparePyramidalCoordinateRender();
                ForceNavigationRefresh();
                BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, z, c, t);
                return;
            }
 
            UpdateImages();
            if (SelectedImage?.isPyramidal != true && View != null)
            {
                RequestViewportRefresh();
            }
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, z, c, t);
        }
 
        private void PreparePyramidalCoordinateRender()
        {
            if (SelectedImage?.isPyramidal != true)
                return;
 
            // A slider drag can generate many coordinate changes per second.
            // Mark earlier plane results stale, but let their HTTP reads finish so
            // HttpClient does not surface routine socket-abort TaskCanceledExceptions.
            slideRenderer?.InvalidateRenderState(cancelActiveFetches: false);
            sKSlideRenderer?.InvalidateRenderState();
            SelectedImage.InvalidateTileCache();
            slideRenderer?.ClearCache(resetLevel: false, cancelActiveFetches: false);
            sKSlideRenderer?.ClearCache();
            SelectedImage.ZarrDisplayMax = 0;
        }
 
        private void RequestViewportRefresh(bool scheduleIdleRetry = true)
        {
            if (View == null)
                return;
 
            View.QueueDraw();
            if (!MacOS)
            {
                glArea?.RequestRedraw();
                glArea?.QueueDraw();
            }
 
            if (!scheduleIdleRetry)
                return;
 
            GLib.Idle.Add(() =>
            {
                if (_viewerCleanupDone || View == null)
                    return false;
 
                View.QueueDraw();
                if (!MacOS)
                {
                    glArea?.RequestRedraw();
                    glArea?.QueueDraw();
                }
 
                return false;
            });
        }
        public ZCT GetCoordinate()
        {
            if (SelectedImage == null)
                return new ZCT();
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, SelectedImage.Coordinate.Z, SelectedImage.Coordinate.C, SelectedImage.Coordinate.T);
            return SelectedImage.Coordinate;
        }
 
        private bool TrySelectVisibleMaskAt(double worldX, double worldY, bool ctrlHeld)
        {
            if (SelectedImage?.Annotations == null)
                return false;
 
            PointD worldPoint = new PointD(worldX, worldY);
            ZCT coord = GetCoordinate();
            ROI hit = null;
 
            var candidates = new List<ROI>();
            candidates.AddRange(SelectedImage.Annotations);
            candidates.AddRange(GetZarrLabelOverlays(SelectedImage));
 
            // Match render order: selected masks are drawn last, so they must win
            // hit-testing before any non-selected mask underneath them.
            for (int pass = 0; pass < 2 && hit == null; pass++)
            {
                for (int i = candidates.Count - 1; i >= 0; i--)
                {
                    ROI an = candidates[i];
                    if (an == null || an.type != ROI.Type.Mask || an.roiMask == null || an.coord != coord)
                        continue;
 
                    if (pass == 0 && !an.Selected)
                        continue;
                    if (pass == 1 && an.Selected)
                        continue;
 
                    if (Tools.HitTestMask(an, worldPoint))
                    {
                        hit = an;
                        break;
                    }
                }
            }
 
            if (hit == null)
                return false;
 
            if (!ctrlHeld)
            {
                foreach (ROI other in candidates)
                {
                    if (other != hit)
                    {
                        other.Selected = false;
                        other.selectedPoints?.Clear();
                    }
                }
            }
 
            hit.Selected = true;
            hit.selectedPoints?.Clear();
            Tools.selectedROI = hit;
            UpdateView();
            return true;
        }
 
        public void AddImage(BioImage im)
        {
            Images.Add(im);
            selectedIndex = Images.Count - 1;
            if (im.Resolutions[0].SizeX < 1920 && im.Resolutions[0].SizeY < 1080)
            {
                if (View != null)
                {
                    View.WidthRequest = im.Resolutions[0].SizeX;
                    View.HeightRequest = im.Resolutions[0].SizeY;
                }
                else
                {
                    View.WidthRequest = im.Resolutions[0].SizeX;
                    View.HeightRequest = im.Resolutions[0].SizeY;
                }
            }
 
            Initialize();
            InitPreview();
            UpdateImages(true);
            UpdateGUI();
            App.roiManager?.UpdateAnnotationList();
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, im?.file ?? string.Empty);
        }
 
        public void SetZarrLabelOverlays(BioImage image, List<ROI> overlays, string? keyOverride = null)
        {
            if (image == null)
                return;
 
            string key = string.IsNullOrWhiteSpace(keyOverride) ? GetOverlayKey(image) : keyOverride;
            if (string.IsNullOrWhiteSpace(key))
                return;
 
            zarrLabelOverlays[key] = overlays ?? new List<ROI>();
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, image?.file ?? string.Empty, overlays?.Count ?? 0, keyOverride ?? string.Empty);
        }
 
        public void RefreshZarrLabelOverlays(string? sourceOverride = null)
        {
            RefreshZarrLabelOverlays(SelectedImage, sourceOverride);
        }
 
        public void RefreshZarrLabelOverlays(BioImage image, string? sourceOverride = null)
        {
            if (image == null)
                return;
 
            string source = sourceOverride ?? image.file;
            if (string.IsNullOrWhiteSpace(source))
                source = image.Filename;
 
            if (string.IsNullOrWhiteSpace(source) ||
                (!source.Contains(".zarr", StringComparison.OrdinalIgnoreCase) && !Directory.Exists(source)))
                return;
 
            try
            {
                var overlays = BioLib.Zarr.LoadLabelOverlaysAsync(image, source).GetAwaiter().GetResult();
                if (overlays == null || overlays.Count == 0)
                {
                    // Some saved Zarrs expose the labels on disk but do not
                    // advertise them through the async label discovery path.
                    // Fall back to a direct labels-folder scan so the masks
                    // still render after reopen.
                    var zarrType = typeof(BioImage).Assembly.GetType("BioLib.Zarr");
                    var method = zarrType?.GetMethod(
                        "LoadLabelsAsROIs",
                        System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
                    if (method != null)
                    {
                        var result = method.Invoke(null, new object[] { image, source }) as List<ROI>;
                        if (result != null && result.Count > 0)
                            overlays = result;
                    }
                }
                if ((overlays == null || overlays.Count == 0) && image.Annotations != null)
                {
                    var existing = image.Annotations.Where(IsZarrLabelRoi).ToList();
                    if (existing.Count > 0)
                        overlays = existing;
                }
 
                SetZarrLabelOverlays(image, overlays);
                SetZarrLabelOverlays(image, overlays, source);
                SyncZarrLabelAnnotations(image, overlays);
                BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, source);
            }
            catch (Exception)
            {
            }
        }
 
        private List<ROI> GetZarrLabelOverlays(BioImage image)
        {
            string key = GetOverlayKey(image);
            if (string.IsNullOrWhiteSpace(key))
                return new List<ROI>();
 
            if (zarrLabelOverlays.TryGetValue(key, out var overlays) && overlays != null && overlays.Count > 0)
                return overlays;
 
            if (!zarrLabelLoadAttempted.Contains(key))
            {
                zarrLabelLoadAttempted.Add(key);
                RefreshZarrLabelOverlays(image, key);
                if (zarrLabelOverlays.TryGetValue(key, out overlays) && overlays != null)
                    return overlays;
            }
 
            if (image?.Annotations != null)
            {
                var synced = image.Annotations.Where(IsZarrLabelRoi).ToList();
                if (synced.Count > 0)
                    return synced;
            }
 
            return new List<ROI>();
        }
 
        public List<ROI> GetZarrLabelOverlaysForImage(BioImage image)
            => new List<ROI>(GetZarrLabelOverlays(image));
 
        private static bool IsZarrLabelRoi(ROI roi)
        {
            return roi != null &&
                   !string.IsNullOrWhiteSpace(roi.roiID) &&
                   roi.roiID.StartsWith("zarr-label:", StringComparison.OrdinalIgnoreCase);
        }
 
        private void SyncZarrLabelAnnotations(BioImage image, List<ROI> overlays)
        {
            if (image == null)
                return;
 
            image.Annotations.RemoveAll(IsZarrLabelRoi);
 
            if (overlays == null || overlays.Count == 0)
                return;
 
            foreach (var overlay in overlays)
            {
                if (!IsZarrLabelRoi(overlay))
                    continue;
 
                image.Annotations.Add(overlay);
            }
        }
 
        private static string GetOverlayKey(BioImage image)
        {
            if (image == null)
                return string.Empty;
 
            if (!string.IsNullOrWhiteSpace(image.file))
                return image.file;
 
            return image.Filename ?? string.Empty;
        }
 
        double pxWmicron = 5;
        double pxHmicron = 5;
        /* A property of the class. */
        public double PxWmicron
        {
            get
            {
                if (SelectedImage == null)
                    return 1;
                if (SelectedImage.Type == BioImage.ImageType.pyramidal)
                    if (openSlide)
                    {
                        if (_openSlideBase?.Schema?.Resolutions != null && _openSlideBase.Schema.Resolutions.Count > 0)
                        {
                            int lev = OpenSlideGTK.TileUtil.GetLevel(_openSlideBase.Schema.Resolutions, Resolution);
                            lev = Math.Clamp(lev, 0, _openSlideBase.Schema.Resolutions.Count - 1);
                            return _openSlideBase.Schema.Resolutions[lev].UnitsPerPixel * pxWmicron;
                        }
                    }
                    else
                    {
                        if (_slideBase?.Schema?.Resolutions != null && _slideBase.Schema.Resolutions.Count > 0)
                        {
                            int lev = OpenSlideGTK.TileUtil.GetLevel(_slideBase.Schema.Resolutions, Resolution);
                            lev = Math.Clamp(lev, 0, _slideBase.Schema.Resolutions.Count - 1);
                            return _slideBase.Schema.Resolutions[lev].UnitsPerPixel * pxWmicron;
                        }
                    }
 
                return pxWmicron;
            }
            set
            {
                pxWmicron = value;
            }
        }
        public double PxHmicron
        {
            get
            {
                if (SelectedImage == null)
                    return 1;
                if (SelectedImage.Type == BioImage.ImageType.pyramidal)
                    if (openSlide)
                    {
                        if (_openSlideBase?.Schema?.Resolutions != null && _openSlideBase.Schema.Resolutions.Count > 0)
                        {
                            int lev = OpenSlideGTK.TileUtil.GetLevel(_openSlideBase.Schema.Resolutions, Resolution);
                            lev = Math.Clamp(lev, 0, _openSlideBase.Schema.Resolutions.Count - 1);
                            return _openSlideBase.Schema.Resolutions[lev].UnitsPerPixel * pxHmicron;
                        }
                    }
                    else
                    {
                        if (_slideBase?.Schema?.Resolutions != null && _slideBase.Schema.Resolutions.Count > 0)
                        {
                            int lev = OpenSlideGTK.TileUtil.GetLevel(_slideBase.Schema.Resolutions, Resolution);
                            lev = Math.Clamp(lev, 0, _slideBase.Schema.Resolutions.Count - 1);
                            return _slideBase.Schema.Resolutions[lev].UnitsPerPixel * pxHmicron;
                        }
                    }
                return pxHmicron;
            }
            set
            {
                pxHmicron = value;
            }
        }
        bool allowNavigation = true;
        public bool AllowNavigation
        {
            get { return allowNavigation; }
            set { allowNavigation = value; }
        }
 
        public bool ShowMasks { get; set; } = true;
        public bool ShowOverview { get; set; } = true;
        private readonly Dictionary<string, List<ROI>> zarrLabelOverlays = new Dictionary<string, List<ROI>>();
        private readonly HashSet<string> zarrLabelLoadAttempted = new HashSet<string>();
        /* Getting the selected buffer from the selected image. */
        public static AForge.Bitmap SelectedBuffer
        {
            get
            {
                int ind = SelectedImage.GetFrameIndex(SelectedImage.Coordinate.Z, SelectedImage.Coordinate.C, SelectedImage.Coordinate.T);
                return SelectedImage.Buffers[ind];
            }
        }
        int selectedIndex = 0;
        public int SelectedIndex
        {
            get 
            { 
                if(selectedIndex >= Images.Count)
                    selectedIndex = Images.Count - 1;  
                return selectedIndex;
            }
            set
            {
                if (value >= 0 && value < Images.Count)
                {
                    selectedIndex = value;
                    Images[selectedIndex] = SelectedImage;
                }
            }
        }
        Menu imagesMenu;
        public static List<ROI> selectedAnnotations
        {
            get
            {
                List<ROI> rois = new List<ROI>();
                foreach (var item in SelectedImage.Annotations)
                {
                    if (item != null && item.Selected)
                        rois.Add(item);
                }
                if (App.viewer != null)
                {
                    foreach (var item in App.viewer.GetZarrLabelOverlaysForImage(SelectedImage))
                    {
                        if (item != null && item.Selected)
                            rois.Add(item);
                    }
                }
                return rois;
            }
        }
#pragma warning disable 649
        [Builder.Object]
        private Gtk.Scale zBar;
        [Builder.Object]
        private Gtk.Scale tBar;
        [Builder.Object]
        private Gtk.Scale cBar;
        [Builder.Object]
        private Gtk.Label statusLabel;
        [Builder.Object]
        private Gtk.Stack rgbStack;
        [Builder.Object]
        private Gtk.Grid grid;
        [Builder.Object]
        private Gtk.Box rgbBox;
        [Builder.Object]
        private Gtk.Box controlsBox;
        [Builder.Object]
        public Gtk.Box mainBox;
        [Builder.Object]
        private Gtk.ComboBox rBox;
        [Builder.Object]
        private Gtk.ComboBox gBox;
        [Builder.Object]
        private Gtk.ComboBox bBox;
        [Builder.Object]
        private Gtk.Scrollbar hScroll;
        [Builder.Object]
        private Gtk.Scrollbar vScroll;
        [Builder.Object]
        public Menu contextMenu;
        [Builder.Object]
        private MenuItem goToOriginMenu;
        [Builder.Object]
        private MenuItem goToImageMenu;
        [Builder.Object]
        private MenuItem overView;
        [Builder.Object]
        private MenuItem roi;
        [Builder.Object]
        private Menu roiMenu;
        [Builder.Object]
        private MenuItem roiShow;
        [Builder.Object]
        private MenuItem roiHide;
        [Builder.Object]
        private MenuItem roiDelete;
        [Builder.Object]
        private MenuItem roiID;
        [Builder.Object]
        private MenuItem copy;
        [Builder.Object]
        private MenuItem paste;
        [Builder.Object]
        private MenuItem draw;
        [Builder.Object]
        private MenuItem fill;
        [Builder.Object]
        private Menu barMenu;
        [Builder.Object]
        private MenuItem play;
        [Builder.Object]
        private MenuItem stop;
        [Builder.Object]
        private MenuItem playSpeed;
        [Builder.Object]
        private MenuItem setValueRange;
        [Builder.Object]
        private MenuItem loop;
#pragma warning restore 649
        #endregion
 
 
        private SKDrawingArea sk = new SKDrawingArea();
        private Widget currentView;
 
        public SlideGLArea glArea;
        public SlideRenderer slideRenderer;
        public SKSlideRenderer sKSlideRenderer;
        public GLWindow window;
        public static bool MacOS = false;
 
        #region Constructors / Destructors
 
        public static ImageView Create(BioImage bm)
        {
            string gladePath = System.IO.Path.Combine(
                System.IO.Path.GetDirectoryName(Environment.ProcessPath)!,
                "Glade",
                "ImageView.glade");
            if (App.tools == null)
                App.tools = Tools.Create();
            Builder builder = new Builder();
            builder.AddFromFile(gladePath);
 
            var imageViewObj = builder.GetObject("imageView");
            ImageView v = new ImageView(builder, imageViewObj.Handle, bm);
            v.Title = bm.Filename;
 
            return v;
        }
 
        /* The above code is a constructor for the ImageView class in C#. It takes in a Builder object,
        a handle, and a BioImage object as parameters. */
        protected ImageView(Builder builder, IntPtr handle, BioImage im) : base(handle)
        {
            _builder = builder;
            App.viewer = this;
            builder.Autoconnect(this);
            var gameWindowSettings = new GameWindowSettings()
            {
                UpdateFrequency = 60,
            };
            NativeWindowSettings nativeSettings;
 
            if (OperatingSystem.IsMacOS())
            {
                MacOS = true;
                // Create the renderer bridge
                View = new SKDrawingArea();
                sKSlideRenderer = new SKSlideRenderer(sk);
            }
            else if (OperatingSystem.IsLinux())
            {
                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)
                };
                //tileCopy = new TileCopyGL(gameWindowSettings, nativeSettings);
                Environment.SetEnvironmentVariable("GDK_BACKEND", "x11");
                Environment.SetEnvironmentVariable("GTK_BACKEND", "x11");
                if (im.isPyramidal)
                {
                    window = new GLWindow(gameWindowSettings, nativeSettings);
                    View = new SlideGLArea();
                    ((SlideGLArea)View).OnSkiaRender += RenderSkia;
                    slideRenderer = new SlideRenderer((SlideGLArea)View);
                }
                else
                {
                    View = new SlideArea();
                    ((SlideArea)View).OnSkiaRender += RenderSkia;
                }
                GLFWProvider.SetErrorCallback((error, description) =>
                {
                });
 
            }
            else if (OperatingSystem.IsWindows())
            {
                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)
                };
                if (im.isPyramidal)
                {
                    window = new GLWindow(gameWindowSettings, nativeSettings);
                    View = new SlideGLArea();
                    ((SlideGLArea)View).OnSkiaRender += RenderSkia;
                    slideRenderer = new SlideRenderer((SlideGLArea)View);
                }
                else
                {
                    View = new SlideArea();
                    ((SlideArea)View).OnSkiaRender += RenderSkia;
                }
                GLFWProvider.SetErrorCallback((error, description) =>
                {
                });
            }
 
            if (MacOS)
            {
                // View is the sole rendering surface on macOS for both pyramidal and non-pyramidal.
                // Always attach it to the grid so the widget appears in the window layout.
                View.Expand = true;
                grid.Attach(View, 0, 0, 1, 1);
 
                if (im.isPyramidal)
                {
                    // Set the source based on image type
                    if (im.OpenSlideBase != null)
                    {
                        sKSlideRenderer.SetSource(im.OpenSlideBase);
                    }
                    else if (im.SlideBase != null)
                    {
                        sKSlideRenderer.SetSource(im.SlideBase);
                    }
                }
            }
            else
            {
                // Set the source based on image type
                if (slideRenderer != null && im.OpenSlideBase != null)
                {
                    slideRenderer.SetSource(im.OpenSlideBase);
                }
                else if (slideRenderer != null && im.SlideBase != null)
                {
                    slideRenderer.SetSource(im.SlideBase);
                }
                if (im.isPyramidal)
                {
                    View.Expand = true;
                    grid.Attach(View,0,0,1,1);
                }                
                else
                {
                    View.Name = "View";
                    View.WidthRequest = 600;
                    View.HeightRequest = 400;
                    grid.Attach(View, 0, 0, 1, 1);
                }
            }
            
            if (!MacOS)
            {
                if (im.isPyramidal)
                {
                    View.WidthRequest = 600;
                    View.HeightRequest = 400;
                    View.Show();
                }
                else
                    View.ShowAll();
            }
            else
            {
                View.WidthRequest = 600;
                View.HeightRequest = 400;
                View.Show();
            }
            roi.Submenu = roiMenu;
            UpdateRoiMenuState();
            roi.ShowAll();
            AddImage(im);
            ShowMasks = true;
            pxWmicron = SelectedImage.PhysicalSizeX;
            pxHmicron = SelectedImage.PhysicalSizeY;
            SetupHandlers();
            EnsureInitialPyramidalRender();
            //pictureBox.WidthRequest = im.SizeX;
            //pictureBox.HeightRequest = im.SizeY;
            Function.InitializeContextMenu();
            this.Scale = new SizeF(1, 1);
            // Set the text column to display for comboboxs.
            var rendererr = new CellRendererText();
            rBox.PackStart(rendererr, false);
            rBox.AddAttribute(rendererr, "text", 0);
            var rendererg = new CellRendererText();
            gBox.PackStart(rendererg, false);
            gBox.AddAttribute(rendererg, "text", 0);
            var rendererb = new CellRendererText();
            bBox.PackStart(rendererb, false);
            bBox.AddAttribute(rendererb, "text", 0);
            UpdateScrollBars();
 
            Gtk.Application.Invoke((s, e) =>
            {
                if (SelectedImage != null)
                    GoToImage(SelectedIndex);
            });
 
            //App.ApplyStyles(this);
        }
        /*
        GRBackendRenderTarget _renderTarget;
        GRContext _grContext;
        SKSurface _skSurface;
        private void InitializeSkia()
        {
            // 1. Get the High-DPI scaling factor for the laptop screen
            int scale = ScaleFactor;
            int width = AllocatedWidth * scale;
            int height = AllocatedHeight * scale;
 
            if (width <= 0 || height <= 0) return;
 
            // 2. Query the current GL state for the framebuffer configuration
            GL.GetInteger(GetPName.FramebufferBinding, out int framebufferId);
            GL.GetInteger(GetPName.Samples, out int samples); // <--- This fills your 'samples'
                                                              // Get Stencil Bits with a fallback
            int stencil;
            try
            {
                // 0x0D57 is the GL constant for STENCIL_BITS
                GL.GetInteger((GetPName)0x0D57, out stencil);
            }
            catch
            {
                stencil = 8; // Standard fallback for Skia
            }
 
            var glInfo = new GRGlFramebufferInfo(
            fboId: (uint)framebufferId,
            format: 0x8058); // GL_RGBA8
 
            // 4. Create the render target with physical pixel dimensions
            _renderTarget = new GRBackendRenderTarget(
                width,
                height,
                samples,
                stencil,
                glInfo);
 
            // 5. Create the context and surface
            _grContext = GRContext.CreateGl();
            _skSurface = SKSurface.Create(_grContext, _renderTarget, GRSurfaceOrigin.BottomLeft, SKColorType.Rgba8888);
        }
        */
        private void RenderSkia(SKCanvas canvas, int width, int height)
        {
            try
            {
                canvas.Save();
                canvas.Scale(ScaleFactor); // Scale coordinates to match High-DPI screen
 
                var paint = new SKPaint
                {
                    Color = SKColors.Gray,
                    BlendMode = SKBlendMode.SrcOver,
                    IsAntialias = true,
                    Style = SKPaintStyle.Fill
                };
                // Draw annotations (ROIs) - keep existing annotation drawing code
                int i = 0;
                foreach (BioImage im in Images)
                {
                    canvas.Save();
                List<ROI> rois = BuildRenderableRois(im);
                    int ri = 0;
                    ZCT co = GetCoordinate();
                    RectangleD rp = ToScreenSpace(new RectangleD(im.StageSizeX * im.PhysicalSizeX, im.StageSizeX * im.PhysicalSizeY, im.SizeX * im.PhysicalSizeX, im.SizeY * im.PhysicalSizeY));
                    if (!im.isPyramidal)
                        canvas.DrawImage(SKImages[i], ToRectangle((float)rp.X, (float)rp.Y, (float)rp.W, (float)rp.H), paint);
                    if (rois.Count > 0)
                    {
                        RenderSkiaAnnotations(canvas, width, height, im);
                    }
                    i++;
                    canvas.Restore();
                }
                canvas.Restore();
                // Draw overview if enabled
                EnsureOverviewCurrent();
                if (overviewImage != null && ShowOverview)
                {
                    paint = new SKPaint
                    {
                        Color = SKColors.Gray,
                        BlendMode = SKBlendMode.SrcOver,
                        IsAntialias = true,
                        Style = SKPaintStyle.Fill
                    };
                    // Draw the overview image at the top-left corner
                    canvas.DrawImage(overviewImage, 0, 0, paint);
                    paint.Style = SKPaintStyle.Stroke;
                    canvas.DrawRect(0, 0, overview.Width, overview.Height, paint);
                }
                else if (overviewImage == null && ShowOverview)
                {
                    paint.Style = SKPaintStyle.Stroke;
                    paint.Color = SKColors.Gray;
                    paint.StrokeWidth = 2;
                    canvas.DrawRect(0, 0, overview.Width, overview.Height, paint);
                }
                SKImageInfo inf = new SKImageInfo(width, height);
                if(SelectedImage!=null)
                if (SelectedImage.isPyramidal)
                    DrawViewportRectangle(canvas, paint);
 
                // Plugin rendering hook
                Plugins.Render(this, new SkiaSharp.Views.Desktop.SKPaintSurfaceEventArgs(canvas.Surface, inf));
                paint.Dispose();
                canvas.Restore();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Annotation render error: {ex.Message}");
            }
        }
        private PointD ToScreenSpaceForImage(BioImage image, PointD p)
        {
            if (image != null && image.isPyramidal)
            {
                double resolution = image.Resolution > 0 ? image.Resolution : 1;
                PointD origin = image.PyramidalOrigin;
                return new PointD((p.X - origin.X) / resolution, (p.Y - origin.Y) / resolution);
            }
 
            double dx = (pxWmicron * (Origin.X)) * Scale.Width;
            double dy = (pxHmicron * (Origin.Y)) * Scale.Height;
            return new PointD((PxWmicron * p.X * Scale.Width + dx), (PxHmicron * p.Y * Scale.Height + dy));
        }
 
        private RectangleD ToScreenRectForImage(BioImage image, double x, double y, double w, double h)
        {
            if (image != null && image.isPyramidal)
            {
                double resolution = image.Resolution > 0 ? image.Resolution : 1;
                PointD origin = image.PyramidalOrigin;
                return new RectangleD(
                    (x - origin.X) / resolution,
                    (y - origin.Y) / resolution,
                    w / resolution,
                    h / resolution);
            }
 
            double dx = (pxWmicron * (Origin.X)) * Scale.Width;
            double dy = (pxHmicron * (Origin.Y)) * Scale.Height;
            return new RectangleD(
                (PxWmicron * x * Scale.Width + dx),
                (PxHmicron * y * Scale.Height + dy),
                (PxWmicron * w * Scale.Width),
                (PxHmicron * h * Scale.Height));
        }
 
        private void RenderSkiaAnnotations(SKCanvas canvas, int width, int height, BioImage im)
        {
            try
            {
                canvas.Save();
                canvas.Scale(ScaleFactor); // Scale coordinates to match High-DPI screen
 
                var paint = new SKPaint
                {
                    Color = SKColors.Gray,
                    BlendMode = SKBlendMode.SrcOver,
                    IsAntialias = true,
                    Style = SKPaintStyle.Fill
                };
 
                canvas.Save();
                List<ROI> rois = BuildRenderableRois(im);
                int ri = 0;
                ZCT co = im?.Coordinate ?? new ZCT();
                if (rois.Count > 0)
                {
                    List<ROI> selectedMasks = new List<ROI>();
                    foreach (ROI an in rois)
                    {
                            if (an.coord != co)
                                continue;
                            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;
                            }
                            if (an.Selected)
                            {
                                paint.Color = SKColors.Magenta;
                            }
                            else
                                paint.Color = new SKColor(an.strokeColor.R, an.strokeColor.G, an.strokeColor.B);
                            paint.StrokeWidth = (float)an.strokeWidth;
                            paint.Style = SKPaintStyle.Stroke;
                            PointF pc = new PointF((float)(an.BoundingBox.X + (an.BoundingBox.W / 2)), (float)(an.BoundingBox.Y + (an.BoundingBox.H / 2)));
                            float widths = ROI.selectBoxSize * (float)Resolution;
                            
                            if (an.type == ROI.Type.Mask && ShowMasks && an.coord == co)
                            {
                                if (an.roiMask == null)
                                    continue;
                                if (an.Selected)
                                {
                                    selectedMasks.Add(an);
                                    continue;
                                }
                                paint.Style = SKPaintStyle.Fill;
                                RectangleD p = ToScreenRectForImage(im, an.X, an.Y, an.W, an.H);
                                if (!IsScreenRectVisible(p, width, height))
                                    continue;
                                const byte maskOverlayAlpha = 96;
                                using SKImage sim = MaskToSKImage(an.roiMask, Color.FromArgb(maskOverlayAlpha, an.fillColor.R, an.fillColor.G, an.fillColor.B), maskOverlayAlpha);
                                canvas.DrawImage(sim, ToRectangle((float)p.X, (float)p.Y, (float)p.W, (float)p.H), paint);
                                continue;
                            }
                            else
                            if (an.type == ROI.Type.Point)
                            {
                                RectangleD r1 = ToScreenRect(an.Point.X, an.Point.Y, ToViewW(3), ToViewH(3));
                                canvas.DrawCircle((float)r1.X, (float)r1.Y, 3, paint);
                            }
                            else
                            if (an.type == ROI.Type.Line)
                            {
                                for (int p = 0; p < an.Points.Count - 1; p++)
                                {
                                    PointD p1 = ToScreenSpaceForImage(im, an.Points[p]);
                                    PointD p2 = ToScreenSpaceForImage(im, an.Points[p + 1]);
                                    canvas.DrawLine(new SKPoint((float)p1.X, (float)p1.Y), new SKPoint((float)p2.X, (float)p2.Y), paint);
                                }
                            }
                            else
                            if (an.type == ROI.Type.Rectangle)
                            {
                                RectangleD rectt = ToScreenRectForImage(im, an.BoundingBox.X, an.BoundingBox.Y, an.BoundingBox.W, an.BoundingBox.H);
                                canvas.DrawRect((float)rectt.X, (float)rectt.Y, (float)rectt.W, (float)rectt.H, paint);
                            }
                            else
                            if (an.type == ROI.Type.Ellipse)
                            {
                                RectangleD rect = ToScreenRectForImage(im, an.BoundingBox.X, an.BoundingBox.Y, an.BoundingBox.W, an.BoundingBox.H);
                                canvas.DrawOval((float)rect.X, (float)rect.Y, (float)rect.W / 2, (float)rect.H / 2, paint);
                            }
                            else
                            if ((an.type == ROI.Type.Polygon && an.closed))
                            {
                                for (int p = 0; p < an.Points.Count - 1; p++)
                                {
                                    PointD p1 = ToScreenSpaceForImage(im, an.Points[p]);
                                    PointD p2 = ToScreenSpaceForImage(im, an.Points[p + 1]);
                                    canvas.DrawLine(new SKPoint((float)p1.X, (float)p1.Y), new SKPoint((float)p2.X, (float)p2.Y), paint);
                                }
                                 PointD pp1 = ToScreenSpaceForImage(im, an.Points[0]);
                                 PointD pp2 = ToScreenSpaceForImage(im, an.Points[an.Points.Count - 1]);
                                 canvas.DrawLine(new SKPoint((float)pp1.X, (float)pp1.Y), new SKPoint((float)pp2.X, (float)pp2.Y), paint);
                            }
                            else
                            if ((an.type == ROI.Type.Polygon && !an.closed) || an.type == ROI.Type.Polyline)
                            {
                                for (int p = 0; p < an.Points.Count - 1; p++)
                                {
                                    PointD p1 = ToScreenSpaceForImage(im, an.Points[p]);
                                    PointD p2 = ToScreenSpaceForImage(im, an.Points[p + 1]);
                                    canvas.DrawLine(new SKPoint((float)p1.X, (float)p1.Y), new SKPoint((float)p2.X, (float)p2.Y), paint);
                                }
                            }
                            else
                            if (an.type == ROI.Type.Freeform)
                            {
                                for (int p = 0; p < an.Points.Count - 1; p++)
                                {
                                    PointD p1 = ToScreenSpaceForImage(im, an.Points[p]);
                                    PointD p2 = ToScreenSpaceForImage(im, an.Points[p + 1]);
                                    canvas.DrawLine(new SKPoint((float)p1.X, (float)p1.Y), new SKPoint((float)p2.X, (float)p2.Y), paint);
                                }
                                PointD pp1 = ToScreenSpaceForImage(im, an.Points[0]);
                                PointD pp2 = ToScreenSpaceForImage(im, an.Points[an.Points.Count - 1]);
                                canvas.DrawLine(new SKPoint((float)pp1.X, (float)pp1.Y), new SKPoint((float)pp2.X, (float)pp2.Y), paint);
                            }
                            else
                            if (an.type == ROI.Type.Label)
                            {
                                PointD p = ToScreenSpaceForImage(im, an.Point);
                                canvas.DrawText(an.Text, (float)p.X, (float)p.Y, new SKFont(SKTypeface.Default, an.fontSize, 1, 0), paint);
                            }
 
                            if (ROIManager.showText)
                            {
                                RectangleD p = ToScreenRectForImage(im, an.Point.X, an.Point.Y, 1, 1);
                                canvas.DrawText(an.Text, (float)p.X, (float)p.Y, new SKFont(SKTypeface.Default, an.fontSize, 1, 0), paint);
                            }
                            if (ROIManager.showBounds && an.type != ROI.Type.Rectangle && an.type != ROI.Type.Mask && an.type != ROI.Type.Label)
                            {
                                RectangleD rrf = ToScreenRectForImage(im, an.BoundingBox.X, an.BoundingBox.Y, an.BoundingBox.W, an.BoundingBox.H);
                                canvas.DrawRect((float)rrf.X, (float)rrf.Y, (float)rrf.W, (float)rrf.H, paint);
                            }
                            paint.Color = SKColors.Red;
                            if (!(an.type == ROI.Type.Freeform && !an.Selected) && an.type != ROI.Type.Mask)
                                foreach (RectangleD re in an.GetSelectBoxes(1))
                                {
                                    RectangleD recd = ToScreenRectForImage(im, re.X, re.Y, re.W, re.H);
                                    canvas.DrawRect((float)recd.X, (float)recd.Y, (float)recd.W, (float)recd.H, paint);
                                }
                            if (an.type != ROI.Type.Mask)
                            {
                                //Lets draw the selection Boxes.
                                List<RectangleD> rects = new List<RectangleD>();
                                RectangleD[] sels = an.GetSelectBoxes(widths);
                                for (int p = 0; p < an.selectedPoints.Count; p++)
                                {
                                    if (an.selectedPoints[p] < an.GetPointCount())
                                    {
                                        rects.Add(sels[an.selectedPoints[p]]);
                                    }
                                }
                                //Lets draw selected selection boxes.
                                paint.Color = SKColors.Blue;
                                if (rects.Count > 0)
                                {
                                    int ind = 0;
                                    foreach (RectangleD re in an.GetSelectBoxes(1))
                                    {
                                        RectangleD recd = ToScreenRectForImage(im, re.X, re.Y, re.W, re.H);
                                        if (an.selectedPoints.Contains(ind))
                                        {
                                            canvas.DrawRect((float)recd.X, (float)recd.Y, (float)recd.W, (float)recd.H, paint);
                                        }
                                        ind++;
                                    }
                                }
                                rects.Clear();
                            }
                            ri++;
                        }
                    foreach (ROI an in selectedMasks)
                    {
                        if (an == null || an.roiMask == null)
                            continue;
                        paint.Style = SKPaintStyle.Fill;
                        RectangleD p = ToScreenRectForImage(im, an.X, an.Y, an.W, an.H);
                        if (!IsScreenRectVisible(p, width, height))
                            continue;
                        using SKImage sim = MaskToSKImage(an.roiMask, Color.FromArgb(220, 0, 120, 255), 220);
                        canvas.DrawImage(sim, ToRectangle((float)p.X, (float)p.Y, (float)p.W, (float)p.H), paint);
                        paint.Style = SKPaintStyle.Stroke;
                        paint.Color = SKColors.Blue;
                        paint.StrokeWidth = 2;
                        canvas.DrawRect(ToRectangle((float)p.X, (float)p.Y, (float)p.W, (float)p.H), paint);
                    }
                }
                canvas.Restore();
                SKImageInfo inf = new SKImageInfo(width, height);
                // Plugin rendering hook
                Plugins.Render(this, new SkiaSharp.Views.Desktop.SKPaintSurfaceEventArgs(canvas.Surface, inf));
                paint.Dispose();
                canvas.Restore();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Annotation render error: {ex.Message}");
            }
        }
 
        private List<ROI> BuildRenderableRois(BioImage image)
        {
            if (!ShowROIs)
                return new List<ROI>();
 
            List<ROI> rois = image?.Annotations?.ToList() ?? new List<ROI>();
            List<ROI> overlays = GetZarrLabelOverlays(image);
            if (overlays.Count == 0)
                return rois;
 
            HashSet<ROI> existing = new HashSet<ROI>(rois.Where(r => r != null));
            foreach (ROI overlay in overlays)
            {
                if (overlay != null && existing.Add(overlay))
                    rois.Add(overlay);
            }
            return rois;
        }
 
        private static bool IsScreenRectVisible(RectangleD rect, int width, int height)
        {
            if (rect.W <= 0 || rect.H <= 0 || width <= 0 || height <= 0)
                return false;
 
            return rect.X < width &&
                   rect.Y < height &&
                   rect.X + rect.W > 0 &&
                   rect.Y + rect.H > 0;
        }
        public static SKImage BitmapToSKImage(Bitmap bmp)
        {
            var rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
 
            var data = bmp.LockBits(
                rect,
                ImageLockMode.ReadOnly,
                AForge.PixelFormat.Format32bppArgb); // This is BGRA in memory
 
            try
            {
                var info = new SKImageInfo(
                    bmp.Width,
                    bmp.Height,
                    SKColorType.Bgra8888,
                    SKAlphaType.Premul);
 
                var pixmap = new SKPixmap(info, data.Scan0, data.Stride);
 
                return SKImage.FromPixels(pixmap);
            }
            finally
            {
                bmp.UnlockBits(data);
            }
        }
 
        private static SKImage MaskToSKImage(ROI.Mask mask, Color color, byte alpha)
        {
            if (mask == null || mask.Width <= 0 || mask.Height <= 0)
                return SKImage.FromBitmap(new SKBitmap(1, 1));
 
            byte[] values = mask.GetBytes();
            int width = mask.Width;
            int height = mask.Height;
            int pixelCount = width * height;
            byte[] bgra = new byte[pixelCount * 4];
            int count = Math.Min(pixelCount, values?.Length ?? 0);
 
            for (int i = 0; i < count; i++)
            {
                if (values[i] == 0)
                    continue;
 
                int d = i * 4;
                bgra[d + 0] = color.B;
                bgra[d + 1] = color.G;
                bgra[d + 2] = color.R;
                bgra[d + 3] = alpha;
            }
 
            var info = new SKImageInfo(width, height, SKColorType.Bgra8888, SKAlphaType.Unpremul);
            var data = SKData.CreateCopy(bgra);
            var pixmap = new SKPixmap(info, data.Data, info.RowBytes);
            return SKImage.FromPixels(pixmap, (address, context) => data.Dispose(), null);
        }
        /*
        private void DrawOverview(SKCanvas canvas, SKPaint paint)
        {
            var ims = BitmapToSKImage(overviewImage.GetImageRGBA(overviewImage.LittleEndian));
            paint.Style = SKPaintStyle.Fill;
            canvas.DrawImage(ims, 0, 0, paint);
 
            paint.Style = SKPaintStyle.Stroke;
            paint.Color = SKColors.Gray;
            canvas.DrawRect(overview.X, overview.Y, overview.Width, overview.Height, paint);
 
            // Draw viewport indicator
            paint.Color = SKColors.Red;
            // ... existing viewport rect calculation ...
 
            ims.Dispose();
        }
        */
        // Immediate render for interactive operations like panning
        public void RequestImmediateRender()
        {
            UpdateView(true);
        }
 
        private void CleanupViewerResources()
        {
            if (_viewerCleanupDone)
                return;
 
            _viewerCleanupDone = true;
 
            _tileFetchCancellation?.Cancel();
            _tileFetchCancellation?.Dispose();
            _tileFetchCancellation = null;
 
            lock (_pendingTileFetches)
            {
                _pendingTileFetches.Clear();
            }
 
            overviewImage?.Dispose();
            overviewImage = null;
            _overviewRequestId++;
 
            slideRenderer?.ClearCache();
            slideRenderer = null;
            sKSlideRenderer?.Dispose();
            sKSlideRenderer = null;
        }
 
        private static SkiaSharp.SKRect ToRectangle(float x1, float y1, float x2, float y2)
        {
            return new SkiaSharp.SKRect()
            {
                Location = new SKPoint(x1, y1),
                Size = new SKSize(x2, y2)
            };
        }
        private bool refresh = false;
        SKImage overviewSKImage;
        private bool _viewerCleanupDone = false;
        private bool _destroyRequested = false;
        private async Task PrefetchSurroundingTiles(Extent viewportExtent, int level)
        {
            if (_viewerCleanupDone)
                return;
            // Cancel any pending prefetch operations
            _tileFetchCancellation?.Cancel();
            _tileFetchCancellation = new CancellationTokenSource();
            var token = _tileFetchCancellation.Token;
 
            // Expand viewport by 1 tile in each direction for prefetching
            var expandedExtent = new Extent(
                viewportExtent.MinX - 256,
                viewportExtent.MinY - 256,
                viewportExtent.MaxX + 256,
                viewportExtent.MaxY + 256
            );
            IEnumerable<TileInfo> tileInfos;
            if (SelectedImage.OpenSlideBase != null)
                tileInfos = SelectedImage.OpenSlideBase.Schema.GetTileInfos(expandedExtent, level);
            else
                tileInfos = SelectedImage.SlideBase.Schema.GetTileInfos(expandedExtent, level);
            // Start fetching tiles asynchronously
            var fetchTasks = new List<Task>();
            foreach (var tileInfo in tileInfos)
            {
                if (token.IsCancellationRequested) break;
 
                var coord = SelectedImage.Coordinate;
                var info = new Info(coord, tileInfo.Index, tileInfo.Extent, level);
                string pendingKey = $"{coord.Z}:{coord.C}:{coord.T}:{tileInfo.Index.Level}:{tileInfo.Index.Col}:{tileInfo.Index.Row}";
 
                // Check the active source cache before scheduling another fetch.
                if (SelectedImage.OpenSlideBase != null)
                {
                    if (SelectedImage.OpenSlideBase.cache.GetTile(info) != null)
                        continue;
                }
                else
                {
                    BioLib.TileInformation tf = new TileInformation(tileInfo.Index, tileInfo.Extent, SelectedImage.Coordinate);
                    if (SelectedImage.SlideBase.cache.GetTile(tf) != null)
                        continue;
                }
 
                // Start async fetch if not already pending
                if (!_pendingTileFetches.ContainsKey(pendingKey))
                {
                    var fetchTask = Task.Run(async () =>
                    {
                        try
                        {
                            if (SelectedImage.OpenSlideBase != null)
                            {
                                Info inf = new Info(coord, tileInfo.Index, tileInfo.Extent, tileInfo.Index.Level);
                                var tile = await SelectedImage.OpenSlideBase.cache.GetTile(inf);
                                return tile;
                            }
                            else
                            {
                                TileInformation tf = new TileInformation(tileInfo.Index, tileInfo.Extent, coord);
                                var tile = await SelectedImage.SlideBase.cache.GetTile(tf);
                                return tile;
                            }
                        }
                        catch (Exception)
                        {
                            return null;
                        }
                    }, token);
 
                    _pendingTileFetches[pendingKey] = fetchTask;
                    fetchTasks.Add(fetchTask);
                }
            }
 
            // Don't await - let prefetching happen in background
            _ = Task.WhenAll(fetchTasks).ContinueWith(t =>
            {
                // Clean up completed fetches
                lock (_pendingTileFetches)
                {
                    var completed = _pendingTileFetches
                        .Where(kvp => kvp.Value.IsCompleted)
                        .Select(kvp => kvp.Key)
                        .ToList();
 
                    foreach (var key in completed)
                        _pendingTileFetches.Remove(key);
                }
 
                // Request a render update if we prefetched any tiles
                if (fetchTasks.Count > 0 && !token.IsCancellationRequested)
                    RequestDeferredRender();
            }, token);
        }
        public void RequestDeferredRender()
        {
            if (_viewerCleanupDone)
                return;
            if (System.Threading.Interlocked.Exchange(ref _deferredRenderQueued, 1) == 1)
                return;
 
            GLib.Timeout.Add(16, () =>
            {
                if (_viewerCleanupDone)
                {
                    System.Threading.Interlocked.Exchange(ref _deferredRenderQueued, 0);
                    return false;
                }
 
                try
                {
                    ExecuteDeferredRender();
                }
                finally
                {
                    System.Threading.Interlocked.Exchange(ref _deferredRenderQueued, 0);
                }
                return false;
            });
        }
        private void ExecuteDeferredRender()
        {
            if (_viewerCleanupDone)
                return;
            // Run directly if already on the GTK main thread so panning and zooming
            // update immediately. Post via Invoke only for background-thread callers.
            if (Thread.CurrentThread == _gtkMainThread)
                DoRender();
            else
                Gtk.Application.Invoke((sender, args) => DoRender());
        }
        private void DoRender()
        {
            if (_viewerCleanupDone)
                return;
            if (SelectedImage?.isPyramidal != true) return;
 
            if (MacOS)
            {
                AForge.Size s;
                if (View.AllocatedWidth <= 1 || View.AllocatedHeight <= 1)
                    s = new AForge.Size(600, 400);
                else
                    s = new AForge.Size(View.AllocatedWidth, View.AllocatedHeight);
 
                var brutileOrigin = new PointD(PyramidalOrigin.X, -PyramidalOrigin.Y);
                int myGeneration = System.Threading.Interlocked.Increment(ref _renderGeneration);
 
                var renderTask = sKSlideRenderer?.UpdateViewAsync(
                    brutileOrigin,
                    Resolution,
                    GetCoordinate(),
                    s.Width,
                    s.Height
                );
                if (renderTask != null)
                {
                    _ = renderTask.ContinueWith(t =>
                    {
                        if (!t.IsFaulted && !_viewerCleanupDone && _renderGeneration == myGeneration)
                            Gtk.Application.Invoke((s2, a2) => View?.QueueDraw());
                    });
                }
            }
            else
            {
                if (View.AllocatedWidth > 1 && View.AllocatedHeight > 1)
                {
                    _ = slideRenderer?.UpdateViewAsync(
                        PyramidalOrigin,
                        View.AllocatedWidth,
                        View.AllocatedHeight,
                        Resolution,
                        GetCoordinate()
                    );
                }
            }
        }
        bool initrend = false;
        #endregion
        private void DrawViewportRectangle(SKCanvas canvas, SKPaint paint)
        {
            if (SelectedImage == null || !SelectedImage.isPyramidal || !ShowOverview)
                return;
 
            try
            {
                TryGetPyramidalViewerBounds(SelectedImage, out double imageMinX, out double imageMinY, out double imageMaxX, out double imageMaxY);
                double imageWorldW = imageMaxX - imageMinX;
                double imageWorldH = imageMaxY - imageMinY;
 
                if (imageWorldW <= 0) imageWorldW = 1;
                if (imageWorldH <= 0) imageWorldH = 1;
 
                // The overview bitmap is a scaled representation of the full image,
                // so the viewport rectangle must be mapped in the same world-space
                // units that GoToImage and the zoom/pan logic use.
                double visibleLeft = PyramidalOrigin.X;
                double visibleTop = PyramidalOrigin.Y;
                double visibleRight = visibleLeft + (View.AllocatedWidth * Resolution);
                double visibleBottom = visibleTop + (View.AllocatedHeight * Resolution);
 
                paint.Color = SKColors.Yellow;
                if (visibleLeft <= imageMinX &&
                    visibleTop <= imageMinY &&
                    visibleRight >= imageMaxX &&
                    visibleBottom >= imageMaxY)
                {
                    paint.Style = SKPaintStyle.Stroke;
                    paint.StrokeWidth = 1f;
                    paint.IsAntialias = true;
                    canvas.DrawRect(0, 0, overview.Width, overview.Height, paint);
                    return;
                }
 
                float ovScaleX = (float)overview.Width / (float)imageWorldW;
                float ovScaleY = (float)overview.Height / (float)imageWorldH;
 
                float ovX = (float)((visibleLeft - imageMinX) * ovScaleX);
                float ovY = (float)((visibleTop - imageMinY) * ovScaleY);
                float ovW = (float)((visibleRight - visibleLeft) * ovScaleX);
                float ovH = (float)((visibleBottom - visibleTop) * ovScaleY);
 
                // 4. Clamp to overview bounds
                float rectLeft = Math.Max(0, ovX);
                float rectTop = Math.Max(0, ovY);
                float rectRight = Math.Min((float)overview.Width, ovX + ovW);
                float rectBottom = Math.Min((float)overview.Height, ovY + ovH);
 
                // 5. Draw
                if (rectRight > rectLeft && rectBottom > rectTop)
                {
                    paint.Style = SKPaintStyle.Stroke;
                    paint.StrokeWidth = 1f;
                    paint.IsAntialias = true;
 
                    canvas.DrawRect(rectLeft, rectTop, rectRight - rectLeft, rectBottom - rectTop, paint);
                }
            }
            catch (Exception)
            {
            }
        }
        private void SetResolution(double newResolution, PointD mouseScreenPos)
        {
            if (newResolution <= 0 || newResolution == Resolution)
                return;
 
            double oldResolution = Resolution;
 
            // 1. World-space point currently under the cursor.
            //    PyramidalOrigin and Resolution are both in world (micron) units.
            double worldX = PyramidalOrigin.X + mouseScreenPos.X * oldResolution;
            double worldY = PyramidalOrigin.Y + mouseScreenPos.Y * oldResolution;
 
            // 2. Apply the new resolution directly on the image to avoid triggering
            //    UpdateView before the origin is also updated.
            _suppressViewUpdates = true;
            try
            {
                if (SelectedImage.isPyramidal)
                    SelectedImage.Resolution = newResolution;
            }
            finally
            {
                _suppressViewUpdates = false;
            }
 
            double actualResolution = Resolution;
            if (actualResolution == oldResolution)
                return;
 
            // 3. Reposition origin so the same world point stays under the cursor.
            double newOriginX = worldX - mouseScreenPos.X * actualResolution;
            double newOriginY = worldY - mouseScreenPos.Y * actualResolution;
 
            // 4. Clamp to translated pyramid bounds in viewer coordinates.
            TryGetPyramidalViewerBounds(SelectedImage, out double imageMinX, out double imageMinY, out double imageMaxX, out double imageMaxY);
            double viewWorldW = Math.Max(1, View?.AllocatedWidth ?? 1) * actualResolution;
            double viewWorldH = Math.Max(1, View?.AllocatedHeight ?? 1) * actualResolution;
 
            PyramidalOrigin = new PointD(
                ClampPyramidalOrigin(newOriginX, imageMinX, imageMaxX, viewWorldW),
                ClampPyramidalOrigin(newOriginY, imageMinY, imageMaxY, viewWorldH)
            );
            // PyramidalOrigin setter fires UpdateView with both the new origin and
            // new resolution already in place — one render, correct result.
        }
        public void SetTitle(string s)
        {
            this.Title = s;
        }
        // In your resize handler
        private void OnViewResized(object sender, EventArgs e)
        {
            if (SelectedImage?.isPyramidal == true)
            {
                UpdateView(true);
                UpdateImages();
            }
        }
 
        // Add these fields to ImageView class
        // Captured at construction time on the GTK main thread so ExecuteDeferredRender
        // can detect whether it's already on the right thread without GLib internals.
        private readonly Thread _gtkMainThread = Thread.CurrentThread;
        // Incremented each time a new macOS pyramidal render is requested.
        // ContinueWith callbacks check this to discard stale results.
        private volatile int _renderGeneration = 0;
        private int _deferredRenderQueued = 0;
        // Set to true while GoToImage is applying a batch of origin/resolution changes
        // so that intermediate setter calls don't each fire a separate UpdateView.
        private bool _suppressViewUpdates = false;
        private bool _isApplyingGoToImage = false;
        private int? _pendingGoToImageIndex = null;
        private bool _updatingGui = false;
        private readonly HashSet<BioImage> _initializedRgbChannelDefaults = new HashSet<BioImage>();
        private CancellationTokenSource _tileFetchCancellation;
        private Dictionary<string, Task<byte[]>> _pendingTileFetches = new Dictionary<string, Task<byte[]>>();
        private List<SKImage> SKImages = new List<SKImage>();
        private List<Bitmap> Bitmaps = new List<Bitmap>();
        public void UpdateImages(bool force = false)
        {
            App.viewer = this;
            if (selectedIndex < 0 || selectedIndex >= Images.Count)
                return;
            BioImage currentImage = Images[selectedIndex];
            if (currentImage == null)
                return;
            EnsureImageChannels(currentImage);
            if (zBar.Adjustment.Upper != currentImage.SizeZ - 1 ||
                tBar.Adjustment.Upper != currentImage.SizeT - 1)
            {
                UpdateGUI();
            }
            if (!MacOS)
            {
                if (currentImage.isPyramidal && glArea.AllocatedWidth > 1 && glArea.AllocatedHeight > 1)
                {
                    // Use the new renderer - no more ReadPixels!
                    _ = slideRenderer.UpdateViewAsync(
                        currentImage.PyramidalOrigin,
                        glArea.AllocatedWidth,
                        glArea.AllocatedHeight,
                        currentImage.Resolution,
                        currentImage.Coordinate
                    );
                }
                else if (!currentImage.isPyramidal)
                {
                    for (int i = 0; i < SKImages.Count; i++)
                    {
                        SKImages[i].Dispose();
                        Bitmaps[i].Dispose();
                    }
                    SKImages.Clear();
                    Bitmaps.Clear();
                    foreach (BioImage b in Images)
                    {
                        ZCT c = b.Coordinate;
                        AForge.Bitmap bitmap = null;
                        int index = b.GetFrameIndex(c.Z, c.C, c.T);
                        if (Mode == ViewMode.Filtered)
                        {
                            bitmap = b.GetFiltered(c, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                        }
                        else if (Mode == ViewMode.RGBImage)
                        {
                            bitmap = b.GetRGBBitmap(c, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                        }
                        else if (Mode == ViewMode.Raw)
                        {
                            bitmap = b.Buffers[index];
                        }
                        else
                        {
                            bitmap = b.GetEmission(c, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                        }
                        if (bitmap == null)
                            return;
                        var bm = bitmap.GetImageRGBA(bitmap.LittleEndian);
                        SKImage skim = BitmapToSKImage(bm);
                        SKImages.Add(skim);
                        Bitmaps.Add(bm);
                    }
                }
            }
            else
            {
                if (currentImage.isPyramidal && sk.AllocatedWidth > 1 && sk.AllocatedHeight > 1)
                {
                    // Use the new renderer - no more ReadPixels!
                    _ = sKSlideRenderer.UpdateViewAsync(
                        currentImage.PyramidalOrigin,
                        currentImage.Resolution,
                        currentImage.Coordinate,
                        sk.AllocatedWidth,
                        sk.AllocatedHeight
                    );
                }
                else if (!currentImage.isPyramidal)
                {
                    for (int i = 0; i < SKImages.Count; i++)
                    {
                        SKImages[i].Dispose();
                        Bitmaps[i].Dispose();
                    }
                    SKImages.Clear();
                    Bitmaps.Clear();
                    foreach (BioImage b in Images)
                    {
                        ZCT c = b.Coordinate;
                        AForge.Bitmap bitmap = null;
                        int index = b.GetFrameIndex(c.Z, c.C, c.T);
                        if (Mode == ViewMode.Filtered)
                        {
                            bitmap = b.GetFiltered(c, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                        }
                        else if (Mode == ViewMode.RGBImage)
                        {
                            bitmap = b.GetRGBBitmap(c, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                        }
                        else if (Mode == ViewMode.Raw)
                        {
                            bitmap = b.Buffers[index];
                        }
                        else
                        {
                            bitmap = b.GetEmission(c, b.RChannel.RangeR, b.GChannel.RangeG, b.BChannel.RangeB);
                        }
                        if (bitmap == null)
                            return;
                        var bm = bitmap.GetImageRGBA(bitmap.LittleEndian);
                        SKImage skim = BitmapToSKImage(bm);
                        SKImages.Add(skim);
                        Bitmaps.Add(bm);
                    }
                }
            }
        }/*
        private async Task UpdateWellImageAsync()
        {
            try
            {
                var bitmap = await SelectedImage.GetWellFieldBitmap().ConfigureAwait(false);
                if (bitmap == null) return;
 
                var tcs = new System.Threading.Tasks.TaskCompletionSource<bool>();
                Gtk.Application.Invoke((s, e) =>
                {
                    try
                    {
                        for (int i = 0; i < SKImages.Count; i++) { SKImages[i].Dispose(); Bitmaps[i].Dispose(); }
                        SKImages.Clear();
                        Bitmaps.Clear();
 
                        SKImage skim = BitmapToSKImage(bitmap);
                        SKImages.Add(skim);
                        Bitmaps.Add(bitmap);
 
                        View?.QueueDraw();
                        tcs.SetResult(true);
                    }
                    catch (Exception ex) { tcs.SetException(ex); }
                });
                await tcs.Task.ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"UpdateWellImageAsync error: {ex.Message}");
            }
        }
        */
        public void UpdateImage()
        {
            UpdateImages();
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false);
        }
        public void RefreshPyramidalTiles()
        {
            if (SelectedImage?.isPyramidal != true)
                return;
 
            // Threshold/channel edits invalidate pixels but do not require socket
            // aborts. Let older Zarr reads drain and discard them by render version.
            slideRenderer?.InvalidateRenderState(cancelActiveFetches: false);
            sKSlideRenderer?.InvalidateRenderState();
            SelectedImage.InvalidateTileCache();
            slideRenderer?.ClearCache(resetLevel: false, cancelActiveFetches: false);
            sKSlideRenderer?.ClearCache();
            SelectedImage.ZarrDisplayMax = 0;
            _overviewSource = null;
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, SelectedImage?.file ?? string.Empty);
        }
 
        public Task<bool> PopulateSelectedZarrStatisticsAsync()
        {
            var image = SelectedImage;
            if (image?.IsZarrSource != true || slideRenderer == null)
                return Task.FromResult(false);
 
            return slideRenderer.PopulateZarrStatisticsAsync(image, image.Coordinate);
        }
        Rectangle overview;
        SKImage overviewImage;
        private BioImage _overviewSource;
        private ZCT _overviewCoordinate;
        private int _overviewDisplayMin, _overviewDisplayMax, _overviewWellIndex;
        private int _overviewRequestId;
 
        private void EnsureOverviewCurrent()
        {
            var image = SelectedImage;
            if (_viewerCleanupDone || image?.isPyramidal != true || !ShowOverview)
                return;
 
            if (!ReferenceEquals(_overviewSource, image) ||
                _overviewCoordinate != image.Coordinate ||
                _overviewDisplayMin != image.ZarrDisplayMin ||
                _overviewDisplayMax != image.ZarrDisplayMax ||
                _overviewWellIndex != image.WellIndex)
                InitPreview();
        }
        public int? MacroResolution { get { return SelectedImage.MacroResolution; } }
        public int? LabelResolution { get { return SelectedImage.LabelResolution; } }
 
        private async void InitPreview()
        {
            var image = SelectedImage;
            if (_viewerCleanupDone || image == null || !image.isPyramidal)
                return;
 
            int requestId = ++_overviewRequestId;
            _overviewSource = image;
            _overviewCoordinate = image.Coordinate;
            _overviewDisplayMin = image.ZarrDisplayMin;
            _overviewDisplayMax = image.ZarrDisplayMax;
            _overviewWellIndex = image.WellIndex;
            ZCT coordinate = image.Coordinate;
            try
            {
                refresh = false;
                int OVERVIEW_SIZE = View.ScaleFactor * 160;
 
                var (sourceBitmap, srcW, srcH) = await FetchPreviewBitmap(image, coordinate, OVERVIEW_SIZE);
                Gtk.Application.Invoke((s, e) =>
                {
                    using (sourceBitmap)
                    {
                        if (_viewerCleanupDone || requestId != _overviewRequestId || !ReferenceEquals(image, SelectedImage))
                            return;
                        try
                        {
                            var (ow, oh) = CalcOverviewSize(srcW, srcH, OVERVIEW_SIZE);
                            var preview = ScaleToOverview(sourceBitmap, srcW, srcH, ow, oh);
                            overview = new Rectangle(0, 0, ow, oh);
                            overviewImage?.Dispose();
                            overviewImage = preview;
                            ShowOverview = overviewImage != null;
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"Overview rendering failed: {ex.Message}");
                            ShowOverview = false;
                            overviewImage?.Dispose();
                            overviewImage = null;
                        }
                        // SlideGLArea uses AutoRender=false, so QueueDraw alone does
                        // not invoke its GL render callback. Request a GL render as
                        // soon as the asynchronously prepared overview is installed;
                        // otherwise it only appears after the next pan/zoom event.
                        if (View is SlideGLArea slideGlArea)
                            slideGlArea.RequestRedraw();
                        else
                            View?.QueueDraw();
                    }
                });
            }
            catch (Exception ex)
            {
                Gtk.Application.Invoke((s, e) =>
                {
                    if (_viewerCleanupDone || requestId != _overviewRequestId)
                        return;
                    Console.WriteLine($"Overview loading failed: {ex.Message}");
                    ShowOverview = false;
                    overviewImage?.Dispose();
                    overviewImage = null;
                });
            }
        }
 
        // Returns (bitmap, srcW, srcH), or (null, 0, 0) on failure.
        private async Task<(Bitmap bitmap, int w, int h)> FetchPreviewBitmap(BioImage image, ZCT coordinate, int overviewSize)
        {
            if (image.Type == BioImage.ImageType.well)
            {
                var bmp = await image.GetWellFieldBitmap(image.WellIndex, coordinate.Z, coordinate.C, coordinate.T);
                if (bmp == null)
                {
                    return (null, 0, 0);
                }
                return (bmp, bmp.Width, bmp.Height);
            }
 
            // The initial pyramidal view is already fit to the complete image.
            // Reuse that rendered frame instead of independently downloading and
            // decoding another multi-megapixel pyramid level for the minimap.
            if (View is SlideGLArea slideGlArea)
            {
                var renderedPreview = await CaptureRenderedPreviewAsync(slideGlArea).ConfigureAwait(false);
                if (renderedPreview.bitmap != null)
                    return renderedPreview;
            }
 
            if (image.OpenSlideBase?.SlideImage != null)
                return await Task.Run(() => FetchOpenSlidePreview(image, overviewSize)).ConfigureAwait(false);
 
            int level = FindOverviewLevel(image, overviewSize);
            if (level < 0)
                return (null, 0, 0);
 
            for (int lev = level; lev >= 0; lev--)
            {
                var res = image.Resolutions[lev];
                int srcW = res.SizeX, srcH = res.SizeY;
 
                try
                {
                    var tileBitmap = await image.GetTile(
                        image.GetFrameIndex(coordinate.Z, coordinate.C, coordinate.T),
                        lev,
                        0, 0,
                        srcW, srcH, coordinate);
                    if (tileBitmap != null && !LooksBlank(tileBitmap))
                        return (tileBitmap, srcW, srcH);
                    tileBitmap?.Dispose();
                }
                catch (Exception)
                {
                }
 
                if (image.SlideBase == null)
                    return (null, 0, 0);
 
                try
                {
                    var sliceInfo = new BioLib.SliceInfo(
                        0, 0,
                        srcW, srcH,
                        image.GetUnitPerPixel(lev),
                        coordinate);
 
                    byte[] bt = await image.SlideBase.GetSlice(
                        sliceInfo,
                        new PointD(0, 0),
                        new AForge.Size(srcW, srcH));
 
                    var bmp = CreatePreviewBitmap(srcW, srcH, bt);
                    if (!LooksBlank(bmp))
                        return (bmp, srcW, srcH);
                    bmp?.Dispose();
                }
                catch (Exception)
                {
                }
            }
 
            return (null, 0, 0);
        }
 
        private static async Task<(Bitmap bitmap, int w, int h)> CaptureRenderedPreviewAsync(SlideGLArea slideGlArea)
        {
            var completion = new TaskCompletionSource<(Bitmap bitmap, int w, int h)>(
                TaskCreationOptions.RunContinuationsAsynchronously);
            Action<byte[], int, int> captureCallback = null;
 
            captureCallback = (bytes, width, height) =>
            {
                try
                {
                    completion.TrySetResult((
                        CreatePreviewBitmap(width, height, bytes), width, height));
                }
                catch (Exception ex)
                {
                    completion.TrySetException(ex);
                }
            };
            Gtk.Application.Invoke((s, e) =>
            {
                slideGlArea.CaptureNextWholeImageFrame(captureCallback);
            });
 
            // A user can zoom before the initial fit frame completes. In that case
            // retain the source-reader fallback rather than waiting indefinitely.
            Task finished = await Task.WhenAny(completion.Task, Task.Delay(TimeSpan.FromSeconds(15)))
                .ConfigureAwait(false);
            if (finished == completion.Task)
                return await completion.Task.ConfigureAwait(false);
 
            Gtk.Application.Invoke((s, e) =>
                slideGlArea.CancelWholeImageFrameCapture(captureCallback));
            return (null, 0, 0);
        }
 
        private static (Bitmap bitmap, int w, int h) FetchOpenSlidePreview(BioImage image, int overviewSize)
        {
            var slide = image?.OpenSlideBase?.SlideImage;
            if (slide == null || slide.LevelCount <= 0)
                return (null, 0, 0);
 
            int targetSize = Math.Max(overviewSize * 2, 512);
            var levels = Enumerable.Range(0, slide.LevelCount)
                .Select(level =>
                {
                    var dimensions = slide.GetLevelDimension(level);
                    int width = (int)Math.Min(int.MaxValue, dimensions.Width);
                    int height = (int)Math.Min(int.MaxValue, dimensions.Height);
                    long score = Math.Abs((long)Math.Max(width, height) - targetSize);
                    return (Level: level, Width: width, Height: height, Score: score);
                })
                .Where(item => item.Width > 0 && item.Height > 0)
                .OrderBy(item => item.Score);
 
            foreach (var item in levels)
            {
                try
                {
                    byte[] bytes = slide.ReadRegion(item.Level, 0, 0, item.Width, item.Height);
                    Bitmap bitmap = CreatePreviewBitmap(item.Width, item.Height, bytes);
                    if (!LooksBlank(bitmap, rejectBlack: true))
                        return (bitmap, item.Width, item.Height);
                    bitmap?.Dispose();
                }
                catch (Exception)
                {
                }
            }
 
            return (null, 0, 0);
        }
 
        private static Bitmap CreatePreviewBitmap(int width, int height, byte[] bytes)
        {
            if (bytes == null)
                return null;
 
            // OpenSlide/Vips preview slices can arrive as packed RGB24. Convert that
            // layout into the BGRA-style buffer expected by the AForge bitmap path.
            if (bytes.Length == width * height * 3)
            {
                byte[] bgra = new byte[width * height * 4];
                for (int i = 0, j = 0; i < bytes.Length; i += 3, j += 4)
                {
                    bgra[j + 0] = bytes[i + 2];
                    bgra[j + 1] = bytes[i + 1];
                    bgra[j + 2] = bytes[i + 0];
                    bgra[j + 3] = 255;
                }
                return new Bitmap(width, height, AForge.PixelFormat.Format32bppArgb, bgra, new ZCT(), "");
            }
 
            return new Bitmap(width, height, AForge.PixelFormat.Format32bppArgb, bytes, new ZCT(), "");
        }
 
        private int FindOverviewLevel(BioImage image, int overviewSize)
        {
            // Exclude macro/label thumbnail levels so the overview shows tissue, not a slide label.
            int maxLevel = image.MacroResolution.HasValue
                ? image.MacroResolution.Value - 1
                : image.Resolutions.Count - 1;
            maxLevel = Math.Clamp(maxLevel, 0, image.Resolutions.Count - 1);
 
            // A small amount of oversampling is sufficient for a 160-pixel minimap.
            // Reading a ~4096-pixel level here duplicated most of the initial viewport
            // work and could transfer tens of megabytes for a tiny preview.
            int targetSize = Math.Max(overviewSize * 2, 512);
 
            int bestLevel = -1;
            int bestScore = int.MaxValue;
 
            for (int lev = maxLevel; lev >= 0; lev--)
            {
                var res = image.Resolutions[lev];
                int maxDim = Math.Max(res.SizeX, res.SizeY);
                if (maxDim < 16)
                    continue;
 
                int score = Math.Abs(maxDim - targetSize);
                if (score < bestScore)
                {
                    bestScore = score;
                    bestLevel = lev;
                }
            }
 
            return bestLevel;
        }
 
        private static (int w, int h) CalcOverviewSize(int srcW, int srcH, int maxSize)
        {
            double ar = (double)srcW / Math.Max(1, srcH);
            int w = ar >= 1.0 ? maxSize : (int)(maxSize * ar);
            int h = ar >= 1.0 ? (int)(maxSize / ar) : maxSize;
            return (Math.Max(w, 20), Math.Max(h, 20));
        }
 
        private static bool LooksBlank(Bitmap bmp, bool rejectBlack = false)
        {
            if (bmp == null || bmp.Width <= 0 || bmp.Height <= 0)
                return true;
 
            int stepX = Math.Max(1, bmp.Width / 16);
            int stepY = Math.Max(1, bmp.Height / 16);
            int samples = 0;
            int bright = 0;
            int dark = 0;
 
            for (int y = 0; y < bmp.Height; y += stepY)
            {
                for (int x = 0; x < bmp.Width; x += stepX)
                {
                    var p = bmp.GetPixel(x, y);
                    int lum = (p.R + p.G + p.B) / 3;
                    if (lum >= 245)
                        bright++;
                    if (rejectBlack && lum <= 5)
                        dark++;
                    samples++;
                }
            }
 
            return samples > 0 &&
                (bright * 100 / samples > 95 ||
                 rejectBlack && dark * 100 / samples > 98);
        }
 
        private SKImage ScaleToOverview(Bitmap src, int srcW, int srcH, int destW, int destH)
        {
            if (src == null)
                return null;
 
            Bitmap previewBitmap = NormalizeOverviewBitmap(src,
                SelectedImage?.ZarrDisplayMin ?? 0, SelectedImage?.ZarrDisplayMax ?? 0);
 
            try
            {
                // Match the main render path: normalize to RGBA first, then
                // hand Skia a 32-bit BGRA bitmap.
                using var rgbaBitmap = previewBitmap.GetImageRGBA(previewBitmap.LittleEndian);
                using (var fullSK = BioImage.BitmapToSKImage(rgbaBitmap))
                {
                    using var scaled = new SKBitmap(destW, destH, SKColorType.Bgra8888, SKAlphaType.Premul);
                    fullSK.ScalePixels(scaled.PeekPixels(), SKSamplingOptions.Default);
                    return SKImage.FromBitmap(scaled);
                }
            }
            finally
            {
                if (!ReferenceEquals(previewBitmap, src))
                    previewBitmap?.Dispose();
            }
        }
 
        private static Bitmap NormalizeOverviewBitmap(Bitmap src, ushort displayMin, int displayMax)
        {
            if (src == null)
                return null;
 
            // GetTile and the slice readers already return display-mapped RGB(A).
            // Applying a 16-bit display maximum again makes an 8-bit preview black.
            // Only raw high-bit-depth bitmaps (e.g. well fields) need conversion.
            if (src.PixelFormat != AForge.PixelFormat.Format16bppGrayScale &&
                src.PixelFormat != AForge.PixelFormat.Format48bppRgb)
                return src;
 
            if (displayMax <= displayMin || displayMax > ushort.MaxValue)
            {
                displayMin = 0;
                displayMax = ComputeOverviewDisplayMax(src);
            }
 
            if (displayMax == 0)
                displayMax = 1;
 
            if (src.PixelFormat == AForge.PixelFormat.Format16bppGrayScale)
                return NormalizeGray16ToArgb(src, displayMin, (ushort)displayMax);
 
            return NormalizeRgb48ToArgb(src, displayMin, (ushort)displayMax);
        }
 
        private static Bitmap NormalizeGray16ToArgb(Bitmap src, ushort displayMin, ushort displayMax)
        {
            byte[] bytes = src.Bytes;
            if (bytes == null || bytes.Length == 0)
                return src;
 
            int pixelCount = src.Width * src.Height;
            if (pixelCount <= 0)
                return src;
 
            byte[] bgra = new byte[pixelCount * 4];
            bool littleEndian = src.LittleEndian;
            float scale = 255f / Math.Max(1, displayMax - displayMin);
 
            for (int srcIndex = 0, dstIndex = 0; srcIndex + 1 < bytes.Length && dstIndex + 3 < bgra.Length; srcIndex += 2, dstIndex += 4)
            {
                ushort value = littleEndian
                    ? (ushort)(bytes[srcIndex] | (bytes[srcIndex + 1] << 8))
                    : (ushort)((bytes[srcIndex] << 8) | bytes[srcIndex + 1]);
                byte gray = (byte)Math.Clamp((value - displayMin) * scale, 0f, 255f);
                bgra[dstIndex + 0] = gray;
                bgra[dstIndex + 1] = gray;
                bgra[dstIndex + 2] = gray;
                bgra[dstIndex + 3] = 255;
            }
 
            return new Bitmap(src.Width, src.Height, AForge.PixelFormat.Format32bppArgb, bgra, new ZCT(), "");
        }
 
        private static Bitmap NormalizeRgb48ToArgb(Bitmap src, ushort displayMin, ushort displayMax)
        {
            byte[] bytes = src.Bytes;
            if (bytes == null || bytes.Length == 0)
                return src;
 
            int pixelCount = src.Width * src.Height;
            if (pixelCount <= 0)
                return src;
 
            byte[] bgra = new byte[pixelCount * 4];
            bool littleEndian = src.LittleEndian;
            float scale = 255f / Math.Max(1, displayMax - displayMin);
 
            for (int srcIndex = 0, dstIndex = 0; srcIndex + 5 < bytes.Length && dstIndex + 3 < bgra.Length; srcIndex += 6, dstIndex += 4)
            {
                ushort r = littleEndian
                    ? (ushort)(bytes[srcIndex + 0] | (bytes[srcIndex + 1] << 8))
                    : (ushort)((bytes[srcIndex + 0] << 8) | bytes[srcIndex + 1]);
                ushort g = littleEndian
                    ? (ushort)(bytes[srcIndex + 2] | (bytes[srcIndex + 3] << 8))
                    : (ushort)((bytes[srcIndex + 2] << 8) | bytes[srcIndex + 3]);
                ushort b = littleEndian
                    ? (ushort)(bytes[srcIndex + 4] | (bytes[srcIndex + 5] << 8))
                    : (ushort)((bytes[srcIndex + 4] << 8) | bytes[srcIndex + 5]);
 
                bgra[dstIndex + 0] = (byte)Math.Clamp((b - displayMin) * scale, 0f, 255f);
                bgra[dstIndex + 1] = (byte)Math.Clamp((g - displayMin) * scale, 0f, 255f);
                bgra[dstIndex + 2] = (byte)Math.Clamp((r - displayMin) * scale, 0f, 255f);
                bgra[dstIndex + 3] = 255;
            }
 
            return new Bitmap(src.Width, src.Height, AForge.PixelFormat.Format32bppArgb, bgra, new ZCT(), "");
        }
 
        private static ushort ComputeOverviewDisplayMax(Bitmap src)
        {
            if (src == null || src.Bytes == null || src.Bytes.Length == 0)
                return 1;
 
            byte[] bytes = src.Bytes;
            bool littleEndian = src.LittleEndian;
 
            if (src.PixelFormat == AForge.PixelFormat.Format16bppGrayScale ||
                src.PixelFormat == AForge.PixelFormat.Format48bppRgb)
            {
                ushort max = 0;
                for (int i = 0; i + 1 < bytes.Length; i += 2)
                {
                    ushort value = littleEndian
                        ? (ushort)(bytes[i] | (bytes[i + 1] << 8))
                        : (ushort)((bytes[i] << 8) | bytes[i + 1]);
                    if (value > max)
                        max = value;
                }
                return max == 0 ? (ushort)1 : max;
            }
 
            int stride = bytes.Length >= src.Width * src.Height * 4 ? 4 : 3;
            byte maxByte = 0;
            for (int i = 0; i + stride - 1 < bytes.Length; i += stride)
            {
                if (bytes[i + 0] > maxByte) maxByte = bytes[i + 0];
                if (bytes[i + 1] > maxByte) maxByte = bytes[i + 1];
                if (bytes[i + 2] > maxByte) maxByte = bytes[i + 2];
            }
 
            return maxByte == 0 ? (ushort)1 : maxByte;
        }
        #region Handlers
 
        protected void SetupHandlers()
        {
            View.Realized += View_Realized;
            this.Shown += ImageView_Shown;
            zBar.ValueChanged += ValueChangedZ;
            cBar.ValueChanged += ValueChangedC;
            tBar.ValueChanged += ValueChangedT;
            zBar.ScrollEvent += ZBar_ScrollEvent;
            cBar.ScrollEvent += CBar_ScrollEvent;
            tBar.ScrollEvent += TBar_ScrollEvent;
            zBar.AddEvents((int)EventMask.ScrollMask);
            cBar.AddEvents((int)EventMask.ScrollMask);
            tBar.AddEvents((int)EventMask.ScrollMask);
            this.ScrollEvent += ImageView_WindowScrollEvent;
            this.AddEvents((int)EventMask.ScrollMask);
            if (MacOS)
            {
                View.MotionNotifyEvent += ImageView_MotionNotifyEvent;
                View.ButtonPressEvent += ImageView_ButtonPressEvent;
                View.ButtonReleaseEvent += ImageView_ButtonReleaseEvent;
                View.ScrollEvent += ImageView_ScrollEvent;
                // OnMouseWheel is intentionally NOT registered here: ImageView_ScrollEvent already
                // handles zoom-to-cursor via SetResolution. Registering both causes double-zoom jumps.
                ((SKDrawingArea)View).PaintSurface += Sk_PaintSurface;
                View.SizeAllocated += PictureBox_SizeAllocated;
                View.SetSizeRequest(600, 400);
                View.AddEvents((int)(EventMask.ButtonPressMask
                | EventMask.ButtonReleaseMask
                | EventMask.KeyPressMask
                | EventMask.PointerMotionMask
                | EventMask.ScrollMask));
            }
            else
            {
                View.MotionNotifyEvent += ImageView_MotionNotifyEvent;
                View.ButtonPressEvent += ImageView_ButtonPressEvent;
                View.ButtonReleaseEvent += ImageView_ButtonReleaseEvent;
                View.ScrollEvent += ImageView_ScrollEvent;
                // OnMouseWheel removed: ImageView_ScrollEvent handles zoom-to-cursor via SetResolution.
                if (glArea != null)
                    glArea.Render += GlArea_Render;
                View.SizeAllocated += PictureBox_SizeAllocated;
                View.AddEvents((int)(EventMask.ButtonPressMask
                | EventMask.ButtonReleaseMask
                | EventMask.KeyPressMask
                | EventMask.PointerMotionMask
                | EventMask.ScrollMask));
            }
            vScroll.ValueChanged += VScroll_ValueChanged;
            hScroll.ValueChanged += HScroll_ValueChanged;   
            this.KeyPressEvent += ImageView_KeyPressEvent;
            this.DestroyEvent += ImageView_DestroyEvent;
            this.DeleteEvent += ImageView_DeleteEvent;
            this.FocusInEvent += ImageView_FocusInEvent;
            rBox.Changed += RBox_Changed;
            gBox.Changed += GBox_Changed;
            bBox.Changed += BBox_Changed;
            //Context Menu
            goToImageMenu.ButtonPressEvent += GoToImageMenu_ButtonPressEvent;
            goToOriginMenu.ButtonPressEvent += GoToOriginMenu_ButtonPressEvent;
            overView.ButtonPressEvent += OverView_ButtonPressEvent;
 
            roiShow.ButtonPressEvent += RoiShow_ButtonPressEvent;
            roiHide.ButtonPressEvent += RoiHide_ButtonPressEvent;
            roiDelete.ButtonPressEvent += RoiDelete_ButtonPressEvent;
            roiID.ButtonPressEvent += RoiID_ButtonPressEvent;
            copy.ButtonPressEvent += Copy_ButtonPressEvent;
            paste.ButtonPressEvent += Paste_ButtonPressEvent;
            draw.ButtonPressEvent += Draw_ButtonPressEvent;
            fill.ButtonPressEvent += Fill_ButtonPressEvent;
 
            play.ButtonPressEvent += Play_ButtonPressEvent;
            stop.ButtonPressEvent += Stop_ButtonPressEvent;
            playSpeed.ButtonPressEvent += PlaySpeed_ButtonPressEvent;
            setValueRange.ButtonPressEvent += SetValueRange_ButtonPressEvent;
            loop.ButtonPressEvent += Loop_ButtonPressEvent;
 
            zBar.ButtonPressEvent += ZBar_ButtonPressEvent;
            tBar.ButtonPressEvent += TBar_ButtonPressEvent;
            cBar.ButtonPressEvent += CBar_ButtonPressEvent;
 
        }
 
        private bool _initialPyramidalRenderQueued = false;
 
        private void EnsureInitialPyramidalRender()
        {
            if (_initialPyramidalRenderQueued || SelectedImage?.isPyramidal != true)
                return;
 
            _initialPyramidalRenderQueued = true;
            int attempts = 0;
            GLib.Timeout.Add(75, () =>
            {
                if (SelectedImage?.isPyramidal != true)
                    return false;
 
                bool hasRenderedImage = MacOS
                    ? (sKSlideRenderer?.HasValidImage ?? false)
                    : ((slideRenderer?.CachedTextureCount ?? 0) > 0);
                if (hasRenderedImage)
                    return false;
 
                if (View == null || !View.IsRealized || View.AllocatedWidth <= 1 || View.AllocatedHeight <= 1)
                    return true;
 
                App.viewer = this;
                GoToImage(SelectedIndex);
                RequestDeferredRender();
                if (!MacOS)
                    glArea?.RequestRedraw();
                else
                    View.QueueDraw();
 
                attempts++;
                return attempts < 20;
            });
        }
 
        private void View_Realized(object sender, EventArgs e)
        {
            EnsureInitialPyramidalRender();
        }
 
        private void ImageView_Shown(object sender, EventArgs e)
        {
            EnsureInitialPyramidalRender();
        }
 
        private void OverView_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if(ShowOverview)
            {
                ShowOverview = false;
                overView.Label = "Show Overview";
            }
            else
            {
                ShowOverview = true;
                overView.Label = "Hide Overview";
            }
            UpdateView();
        }
 
        private void RoiShow_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            ShowROIs = true;
            UpdateRoiMenuState();
            UpdateView();
        }
 
        private void RoiHide_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            ShowROIs = false;
            UpdateRoiMenuState();
            UpdateView();
        }
 
        private void HScroll_ValueChanged(object sender, EventArgs e)
        {
            if (_updatingScrollBars) return;
            if (MacOS) return;  // scrollbars hidden on macOS; ignore stale callbacks
            PyramidalOrigin = new PointD(hScroll.Value, PyramidalOrigin.Y);
        }
 
        private void VScroll_ValueChanged(object sender, EventArgs e)
        {
            if (_updatingScrollBars) return;
            if (MacOS) return;  // scrollbars hidden on macOS; ignore stale callbacks
            PyramidalOrigin = new PointD(PyramidalOrigin.X, vScroll.Value);
        }
 
        private void Sk_PaintSurface(object sender, SkiaSharp.Views.Desktop.SKPaintSurfaceEventArgs e)
        {
            if (MacOS)
            {
                var canvas = e.Surface.Canvas;
                var width = e.Info.Width;
                var height = e.Info.Height;
                if (SelectedImage?.isPyramidal == true && sKSlideRenderer != null)
                {
                    if (sKSlideRenderer.HasValidImage)
                        canvas.Clear(SKColors.Black);
                    sKSlideRenderer.DrawToCanvas(canvas, width, height);
                    RenderSkiaAnnotations(canvas, width, height, SelectedImage);
                }
                else
                {
                    canvas.Clear(SKColors.Black);
                    // Render non-pyramidal images and annotations
                    RenderSkia(canvas, width, height);
                }
            }
        }
 
        private void GlArea_Render(object o, RenderArgs args)
        {
            // The GL area redraws itself from tiles already uploaded to the GPU.
            // Tile fetching and uploading is handled by UpdateViewAsync via RequestDeferredRender.
        }
 
        private void ImageView_FocusInEvent(object o, FocusInEventArgs args)
        {
            //App.SelectWindow(this.Title);
        }
 
        private void ImageView_DestroyEvent(object o, DestroyEventArgs args)
        {
            _destroyRequested = true;
            // Guard: DeleteEvent already performed full cleanup. Only run if
            // this viewer is still registered (e.g. programmatic Destroy()
            // without going through the close button).
            if (App.tabsView == null) return;
            // Check if we're still in the viewers list; if not, cleanup already happened.
            bool stillRegistered = false;
            for (int v = 0; v < App.tabsView.GetViewerCount(); v++)
            {
                if (App.tabsView.GetViewer(v) == this)
                {
                    stillRegistered = true;
                    break;
                }
            }
            if (!stillRegistered) return;
 
            App.tabsView.RemoveViewer(this);
            CleanupViewerResources();
            foreach (var item in this.Images)
            {
                BioLib.Images.RemoveImage(item);
            }
        }
 
        int bar = 0;
        System.Threading.Thread threadZ = null;
        System.Threading.Thread threadC = null;
        System.Threading.Thread threadT = null;
        static bool playZ = false;
        static bool playC = false;
        static bool playT = false;
        static bool loopZ = true;
        static bool loopC = true;
        static bool loopT = true;
        public static int waitz = 1000;
        public static int waitc = 1000;
        public static int waitt = 1000;
        public static int startz = 0;
        public static int startc = 0;
        public static int startt = 0;
        public static int endz = 0;
        public static int endc = 0;
        public static int endt = 0;
        private static void PlayZ()
        {
            do
            {
                ZCT coord = App.viewer.GetCoordinate();
                //Update view on main UI thread
                Application.Invoke(delegate
                {
                    App.viewer.SetCoordinate(coord.Z + 1, coord.C, coord.T);
                });
                if (coord.Z == endz)
                {
                    if (loopZ)
                    {
                        //Update view on main UI thread
                        Application.Invoke(delegate
                        {
                            App.viewer.SetCoordinate(startz, coord.C, coord.T);
                        });
                    }
                    else
                        return;
                }
                System.Threading.Thread.Sleep(waitz);
            } while (playZ);
        }
        private static void PlayC()
        {
            do
            {
                ZCT coord = App.viewer.GetCoordinate();
                Application.Invoke(delegate
                {
                    App.viewer.SetCoordinate(coord.Z, coord.C + 1, coord.T);
                });
                if (coord.C == endc)
                {
                    if (loopC)
                    {
                        //Update view on main UI thread
                        Application.Invoke(delegate
                        {
                            App.viewer.SetCoordinate(coord.Z, startc, coord.T);
                        });
                    }
                    else
                        return;
                }
                System.Threading.Thread.Sleep(waitc);
            } while (playC);
        }
        private static void PlayT()
        {
            do
            {
                ZCT coord = App.viewer.GetCoordinate();
                Application.Invoke(delegate
                {
                    App.viewer.SetCoordinate(coord.Z, coord.C, coord.T + 1);
                });
                if (coord.T == endt)
                {
                    if (loopT)
                    {
                        //Update view on main UI thread
                        Application.Invoke(delegate
                        {
                            App.viewer.SetCoordinate(coord.Z, coord.C, startt);
                        });
                    }
                    else
                        return;
                }
                System.Threading.Thread.Sleep(waitt);
            } while (playT);
        }
        private void CBar_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            bar = 2;
            if (args.Event.Button == 3)
                barMenu.Popup();
        }
 
        private void TBar_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            bar = 1;
            if (args.Event.Button == 3)
                barMenu.Popup();
        }
 
        private void ZBar_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            bar = 0;
            if (args.Event.Button == 3)
                barMenu.Popup();
        }
 
        private void Loop_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (bar == 0)
            {
                if (loopZ)
                    loopZ = false;
                else
                    loopZ = true;
            }
            else if (bar == 1)
            {
                if (loopC)
                    loopC = false;
                else
                    loopC = true;
            }
            else if (bar == 2)
            {
                if (loopT)
                    loopT = false;
                else
                    loopT = true;
            }
        }
 
        private void SetValueRange_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Play play = Play.Create();
            play.Show();
        }
 
        private void PlaySpeed_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Play play = Play.Create();
            play.Show();
        }
 
        private void Stop_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (bar == 0)
            {
                if (playZ)
                    playZ = false;
                else
                    playZ = true;
            }
            else if (bar == 1)
            {
                if (playT)
                    playT = false;
                else
                    playT = true;
            }
            else if (bar == 2)
            {
                if (playC)
                    playC = false;
                else
                    playC = true;
            }
        }
 
        private void Play_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (bar == 0)
            {
                if (endz == 0)
                    endz = SelectedImage.SizeZ - 1;
                playZ = true;
                threadZ = new System.Threading.Thread(PlayZ);
                threadZ.Start();
            }
            else if (bar == 1)
            {
                if (endt == 0)
                    endt = SelectedImage.SizeT - 1;
                playT = true;
                threadT = new System.Threading.Thread(PlayT);
                threadT.Start();
            }
            else if (bar == 2)
            {
                if (endc == 0)
                    endc = SelectedImage.SizeC - 1;
                playC = true;
                threadC = new System.Threading.Thread(PlayC);
                threadC.Start();
            }
        }
 
        private void Fill_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Bio.Graphics.Graphics g = Bio.Graphics.Graphics.FromImage(SelectedBuffer);
            List<ROI> rois = new List<ROI>();
            rois.AddRange(SelectedImage.AnnotationsR);
            rois.AddRange(SelectedImage.AnnotationsG);
            rois.AddRange(SelectedImage.AnnotationsB);
            foreach (ROI item in rois)
            {
                Bio.Graphics.Pen p = new Bio.Graphics.Pen(Tools.DrawColor, (int)Tools.StrokeWidth, SelectedBuffer.BitsPerPixel);
                if (item.Selected)
                {
                    if (item.type == ROI.Type.Line)
                    {
                        PointD pf = SelectedImage.ToImageSpace(item.GetPoint(0));
                        PointD pf2 = SelectedImage.ToImageSpace(item.GetPoint(1));
                        g.DrawLine((int)pf.X, (int)pf.Y, (int)pf2.X, (int)pf2.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);
                    }
                }
            }
            UpdateImage();
            UpdateView();
        }
 
        private void Draw_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Bio.Graphics.Graphics g = Bio.Graphics.Graphics.FromImage(SelectedBuffer);
            List<ROI> rois = new List<ROI>();
            rois.AddRange(SelectedImage.AnnotationsR);
            rois.AddRange(SelectedImage.AnnotationsG);
            rois.AddRange(SelectedImage.AnnotationsB);
            foreach (ROI item in rois)
            {
                Bio.Graphics.Pen p = new Bio.Graphics.Pen(Tools.DrawColor, (int)Tools.StrokeWidth, SelectedBuffer.BitsPerPixel);
                g.pen = p;
                if (item.Selected)
                {
                    if (item.type == ROI.Type.Line)
                    {
                        PointD pf = SelectedImage.ToImageSpace(item.GetPoint(0));
                        PointD pf2 = SelectedImage.ToImageSpace(item.GetPoint(1));
                        g.DrawLine((int)pf.X, (int)pf.Y, (int)pf2.X, (int)pf2.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++)
                            {
                                PointD pf = SelectedImage.ToImageSpace(item.GetPoint(i));
                                PointD pf2 = SelectedImage.ToImageSpace(item.GetPoint(i + 1));
                                g.DrawLine((int)pf.X, (int)pf.Y, (int)pf2.X, (int)pf2.Y);
                            }
                            PointD pp = SelectedImage.ToImageSpace(item.GetPoint(0));
                            PointD p2 = SelectedImage.ToImageSpace(item.GetPoint(item.GetPointCount() - 1));
                            g.DrawLine((int)pp.X, (int)pp.Y, (int)p2.X, (int)p2.Y);
                        }
                        else
                        {
                            for (int i = 0; i < item.GetPointCount() - 1; i++)
                            {
                                PointD pf = SelectedImage.ToImageSpace(item.GetPoint(i));
                                PointD pf2 = SelectedImage.ToImageSpace(item.GetPoint(i + 1));
                                g.DrawLine((int)pf.X, (int)pf.Y, (int)pf2.X, (int)pf2.Y);
                            }
                        }
                    }
                }
            }
            UpdateImage();
            UpdateView();
        }
 
        private void Paste_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            PasteSelection();
        }
 
        private void Copy_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            CopySelection();
        }
 
        private void ImageView_DeleteEvent(object o, DeleteEventArgs args)
        {
            if (_destroyRequested)
            {
                args.RetVal = true;
                return;
            }
 
            _destroyRequested = true;
            // Prevent GTK's default delete handling — we manage teardown ourselves.
            // Without this, GTK proceeds to destroy and then the TabsView
            // WindowStateEvent sees a non-visible viewer and calls Present(),
            // which recreates the native window as an empty shell.
            args.RetVal = true;
 
            // Remove this viewer from the TabsView list BEFORE disposing images,
            // so no event handler can re-present it while we're tearing down.
            App.tabsView.RemoveViewer(this);
            CleanupViewerResources();
 
            for (int i = 0; i < this.Images.Count; i++)
            {
                var item = this.Images[i];
                BioLib.Images.RemoveImage(item);
                App.tabsView.RemoveTab(item.Filename);
                item.Dispose();
            }
            Hide();
        }
 
        private void RoiID_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            TextInput ti = TextInput.Create();
            ti.Show();
            UpdateView();
        }
 
        private void RoiDelete_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            DeleteSelectedRois();
            UpdateView();
        }
 
        private void DeleteSelectedRois()
        {
            if (SelectedImage == null)
                return;
 
            var toDelete = new HashSet<ROI>(selectedAnnotations);
            if (toDelete.Count == 0 && Tools.selectedROI != null)
                toDelete.Add(Tools.selectedROI);
 
            if (toDelete.Count == 0)
                return;
 
            foreach (var roi in toDelete)
            {
                if (roi == null)
                    continue;
 
                if (SelectedImage.Annotations.Contains(roi))
                    SelectedImage.Annotations.Remove(roi);
            }
 
            string key = GetOverlayKey(SelectedImage);
            var overlays = GetZarrLabelOverlays(SelectedImage);
            if (overlays != null && overlays.Count > 0)
            {
                overlays.RemoveAll(r => r != null && toDelete.Contains(r));
                SetZarrLabelOverlays(SelectedImage, overlays, key);
            }
 
            if (Tools.selectedROI != null && toDelete.Contains(Tools.selectedROI))
                Tools.selectedROI = null;
 
            foreach (var roi in toDelete)
            {
                if (roi != null)
                    roi.Selected = false;
            }
        }
 
        private void GoToOriginMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (SelectedImage?.isPyramidal == true)
                PyramidalOrigin = new PointD(0, 0);
            else
                Origin = new PointD(-SelectedImage.Volume.Location.X, -SelectedImage.Volume.Location.Y);
 
            ForceNavigationRefresh();
        }
 
        private void GoToImageMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (Images.Count == 0)
                return;
 
            var picker = NumberPicker.Create(0, Images.Count - 1, SelectedIndex);
            picker.Title = "Go To Image";
            if (picker.Run() != (int)ResponseType.Ok)
                return;
 
            GoToImage((int)picker.SelectedValue);
        }
 
        #endregion
 
        private void BBox_Changed(object sender, EventArgs e)
        {
            if (_updatingGui || SelectedImage == null)
                return;
            SelectedImage.rgbChannels[2] = bBox.Active;
            RefreshDisplayState(invalidatePyramidalTiles: true);
        }
 
        private void GBox_Changed(object sender, EventArgs e)
        {
            if (_updatingGui || SelectedImage == null)
                return;
            SelectedImage.rgbChannels[1] = gBox.Active;
            RefreshDisplayState(invalidatePyramidalTiles: true);
        }
 
        private void RBox_Changed(object sender, EventArgs e)
        {
            if (_updatingGui || SelectedImage == null)
                return;
            SelectedImage.rgbChannels[0] = rBox.Active;
            RefreshDisplayState(invalidatePyramidalTiles: true);
        }
 
        private void RefreshDisplayState(bool invalidatePyramidalTiles = false)
        {
            if (SelectedImage == null)
                return;
 
            if (invalidatePyramidalTiles && SelectedImage.isPyramidal)
            {
                RefreshPyramidalTiles();
                UpdateView();
                return;
            }
 
            UpdateView();
        }
 
        bool initialized = false;
        private int _lastAllocatedWidth = 0;
        private int _lastAllocatedHeight = 0;
 
        private void PictureBox_SizeAllocated(object o, SizeAllocatedArgs args)
        {
            if (SelectedImage == null) return;
 
            int newW = MacOS ? View.AllocatedWidth  : (SelectedImage.isPyramidal ? View.AllocatedWidth  : View.AllocatedWidth);
            int newH = MacOS ? View.AllocatedHeight : (SelectedImage.isPyramidal ? View.AllocatedHeight : View.AllocatedHeight);
 
            // Ignore trivial/degenerate sizes that GTK emits before the window is realized.
            if (newW <= 1 || newH <= 1) return;
 
            bool sizeChanged = (newW != _lastAllocatedWidth || newH != _lastAllocatedHeight);
            _lastAllocatedWidth  = newW;
            _lastAllocatedHeight = newH;
 
            if (SelectedImage.isPyramidal)
            {
                SelectedImage.PyramidalSize = new AForge.Size(newW, newH);
                UpdateScrollBars();
 
                // The first reliable moment we know the actual drawable size is
                // the first real SizeAllocated callback. Kick the initial fit +
                // render from here so startup does not depend on earlier window
                // lifecycle ordering.
                if (!initrend)
                {
                    initrend = true;
                    GLib.Idle.Add(() =>
                    {
                        if (SelectedImage?.isPyramidal != true || View == null ||
                            View.AllocatedWidth <= 1 || View.AllocatedHeight <= 1)
                            return false;
 
                        GoToImage(SelectedIndex);
                        RequestDeferredRender();
                        return false;
                    });
                }
            }
            else
                UpdateImage();
 
            if (!initialized)
            {
                // On macOS, GoToImage already ran in AddImage before SetupHandlers registered
                // this handler. On other platforms it may not have, so we call it once here
                // when we first get a real size.
                if (!MacOS)
                    GoToImage();
                initialized = true;
            }
 
            // Only re-render if the viewport size actually changed (not just GTK noise).
            if (sizeChanged)
                UpdateView();
        }
 
        private static void DrawEllipse(Cairo.Context g, double x, double y, double width, double height)
        {
            g.Save();
            g.MoveTo(x + (width / 2), y);
            g.Translate(x, y);
            g.Scale(width / 2.0, height / 2.0);
            g.Arc(0.0, 0.0, 1.0, 0.0, 2 * Math.PI);
            g.Restore();
            g.Stroke();
            g.Stroke();
        }
        public static Cairo.Color FromColor(Color color)
        {
            return new Cairo.Color((double)color.R / 255, (double)color.G / 255, (double)color.B / 255);
        }
 
        private void TBar_ScrollEvent(object o, ScrollEventArgs args)
        {
            if (AdjustSliderFromScroll(tBar, args))
                args.RetVal = true;
        }
        private void CBar_ScrollEvent(object o, ScrollEventArgs args)
        {
            if (AdjustSliderFromScroll(cBar, args))
                args.RetVal = true;
        }
        private void ZBar_ScrollEvent(object o, ScrollEventArgs args)
        {
            if (AdjustSliderFromScroll(zBar, args))
                args.RetVal = true;
        }
 
        private void ImageView_WindowScrollEvent(object o, ScrollEventArgs args)
        {
            if (args.RetVal is bool handled && handled)
                return;
 
            if (TryAdjustSliderFromPointer(zBar, args) ||
                TryAdjustSliderFromPointer(cBar, args) ||
                TryAdjustSliderFromPointer(tBar, args))
            {
                args.RetVal = true;
            }
        }
 
        private bool TryAdjustSliderFromPointer(Gtk.Scale scale, ScrollEventArgs args)
        {
            if (scale == null || !scale.Visible || !scale.IsSensitive || !scale.IsRealized)
                return false;
 
            Gdk.Window hostWindow = scale.Window;
            if (hostWindow == null)
                return false;
 
            var allocation = scale.Allocation;
            hostWindow.GetOrigin(out int hostX, out int hostY);
            int widgetX = hostX + allocation.X;
            int widgetY = hostY + allocation.Y;
 
            double pointerX = args.Event.XRoot;
            double pointerY = args.Event.YRoot;
 
            bool inside =
                pointerX >= widgetX &&
                pointerX <= widgetX + allocation.Width &&
                pointerY >= widgetY &&
                pointerY <= widgetY + allocation.Height;
 
            return inside && AdjustSliderFromScroll(scale, args);
        }
 
        private bool AdjustSliderFromScroll(Gtk.Scale scale, ScrollEventArgs args)
        {
            if (scale?.Adjustment == null)
                return false;
 
            double delta = GetSliderScrollDelta(args);
            if (delta == 0)
                return false;
 
            double lower = scale.Adjustment.Lower;
            double upper = scale.Adjustment.Upper;
            double newValue = Math.Clamp(scale.Value + delta, lower, upper);
            if (Math.Abs(newValue - scale.Value) < double.Epsilon)
                return false;
 
            scale.Value = newValue;
            return true;
        }
 
        private static double GetSliderScrollDelta(ScrollEventArgs args)
        {
            if (args.Event.Direction == ScrollDirection.Up)
                return 1;
            if (args.Event.Direction == ScrollDirection.Down)
                return -1;
            if (args.Event.Direction == ScrollDirection.Smooth)
            {
                if (args.Event.DeltaY < 0)
                    return 1;
                if (args.Event.DeltaY > 0)
                    return -1;
            }
            return 0;
        }
 
        private void RefreshAfterCoordinateSliderChange()
        {
            if (SelectedImage?.isPyramidal == true)
                ForceNavigationRefresh();
            else
            {
                UpdateImages(true);
                RequestViewportRefresh();
            }
        }
 
        public static Gdk.Key keyDown = Gdk.Key.Key_3270_Test;
        private void ImageView_KeyPressEvent(object o, KeyPressEventArgs e)
        {
            Plugins.KeyDownEvent(o, e);
            keyDown = e.Event.Key;
            double moveAmount = 5 * Scale.Width;
            double movepyr = 50 * (Level + 1);
            if (e.Event.Key == Gdk.Key.c && e.Event.State == ModifierType.ControlMask)
            {
                CopySelection();
            }
            if (e.Event.Key == Gdk.Key.v && e.Event.State == ModifierType.ControlMask)
            {
                PasteSelection();
            }
            if (e.Event.Key == Gdk.Key.e)
            {
                if (SelectedImage.isPyramidal)
                {
                    SetResolution(Resolution * 1.25, new PointD(View.AllocatedWidth / 2.0, View.AllocatedHeight / 2.0));
                }
                else
                    ZoomStackAtPoint(new PointD(View.AllocatedWidth / 2.0, View.AllocatedHeight / 2.0), 0.9);
            }
            if (e.Event.Key == Gdk.Key.q)
            {
                if (SelectedImage.isPyramidal)
                {
                    SetResolution(Resolution * 0.8, new PointD(View.AllocatedWidth / 2.0, View.AllocatedHeight / 2.0));
                }
                else
                    ZoomStackAtPoint(new PointD(View.AllocatedWidth / 2.0, View.AllocatedHeight / 2.0), 1.1);
            }
            if (e.Event.Key == Gdk.Key.s || e.Event.Key == Gdk.Key.S)
            {
                if (SelectedImage.isPyramidal)
                {
                    PyramidalOrigin = new PointD(PyramidalOrigin.X, PyramidalOrigin.Y + movepyr);
                }
                else
                    Origin = new PointD(Origin.X, Origin.Y + moveAmount);
            }
            if (e.Event.Key == Gdk.Key.w || e.Event.Key == Gdk.Key.W)
            {
                if (SelectedImage.isPyramidal)
                {
                    PyramidalOrigin = new PointD(PyramidalOrigin.X, PyramidalOrigin.Y - movepyr);
                }
                else
                    Origin = new PointD(Origin.X, Origin.Y - moveAmount);
            }
            if (e.Event.Key == Gdk.Key.a || e.Event.Key == Gdk.Key.A)
            {
                if (SelectedImage.isPyramidal)
                {
                    PyramidalOrigin = new PointD(PyramidalOrigin.X - movepyr, PyramidalOrigin.Y);
                }
                else
                    Origin = new PointD(Origin.X + moveAmount, Origin.Y);
            }
            if (e.Event.Key == Gdk.Key.d || e.Event.Key == Gdk.Key.D)
            {
                if (SelectedImage.isPyramidal)
                {
                    PyramidalOrigin = new PointD(PyramidalOrigin.X + movepyr, PyramidalOrigin.Y);
                }
                else
                    Origin = new PointD(Origin.X - moveAmount, Origin.Y);
            }
            foreach (Function item in Function.Functions.Values)
            {
                if (item.Key == e.Event.Key && item.Modifier == e.Event.State)
                {
                    if (item.FuncType == Function.FunctionType.ImageJ)
                        item.PerformFunction(true);
                    else
                        item.PerformFunction(false);
                }
            }
            Scripting.State st = new Scripting.State();
            st.key = e.Event.Key;
            st.p = mouseDown;
            st.type = Scripting.Event.Down;
            Scripting.UpdateState(st);
            UpdateView(true);
        }
        private void ImageView_KeyUpEvent(object o, KeyReleaseEventArgs e)
        {
            Plugins.KeyUpEvent(o, e);
            keyDown = Gdk.Key.Key_3270_Test;
            Scripting.State st = new Scripting.State();
            st.key = e.Event.Key;
            st.p = mouseUp;
            st.type = Scripting.Event.Up;
            Scripting.UpdateState(st);
        }
        private void ImageView_ScrollEvent(object o, ScrollEventArgs e)
        {
            Plugins.ScrollEvent(o, e);
            if (SelectedImage.isPyramidal)
            {
                // Anchor zoom to the mouse cursor for natural zoom-to-point behaviour.
                PointD anchor = MouseMove;
                if (e.Event.Direction == ScrollDirection.Smooth)
                {
                    // Smooth / trackpad scroll — use the continuous delta for fluid zoom.
                    double delta = e.Event.DeltaY;
                    if (delta == 0) return;
                    double factor = Math.Pow(2.0, delta * 0.1);
                    SetResolution(Resolution * factor, anchor);
                }
                else if (e.Event.Direction == ScrollDirection.Up)
                    SetResolution(Resolution * 0.8, anchor);   // zoom in
                else if (e.Event.Direction == ScrollDirection.Down)
                    SetResolution(Resolution * 1.25, anchor);  // zoom out
            }
            else
            {
                PointD anchor = MouseMove;
                if (e.Event.Direction == ScrollDirection.Smooth)
                {
                    double delta = e.Event.DeltaY;
                    if (delta == 0) return;
                    double factor = Math.Pow(2.0, delta * 0.1);
                    ZoomStackAtPoint(anchor, factor);
                }
                else if (e.Event.Direction == ScrollDirection.Up)
                    ZoomStackAtPoint(anchor, 1.1);
                else if (e.Event.Direction == ScrollDirection.Down)
                    ZoomStackAtPoint(anchor, 0.9);
            }
        }
 
        private void ValueChangedZ(object? sender, EventArgs e)
        {
            if (_updatingCoordinate)
                return;
            SetCoordinate((int)zBar.Value, (int)cBar.Value, (int)tBar.Value);
        }
        private void ValueChangedC(object? sender, EventArgs e)
        {
            if (_updatingCoordinate)
                return;
            SetCoordinate((int)zBar.Value, (int)cBar.Value, (int)tBar.Value);
        }
        private void ValueChangedT(object? sender, EventArgs e)
        {
            if (_updatingCoordinate)
                return;
            SetCoordinate((int)zBar.Value, (int)cBar.Value, (int)tBar.Value);
        }
        private void UpdateScrollBars()
        {
            if (SelectedImage.isPyramidal)
            {
                // On macOS, panning is handled entirely by the pan tool (mouse drag).
                // The scrollbars use current-level pixel units but PyramidalOrigin is stored in
                // full-resolution pixel units — the mismatch causes GTK to clamp values and fire
                // spurious ValueChanged callbacks that jump the view. Hide them on macOS.
                if (MacOS)
                {
                    hScroll.Hide();
                    vScroll.Hide();
                    return;
                }
                hScroll.ShowAll();
                vScroll.ShowAll();
 
                // Keep the scrollbar adjustment coherent with the viewport size.
                // PyramidalOrigin is stored in full-resolution pixel space, so the
                // adjustment range and page size must also be in full-resolution pixels.
                double viewportW = Math.Max(1, View?.AllocatedWidth ?? 1) * Resolution;
                double viewportH = Math.Max(1, View?.AllocatedHeight ?? 1) * Resolution;
 
                var hAdj = hScroll.Adjustment;
                var vAdj = vScroll.Adjustment;
 
                TryGetPyramidalViewerBounds(SelectedImage, out double imageMinX, out double imageMinY, out double imageMaxX, out double imageMaxY);
 
                hAdj.Lower = imageMinX;
                hAdj.Upper = imageMaxX;
                hAdj.PageSize = Math.Min(viewportW, Math.Max(1, hAdj.Upper - hAdj.Lower));
 
                vAdj.Lower = imageMinY;
                vAdj.Upper = imageMaxY;
                vAdj.PageSize = Math.Min(viewportH, Math.Max(1, vAdj.Upper - vAdj.Lower));
 
                hAdj.StepIncrement = Math.Max(1, hAdj.PageSize / 20.0);
                hAdj.PageIncrement = Math.Max(1, hAdj.PageSize / 2.0);
                vAdj.StepIncrement = Math.Max(1, vAdj.PageSize / 20.0);
                vAdj.PageIncrement = Math.Max(1, vAdj.PageSize / 2.0);
            }
            else
            {
                vScroll.Hide();
                hScroll.Hide();
            }
        }
        public void UpdateGUI()
        {
            if (SelectedImage == null)
                return;
            if (_updatingGui)
                return;
 
            _updatingGui = true;
            try
            {
                EnsureImageChannels(SelectedImage);
                cBar.Adjustment.Lower = 0;
                cBar.Adjustment.Upper = Images[selectedIndex].SizeC - 1;
                zBar.Adjustment.Lower = 0;
                zBar.Adjustment.Upper = Images[selectedIndex].SizeZ - 1;
                tBar.Adjustment.Lower = 0;
                tBar.Adjustment.Upper = Images[selectedIndex].SizeT - 1;
                if (endz == 0 || endz > Images[selectedIndex].SizeZ - 1)
                    endz = Images[selectedIndex].SizeZ - 1;
                if (endc == 0 || endc > Images[selectedIndex].SizeC - 1)
                    endc = Images[selectedIndex].SizeC - 1;
                if (endt == 0 || endt > Images[selectedIndex].SizeT - 1)
                    endt = Images[selectedIndex].SizeT - 1;
                UpdateScrollBars();
                var store = new ListStore(typeof(string));
                for (int i = 0; i < SelectedImage.Channels.Count; i++)
                {
                    store.AppendValues(GetChannelDisplayLabel(SelectedImage.Channels[i], i));
                }
                rBox.Model = store;
                gBox.Model = store;
                bBox.Model = store;
                if (SelectedImage.Channels.Count > 0)
                {
                    int lastChannel = SelectedImage.Channels.Count - 1;
                    rBox.Active = Math.Clamp(SelectedImage.rgbChannels[0], 0, lastChannel);
                    gBox.Active = Math.Clamp(SelectedImage.rgbChannels[1], 0, lastChannel);
                    bBox.Active = Math.Clamp(SelectedImage.rgbChannels[2], 0, lastChannel);
                }
                imagesMenu = new Menu();
                for (int i = 0; i < Images.Count; i++)
                {
                    if (Images[i] == null)
                    {
                        if (SelectedIndex >= Images.Count)
                            SelectedIndex--;
                        Images.RemoveAt(i);
                    }
                    MenuItem mi = new MenuItem(Images[i].Filename);
                    mi.ButtonPressEvent += Mi_ButtonPressEvent;
                    imagesMenu.Append(mi);
                }
                goToImageMenu.Submenu = imagesMenu;
                goToImageMenu.ShowAll();
            }
            finally
            {
                _updatingGui = false;
            }
        }
 
        private static string GetChannelDisplayLabel(Channel channel, int index)
        {
            string name = channel?.Name;
            if (string.IsNullOrWhiteSpace(name) ||
                (int.TryParse(name, out int numericName) && numericName == index))
                name = $"Channel {index + 1}";
            return $"{name} ({index + 1})";
        }
 
        private void EnsureImageChannels(BioImage image)
        {
            if (image?.Channels == null || image.Channels.Count == 0)
                return;
 
            int expectedChannels = Math.Max(1, Math.Max(image.SizeC, image.RGBChannelCount));
            if (image.Resolutions != null && image.Resolutions.Count > 0)
            {
                var pixelFormat = image.Resolutions[0].PixelFormat;
                if (pixelFormat == AForge.PixelFormat.Format24bppRgb ||
                    pixelFormat == AForge.PixelFormat.Format48bppRgb)
                {
                    expectedChannels = Math.Max(expectedChannels, 3);
                }
            }
 
            if (expectedChannels > image.Channels.Count)
            {
                Channel template = image.Channels[0];
                while (image.Channels.Count < expectedChannels)
                {
                    Channel clone = new Channel(0, image.bitsPerPixel, 1)
                    {
                        Name = $"Channel {image.Channels.Count + 1}",
                        Fluor = template.Fluor,
                        Color = template.Color
                    };
                    image.Channels.Add(clone);
                }
            }
 
            for (int i = 0; i < image.Channels.Count; i++)
            {
                if (string.IsNullOrWhiteSpace(image.Channels[i].Name))
                    image.Channels[i].Name = $"Channel {i + 1}";
            }
 
            if (_initializedRgbChannelDefaults.Add(image) &&
                image.rgbChannels[0] == 0 &&
                image.rgbChannels[1] == 0 &&
                image.rgbChannels[2] == 0)
            {
                image.rgbChannels[0] = 0;
                image.rgbChannels[1] = Math.Min(1, image.Channels.Count - 1);
                image.rgbChannels[2] = Math.Min(2, image.Channels.Count - 1);
            }
 
            image.rgbChannels[0] = Math.Clamp(image.rgbChannels[0], 0, image.Channels.Count - 1);
            image.rgbChannels[1] = Math.Clamp(image.rgbChannels[1], 0, image.Channels.Count - 1);
            image.rgbChannels[2] = Math.Clamp(image.rgbChannels[2], 0, image.Channels.Count - 1);
        }
 
        private void Mi_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            MenuItem menuItem = (MenuItem)o;
            int i = 0;
            foreach (BioImage b in Images)
            {
                if (b.Filename == menuItem.Label)
                {
                    GoToImage(i);
                    return;
                }
                i++;
            }
        }
 
        public void CopySelection()
        {
            copys.Clear();
            string s = "";
            List<ROI> rois = new List<ROI>();
            rois.AddRange(SelectedImage.AnnotationsR);
            rois.AddRange(SelectedImage.AnnotationsG);
            rois.AddRange(SelectedImage.AnnotationsB);
            foreach (ROI item in rois)
            {
                if (item.Selected)
                {
                    copys.Add(item);
                    s += BioImage.ROIToString(item);
                }
            }
            Clipboard clipboard = Clipboard.Get(Gdk.Selection.Clipboard);
            clipboard.Text = s;
        }
        public void PasteSelection()
        {
            Clipboard clipboard = Clipboard.Get(Gdk.Selection.Clipboard);
            string text = clipboard.WaitForText();
            string[] sts = text.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);
                }
            }
            UpdateView();
        }
 
        /* Defining an enum. */
        public enum ViewMode
        {
            Raw,
            Filtered,
            RGBImage,
            Emission,
        }
        bool openSlide = false;
        public bool OpenSlide
        {
            get { return openSlide; }
            set { openSlide = value; }
        }
        public static BioImage SelectedImage
        {
            get
            {
                if (App.viewer == null)
                    return null;
                if (App.viewer.Images.Count == 0)
                    return null;
                return App.viewer.Images[App.viewer.SelectedIndex];
            }
            set
            {
                if (value == null)
                    return;
                if (App.viewer == null)
                    App.viewer = ImageView.Create(value);
                App.viewer.Images[App.viewer.SelectedIndex] = value;
            }
        }
        private ViewMode viewMode = ViewMode.Filtered;
        /* Setting the view mode of the application. */
        public ViewMode Mode
        {
            get
            {
                return viewMode;
            }
            set
            {
                viewMode = value;
                if (viewMode == ViewMode.RGBImage)
                {
                    rgbStack.VisibleChild = rgbStack.Children[1];
                }
                else
                if (viewMode == ViewMode.Filtered)
                {
                    rgbStack.VisibleChild = rgbStack.Children[0];
                }
                else
                if (viewMode == ViewMode.Raw)
                {
                    rgbStack.VisibleChild = rgbStack.Children[0];
                }
                else
                {
                    rgbStack.VisibleChild = rgbStack.Children[0];
                }
                RefreshDisplayState(invalidatePyramidalTiles: true);
            }
        }
        /* A property that returns the R channel of the selected image. */
        public Channel RChannel
        {
            get
            {
                return SelectedImage.Channels[SelectedImage.rgbChannels[0]];
            }
        }
        /* A property that returns the G channel of the selected image. */
        public Channel GChannel
        {
            get
            {
                return SelectedImage.Channels[SelectedImage.rgbChannels[1]];
            }
        }
        /* A property that returns the B channel of the selected image. */
        public Channel BChannel
        {
            get
            {
                return SelectedImage.Channels[SelectedImage.rgbChannels[2]];
            }
        }
        PointD origin = new PointD(0, 0);
        /* Origin of the viewer in microns */
        public PointD Origin
        {
            get { return origin; }
            set
            {
                if (AllowNavigation)
                    origin = value;
                if (View != null)
                {
                    UpdateImages();
                    if (!MacOS)
                        glArea?.RequestRedraw();
                    else
                        View.QueueDraw();
                }
            }
        }
        /* Origin of the viewer in microns */
        public PointD TopRightOrigin
        {
            get
            {
                return new PointD((Origin.X - ((View.AllocatedWidth / 2) * pxWmicron)), (Origin.Y - ((View.AllocatedHeight / 2) * pxHmicron)));
            }
        }
        private bool _updatingScrollBars = false;
        public PointD PyramidalOriginTransformed
        {
            get { return new PointD(PyramidalOrigin.X * Resolution, PyramidalOrigin.Y * Resolution); }
            set { PyramidalOrigin = new PointD(value.X / Resolution, value.Y / Resolution); }
        }
 
        /* Setting the origin of a pyramidal image. */
        public PointD PyramidalOrigin
        {
            get
            {
                return SelectedImage.PyramidalOrigin;
            }
            set
            {
                if (!AllowNavigation)
                    return;
                SelectedImage.PyramidalOrigin = value;
                if (!MacOS)
                {
                    double viewWorldW = Math.Max(1, View?.AllocatedWidth ?? 1) * Resolution;
                    double viewWorldH = Math.Max(1, View?.AllocatedHeight ?? 1) * Resolution;
                    double worldRangeX = Math.Max(0, hScroll.Adjustment.Upper - hScroll.Adjustment.Lower);
                    double worldRangeY = Math.Max(0, vScroll.Adjustment.Upper - vScroll.Adjustment.Lower);
                    bool canPanX = SelectedImage?.isPyramidal == true && worldRangeX > viewWorldW;
                    bool canPanY = SelectedImage?.isPyramidal == true && worldRangeY > viewWorldH;
 
                    double maxX = Math.Max(hScroll.Adjustment.Lower, hScroll.Adjustment.Upper - hScroll.Adjustment.PageSize);
                    double maxY = Math.Max(vScroll.Adjustment.Lower, vScroll.Adjustment.Upper - vScroll.Adjustment.PageSize);
                    double clampedX = canPanX
                        ? Math.Clamp(value.X, hScroll.Adjustment.Lower, maxX)
                        : value.X;
                    double clampedY = canPanY
                        ? Math.Clamp(value.Y, vScroll.Adjustment.Lower, maxY)
                        : value.Y;
 
                    _updatingScrollBars = true;
                    if (canPanX && hScroll.Value != clampedX)
                        hScroll.Value = clampedX;
                    if (canPanY && vScroll.Value != clampedY)
                        vScroll.Value = clampedY;
                    _updatingScrollBars = false;
                }
                if (_suppressViewUpdates)
                    return;
 
                if (SelectedImage?.isPyramidal == true)
                {
                    // Pan and zoom only change which part of the same image is
                    // visible. In-flight tiles remain valid cache entries, so do
                    // not cancel their HTTP requests here. Cancellation is still
                    // used for channel, Z/T, threshold, and source changes where
                    // an old tile could contain genuinely stale pixel data.
                    slideRenderer?.InvalidateViewport();
                    // The Skia renderer does not cancel network I/O when its
                    // render state changes, so its existing generation invalidation
                    // is the viewport-safe equivalent.
                    sKSlideRenderer?.InvalidateRenderState();
                    UpdateView();
                }
                else if (View != null)
                {
                    UpdateImages();
                    View.QueueDraw();
                }
            }
        }
        // Mouse wheel handler
        public void OnMouseWheel(object sender, ScrollEventArgs e)
        {
            double mouseX = e?.Event?.X ?? PyramidalOrigin.X;
            double mouseY = e?.Event?.Y ?? PyramidalOrigin.Y;
            if (e.Event.Direction == ScrollDirection.Up)
                ZoomAtPoint(mouseX, mouseY, false);
            else if (e.Event.Direction == ScrollDirection.Down)
                ZoomAtPoint(mouseX, mouseY, true);
        }
        public void ZoomAtPoint(double mouseX, double mouseY, bool zoomIn)
        {
            if (SelectedImage == null || !SelectedImage.isPyramidal) return;
 
            int currentLevel = Level;
            int nextLevel = zoomIn
                ? Math.Max(0, currentLevel - 1)
                : Math.Min(SelectedImage.Resolutions.Count - 1, currentLevel + 1);
 
            if (nextLevel == currentLevel)
                return;
 
            double currentResolution = SelectedImage.GetUnitPerPixel(currentLevel);
            double nextResolution = SelectedImage.GetUnitPerPixel(nextLevel);
            if (currentResolution <= 0 || nextResolution <= 0)
                return;
 
            // Batch the level/origin change so zoom only triggers one viewport
            // update instead of two separate renders.
            SetResolution(nextResolution, new PointD(mouseX, mouseY));
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, mouseX, mouseY, zoomIn);
        }
        public double Resolution
        {
            get
            {
                if (!SelectedImage.isPyramidal)
                    return 1;
                return SelectedImage.Resolution;
            }
            set
            {
                if (SelectedImage.isPyramidal)
                    SelectedImage.Resolution = value;
                if (!_suppressViewUpdates)
                {
                    if (SelectedImage?.isPyramidal == true)
                        UpdateView();
                    else if (View != null)
                    {
                        try
                        {
                            UpdateImages();
                        }
                        catch (Exception)
                        {
 
                        }
                        if (!MacOS)
                            glArea?.RequestRedraw();
                        else
                            View.QueueDraw();
                    }
                }
            }
        }
 
        private void UpdateLevel()
        {
            if (!SelectedImage.isPyramidal) return;
            if (l != ImageView.SelectedImage.Level)
            {
                if (openSlide)
                    for (int j = 0; j < ImageView.SelectedImage.OpenSlideBase.stitch.gpuTiles.Count; j++)
                    {
                        var tile = ImageView.SelectedImage.OpenSlideBase.stitch.gpuTiles[j];
                        if (tile.Index.Level != Level)
                            tile.Dispose();
                    }
                else if (ImageView.SelectedImage.SlideBase?.stitch != null)
                    for (int j = 0; j < ImageView.SelectedImage.SlideBase.stitch.gpuTiles.Count; j++)
                    {
                        var tile = ImageView.SelectedImage.SlideBase.stitch.gpuTiles[j];
                        if (tile.Index.Level != Level)
                            tile.Dispose();
                    }
                l = ImageView.SelectedImage.Level;
            }
        }
 
        private int l;
        public int Level
        {
            get
            {
                return SelectedImage.LevelFromResolution(SelectedImage.Resolution);
            }
            set
            {
                if (value < 0)
                    return;
                if (SelectedImage?.Type == BioImage.ImageType.well)
                {
                    if (l != value)
                        l = value;
                    SelectedImage.Level = value;
                    UpdateScrollBars();
                    if (View != null)
                    {
                        UpdateImages();
                        View.QueueDraw();
                    }
                    return;
                }
                if (l != value)
                    UpdateLevel();
                l = value;
                SelectedImage.Level = l;
                UpdateScrollBars();
            }
        }
 
        SizeF scale = new SizeF(1, 1);
        /* A property that is used to set the scale of the view. */
        public SizeF Scale
        {
            get
            {
                return scale;
            }
            set
            {
                scale = value;
            }
        }
        public void UpdateStatus()
        {
            if (SelectedImage.Buffers.Count == 0 &&
                SelectedImage.Type != BioImage.ImageType.well &&
                !SelectedImage.IsZarrSource)
                return;
            string formattedResolution = FormatResolution(Resolution);
            if (SelectedImage.Type == BioImage.ImageType.stack)
                statusLabel.Text = (zBar.Value + 1) + "/" + (zBar.Adjustment.Upper + 1) + ", " + (cBar.Value + 1) + "/" + (cBar.Adjustment.Upper + 1) + ", " + (tBar.Value + 1) + "/" + (tBar.Adjustment.Upper + 1) + ", " +
                    mousePoint + mouseColor + ", " + SelectedImage.Resolutions[0].PixelFormat.ToString() + ", (" + SelectedImage.Volume.Location.X.ToString("N2") + ", " + SelectedImage.Volume.Location.Y.ToString("N2") + ") "
                    + Origin.X.ToString("N2") + "," + Origin.Y.ToString("N2") + ", Res:" + formattedResolution + " Level:" + Level;
            else if (SelectedImage.Type == BioImage.ImageType.pyramidal || 
                     SelectedImage.Type == BioImage.ImageType.well)
            {
                string wellStatus = SelectedImage.Type == BioImage.ImageType.well
                    ? ", WellIndex:" + SelectedImage.WellIndex
                    : string.Empty;
                statusLabel.Text = (zBar.Value + 1) + "/" + (zBar.Adjustment.Upper + 1) + ", " + (cBar.Value + 1) + "/" + (cBar.Adjustment.Upper + 1) + ", " + (tBar.Value + 1) + "/" + (tBar.Adjustment.Upper + 1) + ", " +
                mousePoint + mouseColor + ", " + SelectedImage.Resolutions[0].PixelFormat.ToString() + ", (" + SelectedImage.Volume.Location.X.ToString("N2") + ", " + SelectedImage.Volume.Location.Y.ToString("N2") + ") "
                + PyramidalOrigin.X.ToString("N2") + "," + PyramidalOrigin.Y.ToString("N2") + " , Level:" + Level + " Res:" + formattedResolution + wellStatus;
            }
        }
 
        private static string FormatResolution(double resolution)
        {
            double magnitude = Math.Abs(resolution);
            if (magnitude >= 1000) return resolution.ToString("F0");
            if (magnitude >= 100) return resolution.ToString("F1");
            if (magnitude >= 10) return resolution.ToString("F2");
            if (magnitude >= 1) return resolution.ToString("F3");
            if (magnitude >= 0.1) return resolution.ToString("F4");
            if (magnitude >= 0.01) return resolution.ToString("F5");
            return resolution.ToString("G4");
        }
        public void UpdateView(bool updateImages = true)
        {
            refresh = true;
            if (SelectedImage?.isPyramidal == true)
            {
                RequestDeferredRender();
            }
            else
            {
                UpdateImages(true);
                RequestViewportRefresh();
            }
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, updateImages);
        }
        private string mousePoint = "";
        private string mouseColor = "";
        private int _cursorPixelSampleRequestId;
 
        private void UpdateCursorPixelSample(PointD imagePoint)
        {
            var image = SelectedImage;
            if (image == null)
                return;
 
            int pixelX = (int)Math.Floor(imagePoint.X);
            int pixelY = (int)Math.Floor(imagePoint.Y);
            if (pixelX < 0 || pixelY < 0 || pixelX >= image.SizeX || pixelY >= image.SizeY)
            {
                Interlocked.Increment(ref _cursorPixelSampleRequestId);
                mouseColor = string.Empty;
                return;
            }
 
            if (image.IsZarrSource)
            {
                QueueCursorPixelSample(imagePoint);
                return;
            }
 
            try
            {
                ZCT coordinate = image.Coordinate;
                if (image.isRGB)
                {
                    double red = image.GetValueRGB(coordinate.Z, RChannel.Index, coordinate.T,
                        pixelX, pixelY, 0);
                    double green = image.GetValueRGB(coordinate.Z, GChannel.Index, coordinate.T,
                        pixelX, pixelY, 1);
                    double blue = image.GetValueRGB(coordinate.Z, BChannel.Index, coordinate.T,
                        pixelX, pixelY, 2);
                    mouseColor = $", Val: ({FormatPixelValue(red)}, {FormatPixelValue(green)}, {FormatPixelValue(blue)})";
                }
                else
                {
                    double value = image.GetValueRGB(coordinate.Z, coordinate.C, coordinate.T,
                        pixelX, pixelY, 0);
                    mouseColor = $", Val: {FormatPixelValue(value)}";
                }
            }
            catch (Exception)
            {
                mouseColor = string.Empty;
            }
        }
 
        private static string FormatPixelValue(double value)
        {
            return Math.Abs(value - Math.Round(value)) < 0.000001
                ? value.ToString("F0")
                : value.ToString("G6");
        }
 
        private void QueueCursorPixelSample(PointD imagePoint)
        {
            var image = SelectedImage;
            if (image?.IsZarrSource != true || slideRenderer == null)
                return;
 
            int pixelX = (int)Math.Floor(imagePoint.X);
            int pixelY = (int)Math.Floor(imagePoint.Y);
            int requestId = Interlocked.Increment(ref _cursorPixelSampleRequestId);
            if (pixelX < 0 || pixelY < 0 || pixelX >= image.SizeX || pixelY >= image.SizeY)
            {
                mouseColor = string.Empty;
                return;
            }
 
            ZCT coordinate = image.Coordinate;
            _ = UpdateCursorPixelValueAsync(image, coordinate, pixelX, pixelY, requestId);
        }
 
        private async Task UpdateCursorPixelValueAsync(
            BioImage image,
            ZCT coordinate,
            int pixelX,
            int pixelY,
            int requestId)
        {
            try
            {
                // Avoid a remote request for every mouse event. Only the last
                // position after a short pause proceeds to the Zarr reader.
                await Task.Delay(60).ConfigureAwait(false);
                if (requestId != _cursorPixelSampleRequestId || !ReferenceEquals(image, SelectedImage))
                    return;
 
                double? value = await slideRenderer.SampleZarrPixelAsync(
                    image, coordinate, pixelX, pixelY).ConfigureAwait(false);
                if (!value.HasValue || requestId != _cursorPixelSampleRequestId ||
                    !ReferenceEquals(image, SelectedImage))
                    return;
 
                Gtk.Application.Invoke((s, e) =>
                {
                    if (requestId != _cursorPixelSampleRequestId || !ReferenceEquals(image, SelectedImage))
                        return;
                    mouseColor = $", Val: {FormatPixelValue(value.Value)}";
                    UpdateStatus();
                });
            }
            catch (Exception ex)
            {
                AppLog.Append($"Cursor Zarr sample failed: {ex.Message}");
            }
        }
 
        public bool showRROIs = true;
        public bool showGROIs = true;
        public bool showBROIs = true;
        public bool ShowROIs { get; private set; } = true;
 
        private void UpdateRoiMenuState()
        {
            if (roiShow != null)
                roiShow.Sensitive = !ShowROIs;
            if (roiHide != null)
                roiHide.Sensitive = ShowROIs;
        }
 
        public double GetScale()
        {
            return ToViewSizeW(ROI.selectBoxSize / Scale.Width);
        }
        public static bool x1State;
        public static bool x2State;
        public static bool mouseLeftState;
        public static ModifierType Modifiers;
        PointD mouseD = new PointD(0, 0);
        PointD pd;
        PointD mouseDownInt = new PointD(0, 0);
        PointD mouseMoveInt = new PointD(0, 0);
        PointD mouseUpInt = new PointD(0, 0);
        PointD mouseUp = new PointD(0, 0);
        PointD mouseDown = new PointD(0, 0);
        PointD mouseMove = new PointD(0, 0);
        public ROI selectedROI = new ROI();
        /* A property that returns the value of the mouseDownInt variable. */
        public PointD MouseDownInt
        {
            get { return mouseDownInt; }
            set { mouseDownInt = value; }
        }
        public PointD MouseMoveInt
        {
            get { return mouseMoveInt; }
            set { mouseMoveInt = value; }
        }
        public PointD MouseUpInt
        {
            get { return mouseUpInt; }
            set { mouseUpInt = value; }
        }
        public PointD MouseDown
        {
            get { return mouseDown; }
            set { mouseDown = value; }
        }
        public PointD MouseUp
        {
            get { return mouseUp; }
            set { mouseUp = value; }
        }
        public PointD MouseMove
        {
            get { return mouseMove; }
            set { mouseMove = value; }
        }
 
        List<ROI> copys = new List<ROI>();
        public List<ROI> GetSelectedROIs()
        {
            List<ROI> roi = new List<ROI>();
            List<ROI> rois = new List<ROI>();
            rois.AddRange(SelectedImage.AnnotationsR);
            rois.AddRange(SelectedImage.AnnotationsG);
            rois.AddRange(SelectedImage.AnnotationsB);
            foreach (ROI r in rois)
            {
                if (r.Selected)
                {
                    roi.Add(r);
                }
            }
            return roi;
        }
        public void ZoomAtPoint(float mouseX, float mouseY, bool zoomIn)
        {
            if (SelectedImage == null) return;
 
            // 1. Define zoom factor (e.g., 2.0x zoom steps)
            float zoomFactor = zoomIn ? 2.0f : 0.5f;
 
            // 2. Get the current level's scale relative to Full Res (Level 0)
            // Formula: CurrentLevelWidth / FullResWidth
            double currentLevelScale = (double)SelectedImage.Resolutions[SelectedImage.Level].SizeX / SelectedImage.SizeX;
 
            // 3. Find the "World Point" (Full Res Level 0) currently under the mouse
            // We add the origin to the mouse offset and then scale up to Level 0
            double worldX = (PyramidalOrigin.X + mouseX) / currentLevelScale;
            double worldY = (PyramidalOrigin.Y + mouseY) / currentLevelScale;
 
            // 4. Update your Level logic here
            // This is where you switch your 'CurrentLevelWidth' to the next level in the pyramid
            //UpdateLevel(zoomIn);
 
            // 5. Get the NEW level's scale relative to Full Res
            double newLevelScale = (double)SelectedImage.Resolutions[SelectedImage.Level].SizeX / SelectedImage.SizeX;
 
            // 6. Calculate the NEW PyramidalOrigin
            // To keep the world point at the same mouse position:
            // NewOrigin = (WorldPoint * NewScale) - MouseOffset
            float newOriginX = (float)(worldX * newLevelScale - mouseX);
            float newOriginY = (float)(worldY * newLevelScale - mouseY);
 
            // 7. Apply and Clamp (to ensure we don't scroll past image edges)
            TryGetPyramidalViewerBounds(SelectedImage, out double imageMinX, out double imageMinY, out double imageMaxX, out double imageMaxY);
            double viewWorldW = Math.Max(1, View?.AllocatedWidth ?? 1) * Resolution;
            double viewWorldH = Math.Max(1, View?.AllocatedHeight ?? 1) * Resolution;
            PyramidalOrigin = new PointD(
                ClampPyramidalOrigin(newOriginX, imageMinX, imageMaxX, viewWorldW),
                ClampPyramidalOrigin(newOriginY, imageMinY, imageMaxY, viewWorldH)
            );
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, mouseX, mouseY, zoomIn);
        }
 
        private void ZoomStackAtPoint(PointD mouseScreenPos, double factor)
        {
            if (SelectedImage == null || SelectedImage.isPyramidal)
                return;
            if (factor <= 0 || double.IsNaN(factor) || double.IsInfinity(factor))
                return;
 
            double oldScaleX = Math.Max(double.Epsilon, Scale.Width);
            double oldScaleY = Math.Max(double.Epsilon, Scale.Height);
            // Keep zoom-out effectively unbounded while avoiding zero/negative
            // scale values that would break coordinate conversion.
            double newScaleX = Math.Clamp(oldScaleX * factor, 1e-6, 4096.0);
            double newScaleY = Math.Clamp(oldScaleY * factor, 1e-6, 4096.0);
 
            double viewCenterX = View?.AllocatedWidth > 0 ? View.AllocatedWidth / 2.0 : 0;
            double viewCenterY = View?.AllocatedHeight > 0 ? View.AllocatedHeight / 2.0 : 0;
 
            double worldX = ((mouseScreenPos.X - viewCenterX) / (PxWmicron * oldScaleX)) - Origin.X;
            double worldY = ((mouseScreenPos.Y - viewCenterY) / (PxHmicron * oldScaleY)) - Origin.Y;
 
            Scale = new SizeF((float)newScaleX, (float)newScaleY);
 
            double newOriginX = ((mouseScreenPos.X - viewCenterX) / (PxWmicron * newScaleX)) - worldX;
            double newOriginY = ((mouseScreenPos.Y - viewCenterY) / (PxHmicron * newScaleY)) - worldY;
 
            Origin = new PointD(newOriginX, newOriginY);
            UpdateView(true);
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, mouseScreenPos.X, mouseScreenPos.Y, factor);
        }
 
        private void ImageView_MotionNotifyEvent(object o, MotionNotifyEventArgs e)
        {
            App.viewer = this;
            Modifiers = e.Event.State;
 
            // Capture previous screen position BEFORE updating MouseMoveInt.
            PointD prevScreenPos = MouseMoveInt;
 
            MouseMove = new PointD(e.Event.X, e.Event.Y);
            MouseMoveInt = new PointD((int)e.Event.X, (int)e.Event.Y);
 
            // Convert to view space (world coordinates)
            PointD p = ImageToViewSpace(e.Event.X, e.Event.Y);
            mousePoint = "(" + (p.X.ToString("F")) + ", " + (p.Y.ToString("F")) + ")";
            if (SelectedImage == null)
                return;
            mouseD = SelectedImage.ToImageSpace(p);
            UpdateCursorPixelSample(mouseD);
            if (e.Event.State.HasFlag(ModifierType.Button2Mask) &&
                Tools.currentTool.type != Tools.Tool.Type.pan)
            {
                Tools.currentTool = Tools.GetTool("pan");
            }
            // Handle pyramidal overview navigation only when the drag is inside
            // the overview widget. Otherwise the active tool needs the event.
            if (e.Event.State.HasFlag(ModifierType.Button1Mask) &&
                TryNavigateFromOverview(e.Event.X, e.Event.Y))
            {
                UpdateStatus();
                pd = p;
                return;
            }
            if(App.tools!=null)
            App.tools.ToolMove(p, e);
            UpdateStatus();
            pd = p;
        }
 
        private bool TryNavigateFromOverview(double eventX, double eventY)
        {
            if (SelectedImage?.isPyramidal != true || !ShowOverview || overview.Width <= 0 || overview.Height <= 0)
                return false;
 
            double overviewScale = Math.Max(1, View?.ScaleFactor ?? 1);
            double overviewX = eventX * overviewScale;
            double overviewY = eventY * overviewScale;
            if (!overview.IntersectsWith(overviewX, overviewY))
                return false;
 
            TryGetPyramidalViewerBounds(SelectedImage, out double imageMinX, out double imageMinY, out double imageMaxX, out double imageMaxY);
            double fullResWidth = Math.Max(1, imageMaxX - imageMinX);
            double fullResHeight = Math.Max(1, imageMaxY - imageMinY);
            double viewWorldW = View.AllocatedWidth * Resolution;
            double viewWorldH = View.AllocatedHeight * Resolution;
 
            double fullResX = imageMinX + (((overviewX - overview.X) / overview.Width) * fullResWidth);
            double fullResY = imageMinY + (((overviewY - overview.Y) / overview.Height) * fullResHeight);
 
            double originX = fullResX - (viewWorldW / 2.0);
            double originY = fullResY - (viewWorldH / 2.0);
 
            PyramidalOrigin = new PointD(
                ClampPyramidalOrigin(originX, imageMinX, imageMaxX, viewWorldW),
                ClampPyramidalOrigin(originY, imageMinY, imageMaxY, viewWorldH));
            return true;
        }
 
        private void ImageView_ButtonReleaseEvent(object o, ButtonReleaseEventArgs e)
        {
            Modifiers = e.Event.State;
            MouseUpInt = new PointD((int)e.Event.X, (int)e.Event.Y);
 
            if (Tools.currentTool.type == Tools.Tool.Type.pan && e.Event.Button == 2)
                Tools.currentTool = Tools.GetTool("move");
            if (e.Event.Button == 1)
                mouseLeftState = false;
            if (SelectedImage == null)
                return;
            App.viewer = this;
            PointD pointer = ImageToViewSpace(e.Event.X, e.Event.Y);
            mouseUp = pointer;
 
            if (SelectedImage == null)
                return;
            // Delegate all tool logic to Tools.cs
            App.tools.ToolUp(pointer, e);
        }
 
        private void ImageView_ButtonPressEvent(object o, ButtonPressEventArgs e)
        {
            Modifiers = e.Event.State;
 
            if (e.Event.Button == 1)
                mouseLeftState = true;
            else
                mouseLeftState = false;
            if (SelectedImage == null)
                return;
            App.viewer = this;
            PointD pointer = ImageToViewSpace(e.Event.X, e.Event.Y);
            MouseDownInt = new PointD(e.Event.X, e.Event.Y);
            pd = pointer;
            mouseDown = pd;
            if (e.Event.Button == 2)
                Tools.currentTool = Tools.GetTool("pan");
            if (SelectedImage == null)
                return;
 
            mouseD = SelectedImage.ToImageSpace(pd);
 
            if (e.Event.Button == 1 && TryNavigateFromOverview(e.Event.X, e.Event.Y))
                return;
 
            if (e.Event.Button == 1)
                TrySelectVisibleMaskAt(pointer.X, pointer.Y, e.Event.State.HasFlag(ModifierType.ControlMask));
 
            // Handle well plate level navigation
            if (ImageView.SelectedImage.Type == BioImage.ImageType.well)
            {
                if (e.Event.Button == 4)
                {
                    Level = ImageView.SelectedImage.Level - 1;
                }
                else if (e.Event.Button == 5)
                {
                    Level = ImageView.SelectedImage.Level + 1;
                }
            }
 
            // Context menu
            if (e.Event.Button == 3)
            {
                contextMenu.Popup();
                return; // Don't process tool events for right-click
            }
 
            // Mouse wheel scrolling for channel/time navigation
            if (e.Event.Button == 4 && Mode != ViewMode.RGBImage)
            {
                if (cBar.Value < cBar.Adjustment.Upper)
                    cBar.Value++;
                x1State = true;
            }
            else if (e.Event.Button == 4 && e.Event.State == ModifierType.ControlMask)
            {
                if (tBar.Value < tBar.Adjustment.Upper)
                    tBar.Value++;
                x1State = true;
            }
 
            if (e.Event.State != ModifierType.Button4Mask)
                x1State = false;
 
            if (e.Event.Button == 5 && Mode != ViewMode.RGBImage)
            {
                if (cBar.Value > cBar.Adjustment.Lower)
                    cBar.Value--;
                x2State = true;
            }
            else if (e.Event.Button == 5 && Modifiers == ModifierType.ControlMask && Mode != ViewMode.RGBImage)
            {
                if (tBar.Value > cBar.Adjustment.Lower)
                    tBar.Value--;
                x2State = true;
            }
 
            if (e.Event.State != ModifierType.Button5Mask)
                x2State = false;
 
            // Select which image is clicked (for multi-image views)
            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(pointer))
                {
                    selectedIndex = ind;
                    UpdateGUI();
                    break;
                }
                ind++;
            }
 
            // Refresh the status value immediately on a click as well as on hover.
            if (e.Event.Button == 1)
                UpdateCursorPixelSample(mouseD);
            UpdateStatus();
 
            App.tools.ToolDown(pointer, e);
            // On macOS pyramidal, a click alone doesn't change origin/resolution so there
            // is nothing to re-render. Avoid launching a spurious async pipeline invocation.
            if (!(MacOS && SelectedImage?.isPyramidal == true))
                UpdateView();
        }
        protected override void OnDestroyed()
        {
            base.OnDestroyed();
        }
 
 
        #region Conversion
        private int Width
        {
            get
            {
                return View.AllocatedWidth;
            }
        }
        private int Height
        {
            get
            {
                return View.AllocatedHeight;
            }
        }
 
        public static ROI SelectedAnnotation
        {
            get
            {
                foreach (var item in SelectedImage.Annotations)
                {
                    if (item.Selected)
                        return item;
                }
                return null;
            }
        }
 
        public double ImageViewWidth
        {
            get
            {
                double d = View.AllocatedWidth / Resolution;
                return d;
            }
        }
        public double ImageViewHeight
        {
            get
            {
                double d = View.AllocatedHeight / Resolution;
                return d;
            }
        }
        public PointD ImageToViewSpace(double x, double y)
        {
            if (SelectedImage == null)
                return ToViewSpace(x, y);
            if (SelectedImage.isPyramidal)
            {
                // PyramidalOrigin is already in world coordinates. Convert the
                // screen-space mouse offset back into the same world space that
                // ToViewSpace() consumes.
                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 Widget View
        {
            get
            {
                if (currentView != null)
                    return currentView;
                if (MacOS)
                    return sk;
                return glArea;
            }
            set
            {
                currentView = value;
                if (value is SKDrawingArea drawingArea)
                    sk = drawingArea;
                if (value is SlideGLArea slideGlArea)
                    glArea = slideGlArea;
            }
        }
        public PointD ToViewSpace(double x, double y)
        {
            if (SelectedImage == null)
            {
                double dx = (ToViewSizeW(x - (View.AllocatedWidth / 2)) / Scale.Width) - Origin.X;
                double dy = (ToViewSizeH(y - (View.AllocatedHeight / 2)) / Scale.Height) - Origin.Y;
                return new PointD(dx, dy);
            }
            if (SelectedImage.isPyramidal)
            {
                // x, y are world (full-resolution pixel) coordinates.
                // Subtract the viewport origin and divide by Resolution to get screen pixels.
                return new PointD((x - PyramidalOrigin.X) / Resolution,
                                  (y - PyramidalOrigin.Y) / Resolution);
            }
            else
            {
                double dx = (ToViewSizeW(x - (View.AllocatedWidth / 2)) / Scale.Width) - Origin.X;
                double dy = (ToViewSizeH(y - (View.AllocatedHeight / 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)
        {
            if (SelectedImage != null)
                if (SelectedImage.isPyramidal)
                {
                    return d / Resolution;
                }
            double x = (double)(d / PxWmicron) / scale.Width;
            return x;
        }
        public double ToViewH(double d)
        {
            if (SelectedImage != null)
                if (SelectedImage.isPyramidal)
                {
                    return d / Resolution;
                }
            double y = (double)(d / PxHmicron) / scale.Height;
            return y;
        }
        public PointD ToScreenSpace(double x, double y)
        {
            RectangleD f = ToScreenRect(x, y, 1, 1);
            return new PointD(f.X, f.Y);
        }
        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;
        }
        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 * Scale.Width);
        }
        public float ToScreenScaleH(double y)
        {
            return (float)(-y * PxHmicron * Scale.Height);
        }
        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)
            {
                double dx = (pxWmicron * (-Origin.X)) * Scale.Width;
                double dy = (pxHmicron * (-Origin.Y)) * Scale.Height;
                RectangleD rf = new RectangleD((PxWmicron * x * Scale.Width + dx), (PxHmicron * y * Scale.Height + dy), (PxWmicron * w * Scale.Width), (PxHmicron * h * Scale.Height));
                return rf;
            }
            if (SelectedImage.isPyramidal)
            {
                PointD d = ToViewSpace(x, y);
                double dw = ToViewSizeW(w);
                double dh = ToViewSizeH(h);
                return new RectangleD(d.X, d.Y, dw, dh);
            }
            else
            {
                double dx = (pxWmicron * (Origin.X)) * Scale.Width;
                double dy = (pxHmicron * (Origin.Y)) * Scale.Height;
                RectangleD rf = new RectangleD((PxWmicron * x * Scale.Width + dx), (PxHmicron * y * Scale.Height + dy), (PxWmicron * w * Scale.Width), (PxHmicron * h * Scale.Height));
                return rf;
            }
        }
 
        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 PointD[] ToScreenSpace(PointD[] p)
        {
            PointD[] rs = new PointD[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                PointD pd = ToScreenSpace(p[i]);
                rs[i] = new PointD((float)pd.X, (float)pd.Y);
            }
            return rs;
        }
        public double ToScreenW(double x)
        {
            return (float)(x * PxWmicron);
        }
        public float ToScreenH(double y)
        {
            return (float)(y * PxHmicron);
        }
        public void GoToImage()
        {
            GoToImage(SelectedIndex);
        }
 
        private static bool IsZarrSource(BioImage image)
        {
            if (image == null)
                return false;
 
            string source = image.file;
            if (string.IsNullOrWhiteSpace(source))
                source = image.Filename;
 
            return source.Contains(".zarr", StringComparison.OrdinalIgnoreCase) ||
                   source.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ||
                   source.StartsWith("s3://", StringComparison.OrdinalIgnoreCase);
        }
 
        private bool TryGetPyramidalViewerBounds(BioImage image, out double minX, out double minY, out double maxX, out double maxY)
        {
            minX = 0;
            minY = 0;
            maxX = 1;
            maxY = 1;
 
            if (image == null)
                return false;
 
            minX = image.Volume.Location.X;
            minY = image.Volume.Location.Y;
            maxX = minX + image.Volume.Width;
            maxY = minY + image.Volume.Height;
 
            ITileSchema schema = null;
            if (image == SelectedImage)
            {
                schema = openSlide
                    ? _openSlideBase?.Schema
                    : _slideBase?.Schema;
            }
 
            schema ??= image.OpenSlideBase?.Schema;
            schema ??= image.SlideBase?.Schema;
 
            if (schema?.Extent != null)
            {
                minX = schema.Extent.MinX;
                maxX = schema.Extent.MaxX;
                minY = -schema.Extent.MaxY;
                maxY = -schema.Extent.MinY;
            }
 
            if (maxX <= minX)
                maxX = minX + 1;
            if (maxY <= minY)
                maxY = minY + 1;
 
            return true;
        }
 
        private static void NormalizeOsmSchemaOrigin(SlideBase slideBase, BioImage image = null)
        {
            if (slideBase?.Schema is not TileSchema schema)
                return;
            if (schema.YAxis != YAxis.OSM)
                return;
 
            BioImage bioImage = image ?? slideBase.Image?.BioImage;
            if (bioImage?.Type != BioImage.ImageType.well &&
                bioImage?.Resolutions != null &&
                bioImage.Resolutions.Count > 0 &&
                schema.Resolutions != null &&
                schema.Resolutions.Count > 0)
            {
                var baseResolution = bioImage.Resolutions[0];
                double unitsPerPixel = schema.Resolutions.ContainsKey(0)
                    ? schema.Resolutions[0].UnitsPerPixel
                    : schema.Resolutions.OrderBy(kv => kv.Key).First().Value.UnitsPerPixel;
 
                if (unitsPerPixel > 0 && baseResolution.SizeX > 0 && baseResolution.SizeY > 0)
                {
                    double expectedWidth = baseResolution.SizeX * unitsPerPixel;
                    double expectedHeight = baseResolution.SizeY * unitsPerPixel;
                    double extentWidth = schema.Extent.MaxX - schema.Extent.MinX;
                    double extentHeight = schema.Extent.MaxY - schema.Extent.MinY;
 
                    if (Math.Abs(extentWidth - expectedWidth) > Math.Max(1e-6, expectedWidth * 0.001) ||
                        Math.Abs(extentHeight - expectedHeight) > Math.Max(1e-6, expectedHeight * 0.001))
                    {
                        double stageX = baseResolution.StageSizeX;
                        double stageY = baseResolution.StageSizeY;
                        schema.Extent = new Extent(
                            stageX,
                            -(stageY + expectedHeight),
                            stageX + expectedWidth,
                            -stageY);
                    }
                }
            }
 
            schema.OriginX = schema.Extent.MinX;
            schema.OriginY = schema.Extent.MaxY;
        }
 
        private static double ClampPyramidalOrigin(double requestedOrigin, double imageMin, double imageMax, double viewWorldSize)
        {
            double imageSize = Math.Max(1, imageMax - imageMin);
            if (viewWorldSize >= imageSize)
                return imageMin - ((viewWorldSize - imageSize) / 2.0);
 
            double maxOrigin = imageMax - viewWorldSize;
            return Math.Max(imageMin, Math.Min(requestedOrigin, maxOrigin));
        }
 
        private void ForceNavigationRefresh()
        {
            if (SelectedImage?.isPyramidal == true)
            {
                // Go To, pan, and zoom only change viewport geometry. Keep
                // reusable tile downloads alive and supersede stale layout work.
                slideRenderer?.InvalidateViewport();
                sKSlideRenderer?.InvalidateRenderState();
                ExecuteDeferredRender();
                ScheduleNavigationRenderRetry(50);
                ScheduleNavigationRenderRetry(150);
            }
 
            UpdateView();
            View?.QueueDraw();
            if (!MacOS)
                glArea?.RequestRedraw();
        }
 
        private void ScheduleNavigationRenderRetry(uint delayMs)
        {
            GLib.Timeout.Add(delayMs, () =>
            {
                if (_viewerCleanupDone || SelectedImage?.isPyramidal != true)
                    return false;
 
                ExecuteDeferredRender();
                View?.QueueDraw();
                if (!MacOS)
                    glArea?.RequestRedraw();
 
                return false;
            });
        }
 
        public void GoToImage(int i)
        {
            if (i < 0 || Images.Count <= i)
                return;
            if (_isApplyingGoToImage)
            {
                _pendingGoToImageIndex = i;
                return;
            }
 
            // Ensure viewport is valid before doing any math
            int vpW = View.AllocatedWidth;
            int vpH = View.AllocatedHeight;
 
            if (vpW < 10 || vpH < 10)
            {
                void OnAllocated(object sender, SizeAllocatedArgs args)
                {
                    if (args.Allocation.Width < 10 || args.Allocation.Height < 10)
                        return;
 
                    View.SizeAllocated -= OnAllocated;
                    GoToImage(i);
                }
 
                View.SizeAllocated += OnAllocated;
                return;
            }
 
            bool imageChanged = selectedIndex != i;
            _isApplyingGoToImage = true;
            _suppressViewUpdates = true;
            try
            {
                if (imageChanged)
                {
                    selectedIndex = i;
                    Initialize();
                    InitPreview();
                    UpdateGUI();
                }
 
                BioImage currentImage = Images[i];
                if (currentImage == null)
                    return;
 
                if (currentImage.isPyramidal)
                {
                    TryGetPyramidalViewerBounds(currentImage, out double imageMinX, out double imageMinY, out double imageMaxX, out double imageMaxY);
 
                    double imageWorldW = imageMaxX - imageMinX;
                    double imageWorldH = imageMaxY - imageMinY;
                    if (imageWorldW <= 0) imageWorldW = 1;
                    if (imageWorldH <= 0) imageWorldH = 1;
 
                    double targetRes = Math.Max(imageWorldW / vpW, imageWorldH / vpH);
                    if (targetRes <= 0) targetRes = 1;
 
                    Resolution = targetRes;
                    UpdateScrollBars();
 
                    double viewWorldW = vpW * Resolution;
                    double viewWorldH = vpH * Resolution;
                    double originX = imageMinX - ((viewWorldW - imageWorldW) / 2.0);
                    double originY = imageMinY - ((viewWorldH - imageWorldH) / 2.0);
                    PyramidalOrigin = new PointD(originX, originY);
                }
                else
                {
                    double imageWorldW = Math.Max(currentImage.Volume.Width, currentImage.SizeX * currentImage.PhysicalSizeX);
                    double imageWorldH = Math.Max(currentImage.Volume.Height, currentImage.SizeY * currentImage.PhysicalSizeY);
                    if (imageWorldW <= 0) imageWorldW = 1;
                    if (imageWorldH <= 0) imageWorldH = 1;
 
                    double wx = vpW / (PxWmicron * imageWorldW);
                    double wy = vpH / (PxHmicron * imageWorldH);
 
                    float fitScale = (float)Math.Min(wx, wy);
                    if (fitScale <= 0) fitScale = 1;
 
                    Scale = new SizeF(fitScale, fitScale);
 
                    double viewWorldW = vpW / (PxWmicron * fitScale);
                    double viewWorldH = vpH / (PxHmicron * fitScale);
                    double originX = -currentImage.Volume.Location.X + ((viewWorldW - imageWorldW) / 2.0);
                    double originY = -currentImage.Volume.Location.Y + ((viewWorldH - imageWorldH) / 2.0);
                    Origin = new PointD(originX, originY);
                }
            }
            finally
            {
                _suppressViewUpdates = false;
                _isApplyingGoToImage = false;
            }
 
            ForceNavigationRefresh();
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, i);
 
            if (_pendingGoToImageIndex.HasValue)
            {
                int pendingIndex = _pendingGoToImageIndex.Value;
                _pendingGoToImageIndex = null;
                if (pendingIndex != i)
                    GoToImage(pendingIndex);
            }
        }
 
        private double GetViewportFitResolution(double targetResolution)
        {
            if (!SelectedImage.isPyramidal || targetResolution <= 0)
                return targetResolution <= 0 ? 1 : targetResolution;
 
            var schema = openSlide
                ? _openSlideBase?.Schema
                : _slideBase?.Schema;
 
            if (schema?.Resolutions != null && schema.Resolutions.Count > 0)
            {
                double? smallest = null;
                double? best = null;
                foreach (var kv in schema.Resolutions.OrderBy(kv => kv.Value.UnitsPerPixel))
                {
                    double upx = kv.Value.UnitsPerPixel;
                    smallest ??= upx;
                    if (upx >= targetResolution)
                    {
                        best = upx;
                        break;
                    }
                }
 
                if (best.HasValue)
                    return best.Value;
                if (schema.Resolutions.Count > 0)
                    return schema.Resolutions.OrderByDescending(kv => kv.Value.UnitsPerPixel).First().Value.UnitsPerPixel;
            }
 
            double fallback = SelectedImage.GetUnitPerPixel(SelectedImage.Resolutions.Count - 1);
            return fallback > 0 ? fallback : targetResolution;
        }
 
        private double PickInitialResolution()
        {
            // Exclude macro/label levels.
            int maxLevel = MacroResolution.HasValue
                ? MacroResolution.Value - 1
                : SelectedImage.Resolutions.Count - 1;
            maxLevel = Math.Clamp(maxLevel, 0, SelectedImage.Resolutions.Count - 1);
 
            // Prefer reading from the schema so we match TileUtil.GetLevel exactly.
            var schema = openSlide
                ? (ITileSchema)_openSlideBase?.Schema
                : _slideBase?.Schema;
 
            if (schema?.Resolutions != null && schema.Resolutions.Count > 0)
            {
                // Schema resolutions are keyed 0..N where 0=finest, N=coarsest.
                // Find the largest key that is <= maxLevel.
                int schemaMax = Math.Min(maxLevel, schema.Resolutions.Keys.Max());
                return schema.Resolutions[schemaMax].UnitsPerPixel;
            }
 
            // Fallback: derive from BioImage geometry (used before SlideBase is set).
            return SelectedImage.GetUnitPerPixel(maxLevel);
        }
 
        #endregion
 
        #region OpenSlide
        private OpenSlideBase _openSlideBase;
        private OpenSlideGTK.ISlideSource _openSlideSource;
        private BioLib.ISlideSource _slideSource;
        private SlideBase _slideBase;
        public void ReinitializeWellField()
        {
            if (SelectedImage?.Type != BioImage.ImageType.well) return;
            if (_slideBase == null) return;
 
            _slideBase.RebuildSchemaForWell(SelectedImage);
            NormalizeOsmSchemaOrigin(_slideBase, SelectedImage);
 
            if (MacOS) sKSlideRenderer?.SetSource(_slideBase);
            else       slideRenderer?.SetSource(_slideBase);
 
            // GoToImage resets the viewport to fit the new field and triggers a render.
            GoToImage(selectedIndex);
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, SelectedImage?.file ?? string.Empty, SelectedImage.WellIndex);
        }
 
        private void Initialize()
        {
            // Pyramidal images can come from either OpenSlideBase or SlideBase.
            // Zarr-backed pyramids are not guaranteed to report ImageType.pyramidal
            // even when they need the pyramidal tile renderer, so key off isPyramidal.
            if (SelectedImage?.isPyramidal == true)
            {
                bool useSlideBase = SelectedImage.SlideBase != null;
                bool useOpenSlideBase = !useSlideBase && SelectedImage.OpenSlideBase != null;
 
                if (useSlideBase)
                {
                    openSlide = false;
                    var sb = SelectedImage.SlideBase;
                    _slideSource = SelectedImage.SlideBase;
                    _slideBase = sb;
                    NormalizeOsmSchemaOrigin(sb, SelectedImage);
                    var sbResolutions = sb.Schema?.Resolutions;
                    if (sbResolutions != null && sbResolutions.Count > 0)
                        Resolution = sbResolutions[sbResolutions.Count - 1].UnitsPerPixel;
                    if (MacOS) sKSlideRenderer?.SetSource(sb);
                    else slideRenderer?.SetSource(sb);
 
                    if (SelectedImage.Type == BioImage.ImageType.well)
                    {
                        RebuildSchemaForWell(SelectedImage);
                        NormalizeOsmSchemaOrigin(sb, SelectedImage);
                    }
                }
                else if (useOpenSlideBase)
                {
                    openSlide = true;
                    var sb = SelectedImage.OpenSlideBase;
                    _openSlideSource = SelectedImage.OpenSlideBase;
                    _openSlideBase = sb;
                    var sbResolutions = sb.Schema?.Resolutions;
                    if (sbResolutions != null && sbResolutions.Count > 0)
                        Resolution = sbResolutions[sbResolutions.Count - 1].UnitsPerPixel;
 
                    if (MacOS) sKSlideRenderer?.SetSource(sb);
                    else slideRenderer?.SetSource(sb);
                    
                    if (SelectedImage.Type == BioImage.ImageType.well)
                    {
                        RebuildSchemaForWell(SelectedImage);
                    }
                }
                else
                {
                }
            }
 
            // Do not force a thumbnail-like pyramid level here. GoToImage handles
            // the visible zoom for pyramidal images; non-pyramidal images still
            // use the legacy initial resolution path.
            if (!SelectedImage.isPyramidal)
                Resolution = PickInitialResolution();
        }
 
        public void RebuildSchemaForWell(BioImage b)
        {
            if (b.ZarrWellLevels == null || b.ZarrWellLevels.Count == 0)
            {
                return;
            }
            int fi = Math.Clamp(b.Level, 0, b.ZarrWellLevels.Count - 1);
            var fieldLevels = b.ZarrWellLevels[fi];
            if (fieldLevels == null || fieldLevels.Count == 0)
            {
                // Requested field not yet loaded — fall back to first non-null field
                // so the schema matches what TryReadRegionAsync will actually serve.
                fieldLevels = b.ZarrWellLevels.FirstOrDefault(l => l != null && l.Count > 0);
                if (fieldLevels == null)
                {
                    return;
                }
            }
 
            int w0 = 1, h0 = 1;
            GetFieldDims(fieldLevels[0], out w0, out h0);
 
            var newSchema = new BruTile.TileSchema
            {
                YAxis = BruTile.YAxis.OSM,
                Format = "jpg",
                Extent = new BruTile.Extent(0, -h0, w0, 0),
                OriginX = 0,
                OriginY = 0,
            };
 
            for (int lev = 0; lev < fieldLevels.Count; lev++)
            {
                GetFieldDims(fieldLevels[lev], out int wL, out int hL);
                double downsample = w0 > 0 ? (double)w0 / Math.Max(1, wL) : Math.Pow(2, lev);
                newSchema.Resolutions[lev] = new BruTile.Resolution(lev, downsample, 256, 256);
            }
 
            var slideBase = SelectedImage?.OpenSlideBase;
            if (slideBase == null)
            {
                return;
            }
            //OpenSlideBase op = new OpenSlideBase(SelectedImage.Filename);
            slideBase.Schema = newSchema;
            BioLib.Recorder.Record(BioLib.Recorder.GetCurrentMethodInfo(), false, b?.file ?? string.Empty, b?.Level ?? 0);
        }
 
        private static void GetFieldDims(ResolutionLevelNode node, out int w, out int h)
        {
            w = 1; h = 1;
            var axes = node.EffectiveAxes;
            var shape = node.Shape;
            for (int i = 0; i < axes.Length; i++)
            {
                switch (axes[i].Name.ToLowerInvariant())
                {
                    case "x": w = (int)shape[i]; break;
                    case "y": h = (int)shape[i]; break;
                }
            }
        }
 
        #endregion
 
    }
 
    internal static class Gray16TileConverter
    {
        internal static byte[] ToBgra(byte[] raw, int width, int height,
            int tileWidth, int tileHeight, int min, int max)
        {
            if (width <= 0 || height <= 0 || width > tileWidth || height > tileHeight)
                throw new ArgumentOutOfRangeException(nameof(width), "The region must fit inside the tile.");
            if (raw == null || raw.Length != checked(width * height * 2))
                throw new ArgumentException("The pixel buffer must match the region dimensions.", nameof(raw));
            if (max <= min)
                throw new ArgumentOutOfRangeException(nameof(max), "The display maximum must exceed the minimum.");
 
            byte[] bgra = new byte[checked(tileWidth * tileHeight * 4)];
            float scale = 255f / (max - min);
            for (int row = 0; row < height; row++)
            {
                int srcRow = row * width * 2;
                int dstRow = row * tileWidth * 4;
                for (int col = 0; col < width; col++)
                {
                    int source = srcRow + col * 2;
                    ushort value = (ushort)(raw[source] | (raw[source + 1] << 8));
                    byte gray = (byte)Math.Clamp((value - min) * scale, 0f, 255f);
                    int destination = dstRow + col * 4;
                    bgra[destination] = gray;
                    bgra[destination + 1] = gray;
                    bgra[destination + 2] = gray;
                    bgra[destination + 3] = 255;
                }
            }
            return bgra;
        }
    }
}