ImageDev

RadialGradientContour2d

Performs a two-dimensional gradient projection with a directional vector defined by a set of contour points of a binary image.

Access to parameter description

For an introduction: The RadialGradientContour2d algorithm performs a gradient projection by computing the directional vector from the contour of objects. For a pixel $P$ in the image, the center $C$ taken into account is the closest pixel contour of the closest object.

Notices: See also

Function Syntax

This function returns a RadialGradientContour2dOutput structure containing outputNormalImage and outputTangentImage. 
// Output structure of the radialGradientContour2d function.
struct RadialGradientContour2dOutput
{
    /// The normal gradient output image.
    std::shared_ptr< iolink::ImageView > outputNormalImage;
    /// The tangent gradient output image.
    std::shared_ptr< iolink::ImageView > outputTangentImage;
};

// Function prototype
RadialGradientContour2dOutput
radialGradientContour2d( std::shared_ptr< iolink::ImageView > inputImageX,
                         std::shared_ptr< iolink::ImageView > inputImageY,
                         std::shared_ptr< iolink::ImageView > inputMarkerImage,
                         RadialGradientContour2d::ProjectionMode projectionMode,
                         std::shared_ptr< iolink::ImageView > outputNormalImage = nullptr,
                         std::shared_ptr< iolink::ImageView > outputTangentImage = nullptr );
This function returns a tuple containing output_normal_image and output_tangent_image. 
// Function prototype.
radial_gradient_contour_2d(input_image_x: idt.ImageType,
                           input_image_y: idt.ImageType,
                           input_marker_image: idt.ImageType,
                           projection_mode: RadialGradientContour2d.ProjectionMode = RadialGradientContour2d.ProjectionMode.GRADIENT_NORMAL,
                           output_normal_image: idt.ImageType = None,
                           output_tangent_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]
This function returns a RadialGradientContour2dOutput structure containing outputNormalImage and outputTangentImage. 
/// Output structure of the RadialGradientContour2d function.
public struct RadialGradientContour2dOutput
{
    /// The normal gradient output image.
    public IOLink.ImageView outputNormalImage;
    /// The tangent gradient output image.
    public IOLink.ImageView outputTangentImage;
};

// Function prototype.
public static RadialGradientContour2dOutput
RadialGradientContour2d( IOLink.ImageView inputImageX,
                         IOLink.ImageView inputImageY,
                         IOLink.ImageView inputMarkerImage,
                         RadialGradientContour2d.ProjectionMode projectionMode = ImageDev.RadialGradientContour2d.ProjectionMode.GRADIENT_NORMAL,
                         IOLink.ImageView outputNormalImage = null,
                         IOLink.ImageView outputTangentImage = null );

Class Syntax

Parameters

Parameter Name Description Type Supported Values Default Value
input
inputImageX
The X-gradient input image. Image Grayscale nullptr
input
inputImageY
The Y-gradient input image. Image Grayscale nullptr
input
inputMarkerImage
The marker input image from which the binary contours are considered as centers. Image Binary nullptr
input
projectionMode
The output images to be computed.
GRADIENT_NORMAL The engine computes the normal gradient. Only the outputNormalImage output is set using this mode.
GRADIENT_NORMAL_TANGENTIAL The engine computes the normal and tangential gradients. Both outputNormalImage and outputTangentImage outputs are set using this mode.
Enumeration GRADIENT_NORMAL
output
outputNormalImage
The normal gradient output image. Image nullptr
output
outputTangentImage
The tangent gradient output image. Image nullptr
Parameter Name Description Type Supported Values Default Value
input
input_image_x
The X-gradient input image. image Grayscale None
input
input_image_y
The Y-gradient input image. image Grayscale None
input
input_marker_image
The marker input image from which the binary contours are considered as centers. image Binary None
input
projection_mode
The output images to be computed.
GRADIENT_NORMAL The engine computes the normal gradient. Only the outputNormalImage output is set using this mode.
GRADIENT_NORMAL_TANGENTIAL The engine computes the normal and tangential gradients. Both outputNormalImage and outputTangentImage outputs are set using this mode.
enumeration GRADIENT_NORMAL
output
output_normal_image
The normal gradient output image. image None
output
output_tangent_image
The tangent gradient output image. image None
Parameter Name Description Type Supported Values Default Value
input
inputImageX
The X-gradient input image. Image Grayscale null
input
inputImageY
The Y-gradient input image. Image Grayscale null
input
inputMarkerImage
The marker input image from which the binary contours are considered as centers. Image Binary null
input
projectionMode
The output images to be computed.
GRADIENT_NORMAL The engine computes the normal gradient. Only the outputNormalImage output is set using this mode.
GRADIENT_NORMAL_TANGENTIAL The engine computes the normal and tangential gradients. Both outputNormalImage and outputTangentImage outputs are set using this mode.
Enumeration GRADIENT_NORMAL
output
outputNormalImage
The normal gradient output image. Image null
output
outputTangentImage
The tangent gradient output image. Image null

Object Examples

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

RadialGradientContour2d radialGradientContour2dAlgo;
radialGradientContour2dAlgo.setInputImageX( polystyrene );
radialGradientContour2dAlgo.setInputImageY( polystyrene );
radialGradientContour2dAlgo.setInputMarkerImage( polystyrene_sep );
radialGradientContour2dAlgo.setProjectionMode( RadialGradientContour2d::ProjectionMode::GRADIENT_NORMAL );
radialGradientContour2dAlgo.execute();

std::cout << "outputNormalImage:" << radialGradientContour2dAlgo.outputNormalImage()->toString();
std::cout << "outputTangentImage:" << radialGradientContour2dAlgo.outputTangentImage()->toString();

polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
polystyrene_sep = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_sep.vip"))

radial_gradient_contour_2d_algo = imagedev.RadialGradientContour2d()
radial_gradient_contour_2d_algo.input_image_x = polystyrene
radial_gradient_contour_2d_algo.input_image_y = polystyrene
radial_gradient_contour_2d_algo.input_marker_image = polystyrene_sep
radial_gradient_contour_2d_algo.projection_mode = imagedev.RadialGradientContour2d.GRADIENT_NORMAL
radial_gradient_contour_2d_algo.execute()

print("output_normal_image:", str(radial_gradient_contour_2d_algo.output_normal_image))
print("output_tangent_image:", str(radial_gradient_contour_2d_algo.output_tangent_image))

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

RadialGradientContour2d radialGradientContour2dAlgo = new RadialGradientContour2d
{
    inputImageX = polystyrene,
    inputImageY = polystyrene,
    inputMarkerImage = polystyrene_sep,
    projectionMode = RadialGradientContour2d.ProjectionMode.GRADIENT_NORMAL
};
radialGradientContour2dAlgo.Execute();

Console.WriteLine( "outputNormalImage:" + radialGradientContour2dAlgo.outputNormalImage.ToString() );
Console.WriteLine( "outputTangentImage:" + radialGradientContour2dAlgo.outputTangentImage.ToString() );

Function Examples

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

auto result = radialGradientContour2d( polystyrene, polystyrene, polystyrene_sep, RadialGradientContour2d::ProjectionMode::GRADIENT_NORMAL );

std::cout << "outputNormalImage:" << result.outputNormalImage->toString();
std::cout << "outputTangentImage:" << result.outputTangentImage->toString();

polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
polystyrene_sep = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_sep.vip"))

result_output_normal_image, result_output_tangent_image = imagedev.radial_gradient_contour_2d(polystyrene, polystyrene, polystyrene_sep, imagedev.RadialGradientContour2d.GRADIENT_NORMAL)

print("output_normal_image:", str(result_output_normal_image))
print("output_tangent_image:", str(result_output_tangent_image))

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

Processing.RadialGradientContour2dOutput result = Processing.RadialGradientContour2d( polystyrene, polystyrene, polystyrene_sep, RadialGradientContour2d.ProjectionMode.GRADIENT_NORMAL );

Console.WriteLine( "outputNormalImage:" + result.outputNormalImage.ToString() );
Console.WriteLine( "outputTangentImage:" + result.outputTangentImage.ToString() );