PyAimsAlgo programming documentation¶
Overview¶
Many classes of AimsAlgo are actually found in the soma.aims module, after importing soma.aimsalgo (mainly because of the C++ namespace aims being merged by SIP bindings). The additional soma.aimsalgo module contains C++ algorithms which do ne reside inside the aims C++ namespace, and additional python submodules.
Contents¶
In soma.aims module¶

class
soma.aims.
ResamplerFactory_FLOAT
¶ ResamplerFactory classes are used to instantiate a Resampler object for the chosen interpolation type. The main method is getResampler().

getResampler
(order) → resampler¶ Instantiate a Resampler of the given order.
Parameters: order (int) – order of interpolation: 0 is nearest neighbour (no interpolation), 1 is linear, 3 is cubic, etc. up to 7th order. Returns: result – a new instance of the selected resampler type Return type: Resampler_FLOAT


class
soma.aims.
FastMarching
¶ Fast marching algorithm implementation, for images.
The fast marching is a propagation algorithm which is typically used to perform distance maps. It may use a speed map to locally change the propagation speed and distance. It may also be used to perform a Voronoi diagam, and to get Voronoi regions boundaries.
It is used the following way:
 instantiate a FastMarching object, with specified connectivity
 if needed, set the speed map (or inverse speed map) using setSpeedMap() or setInvSpeedMap()
 propagate using one of the doit() methods. It will return the distanc map.
 Voronoi and boundaries can then be retreived using voronoiVol(), midInterface() or midInterfaceVol()
FastMarching(connectivity=”26”, process_mid_interface=False)
FastMarching(process_mid_interface)
(2nd form: deprecated constructor, with connectivity 26.)
Parameters:  connectivity (string) – “26”, “18”, “6”. The connectivity type is only used to build the interfaces between the work region and the seeds: the fast marching itself only uses 6connectivity.
 process_mid_interface (bool) – If process_mid_interface is false (the default), voronoi boundaries will not be available after propagation.

doit
(vol, worklabel, inlabel, outlabel)¶ Perform fast marching propagation from a label image “vol”.
This is a simplified interface to the other, more general, doit() method.
Propagation will take place in the region “worklabel”, from seeds “inlabel” and “outlabel”.
Parameters:  vol (rc_ptr_Volume_S16) – label volume to build distance map from. Contains seeds, propagation (work) region, and possibly forbidden regions
 worklabel (int16) –
 inlabel (int16) –
 outlabel (int16) –
 vol – label volume to build distance map from. Contains seeds, propagation (work) region, and possibly forbidden regions
 worklabels (set_S16) – WARNING: the propagation labels in worklabels should be positive
 seedlabels (set_S16) –
Returns:  distance_map (rc_ptr_Volume_FLOAT) – resulting distance map
 doit(vol, worklabels, seedlabels)
 Perform fast marching propagation from a label image “vol”.
 Propagation will take place in the regions listed in “worklabels”, from
 all seeds in the “seedlabels” list.
Returns: distance_map – resulting distance map
Return type: rc_ptr_Volume_FLOAT

midInterface
(label1, label2)¶ get the interface between Voronoi regions label1 and label2, as a bucket.
The mid_interface option must have been used when instantiating the FastMarching object, and propagation maust have taken place.

midInterfaceLabels
()¶ Voronoi interfaces labels. Given as a vector of pairs of labels
Returns: labels – in the shape ((label1, label2), (label3, label4), ...) Return type: tuple of tuples

midInterfaceVol
(label1, label2)¶ get the interface between Voronoi regions label1 and label2, as a volume.
the mid_interface option must have been used when instantiating the FastMarching object, and propagation maust have taken place.

setInvSpeedMap
(invspeed)¶ Sets an initialized inverse speed map (overrides any previous speed map).
Once a speed map (or inverse speed map) has been setup manually, it will be used during propagation in doit(), for only one run. The speed map data contents will be modified during the process, and the map will not be reusable for other data (seed voxels will be printed in it). The input inverse speed map object will also be modified since it is a shared reference, the algorithm will directly work in it.
Parameters: invspeed (rc_ptr_Volume_FLOAT) –

setSpeedMap
(speed)¶ Sets an initialized speed map. The inverse speed will be deduced from it.
Once a speed map (or inverse speed map) has been setup manually, it will be used during propagation in doit(), for only one run. The speed map data contents will be modified during the process, and the map will not be reusable for other data (seed voxels will be printed in it).
Parameters: speed (rc_ptr_Volume_FLOAT) –

voronoiVol
()¶ get the resulting Voronoi regions (after propagation)

class
soma.aims.
FastMarching_BucketMap_S16
¶ Fast marching algorithm implementation, for buckets.
The fast marching is a propagation algorithm which is typically used to perform distance maps. It may use a speed map to locally change the propagation speed and distance. It may also be used to perform a Voronoi diagam, and to get Voronoi regions boundaries.
It is used the following way:
 instantiate a FastMarching object, with specified connectivity
 if needed, set the speed map (or inverse speed map) using setSpeedMap() or setInvSpeedMap()
 propagate using one of the doit() methods. It will return the distanc map.
 Voronoi and boundaries can then be retreived using voronoiVol(), midInterface() or midInterfaceVol()
FastMarching_BucketMap_S16(connectivity=”26”, process_mid_interface=False)
FastMarching_BucketMap_S16(process_mid_interface)
(2nd form: deprecated constructor, with connectivity 26.)
Parameters:  connectivity (string) – “26”, “18”, “6”. The connectivity type is only used to build the interfaces between the work region and the seeds: the fast marching itself only uses 6connectivity.
 process_mid_interface (bool) – If process_mid_interface is false (the default), voronoi boundaries will not be available after propagation.

doit
(vol, worklabel, inlabel, outlabel)¶ Perform fast marching propagation from a label bucket “vol”.
This is a simplified interface to the other, more general, doit() method.
Propagation will take place in the region “worklabel”, from seeds “inlabel” and “outlabel”.
Parameters:  vol (rc_ptr_BucketMap_S16) – label bucket to build distance map from. Contains seeds, propagation (work) region. Propagation outside the bucket will be forbidden.
 worklabel (int16) –
 inlabel (int16) –
 outlabel (int16) –
 vol – label bucket to build distance map from. Contains seeds, propagation (work) region, and possibly forbidden regions
 worklabels (set_S16) –
 seedlabels (set_S16) –
Returns:  distance_map (rc_ptr_Volume_FLOAT) – resulting distance map
 doit(vol, worklabels, seedlabels)
 Perform fast marching propagation from a label bucket “vol”.
 Propagation will take place in the regions listed in “worklabels”, from
 all seeds in the “seedlabels” list.
Returns: distance_map – resulting distance map
Return type: rc_ptr_Volume_FLOAT

midInterface
(label1, label2)¶ get the interface between Voronoi regions label1 and label2, as a bucket.
The mid_interface option must have been used when instantiating the FastMarching object, and propagation maust have taken place.

midInterfaceLabels
()¶ Voronoi interfaces labels. Given as a vector of pairs of labels
Returns: labels – in the shape ((label1, label2), (label3, label4), ...) Return type: tuple of tuples

midInterfaceVol
(label1, label2)¶ get the interface between Voronoi regions label1 and label2, as a volume.
the mid_interface option must have been used when instantiating the FastMarching object, and propagation maust have taken place.

setInvSpeedMap
(invspeed)¶ Sets an initialized inverse speed map (overrides any previous speed map).
Parameters: invspeed (rc_ptr_BucketMap_FLOAT) –

setSpeedMap
(speed)¶ Sets an initialized speed map. The inverse speed will be deduced from it.
Parameters: speed (rc_ptr_BucketMap_FLOAT) –

voronoiVol
()¶ get the resulting Voronoi regions (after propagation)

class
soma.aims.
FoldArgOverSegment
¶

class
soma.aims.
FoldGraphAttributes
¶

class
soma.aims.
GradientAdvection
¶

class
soma.aims.
MeshInterpoler
¶

class
soma.aims.
RegularBinnedHistogram_FLOAT
¶

class
soma.aims.
GeodesicPath
¶ Geodesic paths or distance maps, using the Dijkstra algorithm
Ex:
from soma import aims, aimsalgo mesh = aims.read('mesh.gii') gp = GeodesicPath(mesh, 0, 0) dmap = TimeTexture('FLOAT') // get a distance map from vertex no 12 dmax = gp.distanceMap_1_N_ind(12, dmap[0].data(), 0) aims.write(dmax, 'distance.gii')
It is possible to get distance maps, or paths between two or more points.
GeodesicPath(surface, texCurv, method, strain) GeodesicPath(surface, method, strain)
Initializes the geodesic path structures for a given mesh geometry, using a constraint map (curvature, typically). Several methods are available.
Parameters:  surface (AimsTimeSurface_3_VOID) – mesh to compute geodesic paths or distances on
 texCurv (TimeTexture_FLOAT) – constraint map texture. If not specified, the curvature will be computed and used as constraint.
 method (int) –
 0:
 unconstrained,
 1:
 minimize the constraint map, suitable for sulci using the curvature as constraint,
 2:
 maximize constraint map, suitable for gyri using the curvature as constraint,
 3:
 unconstrained
 strain (int) – weight factor on the constraints map. In practice we use 3 for sulci and gyri.

distanceMap_1_N_ind
()¶ Compute a distance map from a given point
Parameters: Returns: length – max distance
Return type:

longestPath_1_N_ind
(source, targets, type_distance)¶ Parameters:  source (unsigned) –
 targets (vector_U32) –
 type_distance (int) –
Returns:  target (unsigned)
 length (float)

longestPath_N_N_ind
(points, type_distance)¶ Parameters:  points (vector_U32) –
 type_distance (int) –
Returns:  s (int)
 d (int)
 length (float)

shortestPath_1_1_1_ind
(source, middle, target)¶ Parameters:  source (unsigned) –
 middle (unsigned) –
 target (unsigned) –
Returns: path
Return type: vector_U32

shortestPath_1_1_ind
(source, target)¶ Parameters:  source (unsigned) –
 target (unsigned) –
 source –
 target –
 subset (TimeTexture_S16) –
Returns:  path (vector_U32)
 shortestPath_1_1_ind(source, target, subset)
Returns: path
Return type: vector_U32

shortestPath_1_1_ind_xyz
(source, target, indice, coord3D)¶ Parameters:  source (unsigned) –
 target (unsigned) –
 indice (vector_U32 (output)) –
 coord3D (vector_POINT3DF (output)) –

shortestPath_1_1_len
(source, target)¶ Parameters:  source (unsigned) –
 target (unsigned) –
Returns: length
Return type:

shortestPath_1_1_tex
(source, target, texturevalue, tex)¶ Parameters:  source (unsigned) –
 target (unsigned) –
 texturevalue (float) –
 tex (TimeTexture_S16 (output)) –

shortestPath_1_N_ind
(source, targets)¶ Parameters:  source (unsigned) –
 targets (vector_U32) –
Returns:  target (unsigned)
 length (float)

class
soma.aims.
Spam
¶

class
soma.aims.
SpamBase
¶

class
soma.aims.
SpamFromLikelihood
¶

class
soma.aims.
SplineFfd
(*args)¶ FFD vector field deformation transform
Free Form Deformation is the registration technique used to build the vector fields. This class is dedicated to the application of the vector field deformation to transform coordinates.
Vector fields are stored in volumes AimsData_POINT3DF.
This Spline FFD uses cubic spline interpolation between displacement vectors to process transformed coordinates. See TrilinearFfd for a variant using trilinear interpolation.
This class is the “base” vector field deformation class, which can perform pointtopoint transformation. It is used by various higherlevel classes or functions to work on higherlevel objects:
To resample full 2D or 3D images, see the Resampler class and its derived classes (see also ResamplerFactory).
As a Transformation3d specialization, the main method of this class is the transform() method, which actually performs 3D coordinates transformation. The other methods can be seen as “internal machinery”.
see transformMesh, transformBucket, transformGraph and BundleTransformer to apply vector field deformations to various types of objects.

class
soma.aims.
TrilinearFfd
(*args)¶ FFD vector field deformation transform
Free Form Deformation is the registration technique used to build the vector fields. This class is dedicated to the application of the vector field deformation to transform coordinates.
This is a variant of SplineFfd which is performing trilinear interpolation between displacement vectors. See SplineFfd for details.
soma.aimsalgo module¶

soma.aimsalgo.
AimsDistanceFrontPropagation
()¶

soma.aimsalgo.
AimsMorphoChamferClosing
()¶ Please use preferably MorphoGreyLevel_* classes.

soma.aimsalgo.
AimsMorphoChamferDilation
()¶ Please use preferably MorphoGreyLevel_* classes.

soma.aimsalgo.
AimsMorphoChamferErosion
()¶ Please use preferably MorphoGreyLevel_* classes.

soma.aimsalgo.
AimsMorphoChamferOpening
()¶ Please use preferably MorphoGreyLevel_* classes.

soma.aimsalgo.
AimsMorphoClosing
()¶

soma.aimsalgo.
AimsMorphoDilation
()¶

soma.aimsalgo.
AimsMorphoErosion
()¶

soma.aimsalgo.
AimsMorphoOpening
()¶

soma.aimsalgo.
AimsVoronoiFrontPropagation
()¶

soma.aimsalgo.
AimsMeshLabelConnectedComponent
()¶

class
soma.aimsalgo.
DiffusionSmoother_S16
¶

class
soma.aimsalgo.
DiffusionSmoother_FLOAT
¶

class
soma.aimsalgo.
Gaussian2DSmoothing_DOUBLE
¶

class
soma.aimsalgo.
Gaussian2DSmoothing_FLOAT
¶

class
soma.aimsalgo.
Gaussian2DSmoothing_S16
¶

class
soma.aimsalgo.
Gaussian2DSmoothing_S32
¶

class
soma.aimsalgo.
Gaussian2DSmoothing_U16
¶

class
soma.aimsalgo.
Gaussian2DSmoothing_U32
¶

class
soma.aimsalgo.
Gaussian2DSmoothing_U8
¶

class
soma.aimsalgo.
Gaussian3DSmoothing_DOUBLE
¶

class
soma.aimsalgo.
Gaussian3DSmoothing_FLOAT
¶

class
soma.aimsalgo.
Gaussian3DSmoothing_S16
¶

class
soma.aimsalgo.
Gaussian3DSmoothing_S32
¶

class
soma.aimsalgo.
Gaussian3DSmoothing_U16
¶

class
soma.aimsalgo.
Gaussian3DSmoothing_U32
¶

class
soma.aimsalgo.
Gaussian3DSmoothing_U8
¶

class
soma.aimsalgo.
GeneralSampler_FLOAT_3
¶

class
soma.aimsalgo.
GeometricMoment_DOUBLE
¶

class
soma.aimsalgo.
AimsGradient_FLOAT
¶

class
soma.aimsalgo.
Histogram_FLOAT
¶

class
soma.aimsalgo.
MedianSmoothing_DOUBLE
¶

class
soma.aimsalgo.
MedianSmoothing_FLOAT
¶

class
soma.aimsalgo.
MedianSmoothing_S16
¶

class
soma.aimsalgo.
MedianSmoothing_S32
¶

class
soma.aimsalgo.
MedianSmoothing_U16
¶

class
soma.aimsalgo.
MedianSmoothing_U32
¶

class
soma.aimsalgo.
MedianSmoothing_U8
¶

class
soma.aimsalgo.
Mesher
¶ Mesh binary objects in a volume and produce surface meshes.

class
soma.aimsalgo.
MomentInvariant_FLOAT
¶

class
soma.aimsalgo.
Moment_FLOAT
¶

class
soma.aimsalgo.
TriangulationMoment
¶

class
soma.aimsalgo.
CubicResampler_DOUBLE
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_DOUBLE and SplineResampler_DOUBLE.

class
soma.aimsalgo.
CubicResampler_FLOAT
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_FLOAT and SplineResampler_FLOAT.

class
soma.aimsalgo.
CubicResampler_HSV
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_HSV and SplineResampler_HSV.

class
soma.aimsalgo.
CubicResampler_POINT3DF
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_POINT3DF and SplineResampler_POINT3DF.

class
soma.aimsalgo.
CubicResampler_RGB
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_RGB and SplineResampler_RGB.

class
soma.aimsalgo.
CubicResampler_RGBA
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_RGBA and SplineResampler_RGBA.

class
soma.aimsalgo.
CubicResampler_S16
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_S16 and SplineResampler_S16.

class
soma.aimsalgo.
CubicResampler_S32
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_S32 and SplineResampler_S32.

class
soma.aimsalgo.
CubicResampler_U16
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_U16 and SplineResampler_U16.

class
soma.aimsalgo.
CubicResampler_U32
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_U32 and SplineResampler_U32.

class
soma.aimsalgo.
CubicResampler_U8
(*args)¶ Volume resampler using cubic interpolation.
The resampling API is described in the base classes, Resampler_U8 and SplineResampler_U8.

class
soma.aimsalgo.
LinearResampler_DOUBLE
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_DOUBLE and SplineResampler_DOUBLE.

class
soma.aimsalgo.
LinearResampler_FLOAT
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_FLOAT and SplineResampler_FLOAT.

class
soma.aimsalgo.
LinearResampler_HSV
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_HSV and SplineResampler_HSV.

class
soma.aimsalgo.
LinearResampler_POINT3DF
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_POINT3DF and SplineResampler_POINT3DF.

class
soma.aimsalgo.
LinearResampler_RGB
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_RGB and SplineResampler_RGB.

class
soma.aimsalgo.
LinearResampler_RGBA
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_RGBA and SplineResampler_RGBA.

class
soma.aimsalgo.
LinearResampler_S16
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_S16 and SplineResampler_S16.

class
soma.aimsalgo.
LinearResampler_S32
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_S32 and SplineResampler_S32.

class
soma.aimsalgo.
LinearResampler_U16
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_U16 and SplineResampler_U16.

class
soma.aimsalgo.
LinearResampler_U32
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_U32 and SplineResampler_U32.

class
soma.aimsalgo.
LinearResampler_U8
(*args)¶ Volume resampler using linear (order 1) interpolation.
The resampling API is described in the base classes, Resampler_U8 and SplineResampler_U8.

class
soma.aimsalgo.
MaskLinearResampler_S16
(*args)¶ Volume resampler using linear (order 1) interpolation.
This resampler shows unreliable behaviour: depending of the platform it does not always resample the last element along each axis correctly. Also, it uses some clever optimizations that do not check for overflow. If you need such a masked resampler, please consider contributing a fixed version.
This resampler will consider input voxels that are equal to 32768 (hardcoded) as masked. The mask value (32768) will always be returned for any interpolation involving a masked voxel.
The default background value for this resampler is 32768 (same as the mask value).
The resampling API is described in the base class, Resampler_S16.

class
soma.aimsalgo.
Mesher
Mesh binary objects in a volume and produce surface meshes.

doit
(volume, filename_base, write_mode="binar")¶ Mesh every interface of objects in the input label volume. Each mesh is written in a separate file. Files are numbered according to objects interfaces (label1_label2) and an interface number for this pair of objects. write_mode is an old flag to write files in ascii or binary modes. It’s obsolete.


class
soma.aimsalgo.
MorphoGreyLevel_DOUBLE
¶ Greylevel mathematical morphology.
when enabled, on binary images, the chamferbased morphomath is used instead of the greylevel one. This is the default as it is way faster (see setChamferBinaryMorphoEnabled).
In binary mode, the input data (volume) should contain a border of “sufficent” size. The border size will be checked, and a new volume with larger border will be temporarily allocated and used if needed, but it is more efficient (and consumes less memory) if this border is already allocated in the input image.
Greylevel operations do not need a border in input images, the test is included in the algorithm (which makes it even slower).
See the method neededBorderWidth().
This class thus regroups all basic morphological operations, and makes obsolete direct calls to AimsMorphoChamferErosion(), AimsMorphoChamferDilation(), AimsMorphoChamferClosing(), AimsMorphoChamferOpening().

chamferFactor
()¶ chamfer factor is used to store chamfer distances as int with a sufficient precision. Used only in binary operations. The default is 50.

chamferMaskSize
()¶ Get the chamfer mask size used in binary operations. The default is 3x3x3.
Returns: mask_size – size in the 3 directions, in voxels Return type: Point3df

doClosing
(dataIn, radius)¶ Closing operation (dilation + erosion)
Parameters:  dataIn (rc_ptr_Volume_DOUBLE) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_DOUBLE

doDilation
(dataIn, radius)¶ Dilation operation
Parameters:  dataIn (rc_ptr_Volume_DOUBLE) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_DOUBLE

doErosion
(dataIn, radius)¶ Erosion operation
Parameters:  dataIn (rc_ptr_Volume_DOUBLE) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_DOUBLE

doOpening
(dataIn, radius)¶ Opening operation (erosion + dilation)
Parameters:  dataIn (rc_ptr_Volume_DOUBLE) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_DOUBLE

isBinary
()¶ Tells if the given volume is considered a binary volume and thus is compatible with binary fast operators.

isChamferBinaryMorphoEnabled
()¶ True if binary moprhological operations are allowed (when binary input data are detected)

neededBorderWidth
()¶ border width needed to perform chamfer mask operations, in binary mode (int).

setChamferBinaryMorphoEnabled
(enabled)¶ Enable or disable binary moprhological operations (when binary input data are detected)
Parameters: enabled (bool) –

setChamferFactor
(factor)¶ Set the chamfer distance factor, used in binary operations.


class
soma.aimsalgo.
MorphoGreyLevel_FLOAT
¶ Greylevel mathematical morphology.
when enabled, on binary images, the chamferbased morphomath is used instead of the greylevel one. This is the default as it is way faster (see setChamferBinaryMorphoEnabled).
In binary mode, the input data (volume) should contain a border of “sufficent” size. The border size will be checked, and a new volume with larger border will be temporarily allocated and used if needed, but it is more efficient (and consumes less memory) if this border is already allocated in the input image.
Greylevel operations do not need a border in input images, the test is included in the algorithm (which makes it even slower).
See the method neededBorderWidth().
This class thus regroups all basic morphological operations, and makes obsolete direct calls to AimsMorphoChamferErosion(), AimsMorphoChamferDilation(), AimsMorphoChamferClosing(), AimsMorphoChamferOpening().

chamferFactor
()¶ chamfer factor is used to store chamfer distances as int with a sufficient precision. Used only in binary operations. The default is 50.

chamferMaskSize
()¶ Get the chamfer mask size used in binary operations. The default is 3x3x3.
Returns: mask_size – size in the 3 directions, in voxels Return type: Point3df

doClosing
(dataIn, radius)¶ Closing operation (dilation + erosion)
Parameters:  dataIn (rc_ptr_Volume_FLOAT) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_FLOAT

doDilation
(dataIn, radius)¶ Dilation operation
Parameters:  dataIn (rc_ptr_Volume_FLOAT) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_FLOAT

doErosion
(dataIn, radius)¶ Erosion operation
Parameters:  dataIn (rc_ptr_Volume_FLOAT) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_FLOAT

doOpening
(dataIn, radius)¶ Opening operation (erosion + dilation)
Parameters:  dataIn (rc_ptr_Volume_FLOAT) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_FLOAT

isBinary
()¶ Tells if the given volume is considered a binary volume and thus is compatible with binary fast operators.

isChamferBinaryMorphoEnabled
()¶ True if binary moprhological operations are allowed (when binary input data are detected)

neededBorderWidth
()¶ border width needed to perform chamfer mask operations, in binary mode (int).

setChamferBinaryMorphoEnabled
(enabled)¶ Enable or disable binary moprhological operations (when binary input data are detected)
Parameters: enabled (bool) –

setChamferFactor
(factor)¶ Set the chamfer distance factor, used in binary operations.


class
soma.aimsalgo.
MorphoGreyLevel_S16
¶ Greylevel mathematical morphology.
when enabled, on binary images, the chamferbased morphomath is used instead of the greylevel one. This is the default as it is way faster (see setChamferBinaryMorphoEnabled).
In binary mode, the input data (volume) should contain a border of “sufficent” size. The border size will be checked, and a new volume with larger border will be temporarily allocated and used if needed, but it is more efficient (and consumes less memory) if this border is already allocated in the input image.
Greylevel operations do not need a border in input images, the test is included in the algorithm (which makes it even slower).
See the method neededBorderWidth().
This class thus regroups all basic morphological operations, and makes obsolete direct calls to AimsMorphoChamferErosion(), AimsMorphoChamferDilation(), AimsMorphoChamferClosing(), AimsMorphoChamferOpening().

chamferFactor
()¶ chamfer factor is used to store chamfer distances as int with a sufficient precision. Used only in binary operations. The default is 50.

chamferMaskSize
()¶ Get the chamfer mask size used in binary operations. The default is 3x3x3.
Returns: mask_size – size in the 3 directions, in voxels Return type: Point3df

doClosing
(dataIn, radius)¶ Closing operation (dilation + erosion)
Parameters:  dataIn (rc_ptr_Volume_S16) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_S16

doDilation
(dataIn, radius)¶ Dilation operation
Parameters:  dataIn (rc_ptr_Volume_S16) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_S16

doErosion
(dataIn, radius)¶ Erosion operation
Parameters:  dataIn (rc_ptr_Volume_S16) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_S16

doOpening
(dataIn, radius)¶ Opening operation (erosion + dilation)
Parameters:  dataIn (rc_ptr_Volume_S16) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_S16

isBinary
()¶ Tells if the given volume is considered a binary volume and thus is compatible with binary fast operators.

isChamferBinaryMorphoEnabled
()¶ True if binary moprhological operations are allowed (when binary input data are detected)

neededBorderWidth
()¶ border width needed to perform chamfer mask operations, in binary mode (int).

setChamferBinaryMorphoEnabled
(enabled)¶ Enable or disable binary moprhological operations (when binary input data are detected)
Parameters: enabled (bool) –

setChamferFactor
(factor)¶ Set the chamfer distance factor, used in binary operations.


class
soma.aimsalgo.
MorphoGreyLevel_S32
¶ Greylevel mathematical morphology.
when enabled, on binary images, the chamferbased morphomath is used instead of the greylevel one. This is the default as it is way faster (see setChamferBinaryMorphoEnabled).
In binary mode, the input data (volume) should contain a border of “sufficent” size. The border size will be checked, and a new volume with larger border will be temporarily allocated and used if needed, but it is more efficient (and consumes less memory) if this border is already allocated in the input image.
Greylevel operations do not need a border in input images, the test is included in the algorithm (which makes it even slower).
See the method neededBorderWidth().
This class thus regroups all basic morphological operations, and makes obsolete direct calls to AimsMorphoChamferErosion(), AimsMorphoChamferDilation(), AimsMorphoChamferClosing(), AimsMorphoChamferOpening().

chamferFactor
()¶ chamfer factor is used to store chamfer distances as int with a sufficient precision. Used only in binary operations. The default is 50.

chamferMaskSize
()¶ Get the chamfer mask size used in binary operations. The default is 3x3x3.
Returns: mask_size – size in the 3 directions, in voxels Return type: Point3df

doClosing
(dataIn, radius)¶ Closing operation (dilation + erosion)
Parameters:  dataIn (rc_ptr_Volume_S32) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_S32

doDilation
(dataIn, radius)¶ Dilation operation
Parameters:  dataIn (rc_ptr_Volume_S32) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_S32

doErosion
(dataIn, radius)¶ Erosion operation
Parameters:  dataIn (rc_ptr_Volume_S32) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_S32

doOpening
(dataIn, radius)¶ Opening operation (erosion + dilation)
Parameters:  dataIn (rc_ptr_Volume_S32) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_S32

isBinary
()¶ Tells if the given volume is considered a binary volume and thus is compatible with binary fast operators.

isChamferBinaryMorphoEnabled
()¶ True if binary moprhological operations are allowed (when binary input data are detected)

neededBorderWidth
()¶ border width needed to perform chamfer mask operations, in binary mode (int).

setChamferBinaryMorphoEnabled
(enabled)¶ Enable or disable binary moprhological operations (when binary input data are detected)
Parameters: enabled (bool) –

setChamferFactor
(factor)¶ Set the chamfer distance factor, used in binary operations.


class
soma.aimsalgo.
MorphoGreyLevel_U16
¶ Greylevel mathematical morphology.
when enabled, on binary images, the chamferbased morphomath is used instead of the greylevel one. This is the default as it is way faster (see setChamferBinaryMorphoEnabled).
In binary mode, the input data (volume) should contain a border of “sufficent” size. The border size will be checked, and a new volume with larger border will be temporarily allocated and used if needed, but it is more efficient (and consumes less memory) if this border is already allocated in the input image.
Greylevel operations do not need a border in input images, the test is included in the algorithm (which makes it even slower).
See the method neededBorderWidth().
This class thus regroups all basic morphological operations, and makes obsolete direct calls to AimsMorphoChamferErosion(), AimsMorphoChamferDilation(), AimsMorphoChamferClosing(), AimsMorphoChamferOpening().

chamferFactor
()¶ chamfer factor is used to store chamfer distances as int with a sufficient precision. Used only in binary operations. The default is 50.

chamferMaskSize
()¶ Get the chamfer mask size used in binary operations. The default is 3x3x3.
Returns: mask_size – size in the 3 directions, in voxels Return type: Point3df

doClosing
(dataIn, radius)¶ Closing operation (dilation + erosion)
Parameters:  dataIn (rc_ptr_Volume_U16) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U16

doDilation
(dataIn, radius)¶ Dilation operation
Parameters:  dataIn (rc_ptr_Volume_U16) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U16

doErosion
(dataIn, radius)¶ Erosion operation
Parameters:  dataIn (rc_ptr_Volume_U16) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U16

doOpening
(dataIn, radius)¶ Opening operation (erosion + dilation)
Parameters:  dataIn (rc_ptr_Volume_U16) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U16

isBinary
()¶ Tells if the given volume is considered a binary volume and thus is compatible with binary fast operators.

isChamferBinaryMorphoEnabled
()¶ True if binary moprhological operations are allowed (when binary input data are detected)

neededBorderWidth
()¶ border width needed to perform chamfer mask operations, in binary mode (int).

setChamferBinaryMorphoEnabled
(enabled)¶ Enable or disable binary moprhological operations (when binary input data are detected)
Parameters: enabled (bool) –

setChamferFactor
(factor)¶ Set the chamfer distance factor, used in binary operations.


class
soma.aimsalgo.
MorphoGreyLevel_U32
¶ Greylevel mathematical morphology.
when enabled, on binary images, the chamferbased morphomath is used instead of the greylevel one. This is the default as it is way faster (see setChamferBinaryMorphoEnabled).
In binary mode, the input data (volume) should contain a border of “sufficent” size. The border size will be checked, and a new volume with larger border will be temporarily allocated and used if needed, but it is more efficient (and consumes less memory) if this border is already allocated in the input image.
Greylevel operations do not need a border in input images, the test is included in the algorithm (which makes it even slower).
See the method neededBorderWidth().
This class thus regroups all basic morphological operations, and makes obsolete direct calls to AimsMorphoChamferErosion(), AimsMorphoChamferDilation(), AimsMorphoChamferClosing(), AimsMorphoChamferOpening().

chamferFactor
()¶ chamfer factor is used to store chamfer distances as int with a sufficient precision. Used only in binary operations. The default is 50.

chamferMaskSize
()¶ Get the chamfer mask size used in binary operations. The default is 3x3x3.
Returns: mask_size – size in the 3 directions, in voxels Return type: Point3df

doClosing
(dataIn, radius)¶ Closing operation (dilation + erosion)
Parameters:  dataIn (rc_ptr_Volume_U32) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U32

doDilation
(dataIn, radius)¶ Dilation operation
Parameters:  dataIn (rc_ptr_Volume_U32) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U32

doErosion
(dataIn, radius)¶ Erosion operation
Parameters:  dataIn (rc_ptr_Volume_U32) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U32

doOpening
(dataIn, radius)¶ Opening operation (erosion + dilation)
Parameters:  dataIn (rc_ptr_Volume_U32) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U32

isBinary
()¶ Tells if the given volume is considered a binary volume and thus is compatible with binary fast operators.

isChamferBinaryMorphoEnabled
()¶ True if binary moprhological operations are allowed (when binary input data are detected)

neededBorderWidth
()¶ border width needed to perform chamfer mask operations, in binary mode (int).

setChamferBinaryMorphoEnabled
(enabled)¶ Enable or disable binary moprhological operations (when binary input data are detected)
Parameters: enabled (bool) –

setChamferFactor
(factor)¶ Set the chamfer distance factor, used in binary operations.


class
soma.aimsalgo.
MorphoGreyLevel_U8
¶ Greylevel mathematical morphology.
when enabled, on binary images, the chamferbased morphomath is used instead of the greylevel one. This is the default as it is way faster (see setChamferBinaryMorphoEnabled).
In binary mode, the input data (volume) should contain a border of “sufficent” size. The border size will be checked, and a new volume with larger border will be temporarily allocated and used if needed, but it is more efficient (and consumes less memory) if this border is already allocated in the input image.
Greylevel operations do not need a border in input images, the test is included in the algorithm (which makes it even slower).
See the method neededBorderWidth().
This class thus regroups all basic morphological operations, and makes obsolete direct calls to AimsMorphoChamferErosion(), AimsMorphoChamferDilation(), AimsMorphoChamferClosing(), AimsMorphoChamferOpening().

chamferFactor
()¶ chamfer factor is used to store chamfer distances as int with a sufficient precision. Used only in binary operations. The default is 50.

chamferMaskSize
()¶ Get the chamfer mask size used in binary operations. The default is 3x3x3.
Returns: mask_size – size in the 3 directions, in voxels Return type: Point3df

doClosing
(dataIn, radius)¶ Closing operation (dilation + erosion)
Parameters:  dataIn (rc_ptr_Volume_U8) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U8

doDilation
(dataIn, radius)¶ Dilation operation
Parameters:  dataIn (rc_ptr_Volume_U8) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U8

doErosion
(dataIn, radius)¶ Erosion operation
Parameters:  dataIn (rc_ptr_Volume_U8) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U8

doOpening
(dataIn, radius)¶ Opening operation (erosion + dilation)
Parameters:  dataIn (rc_ptr_Volume_U8) – volume to perform the operation on
 radius (float) – radius of the morphological operation (in mm)
Returns: result
Return type: rc_ptr_Volume_U8

isBinary
()¶ Tells if the given volume is considered a binary volume and thus is compatible with binary fast operators.

isChamferBinaryMorphoEnabled
()¶ True if binary moprhological operations are allowed (when binary input data are detected)

neededBorderWidth
()¶ border width needed to perform chamfer mask operations, in binary mode (int).

setChamferBinaryMorphoEnabled
(enabled)¶ Enable or disable binary moprhological operations (when binary input data are detected)
Parameters: enabled (bool) –

setChamferFactor
(factor)¶ Set the chamfer distance factor, used in binary operations.


class
soma.aimsalgo.
NearestNeighborResampler_DOUBLE
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_FLOAT
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_HSV
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_POINT3DF
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_RGB
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_RGBA
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_S16
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_S32
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_U16
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_U32
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
NearestNeighborResampler_U8
(*args)¶ Volume resampler using nearestneighbour interpolation.
The Resampling API is described in the base Resampler class.

class
soma.aimsalgo.
QuarticResampler_DOUBLE
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_DOUBLE and SplineResampler_DOUBLE.

class
soma.aimsalgo.
QuarticResampler_FLOAT
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_FLOAT and SplineResampler_FLOAT.

class
soma.aimsalgo.
QuarticResampler_HSV
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_HSV and SplineResampler_HSV.

class
soma.aimsalgo.
QuarticResampler_POINT3DF
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_POINT3DF and SplineResampler_POINT3DF.

class
soma.aimsalgo.
QuarticResampler_RGB
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_RGB and SplineResampler_RGB.

class
soma.aimsalgo.
QuarticResampler_RGBA
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_RGBA and SplineResampler_RGBA.

class
soma.aimsalgo.
QuarticResampler_S16
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_S16 and SplineResampler_S16.

class
soma.aimsalgo.
QuarticResampler_S32
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_S32 and SplineResampler_S32.

class
soma.aimsalgo.
QuarticResampler_U16
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_U16 and SplineResampler_U16.

class
soma.aimsalgo.
QuarticResampler_U32
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_U32 and SplineResampler_U32.

class
soma.aimsalgo.
QuarticResampler_U8
(*args)¶ Volume resampler using quartic (order 4) interpolation.
The resampling API is described in the base classes, Resampler_U8 and SplineResampler_U8.

class
soma.aimsalgo.
QuinticResampler_DOUBLE
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_DOUBLE and SplineResampler_DOUBLE.

class
soma.aimsalgo.
QuinticResampler_FLOAT
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_FLOAT and SplineResampler_FLOAT.

class
soma.aimsalgo.
QuinticResampler_HSV
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_HSV and SplineResampler_HSV.

class
soma.aimsalgo.
QuinticResampler_POINT3DF
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_POINT3DF and SplineResampler_POINT3DF.

class
soma.aimsalgo.
QuinticResampler_RGB
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_RGB and SplineResampler_RGB.

class
soma.aimsalgo.
QuinticResampler_RGBA
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_RGBA and SplineResampler_RGBA.

class
soma.aimsalgo.
QuinticResampler_S16
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_S16 and SplineResampler_S16.

class
soma.aimsalgo.
QuinticResampler_S32
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_S32 and SplineResampler_S32.

class
soma.aimsalgo.
QuinticResampler_U16
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_U16 and SplineResampler_U16.

class
soma.aimsalgo.
QuinticResampler_U32
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_U32 and SplineResampler_U32.

class
soma.aimsalgo.
QuinticResampler_U8
(*args)¶ Volume resampler using quintic (order 5) interpolation.
The resampling API is described in the base classes Resampler_U8 and SplineResampler_U8.

class
soma.aimsalgo.
Reader_FfdTransformation
¶ FFD vector field transformation reader. It actually reads a volume of Point3df.

class
soma.aimsalgo.
Resampler_DOUBLE
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

defaultValue
()¶ Background value used by the doit() methods
Returns: Return type: double

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_DOUBLE) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_DOUBLE

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_DOUBLE) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (double) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_DOUBLE) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: double

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_DOUBLE) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (double) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_DOUBLE) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: double

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_DOUBLE) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (double) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_DOUBLE) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: double

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (double) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_DOUBLE) – volume to be resampled


class
soma.aimsalgo.
Resampler_FLOAT
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_FLOAT) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_FLOAT

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_FLOAT) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (float) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_FLOAT) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_FLOAT) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (float) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_FLOAT) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_FLOAT) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (float) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_FLOAT) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (float) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_FLOAT) – volume to be resampled


class
soma.aimsalgo.
Resampler_HSV
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

defaultValue
()¶ Background value used by the doit() methods
Returns: Return type: AimsHSV

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_HSV) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Volume_HSV
Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_HSV

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_HSV) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (AimsHSV) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_HSV) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: AimsHSV

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_HSV) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (AimsHSV) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_HSV) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: AimsHSV

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_HSV) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (AimsHSV) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_HSV) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: AimsHSV

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (AimsHSV) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_HSV) – volume to be resampled


class
soma.aimsalgo.
Resampler_POINT3DF
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_POINT3DF) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Volume_POINT3DF
Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_POINT3DF

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_POINT3DF) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (Point3df) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_POINT3DF) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_POINT3DF) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (Point3df) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_POINT3DF) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_POINT3DF) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (Point3df) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_POINT3DF) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (Point3df) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_POINT3DF) – volume to be resampled


class
soma.aimsalgo.
Resampler_RGB
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_RGB) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_RGB

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_RGB) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (AimsRGB) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_RGB) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_RGB) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (AimsRGB) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_RGB) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_RGB) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (AimsRGB) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_RGB) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (AimsRGB) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_RGB) – volume to be resampled


class
soma.aimsalgo.
Resampler_RGBA
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_RGBA) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_RGBA

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_RGBA) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (AimsRGBA) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_RGBA) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_RGBA) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (AimsRGBA) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_RGBA) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_RGBA) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (AimsRGBA) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_RGBA) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (AimsRGBA) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_RGBA) – volume to be resampled


class
soma.aimsalgo.
Resampler_S16
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

defaultValue
()¶ Background value used by the doit() methods
Returns: Return type: short

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_S16) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_S16

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_S16) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (short) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_S16) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: short

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_S16) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (short) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_S16) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: short

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_S16) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (short) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_S16) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: short

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (short) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_S16) – volume to be resampled


class
soma.aimsalgo.
Resampler_S32
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_S32) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_S32

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_S32) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (int) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_S32) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_S32) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (int) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_S32) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_S32) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (int) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_S32) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type:

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (int) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_S32) – volume to be resampled


class
soma.aimsalgo.
Resampler_U16
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

defaultValue
()¶ Background value used by the doit() methods
Returns: Return type: uint16_t

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_U16) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_U16

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_U16) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (uint16_t) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_U16) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: uint16_t

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_U16) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (uint16_t) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_U16) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: uint16_t

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_U16) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (uint16_t) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_U16) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: uint16_t

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (uint16_t) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_U16) – volume to be resampled


class
soma.aimsalgo.
Resampler_U32
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

defaultValue
()¶ Background value used by the doit() methods
Returns: Return type: unsigned

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_U32) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Raises: RuntimeError: if no input volume has been set with setRef.

ref
()¶ Input data to be resampled by the doit() methods
Returns: Return type: Volume_U32

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_U32) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (unsigned) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_U32) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: unsigned

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_U32) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (unsigned) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_U32) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: unsigned

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_U32) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (unsigned) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_U32) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: unsigned

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (unsigned) – background value

setRef
(input_data)¶ Set the input data to be resampled by the doit() methods
Parameters: input_data (Volume_U32) – volume to be resampled


class
soma.aimsalgo.
Resampler_U8
(*args)¶ Resampling of data from a volume, applying a transformation.
The doit() and resample() methods can be used to apply an affine transformation (aims::AffineTransformation3d). They take a direct transformation, i.e. the transformation goes from the space of the input image (unit: mm) to the space of the output image (unit: mm). The transformation is inverted and normalized internally as needed, because the resamplers “pull” data by transforming output coordinates into input coordinates.
The doit() methods work on input data passed to the setRef() method. setDefaultValue() can also be called to set the background value.
The resample() methods provide stateless alternatives.
You can also use arbitrary nonaffine transformations (inheriting aims::Transformation3d) by using the resample_inv() family of methods. In this case, you must pass the backward transformation (from output space to input space), because of the “pulling” mechanism described above.
Beware that contrary to the other methods, the resample_inv_to_vox() overloads take a transformation that maps to voxel coordinates of the input image. These methods can be slightly faster than resample_inv() because they map directly to the API of the actual resamplers are implementing (doResample()). This is especially true of the overload that performs resampling for a single point only.

defaultValue
()¶ Background value used by the doit() methods
Returns: Return type: unsigned short

doit
(transform, output_data)¶ Resample the input volume set with setRef() into an existing volume.
The background value (to be used for regions that are outside of the input volume) can be set with setDefaultValue().
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
The level of verbosity is taken from carto::verbose (i.e. the –verbose commandline argument is honoured).
Parameters:  transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 output_data (Volume_U8) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 transform – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 dimY, dimZ (dimX,) – dimensions of the newly allocated volume
 voxel_size (Point3df (list of 3 floats)) – voxel size of the newly allocated volume (unit: mm)
Raises: RuntimeError
– if no input volume has been set with setRef. doit(transform, dimx, dimy, dimz, voxel_size)
=============================================
 Resample the input volume set with setRef() in a newly allocated volume.
 The background value (to be used for regions that are outside of the
 input volume) can be set with setDefaultValue().
 The level of verbosity is taken from carto::verbose (i.e. the
 –verbose commandline argument is honoured).
 The transformations, referentials, and referential header attributes of
 the new volume are reset if transform.isIdentity() is false:
 the referential attribute is removed
  each transformation in transformations is composed with transform so – that the output volume still points to the original space. If that is not possible (e.g. the transformations attribute is missing or invalid), then a new transformation is added that points to the input volume.
Returns: a newly allocated volume containing the resampled data (its size along the t axis is the same as the input volume).
Return type: Raises: RuntimeError: if no input volume has been set with setRef.

resample
(input_data, transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_U8) – data to be resampled (its voxel size is taken into account)
 transform (AffineTransformation3d) – transformation from coordinates of the input volume (unit: mm), to coordinates of the output volume (unit: mm) (its inverse is used for resampling)
 background (unsigned short) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_U8) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 transform, background, output_location, timestep) > output_value (resample(input_data,) –
 ====================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 transform – transformation from coordinates of the input volume (unit: mm), to output coordinates (its inverse is used for resampling)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: unsigned short

resample_inv
(input_data, inverse_transform, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Parameters:  input_data (Volume_U8) – data to be resampled (its voxel size is taken into account)
 inverse_transform (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: mm)
 background (unsigned short) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_U8) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform, background, output_location, timestep) > output_value (resample_inv(input_data,) –
 ================================================================================================== –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform – transformation from output coordinates to coordinates of the input volume (unit: mm)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: unsigned short

resample_inv_to_vox
(input_data, inverse_transform_to_vox, background, output_data, verbose=False)¶ Resample a volume into an existing output volume.
The transformations, referentials, and referential header attributes of output_data are not touched; it is up to the calling code to update them accordingly.
This method does not use the instance state set by setRef() or setDefaultValue().
Derived classes can override this method to optimize interpolation of a full volume. The base class method simply calls doResample for each point.
Parameters:  input_data (Volume_U8) – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox (Transformation3d) – transformation from coordinates of the output volume (unit: mm), to coordinates of the input volume (unit: voxel)
 background (unsigned short) – value set in output regions that are outside of the transformed input volume
 output_data (Volume_U8) – existing volume to be filled with resampled data (its preexisting dimensions and voxel size are used)
 verbose (bool) – print progress to stdout
 inverse_transform_to_vox, background, output_location, timestep) > output_value (resample_inv_to_vox(input_data,) –
 ================================================================================================================ –
 a volume at a single location. (Resample) –
 method does not use the instance state set by setRef() or (This) –
 setDefaultValue() –
 input_data – data to be resampled (its voxel size is taken into account)
 inverse_transform_to_vox – transformation from output coordinates to coordinates of the input volume (unit: voxel)
 background – value set in output regions that are outside of the transformed input volume
 output_location (Point3df (list of 3 floats)) – coordinates in output space (destination space of transform)
 timestep (int) – for 4D volume, time step to be used
Returns: resampled value
Return type: unsigned short

setDefaultValue
(value)¶ Set the background value to be used by the doit() methods
Parameters: value (unsigned short) – background value


class
soma.aimsalgo.
SeventhOrderResampler_DOUBLE
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_DOUBLE and SplineResampler_DOUBLE.

class
soma.aimsalgo.
SeventhOrderResampler_FLOAT
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_FLOAT and SplineResampler_FLOAT.

class
soma.aimsalgo.
SeventhOrderResampler_HSV
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_HSV and SplineResampler_HSV.

class
soma.aimsalgo.
SeventhOrderResampler_POINT3DF
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_POINT3DF and SplineResampler_POINT3DF.

class
soma.aimsalgo.
SeventhOrderResampler_RGB
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_RGB and SplineResampler_RGB.

class
soma.aimsalgo.
SeventhOrderResampler_RGBA
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_RGBA and SplineResampler_RGBA.

class
soma.aimsalgo.
SeventhOrderResampler_S16
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_S16 and SplineResampler_S16.

class
soma.aimsalgo.
SeventhOrderResampler_S32
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_S32 and SplineResampler_S32.

class
soma.aimsalgo.
SeventhOrderResampler_U16
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_U16 and SplineResampler_U16.

class
soma.aimsalgo.
SeventhOrderResampler_U32
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_U32 and SplineResampler_U32.

class
soma.aimsalgo.
SeventhOrderResampler_U8
(*args)¶ Volume resampler using seventhorder interpolation.
The resampling API is described in the base classes, Resampler_U8 and SplineResampler_U8.

class
soma.aimsalgo.
SixthOrderResampler_DOUBLE
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_DOUBLE and SplineResampler_DOUBLE.

class
soma.aimsalgo.
SixthOrderResampler_FLOAT
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_FLOAT and SplineResampler_FLOAT.

class
soma.aimsalgo.
SixthOrderResampler_HSV
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_HSV and SplineResampler_HSV.

class
soma.aimsalgo.
SixthOrderResampler_POINT3DF
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_POINT3DF and SplineResampler_POINT3DF.

class
soma.aimsalgo.
SixthOrderResampler_RGB
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_RGB and SplineResampler_RGB.

class
soma.aimsalgo.
SixthOrderResampler_RGBA
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_RGBA and SplineResampler_RGBA.

class
soma.aimsalgo.
SixthOrderResampler_S16
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_S16 and SplineResampler_S16.

class
soma.aimsalgo.
SixthOrderResampler_S32
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_S32 and SplineResampler_S32.

class
soma.aimsalgo.
SixthOrderResampler_U16
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_U16 and SplineResampler_U16.

class
soma.aimsalgo.
SixthOrderResampler_U32
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_U32 and SplineResampler_U32.

class
soma.aimsalgo.
SixthOrderResampler_U8
(*args)¶ Volume resampler using sixthorder interpolation.
The resampling API is described in the base classes, Resampler_U8 and SplineResampler_U8.

class
soma.aimsalgo.
SplineResampler_DOUBLE
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_DOUBLE.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters:  inVolume (Volume_DOUBLE) – input image
 t (int) – volume to use in the T dimension in the case where inVolume is a time series.
 verbose (bool) – print progress on stdout
Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_FLOAT
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_FLOAT.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters:  inVolume (Volume_FLOAT) – input image
 t (int) – volume to use in the T dimension in the case where inVolume is a time series.
 verbose (bool) – print progress on stdout
Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_HSV
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_HSV.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters: Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_POINT3DF
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_POINT3DF.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters: Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_RGB
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_RGB.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters:  inVolume (Volume_RGB) – input image
 t (int) – volume to use in the T dimension in the case where inVolume is a time series.
 verbose (bool) – print progress on stdout
Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_RGBA
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_RGBA.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters:  inVolume (Volume_RGBA) – input image
 t (int) – volume to use in the T dimension in the case where inVolume is a time series.
 verbose (bool) – print progress on stdout
Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_S16
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_S16.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters:  inVolume (Volume_S16) – input image
 t (int) – volume to use in the T dimension in the case where inVolume is a time series.
 verbose (bool) – print progress on stdout
Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_S32
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_S32.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters:  inVolume (Volume_S32) – input image
 t (int) – volume to use in the T dimension in the case where inVolume is a time series.
 verbose (bool) – print progress on stdout
Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_U16
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_U16.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters:  inVolume (Volume_U16) – input image
 t (int) – volume to use in the T dimension in the case where inVolume is a time series.
 verbose (bool) – print progress on stdout
Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_U32
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_U32.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters:  inVolume (Volume_U32) – input image
 t (int) – volume to use in the T dimension in the case where inVolume is a time series.
 verbose (bool) – print progress on stdout
Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
SplineResampler_U8
(*args)¶ BSplinebased resampling.
This is the base class for all resamplers based on Bspline interpolation as described by Unser, Aldroubi & Eden in IEEE PAMI (1991). A class computing the actual spline coefficient is derived for each spline order (1 to 7).
 See : LinearResampler, CubicResampler, QuadraticResampler,
 QuinticResampler, SixthOrderResampler, SeventhOrderResampler
Coefficients are computed through a recursive scheme from an input reference volume. This recursive algorithm is fast for whole volume resampling, but slower for single points. A cache mechanism has thus been implemented so that coefficients are not recomputed if the input volume did not change.
The Resampling API is described in the base class, Resampler_U8.

reset
()¶ Computes spline coefficients corresponding to an input volume.
Spline coefficients are recomputed only if one of these conditions is satisfied:  inVolume is different from the last volume used for coefficients
computation (in the sense that they share the same adress) t is different from the last t used for coefficients computation
 A call to reset() has previously been made
This method actually calls updateParameters() and returns the coeff container
Parameters: Returns: Volume of double containing the coefficients in the image domain. Border coefficient need to be retrieved by mirror.
Return type:

class
soma.aimsalgo.
Writer_FfdTransformation
¶ FFD vector field transformation writer. It actually reads a volume of Point3df.

soma.aimsalgo.
resampleBucket
()¶ Apply a spatial transformation to a BucketMap
The bucket is transformed by resampling, using a pullback method in the same way as nearest neighbour resampling of a Volume.
Pure pullback resampling does not behave well when downsampling (it introduces holes), so by default this function returns the union of voxels transformed using the pushforward and pullback methods. Set also_pushforward to false to disable this behaviour and only perform pure pullback.
The voxel size of the output bucket can optionally be specified in vs. By default, the same voxel size as the input bucket is used.
Warning
Alhtough this method is more reliable than transformBucketDirect, it still provides no guarantees of topology preservation.

soma.aimsalgo.
transformBucketDirect
()¶ Apply a spatial transformation to a BucketMap
Each voxel of the input bucket is transformed with direct_transformation, and the closest voxel of the output bucket is set. The voxel size of the output bucket can optionally be specified in vs. By default, the same voxel size as the input bucket is used.
Warning
This method provides no guarantees of topology preservation; in fact it will create holes in the resulting bucket, particularly when upsampling. When possible, you should use resampleBucket() instead, which performs nearestneighbour resampling.

soma.aimsalgo.
transformGraph
()¶ Apply a spatial transformation to all objects contained in a Graph.
The graph is modified inplace.
An inverse transformation is necessary for correctly transforming Buckets (see resampleBucket). If inverse_transformation is NULL, buckets will be transformed with the pushforward method only (transformBucketDirect).
Warning
Volumes are not transformed, neither are graph attributes. Please run AimsFoldArgAtt to fix the values of basic attributes, or the CorticalFoldsGraphUpgradeFromOld BrainVisa process, which can be found under Morphologist/Sulci/graphmanipulation, for a complete update.

soma.aimsalgo.
transformMesh
()¶ Apply a spatial transformation to a mesh (AimsTimeSurface)
Each vertex of the mesh is transformed according to the supplied transformation. Normals are recalculated from the new vertex positions. Apply a spatial transformation to a mesh (AimsTimeSurface)
Each vertex of the mesh is transformed according to the supplied transformation. Normals are recalculated from the new vertex positions. Apply a spatial transformation to a mesh (AimsTimeSurface)
Each vertex of the mesh is transformed according to the supplied transformation. Normals are recalculated from the new vertex positions.
soma.aimsalgo.t1mapping module¶
Reconstruct magnetic resonance parametres.
This is mainly a reimplementation of scripts provided by Alexandre Vignaud, plus a few improvements functions (such as mask and B1 map holes filling).

class
soma.aimsalgo.t1mapping.
BAFIData
(amplitude_volume, phase_volume)[source]¶ B1 map reconstruction class using the VFA (Variable Flip Angle) method.
Pass the BAFI data as two amplitudephase 4D AIMS volumes.
The last dimension of both arrays represents the different echos.

static
correctB0
(FA_map, FA_phase, B0_map, tau, echo_time)[source]¶ Apply B0 correction to a B1 map.
This is a reimplementation of correctB0.m, courtesy of Alexandre Vignaud.

fix_b1_map
(b1map, smooth_type='median', gaussian=False, output_median=False)[source]¶ Fix/improve the B1 map by filling holes, smoothing, and extending it a little bit spacially so as to use it on the complete whole brain.
Parameters:  b1map (volume) – the B1 map to be corrected, may be the output of self.make_flip_angle_map()
 smooth_type (str (optional)) – smoothing correction type. default: ‘median’ median: dilated:
 gaussian (float (optional)) – default: 0 (not applied) perform an additional gaussian filtering of given stdev
 output_median (bool (optional)) – if set, the output will be a tuple including a 2nd volume: the medianfiltered B1 map. Only valid if smooth_type is ‘median’.
Returns:  The corrected B1 map.
 If output_median is set, the return value is a tuple
 (corrected B1 map, medianfiltered B1 map)

make_B0_map
()[source]¶ Build a map of B0 in Hz from BAFI data.
Return the map as a numpy array.
This is a reimplementation of Phase2B0Map.m, courtesy of Alexandre Vignaud.

make_B1_map
(B0_correction=False)[source]¶ Build a map of B1 (in radians) from BAFI data.
Return a numpy array of complex type.
This is a reimplementation of BAFI2B1map.m, courtesy of Alexandre Vignaud.
 The method is Yarnykh’s (MRM 57:192200 (2007)) +
 Amadon ISMRM2008 (MAFI sequence: simultaneaous cartography of B0
and B1)

make_flip_angle_map
()[source]¶ Build a map of actual flip angle (in radians) from BAFI data.
This is a reimplementation of BAFI2FAmap.m (courtesy of Alexandre Vignaud) modified to return only the real flip angle (omitting the phase).
 The method is Yarnykh’s (MRM 57:192200 (2007)) +
 Amadon ISMRM2008 (MAFI sequence: simultaneaous cartography of B0
and B1)

static

soma.aimsalgo.t1mapping.
correct_bias
(biased_vol, b1map, dp_gre_low_contrast=None, field_threshold=None)[source]¶ Apply bias correction on biased_vol according to the B1 map, and possibly a GRE low contrast image.
Without dp_gre_low_contrast image:
\[unbiased\_vol = biased\_vol / b1map\](plus improvements)
With dp_gre_low_contrast image:
\[unbiased\_vol = biased\_vol / (lowpass(dp\_gre\_low\_contrast) * b1map)\](roughly)
\(lowpass\) is currently a gaussian filter with
sigma=8mm
.method: courtesy of Alexandre Vignaud.
ref: ISMRM abstract Mauconduit et al.
All input images are expected to contain transformation information to a common space in their header (1st transformation, normally to the scannerbased referential). They are thus not expected to have the same field of view or voxel size, all are resampled to the biased_vol space.
The returned value is a tuple containing 2 images: the corrected image, and the multiplicative correction field.
Parameters:  biased_vol (volume) – volume to be corrected
 b1map (volume) – B1 map as flip angles in degrees, generally returned by BAFIData.make_flip_angle_map. May be improved (holes filled, dilated) using BAFIData.fix_b1_map() which is generally better.
 dp_gre_low_contrast (volume (optional)) – GRE low contrast image
 field_threshold (float (optional)) – Threshold for the corrective field before inversion: the biased image will be divided by this field. To avoid too high values, field values under this threshold are clamped. Null values are masked out, so the threshold applies only to nonnull values. If not specified, the threshold is 100 if the dp_gre_low_contrast is not provided, and 3000 when dp_gre_low_contrast is used. If field_threshold is 0, then no thresholding is applied.
Returns:  unbiased_vol (volume) – according to the calculations explained above. The returned image has the same voxel type as the input one (althrough calculations are performed in float in the function), and the grey levels are roughly adjusted to the level of input data (unless it produces overflow, in which case the max value is adjusted to fit in the voxel type).
 field (volume) – The correction field applied to the image (multiplicatively)
soma.wip.aimsalgo module¶

class
soma.wip.aimsalgo.foldsgraphthickness.
FoldsGraphThickness
(fold_graph, lgw_vol, gm_wm_mesh, gm_lcr_mesh, voronoi=None)[source]¶

class
soma.wip.aimsalgo.samplables.
SuperQuadricSamplable
(coefficients, bending=True, tapering=True, checkActivated=True, maxBoundingBoxVolume=10000000)[source]¶ Constructor of the class.
@type coefficients: list @param checkActivated: list of the 10 deformable superquadric coefficients.
 e1 : first shape parameter
 e2 : second shape parameter
 a1 : x axis ray
 a2 : y axis ray
 a3 : z axis ray
 k1 : first tapering parameter
 k2 : second tapering parameter
 k3 : third tapering parameter
 alpha : angle of bending plan
 kapa : curvature radius for the bending transform