BioLib.Stitch Class Reference

Classes
struct	TileData

Public Member Functions
bool	HasTile (Extent ex)
bool	HasTile (TileInfo t)
void	AddTile (Tuple< TileInfo, byte[]> tile)
void	Initialize ()
byte[]	StitchImages (List< TileInfo > tiles, int pxwidth, int pxheight, double x, double y, double resolution)

Static Public Member Functions
static Bitmap	ConvertCudaDeviceVariableToBitmap (CudaDeviceVariable< byte > deviceVar, int width, int height, PixelFormat pixelFormat)

Public Attributes
List< Tuple< TileInfo, CudaDeviceVariable< byte > > >	gpuTiles = new List<Tuple<TileInfo, CudaDeviceVariable<byte>>>()

Detailed Description

Definition at line 18 of file Stitch.cs.

Constructor & Destructor Documentation

Stitch()

BioLib.Stitch.Stitch

(

)

Definition at line 38 of file Stitch.cs.

        {
            Initialize();
        }

Member Function Documentation

AddTile()

void BioLib.Stitch.AddTile

(

Tuple< TileInfo, byte[]>

tile

)

Definition at line 61 of file Stitch.cs.

        {
            if (HasTile(tile.Item1))
                return;
            byte[] tileData = null;
            if (tile.Item2.Length != 256 * 256 * 2)
                tileData = Bitmap.Convert16BitGrayscaleTo24BitRGB(tile.Item2);
            else
            if (tile.Item2.Length != 256 * 256 * 4)
                tileData = Bitmap.Convert32BitARGBTo24BitRGB(tile.Item2);
            else
            if (tile.Item2.Length != 256 * 256 * 6)
                tileData = Bitmap.Convert48BitTo24BitRGB(tile.Item2);
            else
            if (tile.Item2.Length != 256 * 256 * 3)
                tileData = tile.Item2;
            else
                throw new NotSupportedException("Current pixel format is not supported.");
            if (gpuTiles.Count > maxTiles)
            {
                var ti = gpuTiles.First();
                ti.Item2.Dispose();
                gpuTiles.Remove(gpuTiles.First());
            }
            try
            {
                CudaDeviceVariable<byte> devTile = new CudaDeviceVariable<byte>(tileData.Length);
                devTile.CopyToDevice(tileData);
                gpuTiles.Add(new Tuple<TileInfo, CudaDeviceVariable<byte>>(tile.Item1, devTile));
            }
            catch (Exception e)
            {
                Initialize();
                Console.WriteLine(e.Message);
            }
 
        }

ConvertCudaDeviceVariableToBitmap()

static Bitmap BioLib.Stitch.ConvertCudaDeviceVariableToBitmap ( CudaDeviceVariable< byte > deviceVar, int width, int height, PixelFormat pixelFormat )

static

Definition at line 118 of file Stitch.cs.

        {
            // Step 1: Allocate a byte array on the CPU (host)
            byte[] hostArray = new byte[deviceVar.Size];
 
            // Step 2: Copy the data from the GPU (device) to the CPU (host)
            deviceVar.CopyToHost(hostArray);
 
            // Step 3: Create a Bitmap object from the byte array
            Bitmap bitmap = new Bitmap(width, height, pixelFormat);
 
            // Step 4: Lock the bitmap's bits for writing
            BitmapData bmpData = bitmap.LockBits(new AForge.Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, pixelFormat);
 
            // Step 5: Copy the byte array to the bitmap's pixel buffer
            System.Runtime.InteropServices.Marshal.Copy(hostArray, 0, bmpData.Scan0, hostArray.Length);
 
            // Step 6: Unlock the bitmap's bits
            bitmap.UnlockBits(bmpData);
 
            // Return the Bitmap object
            return bitmap;
        }

HasTile() [1/2]

bool BioLib.Stitch.HasTile

(

Extent

ex

)

Definition at line 42 of file Stitch.cs.

        {
            foreach (var item in gpuTiles)
            {
                if (item.Item1.Extent == ex)
                    return true;
            }
            return false;
        }

HasTile() [2/2]

bool BioLib.Stitch.HasTile

(

TileInfo

t

)

Definition at line 51 of file Stitch.cs.

        {
            foreach (var item in gpuTiles)
            {
                if (item.Item1.Index == t.Index)
                    return true;
            }
            return false;
        }

Initialize()

void BioLib.Stitch.Initialize

(

)

Definition at line 98 of file Stitch.cs.

        {
            
            try
            {
                context = new CudaContext();
                // Load the CUDA kernel
                kernel = context.LoadKernelPTX(System.IO.Path.GetDirectoryName(Environment.ProcessPath) + "/tile_copy.ptx", "copyTileToCanvas");
                initialized = true;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                OpenSlideBase.useGPU = false;
                //SlideSourceBase.useGPU = false;
                SlideBase.UseVips = true;
                OpenSlideBase.UseVips = true;
            }
 
        }

StitchImages()

byte[] BioLib.Stitch.StitchImages	(	List< TileInfo >	tiles,
		int	pxwidth,
		int	pxheight,
		double	x,
		double	y,
		double	resolution )

Definition at line 141 of file Stitch.cs.

        {
            try
            {
                // Convert world coordinates of tile extents to pixel space based on resolution
                foreach (var item in tiles)
                {
                    item.Extent = item.Extent.WorldToPixelInvertedY(resolution);
                }
 
                if (!initialized)
                {
                    Initialize();
                }
 
                // Calculate the bounding box (min/max extents) of the stitched image
                double maxX = tiles.Max(t => t.Extent.MaxX);
                double maxY = tiles.Max(t => t.Extent.MaxY);
                double minX = tiles.Min(t => t.Extent.MinX);
                double minY = tiles.Min(t => t.Extent.MinY);
 
                // Calculate canvas size in pixels
                int canvasWidth = (int)(maxX - minX);
                int canvasHeight = (int)(maxY - minY);
 
                // Allocate memory for the output stitched image on the GPU
                using (CudaDeviceVariable<byte> devCanvas = new CudaDeviceVariable<byte>(canvasWidth * canvasHeight * 3)) // 3 channels for RGB
                {
                    // Set block and grid sizes for kernel launch
                    dim3 blockSize = new dim3(16, 16, 1);
                    dim3 gridSize = new dim3((uint)((canvasWidth + blockSize.x - 1) / blockSize.x), (uint)((canvasHeight + blockSize.y - 1) / blockSize.y), 1);
 
                    // Iterate through each tile and copy it to the GPU canvas
                    foreach (var tile in tiles)
                    {
                        Extent extent = tile.Extent;
                        // Find the corresponding GPU tile (already loaded into GPU memory)
                        CudaDeviceVariable<byte> devTile = null;
                        foreach (var t in gpuTiles)
                        {
                            if (t.Item1.Index == tile.Index)
                            {
                                devTile = t.Item2;
                                break;
                            }
                        }
                        if (devTile != null)
                        {
                            // Calculate the start position on the canvas and the dimensions of the tile
                            int startX = (int)Math.Ceiling(extent.MinX - minX);
                            int startY = (int)Math.Ceiling(extent.MinY - minY);
                           
                            int tileWidth = (int)Math.Ceiling(extent.MaxX - extent.MinX);
                            int tileHeight = (int)Math.Ceiling(extent.MaxY - extent.MinY);
 
                            // canvasTileWidth and canvasTileHeight handle the scaling of the tile to the canvas
                            int canvasTileWidth = tileWidth;
                            int canvasTileHeight = tileHeight;
 
                            // Run the CUDA kernel to copy the tile to the canvas
                            kernel.BlockDimensions = blockSize;
                            kernel.GridDimensions = gridSize;
 
                            // Run the kernel, including scaling factors
                            kernel.Run(devCanvas.DevicePointer, canvasWidth, canvasHeight, devTile.DevicePointer, 256, 256, startX, startY, canvasTileWidth, canvasTileHeight);
                        }
                    }
 
                    // Download the stitched image from the GPU to the host (CPU)
                    byte[] stitchedImageData = new byte[canvasWidth * canvasHeight * 3]; // Assuming 3 channels (RGB)
                    devCanvas.CopyToHost(stitchedImageData);
 
                    // Clip (x, y) to the canvas bounds
                    int clippedX = Math.Max(0, (int)(x - minX));
                    int clippedY = Math.Max(0, (int)(y - minY));
 
                    // Make sure the viewport fits within the canvas bounds
                    int viewportWidth = pxwidth;
                    int viewportHeight = pxheight;
 
                    // Extract the viewport region from the stitched image
                    byte[] viewportImageData = new byte[viewportWidth * viewportHeight * 3]; // Assuming 3 channels
                    System.Threading.Tasks.Parallel.For(0, viewportHeight, row =>
                    {
                        try
                        {
                            int srcOffset = (clippedY + row) * canvasWidth * 3 + clippedX * 3;
                            int dstOffset = row * viewportWidth * 3;
                            Array.Copy(stitchedImageData, srcOffset, viewportImageData, dstOffset, viewportWidth * 3);
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("An error occurred while extracting the viewport: " + ex.Message);
                        }
                    });
 
                    return viewportImageData; // Return the extracted viewport
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("An error occurred: " + ex.Message);
                Initialize(); // Reinitialize in case of errors
                return null;
            }
        }

Member Data Documentation

gpuTiles

List<Tuple<TileInfo, CudaDeviceVariable<byte> > > BioLib.Stitch.gpuTiles = new List<Tuple<TileInfo, CudaDeviceVariable<byte>>>()

Definition at line 35 of file Stitch.cs.

---

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

• BioLib/Source/Stitch.cs