ImageDev

RadialGradientCentered2d

Performs a two-dimensional gradient projection with a directional vector defined by a center point.

Access to parameter description

For an introduction: The RadialGradientCentered2d algorithm performs a gradient projection by computing the directional vector from a single given center. For all pixels $P$ in the image, the projection is applied from the same user-defined center $C$.

Notices:
See also

Function Syntax

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

// Function prototype
RadialGradientCentered2dOutput radialGradientCentered2d( std::shared_ptr< iolink::ImageView > inputImageX, std::shared_ptr< iolink::ImageView > inputImageY, iolink::Vector2i32 projectionCenter, RadialGradientCentered2d::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_centered_2d(input_image_x: idt.ImageType,
                            input_image_y: idt.ImageType,
                            projection_center: Iterable[int] = [1, 1],
                            projection_mode: RadialGradientCentered2d.ProjectionMode = RadialGradientCentered2d.ProjectionMode.GRADIENT_NORMAL,
                            output_normal_image: idt.ImageType = None,
                            output_tangent_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]
This function returns a RadialGradientCentered2dOutput structure containing outputNormalImage and outputTangentImage.
/// Output structure of the RadialGradientCentered2d function.
public struct RadialGradientCentered2dOutput
{
    /// The normal gradient output image.
    public IOLink.ImageView outputNormalImage;
    /// The tangent gradient output image.
    public IOLink.ImageView outputTangentImage;
};

// Function prototype.
public static RadialGradientCentered2dOutput
RadialGradientCentered2d( IOLink.ImageView inputImageX,
                          IOLink.ImageView inputImageY,
                          int[] projectionCenter = null,
                          RadialGradientCentered2d.ProjectionMode projectionMode = ImageDev.RadialGradientCentered2d.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 or Multispectral nullptr
input
inputImageY
The Y-gradient input image. Image Grayscale or Multispectral nullptr
input
projectionCenter
The center of projection coordinates. Vector2i32 >=0 {1, 1}
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 or Multispectral None
input
input_image_y
The Y-gradient input image. image Grayscale or Multispectral None
input
projection_center
The center of projection coordinates. vector2i32 >=0 [1, 1]
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 or Multispectral null
input
inputImageY
The Y-gradient input image. Image Grayscale or Multispectral null
input
projectionCenter
The center of projection coordinates. Vector2i32 >=0 {1, 1}
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" );

RadialGradientCentered2d radialGradientCentered2dAlgo;
radialGradientCentered2dAlgo.setInputImageX( polystyrene );
radialGradientCentered2dAlgo.setInputImageY( polystyrene );
radialGradientCentered2dAlgo.setProjectionCenter( {1, 1} );
radialGradientCentered2dAlgo.setProjectionMode( RadialGradientCentered2d::ProjectionMode::GRADIENT_NORMAL );
radialGradientCentered2dAlgo.execute();

std::cout << "outputNormalImage:" << radialGradientCentered2dAlgo.outputNormalImage()->toString();
std::cout << "outputTangentImage:" << radialGradientCentered2dAlgo.outputTangentImage()->toString();
polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

radial_gradient_centered_2d_algo = imagedev.RadialGradientCentered2d()
radial_gradient_centered_2d_algo.input_image_x = polystyrene
radial_gradient_centered_2d_algo.input_image_y = polystyrene
radial_gradient_centered_2d_algo.projection_center = [1, 1]
radial_gradient_centered_2d_algo.projection_mode = imagedev.RadialGradientCentered2d.GRADIENT_NORMAL
radial_gradient_centered_2d_algo.execute()

print("output_normal_image:", str(radial_gradient_centered_2d_algo.output_normal_image))
print("output_tangent_image:", str(radial_gradient_centered_2d_algo.output_tangent_image))
ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

RadialGradientCentered2d radialGradientCentered2dAlgo = new RadialGradientCentered2d
{
    inputImageX = polystyrene,
    inputImageY = polystyrene,
    projectionCenter = new int[]{1, 1},
    projectionMode = RadialGradientCentered2d.ProjectionMode.GRADIENT_NORMAL
};
radialGradientCentered2dAlgo.Execute();

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

Function Examples

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

auto result = radialGradientCentered2d( polystyrene, polystyrene, {1, 1}, RadialGradientCentered2d::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"))

result_output_normal_image, result_output_tangent_image = imagedev.radial_gradient_centered_2d(polystyrene, polystyrene, [1, 1], imagedev.RadialGradientCentered2d.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" );

Processing.RadialGradientCentered2dOutput result = Processing.RadialGradientCentered2d( polystyrene, polystyrene, new int[]{1, 1}, RadialGradientCentered2d.ProjectionMode.GRADIENT_NORMAL );

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