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	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.

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 114 of file SlideGLArea.cs.

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

Member Function Documentation

◆ ClearTextureCache()

void BioImager.SlideGLArea.ClearTextureCache ( )

Clear all cached textures.

Definition at line 465 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 427 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 514 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 448 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 435 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 495 of file SlideGLArea.cs.

        {
            NeedsRedraw = true;
            Invalidate();
        }

◆ SetTilesToRender()

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

Prepare tiles for rendering. Call before RequestRedraw().

Definition at line 504 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 351 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)
            {
                Console.WriteLine($"[SlideGLArea] UploadTileTexture skipped — control handle not created yet.");
                return false;
            }
 
            try
            {
                MakeCurrent();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[SlideGLArea] MakeCurrent failed in UploadTileTexture: {ex.Message}");
                return false;
            }
 
            if (!_glInitialized)
                InitializeGL();
 
            if (!_glInitialized)
            {
                Console.WriteLine($"[SlideGLArea] UploadTileTexture skipped — GL init failed.");
                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);
 
            // Validate pixel data size
            int expectedBytes = tileWidth * tileHeight * 4;
            if (pixelData.Length < expectedBytes)
            {
                Console.WriteLine($"[SlideGLArea] UploadTileTexture: pixel data too small. Expected {expectedBytes} bytes for {tileWidth}x{tileHeight}, got {pixelData.Length}.");
                return false;
            }
 
            // Create and upload texture
            int tex = GL.GenTexture();
            GL.BindTexture(TextureTarget.Texture2D, tex);
            GL.PixelStore(PixelStoreParameter.UnpackAlignment, 1);
 
            GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba,
                          tileWidth, tileHeight, 0, PixelFormat.Rgba, PixelType.UnsignedByte, pixelData);
 
            var glErr = GL.GetError();
            if (glErr != ErrorCode.NoError)
            {
                Console.WriteLine($"[SlideGLArea] GL error after TexImage2D ({tileWidth}x{tileHeight}): {glErr}");
                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

◆ 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 61 of file SlideGLArea.cs.

◆ NeedsRedraw

bool BioImager.SlideGLArea.NeedsRedraw

get

Definition at line 43 of file SlideGLArea.cs.

43{ get; private set; }

◆ TilesToRender

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

get

Definition at line 42 of file SlideGLArea.cs.

42{ 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 54 of file SlideGLArea.cs.

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

BioImager/Source/SlideGLArea.cs

Public Member Functions

Properties

Events