Inheritance diagram for BioImager.SlideGLArea:

Public Member Functions
bool	UploadTileTexture (TileIndex index, byte[] pixelData, int tileWidth, int tileHeight)
	Upload a tile texture to the GPU. Call from the main thread. Returns true if upload succeeded.

bool	HasTileTexture (TileIndex index)
	Check if a tile texture is already in the GPU cache.

void	ReleaseTileTexture (TileIndex index)
	Release a specific tile texture.

void	ReleaseLevelTextures (int level)
	Release all textures for a specific pyramid level.

void	ClearTextureCache ()
	Clear all cached textures.

void	RequestRedraw ()
	Request a redraw of the GLArea.

void	SetOverlayBitmap (System.Drawing.Bitmap bitmap)

void	ClearOverlayBitmap ()

void	SetTilesToRender (IEnumerable< TileRenderInfo > tiles)
	Prepare tiles for rendering. Call before RequestRedraw().

byte[]	ReadPixels ()
	Read pixels from the current framebuffer (for export/save operations). This is slow — only use for export, not display.

Properties
List< TileRenderInfo >	TilesToRender = new() `[get]`

bool	NeedsRedraw `[get]`

bool	IsGLReady `[get]`
	True after the GL context has been fully initialized and is ready for texture uploads and rendering.

int	CachedTextureCount `[get]`

Events
EventHandler	GLReady
	Fires exactly once after the GL context has been successfully initialized. Subscribe to this from ImageView to trigger the first tile load at a point where GL texture uploads are guaranteed to work.

Detailed Description

Definition at line 14 of file SlideGLArea.cs.

Constructor & Destructor Documentation

◆ SlideGLArea()

BioImager.SlideGLArea.SlideGLArea ( )

Definition at line 120 of file SlideGLArea.cs.

        {
            Paint += OnPaint;
            Disposed += OnDisposed;
            Resize += OnResized;
        }

Member Function Documentation

◆ ClearOverlayBitmap()

void BioImager.SlideGLArea.ClearOverlayBitmap ( )

Definition at line 696 of file SlideGLArea.cs.

        {
            _overlayPixels = null;
            _overlayWidth = 0;
            _overlayHeight = 0;
            _overlayDirty = true;
            RequestRedraw();
        }

◆ ClearTextureCache()

void BioImager.SlideGLArea.ClearTextureCache ( )

Clear all cached textures.

Definition at line 618 of file SlideGLArea.cs.

        {
            if (!_glInitialized) return;
 
            MakeCurrent();
 
            foreach (var tex in _textureCache.Values)
                GL.DeleteTexture(tex);
 
            _textureCache.Clear();
        }

◆ HasTileTexture()

bool BioImager.SlideGLArea.HasTileTexture ( TileIndex index )

Check if a tile texture is already in the GPU cache.

Definition at line 580 of file SlideGLArea.cs.

        {
            return _textureCache.ContainsKey(index);
        }

◆ ReadPixels()

byte[] BioImager.SlideGLArea.ReadPixels ( )

Read pixels from the current framebuffer (for export/save operations). This is slow — only use for export, not display.

Definition at line 720 of file SlideGLArea.cs.

        {
            if (!_glInitialized) return null;
 
            MakeCurrent();
 
            int width = Width;
            int height = Height;
 
            byte[] pixels = new byte[width * height * 4];
            GL.ReadPixels(0, 0, width, height, PixelFormat.Rgba, PixelType.UnsignedByte, pixels);
 
            return pixels;
        }

◆ ReleaseLevelTextures()

void BioImager.SlideGLArea.ReleaseLevelTextures ( int level )

Release all textures for a specific pyramid level.

Definition at line 601 of file SlideGLArea.cs.

        {
            if (!_glInitialized) return;
 
            MakeCurrent();
 
            var toRemove = _textureCache.Where(kvp => kvp.Key.Level == level).ToList();
            foreach (var kvp in toRemove)
            {
                GL.DeleteTexture(kvp.Value);
                _textureCache.Remove(kvp.Key);
            }
        }

◆ ReleaseTileTexture()

void BioImager.SlideGLArea.ReleaseTileTexture ( TileIndex index )

Release a specific tile texture.

Definition at line 588 of file SlideGLArea.cs.

        {
            if (_textureCache.TryGetValue(index, out int tex))
            {
                MakeCurrent();
                GL.DeleteTexture(tex);
                _textureCache.Remove(index);
            }
        }

◆ RequestRedraw()

void BioImager.SlideGLArea.RequestRedraw ( )

Request a redraw of the GLArea.

Definition at line 648 of file SlideGLArea.cs.

        {
            NeedsRedraw = true;
            Invalidate();
        }

◆ SetOverlayBitmap()

void BioImager.SlideGLArea.SetOverlayBitmap ( System.Drawing.Bitmap bitmap )

Definition at line 654 of file SlideGLArea.cs.

        {
            if (bitmap == null)
            {
                _overlayPixels = null;
                _overlayWidth = 0;
                _overlayHeight = 0;
                _overlayDirty = true;
                RequestRedraw();
                return;
            }
 
            var rect = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height);
            var data = bitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
 
            try
            {
                int rowBytes = bitmap.Width * 4;
                byte[] buffer = new byte[rowBytes * bitmap.Height];
                int stride = data.Stride;
                int absStride = Math.Abs(stride);
 
                for (int y = 0; y < bitmap.Height; y++)
                {
                    IntPtr srcRow = stride >= 0
                        ? IntPtr.Add(data.Scan0, y * stride)
                        : IntPtr.Add(data.Scan0, (bitmap.Height - 1 - y) * absStride);
                    Marshal.Copy(srcRow, buffer, y * rowBytes, rowBytes);
                }
 
                _overlayPixels = buffer;
                _overlayWidth = bitmap.Width;
                _overlayHeight = bitmap.Height;
                _overlayDirty = true;
                RequestRedraw();
            }
            finally
            {
                bitmap.UnlockBits(data);
            }
        }

◆ SetTilesToRender()

void BioImager.SlideGLArea.SetTilesToRender ( IEnumerable< TileRenderInfo > tiles )

Prepare tiles for rendering. Call before RequestRedraw().

Definition at line 708 of file SlideGLArea.cs.

        {
            TilesToRender.Clear();
            TilesToRender.AddRange(tiles);
        }

◆ UploadTileTexture()

bool BioImager.SlideGLArea.UploadTileTexture	(	TileIndex	index,
		byte[]	pixelData,
		int	tileWidth,
		int	tileHeight )

Upload a tile texture to the GPU. Call from the main thread. Returns true if upload succeeded.

Definition at line 418 of file SlideGLArea.cs.

        {
            if (pixelData == null || pixelData.Length == 0)
                return false;
 
            // Guard: don't attempt GL operations if the context isn't ready
            if (!IsHandleCreated)
            {
                return false;
            }
 
            try
            {
                MakeCurrent();
            }
            catch
            {
                return false;
            }
 
            if (!_glInitialized)
                InitializeGL();
 
            if (!_glInitialized)
            {
                return false;
            }
 
            // Already cached — nothing to do
            if (_textureCache.ContainsKey(index))
                return true;
 
            // Evict old textures if cache is full
            if (_textureCache.Count >= MAX_CACHED_TEXTURES)
                EvictOldestTextures(MAX_CACHED_TEXTURES / 4);
 
            int expectedPixels = tileWidth * tileHeight;
            if (expectedPixels <= 0)
                return false;
 
            byte[] uploadData = pixelData;
            PixelFormat uploadFormat = PixelFormat.Bgra;
            int expectedBytes = expectedPixels * 4;
 
            if (pixelData.Length == expectedBytes)
            {
                // Already BGRA.
            }
            else if (pixelData.Length == expectedPixels * 3)
            {
                uploadData = Convert24BitRgbToBgra(pixelData, expectedPixels);
            }
            else if (pixelData.Length >= expectedPixels * 2)
            {
                uploadData = Convert16BitGrayToBgra(pixelData, expectedPixels);
            }
            else if (pixelData.Length >= expectedPixels)
            {
                uploadData = Convert8BitGrayToBgra(pixelData, expectedPixels);
            }
            else
            {
                return false;
            }
 
            // Create and upload texture
            int tex = GL.GenTexture();
            GL.BindTexture(TextureTarget.Texture2D, tex);
            GL.PixelStore(PixelStoreParameter.UnpackAlignment, 1);
 
            // OpenSlide-style tile buffers arrive as BGRA on little-endian systems.
            // Using the matching OpenGL pixel format avoids channel/alpha mismatches.
            GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba,
                          tileWidth, tileHeight, 0, uploadFormat, PixelType.UnsignedByte, uploadData);
 
            var glErr = GL.GetError();
            if (glErr != ErrorCode.NoError)
            {
                GL.DeleteTexture(tex);
                return false;
            }
 
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
 
            GL.BindTexture(TextureTarget.Texture2D, 0);
            _textureCache[index] = tex;
            return true;
        }

Property Documentation

◆ CachedTextureCount

int BioImager.SlideGLArea.CachedTextureCount

get

Definition at line 714 of file SlideGLArea.cs.

◆ IsGLReady

bool BioImager.SlideGLArea.IsGLReady

get

True after the GL context has been fully initialized and is ready for texture uploads and rendering.

Definition at line 67 of file SlideGLArea.cs.

◆ NeedsRedraw

bool BioImager.SlideGLArea.NeedsRedraw

get

Definition at line 49 of file SlideGLArea.cs.

49{ get; private set; }

◆ TilesToRender

List<TileRenderInfo> BioImager.SlideGLArea.TilesToRender = new()

get

Definition at line 48 of file SlideGLArea.cs.

48{ get; } = new();

Event Documentation

◆ GLReady

EventHandler BioImager.SlideGLArea.GLReady

Fires exactly once after the GL context has been successfully initialized. Subscribe to this from ImageView to trigger the first tile load at a point where GL texture uploads are guaranteed to work.

Definition at line 60 of file SlideGLArea.cs.

The documentation for this class was generated from the following file:

BioImager/Source/SlideGLArea.cs

Public Member Functions

Properties

Events