CartesianToPolar2d

Transforms a pair of real and imaginary part two-dimensional images into a pair of module and phase images.

Access to parameter description

For an introduction: see section Frequency Domain.

This algorithm computes the cartesian-to-polar transformation or real/imaginary to the module/phase transformation.

If $I_1$ is the real part or $X$ coordinate image and $I_2$ the imaginary part or $Y$ coordinate image, then:

Module image $O_1$ is defined as: $O_1(n,m)=\sqrt{I_1^2(n,m)+I_2^2(n,m)}$
Phase image $O_2$ is defined as: $O_2(n,m)=\tan^{-1}\left(\frac{I_2(n,m)}{I_1(n,m)}\right)$

See also

Function Syntax

This function returns a CartesianToPolar2dOutput structure containing outputModulusImage and outputPhaseImage.

// Output structure of the cartesianToPolar2d function.
struct CartesianToPolar2dOutput
{
    /// The output modulus image. Its dimensions and type are forced to the same values as the input.
    std::shared_ptr< iolink::ImageView > outputModulusImage;
    /// The output phase image. Its dimensions and type are forced to the same values as the input.
    std::shared_ptr< iolink::ImageView > outputPhaseImage;
};

// Function prototype
CartesianToPolar2dOutput
cartesianToPolar2d( std::shared_ptr< iolink::ImageView > inputRealImage,
                    std::shared_ptr< iolink::ImageView > inputImaginaryImage,
                    std::shared_ptr< iolink::ImageView > outputModulusImage = nullptr,
                    std::shared_ptr< iolink::ImageView > outputPhaseImage = nullptr );

This function returns a tuple containing output_modulus_image and output_phase_image.

// Function prototype.
cartesian_to_polar_2d(input_real_image: idt.ImageType,
                      input_imaginary_image: idt.ImageType,
                      output_modulus_image: idt.ImageType = None,
                      output_phase_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]

This function returns a CartesianToPolar2dOutput structure containing outputModulusImage and outputPhaseImage.

/// Output structure of the CartesianToPolar2d function.
public struct CartesianToPolar2dOutput
{
    /// 
    /// The output modulus image. Its dimensions and type are forced to the same values as the input.
    /// 
    public IOLink.ImageView outputModulusImage;
    /// 
    /// The output phase image. Its dimensions and type are forced to the same values as the input.
    /// 
    public IOLink.ImageView outputPhaseImage;
};

// Function prototype.
public static CartesianToPolar2dOutput
CartesianToPolar2d( IOLink.ImageView inputRealImage,
                    IOLink.ImageView inputImaginaryImage,
                    IOLink.ImageView outputModulusImage = null,
                    IOLink.ImageView outputPhaseImage = null );

Class Syntax

// Command constructor.
CartesianToPolar2d();

/// Gets the inputRealImage parameter.
/// The real part input image. It must be a floating point image.
std::shared_ptr< iolink::ImageView > inputRealImage() const;
/// Sets the inputRealImage parameter.
/// The real part input image. It must be a floating point image.
void setInputRealImage( std::shared_ptr< iolink::ImageView > inputRealImage );

/// Gets the inputImaginaryImage parameter.
/// The imaginary part input image. This image must have same dimensions and data type as the real input image.
std::shared_ptr< iolink::ImageView > inputImaginaryImage() const;
/// Sets the inputImaginaryImage parameter.
/// The imaginary part input image. This image must have same dimensions and data type as the real input image.
void setInputImaginaryImage( std::shared_ptr< iolink::ImageView > inputImaginaryImage );

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

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


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

# Property of the inputRealImage parameter.
CartesianToPolar2d.input_real_image
# Property of the inputImaginaryImage parameter.
CartesianToPolar2d.input_imaginary_image
# Property of the outputModulusImage parameter.
CartesianToPolar2d.output_modulus_image
# Property of the outputPhaseImage parameter.
CartesianToPolar2d.output_phase_image

// Method to launch the command.
execute()

// Command constructor.
CartesianToPolar2d()

// Property of the inputRealImage parameter.
CartesianToPolar2d.inputRealImage
// Property of the inputImaginaryImage parameter.
CartesianToPolar2d.inputImaginaryImage
// Property of the outputModulusImage parameter.
CartesianToPolar2d.outputModulusImage
// Property of the outputPhaseImage parameter.
CartesianToPolar2d.outputPhaseImage

// Method to launch the command.
Execute()

Parameters

	Description	Type	Supported Values	Default Value
inputRealImage	The real part input image. It must be a floating point image.	Image	Grayscale or Multispectral	nullptr
inputImaginaryImage	The imaginary part input image. This image must have same dimensions and data type as the real input image.	Image	Grayscale or Multispectral	nullptr
outputModulusImage	The output modulus image. Its dimensions and type are forced to the same values as the input.	Image		nullptr
outputPhaseImage	The output phase image. Its dimensions and type are forced to the same values as the input.	Image		nullptr

	Description	Type	Supported Values	Default Value
input_real_image	The real part input image. It must be a floating point image.	image	Grayscale or Multispectral	None
input_imaginary_image	The imaginary part input image. This image must have same dimensions and data type as the real input image.	image	Grayscale or Multispectral	None
output_modulus_image	The output modulus image. Its dimensions and type are forced to the same values as the input.	image		None
output_phase_image	The output phase image. Its dimensions and type are forced to the same values as the input.	image		None

	Description	Type	Supported Values	Default Value
inputRealImage	The real part input image. It must be a floating point image.	Image	Grayscale or Multispectral	null
inputImaginaryImage	The imaginary part input image. This image must have same dimensions and data type as the real input image.	Image	Grayscale or Multispectral	null
outputModulusImage	The output modulus image. Its dimensions and type are forced to the same values as the input.	Image		null
outputPhaseImage	The output phase image. Its dimensions and type are forced to the same values as the input.	Image		null

Object Examples

auto polystyrene_float = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_float.vip" );

CartesianToPolar2d cartesianToPolar2dAlgo;
cartesianToPolar2dAlgo.setInputRealImage( polystyrene_float );
cartesianToPolar2dAlgo.setInputImaginaryImage( polystyrene_float );
cartesianToPolar2dAlgo.execute();

std::cout << "outputModulusImage:" << cartesianToPolar2dAlgo.outputModulusImage()->toString();
std::cout << "outputPhaseImage:" << cartesianToPolar2dAlgo.outputPhaseImage()->toString();

polystyrene_float = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_float.vip"))

cartesian_to_polar_2d_algo = imagedev.CartesianToPolar2d()
cartesian_to_polar_2d_algo.input_real_image = polystyrene_float
cartesian_to_polar_2d_algo.input_imaginary_image = polystyrene_float
cartesian_to_polar_2d_algo.execute()

print("output_modulus_image:", str(cartesian_to_polar_2d_algo.output_modulus_image))
print("output_phase_image:", str(cartesian_to_polar_2d_algo.output_phase_image))

ImageView polystyrene_float = Data.ReadVipImage( @"Data/images/polystyrene_float.vip" );

CartesianToPolar2d cartesianToPolar2dAlgo = new CartesianToPolar2d
{
    inputRealImage = polystyrene_float,
    inputImaginaryImage = polystyrene_float
};
cartesianToPolar2dAlgo.Execute();

Console.WriteLine( "outputModulusImage:" + cartesianToPolar2dAlgo.outputModulusImage.ToString() );
Console.WriteLine( "outputPhaseImage:" + cartesianToPolar2dAlgo.outputPhaseImage.ToString() );

Function Examples

auto polystyrene_float = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_float.vip" );

auto result = cartesianToPolar2d( polystyrene_float, polystyrene_float );

std::cout << "outputModulusImage:" << result.outputModulusImage->toString();
std::cout << "outputPhaseImage:" << result.outputPhaseImage->toString();

polystyrene_float = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_float.vip"))

result_output_modulus_image, result_output_phase_image = imagedev.cartesian_to_polar_2d(polystyrene_float, polystyrene_float)

print("output_modulus_image:", str(result_output_modulus_image))
print("output_phase_image:", str(result_output_phase_image))

ImageView polystyrene_float = Data.ReadVipImage( @"Data/images/polystyrene_float.vip" );

Processing.CartesianToPolar2dOutput result = Processing.CartesianToPolar2d( polystyrene_float, polystyrene_float );

Console.WriteLine( "outputModulusImage:" + result.outputModulusImage.ToString() );
Console.WriteLine( "outputPhaseImage:" + result.outputPhaseImage.ToString() );