CudaOpening2d

Performs a two-dimensional opening using a structuring element matching with a square or a cross. The calculations are performed on the GPU.

Access to parameter description

This command is experimental, his signature may be modified between now and his final version.

For an introduction:

section Mathematical Morphology
section Introduction To Opening

This algorithm successively runs an Erosion2d and a Dilation2d with the same kernel.

See also

Function Syntax

This function returns outputImage.

// Function prototype
std::shared_ptr< iolink::ImageView >
cudaOpening2d( std::shared_ptr< iolink::ImageView > inputImage,
               uint32_t kernelRadius,
               CudaOpening2d::Neighborhood neighborhood,
               CudaOpening2d::TilingMode tilingMode,
               iolink::Vector2u32 tileSize,
               CudaContext::Ptr cudaContext,
               std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

// Function prototype.
cuda_opening_2d(input_image: idt.ImageType,
                kernel_radius: int = 3,
                neighborhood: CudaOpening2d.Neighborhood = CudaOpening2d.Neighborhood.CONNECTIVITY_8,
                tiling_mode: CudaOpening2d.TilingMode = CudaOpening2d.TilingMode.NONE,
                tile_size: Iterable[int] = [1024, 1024],
                cuda_context: Union[CudaContext, None] = None,
                output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

// Function prototype.
public static IOLink.ImageView
CudaOpening2d( IOLink.ImageView inputImage,
               UInt32 kernelRadius = 3,
               CudaOpening2d.Neighborhood neighborhood = ImageDev.CudaOpening2d.Neighborhood.CONNECTIVITY_8,
               CudaOpening2d.TilingMode tilingMode = ImageDev.CudaOpening2d.TilingMode.NONE,
               uint[] tileSize = null,
               Data.CudaContext cudaContext = null,
               IOLink.ImageView outputImage = null );

Class Syntax

// Command constructor.
CudaOpening2d();

/// Gets the inputImage parameter.
/// The input image. The image type can be integer or float.
std::shared_ptr< iolink::ImageView > inputImage() const;
/// Sets the inputImage parameter.
/// The input image. The image type can be integer or float.
void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

/// Gets the kernelRadius parameter.
/// The number of iterations (the half size of the structuring element, in pixels). A square structuring element always has an odd side length (3x3, 5x5, etc.) which is defined by twice the kernel radius + 1.
uint32_t kernelRadius() const;
/// Sets the kernelRadius parameter.
/// The number of iterations (the half size of the structuring element, in pixels). A square structuring element always has an odd side length (3x3, 5x5, etc.) which is defined by twice the kernel radius + 1.
void setKernelRadius( const uint32_t& kernelRadius );

/// Gets the neighborhood parameter.
/// The 2D neighborhood configuration.
CudaOpening2d::Neighborhood neighborhood() const;
/// Sets the neighborhood parameter.
/// The 2D neighborhood configuration.
void setNeighborhood( const CudaOpening2d::Neighborhood& neighborhood );

/// Gets the tilingMode parameter.
/// The way to manage the GPU memory.
CudaOpening2d::TilingMode tilingMode() const;
/// Sets the tilingMode parameter.
/// The way to manage the GPU memory.
void setTilingMode( const CudaOpening2d::TilingMode& tilingMode );

/// Gets the tileSize parameter.
/// The tile width and height in pixels. This parameter is used only in USER_DEFINED tiling mode.
iolink::Vector2u32 tileSize() const;
/// Sets the tileSize parameter.
/// The tile width and height in pixels. This parameter is used only in USER_DEFINED tiling mode.
void setTileSize( const iolink::Vector2u32& tileSize );

/// Gets the cudaContext parameter.
/// CUDA context information.
CudaContext::Ptr cudaContext() const;
/// Sets the cudaContext parameter.
/// CUDA context information.
void setCudaContext( const CudaContext::Ptr& cudaContext );

/// Gets the outputImage parameter.
/// The output image. Its dimensions and type are forced to the same values as the input image.
std::shared_ptr< iolink::ImageView > outputImage() const;
/// Sets the outputImage parameter.
/// The output image. Its dimensions and type are forced to the same values as the input image.
void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );


// Method to launch the command.
void execute();

# Property of the inputImage parameter.
CudaOpening2d.input_image
# Property of the kernelRadius parameter.
CudaOpening2d.kernel_radius
# Property of the neighborhood parameter.
CudaOpening2d.neighborhood
# Property of the tilingMode parameter.
CudaOpening2d.tiling_mode
# Property of the tileSize parameter.
CudaOpening2d.tile_size
# Property of the cudaContext parameter.
CudaOpening2d.cuda_context
# Property of the outputImage parameter.
CudaOpening2d.output_image

// Method to launch the command.
execute()

// Command constructor.
CudaOpening2d()

// Property of the inputImage parameter.
CudaOpening2d.inputImage
// Property of the kernelRadius parameter.
CudaOpening2d.kernelRadius
// Property of the neighborhood parameter.
CudaOpening2d.neighborhood
// Property of the tilingMode parameter.
CudaOpening2d.tilingMode
// Property of the tileSize parameter.
CudaOpening2d.tileSize
// Property of the cudaContext parameter.
CudaOpening2d.cudaContext
// Property of the outputImage parameter.
CudaOpening2d.outputImage

// Method to launch the command.
Execute()

Parameters

Parameter Name

Description

Type

Supported Values

Default Value

inputImage

The input image. The image type can be integer or float.

Image

Binary, Label, Grayscale or Multispectral

nullptr

kernelRadius

The number of iterations (the half size of the structuring element, in pixels). A square structuring element always has an odd side length (3x3, 5x5, etc.) which is defined by twice the kernel radius + 1.

UInt32

>=1

neighborhood

The 2D neighborhood configuration.

CONNECTIVITY_4	The structuring element is a cross.
CONNECTIVITY_8	The structuring element is a square.

Enumeration

CONNECTIVITY_8

tilingMode

The way to manage the GPU memory.

NONE	The entire input image is transferred to the GPU memory. If the total input, intermediate and output data size exceed the GPU memory, the computation will fail.
USER_DEFINED	The input image is processed by tiles of a predefined size.

Enumeration

NONE

tileSize

The tile width and height in pixels. This parameter is used only in USER_DEFINED tiling mode.

Vector2u32

>=5

{1024, 1024}

cudaContext

CUDA context information.

CudaContext

nullptr

outputImage

The output image. Its dimensions and type are forced to the same values as the input image.

Image

nullptr

Object Examples

auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

CudaOpening2d cudaOpening2dAlgo;
cudaOpening2dAlgo.setInputImage( polystyrene );
cudaOpening2dAlgo.setKernelRadius( 3 );
cudaOpening2dAlgo.setNeighborhood( CudaOpening2d::Neighborhood::CONNECTIVITY_8 );
cudaOpening2dAlgo.setTilingMode( CudaOpening2d::TilingMode::NONE );
cudaOpening2dAlgo.setTileSize( {264, 264} );
cudaOpening2dAlgo.setCudaContext( nullptr );
cudaOpening2dAlgo.setOutputImage( iolink::ImageViewFactory::allocate( iolink::VectorXu64( { 1, 1 } ), iolink::DataTypeId::UINT8 ) );
cudaOpening2dAlgo.execute();

std::cout << "outputImage:" << cudaOpening2dAlgo.outputImage()->toString();

polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

cuda_opening_2d_algo = imagedev.CudaOpening2d()
cuda_opening_2d_algo.input_image = polystyrene
cuda_opening_2d_algo.kernel_radius = 3
cuda_opening_2d_algo.neighborhood = imagedev.CudaOpening2d.CONNECTIVITY_8
cuda_opening_2d_algo.tiling_mode = imagedev.CudaOpening2d.NONE
cuda_opening_2d_algo.tile_size = [264, 264]
cuda_opening_2d_algo.cuda_context = None
cuda_opening_2d_algo.execute()

print("output_image:", str(cuda_opening_2d_algo.output_image))

ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

CudaOpening2d cudaOpening2dAlgo = new CudaOpening2d
{
    inputImage = polystyrene,
    kernelRadius = 3,
    neighborhood = CudaOpening2d.Neighborhood.CONNECTIVITY_8,
    tilingMode = CudaOpening2d.TilingMode.NONE,
    tileSize = new uint[]{264, 264},
    cudaContext = null
};
cudaOpening2dAlgo.Execute();

Console.WriteLine( "outputImage:" + cudaOpening2dAlgo.outputImage.ToString() );

Function Examples

auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

auto result = cudaOpening2d( polystyrene, 3, CudaOpening2d::Neighborhood::CONNECTIVITY_8, CudaOpening2d::TilingMode::NONE, {264, 264}, nullptr , iolink::ImageViewFactory::allocate( iolink::VectorXu64( { 1, 1 } ), iolink::DataTypeId::UINT8 ));

std::cout << "outputImage:" << result->toString();

polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

result = imagedev.cuda_opening_2d(polystyrene, 3, imagedev.CudaOpening2d.CONNECTIVITY_8, imagedev.CudaOpening2d.NONE, [264, 264], None)

print("output_image:", str(result))

ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

IOLink.ImageView result = Processing.CudaOpening2d( polystyrene, 3, CudaOpening2d.Neighborhood.CONNECTIVITY_8, CudaOpening2d.TilingMode.NONE, new uint[]{264, 264}, null );

Console.WriteLine( "outputImage:" + result.ToString() );

CudaOpening2d

- Function Syntax

+ Class Syntax

Parameters

Object Examples

Function Examples

Function Syntax

Class Syntax