PolarToCartesian2d

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

Access to parameter description

For an introduction: see section Frequency Domain.

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

If $I_1$ is the module image and $I_2$ the phase image, then:

Real part or $X$ coordinate $O_1$ is defined as: $O_1(n,m)=I_1(n,m)\cos(I_2(n,m))$
Imaginary part or $Y$ coordinate $O_2$ is defined as: $O_2(n,m)=I_1(n,m)\sin(I_2(n,m))$

See also

Function Syntax

This function returns a PolarToCartesian2dOutput structure containing outputRealImage and outputImaginaryImage.

// Output structure of the polarToCartesian2d function.
struct PolarToCartesian2dOutput
{
    /// The output real part image. Its dimensions and type are forced to the same values as the input.
    std::shared_ptr< iolink::ImageView > outputRealImage;
    /// The output imaginary part image. Its dimensions and type are forced to the same values as the input.
    std::shared_ptr< iolink::ImageView > outputImaginaryImage;
};

// Function prototype
PolarToCartesian2dOutput
polarToCartesian2d( std::shared_ptr< iolink::ImageView > inputModulusImage,
                    std::shared_ptr< iolink::ImageView > inputPhaseImage,
                    std::shared_ptr< iolink::ImageView > outputRealImage = NULL,
                    std::shared_ptr< iolink::ImageView > outputImaginaryImage = NULL );

This function returns a tuple containing output_real_image and output_imaginary_image.

// Function prototype.
polar_to_cartesian_2d( input_modulus_image,
                       input_phase_image,
                       output_real_image = None,
                       output_imaginary_image = None )

This function returns a PolarToCartesian2dOutput structure containing outputRealImage and outputImaginaryImage.

/// Output structure of the PolarToCartesian2d function.
public struct PolarToCartesian2dOutput
{
    /// 
    /// The output real part image. Its dimensions and type are forced to the same values as the input.
    /// 
    public IOLink.ImageView outputRealImage;
    /// 
    /// The output imaginary part image. Its dimensions and type are forced to the same values as the input.
    /// 
    public IOLink.ImageView outputImaginaryImage;
};

// Function prototype.
public static PolarToCartesian2dOutput
PolarToCartesian2d( IOLink.ImageView inputModulusImage,
                    IOLink.ImageView inputPhaseImage,
                    IOLink.ImageView outputRealImage = null,
                    IOLink.ImageView outputImaginaryImage = null );

Class Syntax

// Command constructor.
PolarToCartesian2d();

/// Gets the inputModulusImage parameter.
/// The modulus input image. It must be a floating point image.
std::shared_ptr< iolink::ImageView > inputModulusImage() const;
/// Sets the inputModulusImage parameter.
/// The modulus input image. It must be a floating point image.
void setInputModulusImage( std::shared_ptr< iolink::ImageView > inputModulusImage );

/// Gets the inputPhaseImage parameter.
/// The phase input image. This image must have same dimensions and data type as the modulus input image.
std::shared_ptr< iolink::ImageView > inputPhaseImage() const;
/// Sets the inputPhaseImage parameter.
/// The phase input image. This image must have same dimensions and data type as the modulus input image.
void setInputPhaseImage( std::shared_ptr< iolink::ImageView > inputPhaseImage );

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

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


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

# Property of the inputModulusImage parameter.
PolarToCartesian2d.input_modulus_image
# Property of the inputPhaseImage parameter.
PolarToCartesian2d.input_phase_image
# Property of the outputRealImage parameter.
PolarToCartesian2d.output_real_image
# Property of the outputImaginaryImage parameter.
PolarToCartesian2d.output_imaginary_image

// Method to launch the command.
execute()

// Command constructor.
PolarToCartesian2d()

// Property of the inputModulusImage parameter.
PolarToCartesian2d.inputModulusImage
// Property of the inputPhaseImage parameter.
PolarToCartesian2d.inputPhaseImage
// Property of the outputRealImage parameter.
PolarToCartesian2d.outputRealImage
// Property of the outputImaginaryImage parameter.
PolarToCartesian2d.outputImaginaryImage

// Method to launch the command.
Execute()

Parameters

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

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

	Description	Type	Supported Values	Default Value
inputModulusImage	The modulus input image. It must be a floating point image.	Image	Grayscale or Multispectral	null
inputPhaseImage	The phase input image. This image must have same dimensions and data type as the modulus input image.	Image	Grayscale or Multispectral	null
outputRealImage	The output real part image. Its dimensions and type are forced to the same values as the input.	Image		null
outputImaginaryImage	The output imaginary part 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" );

PolarToCartesian2d polarToCartesian2dAlgo;
polarToCartesian2dAlgo.setInputModulusImage( polystyrene_float );
polarToCartesian2dAlgo.setInputPhaseImage( polystyrene_float );
polarToCartesian2dAlgo.execute();

std::cout << "outputRealImage:" << polarToCartesian2dAlgo.outputRealImage()->toString();
std::cout << "outputImaginaryImage:" << polarToCartesian2dAlgo.outputImaginaryImage()->toString();

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

polar_to_cartesian_2d_algo = imagedev.PolarToCartesian2d()
polar_to_cartesian_2d_algo.input_modulus_image = polystyrene_float
polar_to_cartesian_2d_algo.input_phase_image = polystyrene_float
polar_to_cartesian_2d_algo.execute()

print( "output_real_image:", str( polar_to_cartesian_2d_algo.output_real_image ) )
print( "output_imaginary_image:", str( polar_to_cartesian_2d_algo.output_imaginary_image ) )

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

PolarToCartesian2d polarToCartesian2dAlgo = new PolarToCartesian2d
{
    inputModulusImage = polystyrene_float,
    inputPhaseImage = polystyrene_float
};
polarToCartesian2dAlgo.Execute();

Console.WriteLine( "outputRealImage:" + polarToCartesian2dAlgo.outputRealImage.ToString() );
Console.WriteLine( "outputImaginaryImage:" + polarToCartesian2dAlgo.outputImaginaryImage.ToString() );

Function Examples

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

auto result = polarToCartesian2d( polystyrene_float, polystyrene_float );

std::cout << "outputRealImage:" << result.outputRealImage->toString();
std::cout << "outputImaginaryImage:" << result.outputImaginaryImage->toString();

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

result_output_real_image, result_output_imaginary_image = imagedev.polar_to_cartesian_2d( polystyrene_float, polystyrene_float )

print( "output_real_image:", str( result_output_real_image ) )
print( "output_imaginary_image:", str( result_output_imaginary_image ) )

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

Processing.PolarToCartesian2dOutput result = Processing.PolarToCartesian2d( polystyrene_float, polystyrene_float );

Console.WriteLine( "outputRealImage:" + result.outputRealImage.ToString() );
Console.WriteLine( "outputImaginaryImage:" + result.outputImaginaryImage.ToString() );