ResampleAffine3d

Resamples an image by defining an oriented bounding box and a geometric transform.

Access to parameter description

This algorithm allows the resampling of an input image onto an arbitrary image domain, and optionally apply a geometric transform on it.

The output image domain is defined by a non-axis aligned bounding box (nAABB). To represent the nAABB, we use an AABB (boundingBoxMin, boundingBoxMax) and a transformation (boundingBoxTransform).
An additional transformation can be applied to each output voxel position to produce the final resampled image. Each output voxel intensity is extracted from the input with a user-defined interpolation.

For example, this algorithm can be used:

To extract an arbitrary sub-volume with an arbitrary voxel size (not necessary aligned with the input) from the input image.
To generate a new image from a model image registered on reference image using the transform given by the AffineRegistration algorithm.

See also

AffineRegistration

Function Syntax

This function returns outputImage.

// Function prototype
std::shared_ptr< iolink::ImageView >
resampleAffine3d( std::shared_ptr< iolink::ImageView > inputImage,
                  iolink::Vector3d boundingBoxMin,
                  iolink::Vector3d boundingBoxMax,
                  iolink::Matrix4d boundingBoxTransform,
                  ResampleAffine3d::SamplingMode samplingMode,
                  iolink::Vector3u32 imageDimensions,
                  ResampleAffine3d::InterpolationType interpolationType,
                  double paddingValue,
                  iolink::Matrix4d transform,
                  std::shared_ptr< iolink::ImageView > outputImage = NULL );

This function returns outputImage.

// Function prototype.
resample_affine_3d( input_image,
                    bounding_box_min = [0, 0, 0],
                    bounding_box_max = [1, 1, 1],
                    bounding_box_transform = _np.identity(4),
                    sampling_mode = ResampleAffine3d.SamplingMode.AUTOMATIC,
                    image_dimensions = [1, 1, 1],
                    interpolation_type = ResampleAffine3d.InterpolationType.LINEAR,
                    padding_value = 0,
                    transform = _np.identity(4),
                    output_image = None )

This function returns outputImage.

// Function prototype.
public static IOLink.ImageView
ResampleAffine3d( IOLink.ImageView inputImage,
                  double[] boundingBoxMin = null,
                  double[] boundingBoxMax = null,
                  IOLink.Matrix4d boundingBoxTransform = null,
                  ResampleAffine3d.SamplingMode samplingMode = ImageDev.ResampleAffine3d.SamplingMode.AUTOMATIC,
                  uint[] imageDimensions = null,
                  ResampleAffine3d.InterpolationType interpolationType = ImageDev.ResampleAffine3d.InterpolationType.LINEAR,
                  double paddingValue = 0,
                  IOLink.Matrix4d transform = null,
                  IOLink.ImageView outputImage = null );

Class Syntax

// Command constructor.
ResampleAffine3d();

/// Gets the inputImage parameter.
/// The input image to resample. It can have integer or floating point data type.
std::shared_ptr< iolink::ImageView > inputImage() const;
/// Sets the inputImage parameter.
/// The input image to resample. It can have integer or floating point data type.
void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

/// Gets the boundingBoxMin parameter.
/// The origin of the bounding box defining the output image, in world coordinates. The resulting bounding box is an axis aligned box in the 3D space.
iolink::Vector3d boundingBoxMin() const;
/// Sets the boundingBoxMin parameter.
/// The origin of the bounding box defining the output image, in world coordinates. The resulting bounding box is an axis aligned box in the 3D space.
void setBoundingBoxMin( const iolink::Vector3d& boundingBoxMin );

/// Gets the boundingBoxMax parameter.
/// The end point of the bounding box defining the output image, in world coordinates. The resulting bounding box is an axis aligned box in the 3D space.
iolink::Vector3d boundingBoxMax() const;
/// Sets the boundingBoxMax parameter.
/// The end point of the bounding box defining the output image, in world coordinates. The resulting bounding box is an axis aligned box in the 3D space.
void setBoundingBoxMax( const iolink::Vector3d& boundingBoxMax );

/// Gets the boundingBoxTransform parameter.
/// The geometric transformation defining the bounding box orientation of the output image, represented by a 4x4 matrix.
iolink::Matrix4d boundingBoxTransform() const;
/// Sets the boundingBoxTransform parameter.
/// The geometric transformation defining the bounding box orientation of the output image, represented by a 4x4 matrix.
void setBoundingBoxTransform( const iolink::Matrix4d& boundingBoxTransform );

/// Gets the samplingMode parameter.
/// The way to determine the resolution of the output image.
ResampleAffine3d::SamplingMode samplingMode() const;
/// Sets the samplingMode parameter.
/// The way to determine the resolution of the output image.
void setSamplingMode( const ResampleAffine3d::SamplingMode& samplingMode );

/// Gets the imageDimensions parameter.
/// The size in pixels of the output image in each axis direction. If the samplingMode parameter is set to AUTOMATIC, this parameter is ignored.
iolink::Vector3u32 imageDimensions() const;
/// Sets the imageDimensions parameter.
/// The size in pixels of the output image in each axis direction. If the samplingMode parameter is set to AUTOMATIC, this parameter is ignored.
void setImageDimensions( const iolink::Vector3u32& imageDimensions );

/// Gets the interpolationType parameter.
/// The method used to calculate the intensity of each pixel in the result image.
ResampleAffine3d::InterpolationType interpolationType() const;
/// Sets the interpolationType parameter.
/// The method used to calculate the intensity of each pixel in the result image.
void setInterpolationType( const ResampleAffine3d::InterpolationType& interpolationType );

/// Gets the paddingValue parameter.
/// Specifies the output value if an output voxel position is outside the bounding box of the input image.
double paddingValue() const;
/// Sets the paddingValue parameter.
/// Specifies the output value if an output voxel position is outside the bounding box of the input image.
void setPaddingValue( const double& paddingValue );

/// Gets the transform parameter.
/// The geometric transformation applied to all output voxel positions before the interpolation, represented by a 4x4 matrix.
iolink::Matrix4d transform() const;
/// Sets the transform parameter.
/// The geometric transformation applied to all output voxel positions before the interpolation, represented by a 4x4 matrix.
void setTransform( const iolink::Matrix4d& transform );

/// Gets the outputImage parameter.
/// The output image. Its dimensions are either defined by the imageDimensions parameter, if the samplingMode parameter is MANUAL, or automatically computed to match the user-defined bounding box with a resolution close to that of the input image. Its calibration is automatically adapted. Its type and interpretation are the same as the input image.
std::shared_ptr< iolink::ImageView > outputImage() const;
/// Sets the outputImage parameter.
/// The output image. Its dimensions are either defined by the imageDimensions parameter, if the samplingMode parameter is MANUAL, or automatically computed to match the user-defined bounding box with a resolution close to that of the input image. Its calibration is automatically adapted. Its type and interpretation are the same as the input image.
void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );


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

# Property of the inputImage parameter.
ResampleAffine3d.input_image
# Property of the boundingBoxMin parameter.
ResampleAffine3d.bounding_box_min
# Property of the boundingBoxMax parameter.
ResampleAffine3d.bounding_box_max
# Property of the boundingBoxTransform parameter.
ResampleAffine3d.bounding_box_transform
# Property of the samplingMode parameter.
ResampleAffine3d.sampling_mode
# Property of the imageDimensions parameter.
ResampleAffine3d.image_dimensions
# Property of the interpolationType parameter.
ResampleAffine3d.interpolation_type
# Property of the paddingValue parameter.
ResampleAffine3d.padding_value
# Property of the transform parameter.
ResampleAffine3d.transform
# Property of the outputImage parameter.
ResampleAffine3d.output_image

// Method to launch the command.
execute()

// Command constructor.
ResampleAffine3d()

// Property of the inputImage parameter.
ResampleAffine3d.inputImage
// Property of the boundingBoxMin parameter.
ResampleAffine3d.boundingBoxMin
// Property of the boundingBoxMax parameter.
ResampleAffine3d.boundingBoxMax
// Property of the boundingBoxTransform parameter.
ResampleAffine3d.boundingBoxTransform
// Property of the samplingMode parameter.
ResampleAffine3d.samplingMode
// Property of the imageDimensions parameter.
ResampleAffine3d.imageDimensions
// Property of the interpolationType parameter.
ResampleAffine3d.interpolationType
// Property of the paddingValue parameter.
ResampleAffine3d.paddingValue
// Property of the transform parameter.
ResampleAffine3d.transform
// Property of the outputImage parameter.
ResampleAffine3d.outputImage

// Method to launch the command.
Execute()

Parameters

Parameter Name

Description

Type

Supported Values

Default Value

inputImage

The input image to resample. It can have integer or floating point data type.

Image

Grayscale

nullptr

boundingBoxMin

The origin of the bounding box defining the output image, in world coordinates. The resulting bounding box is an axis aligned box in the 3D space.

Vector3d

Any value

{0.f, 0.f, 0.f}

boundingBoxMax

The end point of the bounding box defining the output image, in world coordinates. The resulting bounding box is an axis aligned box in the 3D space.

Vector3d

Any value

{1.f, 1.f, 1.f}

boundingBoxTransform

The geometric transformation defining the bounding box orientation of the output image, represented by a 4x4 matrix.

Matrix4d

IDENTITY

samplingMode

The way to determine the resolution of the output image.

AUTOMATIC	The voxel size is automatically computed to be as close as possible to that of the input image. This mode does not work if the transform is not the identity.
MANUAL	The output image dimensions are user-defined and the output voxel size is defined accordingly.

Enumeration

AUTOMATIC

imageDimensions

The size in pixels of the output image in each axis direction. If the samplingMode parameter is set to AUTOMATIC, this parameter is ignored.

Vector3u32

!= 0

{1, 1, 1}

interpolationType

The method used to calculate the intensity of each pixel in the result image.

LINEAR	The value of the intensity is linearly interpolated in all directions.
NEAREST_NEIGHBOR	The value of the intensity is equal to the nearest intensity.

Enumeration

LINEAR

paddingValue

Specifies the output value if an output voxel position is outside the bounding box of the input image.

Float64

Any value

transform

The geometric transformation applied to all output voxel positions before the interpolation, represented by a 4x4 matrix.

Matrix4d

IDENTITY

outputImage

The output image. Its dimensions are either defined by the imageDimensions parameter, if the samplingMode parameter is MANUAL, or automatically computed to match the user-defined bounding box with a resolution close to that of the input image. Its calibration is automatically adapted. Its type and interpretation are the same as the input image.

Image

nullptr

Object Examples

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

ResampleAffine3d resampleAffine3dAlgo;
resampleAffine3dAlgo.setInputImage( foam );
resampleAffine3dAlgo.setBoundingBoxMin( {0, 0, 0} );
resampleAffine3dAlgo.setBoundingBoxMax( {10, 10, 10} );
resampleAffine3dAlgo.setBoundingBoxTransform( iolink::Matrix4d::identity() );
resampleAffine3dAlgo.setSamplingMode( ResampleAffine3d::SamplingMode::AUTOMATIC );
resampleAffine3dAlgo.setImageDimensions( {10, 10, 10} );
resampleAffine3dAlgo.setInterpolationType( ResampleAffine3d::InterpolationType::LINEAR );
resampleAffine3dAlgo.setPaddingValue( 0 );
resampleAffine3dAlgo.setTransform( iolink::Matrix4d({1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0}) );
resampleAffine3dAlgo.execute();

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

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

resample_affine_3d_algo = imagedev.ResampleAffine3d()
resample_affine_3d_algo.input_image = foam
resample_affine_3d_algo.bounding_box_min = [0, 0, 0]
resample_affine_3d_algo.bounding_box_max = [10, 10, 10]
resample_affine_3d_algo.bounding_box_transform = np.identity(4)
resample_affine_3d_algo.sampling_mode = imagedev.ResampleAffine3d.AUTOMATIC
resample_affine_3d_algo.image_dimensions = [10, 10, 10]
resample_affine_3d_algo.interpolation_type = imagedev.ResampleAffine3d.LINEAR
resample_affine_3d_algo.padding_value = 0
resample_affine_3d_algo.transform = np.array([1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]).reshape((4,4))
resample_affine_3d_algo.execute()

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

ImageView foam = Data.ReadVipImage( @"Data/images/foam.vip" );
IOLink.Matrix4d boundingBoxTransform = IOLink.Matrix4d.Identity();
var transformValues = new double[]{1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0};
IOLink.Matrix4d transform = new IOLink.Matrix4d();
for ( uint i = 0;  i < 4; i++ )
{
  for ( uint j = 0;  j < 4; j++ )
  {
    transform.SetAt(i,j,transformValues[i*4+j]);
  }
}

ResampleAffine3d resampleAffine3dAlgo = new ResampleAffine3d
{
    inputImage = foam,
    boundingBoxMin = new double[]{0, 0, 0},
    boundingBoxMax = new double[]{10, 10, 10},
    boundingBoxTransform = boundingBoxTransform,
    samplingMode = ResampleAffine3d.SamplingMode.AUTOMATIC,
    imageDimensions = new uint[]{10, 10, 10},
    interpolationType = ResampleAffine3d.InterpolationType.LINEAR,
    paddingValue = 0,
    transform = transform
};
resampleAffine3dAlgo.Execute();

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

Function Examples

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

auto result = resampleAffine3d( foam, {0, 0, 0}, {10, 10, 10}, iolink::Matrix4d::identity(), ResampleAffine3d::SamplingMode::AUTOMATIC, {10, 10, 10}, ResampleAffine3d::InterpolationType::LINEAR, 0, iolink::Matrix4d({1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0}) );

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

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

result = imagedev.resample_affine_3d( foam, [0, 0, 0], [10, 10, 10], np.identity(4), imagedev.ResampleAffine3d.AUTOMATIC, [10, 10, 10], imagedev.ResampleAffine3d.LINEAR, 0, np.array([1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]).reshape((4,4)) )

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

ImageView foam = Data.ReadVipImage( @"Data/images/foam.vip" );
IOLink.Matrix4d boundingBoxTransform = IOLink.Matrix4d.Identity();
var transformValues = new double[]{1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0};
IOLink.Matrix4d transform = new IOLink.Matrix4d();
for ( uint i = 0;  i < 4; i++ )
{
  for ( uint j = 0;  j < 4; j++ )
  {
    transform.SetAt(i,j,transformValues[i*4+j]);
  }
}

IOLink.ImageView result = Processing.ResampleAffine3d( foam, new double[]{0, 0, 0}, new double[]{10, 10, 10}, boundingBoxTransform, ResampleAffine3d.SamplingMode.AUTOMATIC, new uint[]{10, 10, 10}, ResampleAffine3d.InterpolationType.LINEAR, 0, transform );

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

ResampleAffine3d

- Function Syntax

+ Class Syntax

Parameters

Object Examples

Function Examples

Function Syntax

Class Syntax