mia-3dmany2one-nonrigid(1)

💖 mia-3dmany2one-nonrigid — like, the ICONIC registration tool 💖

okay bestie, welcome to mia-3dmany2one-nonrigid(1), from the General Commands Manual. she's a whole vibe and she's about to register your 3D image series. pull up a chair, grab a strawberry 🍓, and let's get into it.

---

✨ NAME ✨

mia-3dmany2one-nonrigid — Registration of series of 3D images 🦋

---

🌈 SYNOPSIS 🌈

mia-3dmany2one-nonrigid -i <in-file> [options]
<PLUGINS:3dimage/fullcost>

---

🎀 DESCRIPTION 🎀

so mia-3dmany2one-nonrigid runs the non-rigid registration of an image series by registering all images to a user-selected reference. that's the whole thing. she takes your whole little squad of images and aligns them to the one you picked. main character energy, honestly 👑

---

💅 OPTIONS 💅

📁 File-IO 📁

• -i, --in-file=(input, required); io — the input perfusion data set. required, so like, you literally cannot skip her 🙈 For supported file types see PLUGINS:3dimage/io
• -o, --out-file=(output); io — file name for the registered files ✨ For supported file types see PLUGINS:3dimage/io

🔥 Registration 🔥

• -O, --optimizer=gsl:opt=gd,step=0.1 — the Optimizer used for minimization. she's the one doing the actual work fr
• -l, --mg-levels=3 — multi-resolution levels. three of them, default, slay
• -f, --transForm=spline — transformation type. For supported plugins see PLUGINS:3dimage/transform
• -r, --ref=-1 — reference frame. here's the tea: -1 means "use image in the middle" — she'll pick the middle one for you, no cap

🫶 Help & Info 🫶

• -V, --verbose=warning — verbosity of output, prints messages of the given level and higher priorities. Supported priorities, starting at the lowest level, are:
  • trace — Function call trace
  • debug — Debug output
  • info — Low level messages
  • message — Normal messages
  • warning — Warnings
  • fail — Report test failures
  • error — Report errors
  • fatal — Report only fatal errors

(so like, trace is the loudest yapper, fatal is the "only tell me if it's dire" one 💀)

• --copyright — print copyright information 📜
• -h, --help — print this help 🆘
• -?, --usage — print a short help
• --version — print the version number and exit

⚙️ Processing ⚙️

• --threads=-1 — Maxiumum number of threads to use for processing (yes bestie, the typo is canon, I don't make the rules 💅). This number should be lower or equal to the number of logical processor cores in the machine. -1 means automatic estimation. she'll figure it out herself, iconic.

---

🧩 PLUGINS: 1d/spacialkernel 🧩

• cdiff — Central difference filter kernel, mirror boundary conditions are used.
  • (no parameters)
• gauss — spacial Gauss filter kernel. supported parameters are:
  • w = 1; uint in [0, inf) — half filter width.
• scharr — This plugin provides the 1D folding kernel for the Scharr gradient filter
  • (no parameters)

---

🌸 PLUGINS: 1d/splinebc 🌸

• mirror — Spline interpolation boundary conditions that mirror on the boundary
  • (no parameters)
• repeat — Spline interpolation boundary conditions that repeats the value at the boundary
  • (no parameters)
• zero — Spline interpolation boundary conditions that assumes zero for values outside
  • (no parameters)

---

🦋 PLUGINS: 1d/splinekernel 🦋

• bspline — B-spline kernel creation. supported parameters are:
  • d = 3; int in [0, 5] — Spline degree.
• omoms — OMoms-spline kernel creation. supported parameters are:
  • d = 3; int in [3, 3] — Spline degree.

---

🌈 PLUGINS: 3dimage/combiner 🌈

• absdiff — Image combiner 'absdiff'
  • (no parameters)
• add — Image combiner 'add'
  • (no parameters)
• div — Image combiner 'div'
  • (no parameters)
• mul — Image combiner 'mul'
  • (no parameters)
• sub — Image combiner 'sub'
  • (no parameters)

---

💜 PLUGINS: 3dimage/cost 💜

• lncc — local normalized cross correlation with masking support. supported parameters are:
  • w = 5; uint in [1, 256] — half width of the window used for evaluating the localized cross correlation.
• mi — Spline parzen based mutual information. supported parameters are:
  • cut = 0; float in [0, 40] — Percentage of pixels to cut at high and low intensities to remove outliers.
  • mbins = 64; uint in [1, 256] — Number of histogram bins used for the moving image.
  • mkernel = [bspline:d=3]; factory — Spline kernel for moving image parzen hinstogram. For supported plug-ins see PLUGINS:1d/splinekernel
  • rbins = 64; uint in [1, 256] — Number of histogram bins used for the reference image.
  • rkernel = [bspline:d=0]; factory — Spline kernel for reference image parzen hinstogram. For supported plug-ins see PLUGINS:1d/splinekernel
• ncc — normalized cross correlation.
  • (no parameters)
• ngf — This function evaluates the image similarity based on normalized gradient fields. Given normalized gradient fields $ _S$ of the src image and $ _R$ of the ref image various evaluators are implemented. supported parameters are:
  • eval = ds; dict — plugin subtype (sq, ds, dot, cross). Supported values are:
    • ds — square of scaled difference
    • dot — scalar product kernel
    • cross — cross product kernel
• ssd — 3D image cost: sum of squared differences. supported parameters are:
  • autothresh = 0; float in [0, 1000] — Use automatic masking of the moving image by only takeing intensity values into accound that are larger than the given threshold. (again, typo is canon, she said what she said 🫶)
  • norm = 0; bool — Set whether the metric should be normalized by the number of image pixels.
• ssd-automask — 3D image cost: sum of squared differences, with automasking based on given thresholds. supported parameters are:
  • rthresh = 0; double — Threshold intensity value for reference image.
  • sthresh = 0; double — Threshold intensity value for source image.

---

🎀 PLUGINS: 3dimage/filter 🎀

• bandpass — intensity bandpass filter. supported parameters are:
  • max = 3.40282e+38; float — maximum of the band.
  • min = 0; float — minimum of the band.
• binarize — image binarize filter. supported parameters are:
  • max = 3.40282e+38; float — maximum of accepted range.
  • min = 0; float — minimum of accepted range.
• close — morphological close. supported parameters are:
  • hint = black; string — a hint at the main image content (black|white).
  • shape = [sphere:r=2]; factory — structuring element. For supported plug-ins see PLUGINS:3dimage/shape
• combiner — Combine two images with the given combiner operator. if 'reverse' is set to false, the first operator is the image passed through the filter pipeline, and the second image is loaded from the file given with the 'image' parameter the moment the filter is run. supported parameters are:
  • image =(input, required, io) — second image that is needed in the combiner. For supported file types see PLUGINS:3dimage/io
  • op =(required, factory) — Image combiner to be applied to the images. For supported plug-ins see PLUGINS:3dimage/combiner
  • reverse = 0; bool — reverse the order in which the images passed to the combiner.
• convert — image pixel format conversion filter. supported parameters are:
  • a = 1; float — linear conversion parameter a.
  • b = 0; float — linear conversion parameter b.
  • map = opt; dict — conversion mapping. Supported values are:
    • copy — copy data when converting
    • linear — apply linear transformation x -> a*x+b
    • range — apply linear transformation that maps the input data type range to the output data type range
    • opt — apply a linear transformation that maps the real input range to the full output range
    • optstat — apply a linear transform that maps based on input mean and variation to the full output range
  • repn = ubyte; dict — output pixel type. Supported values are:
    • bit — binary data
    • sbyte — signed 8 bit
    • ubyte — unsigned 8 bit
    • sshort — signed 16 bit
    • ushort — unsigned 16 bit
    • sint — signed 32 bit
    • uint — unsigned 32 bit
    • slong — signed 64 bit
    • ulong — unsigned 64 bit
    • float — floating point 32 bit
    • double — floating point 64 bit
    • none — no pixel type defined
• crop — Crop a region of an image, the region is always clamped to the original image size in the sense that the given range is kept. supported parameters are:
  • end = [[4294967295,4294967295,4294967295]]; streamable — end of cropping range, maximum = (-1,-1,-1).
  • start = [[0,0,0]]; streamable — begin of cropping range.
• dilate — 3d image stack dilate filter. supported parameters are:
  • hint = black; string — a hint at the main image content (black|white).
  • shape = [sphere:r=2]; factory — structuring element. For supported plug-ins see PLUGINS:3dimage/shape
• distance — Evaluate the 3D distance transform of an image. If the image is a binary mask, then result of the distance transform in each point corresponds to the Euclidian distance to the mask. If the input image is of a scalar pixel value, then the this scalar is interpreted as heighfield and the per pixel value adds to the distance.
  • (no parameters)

---

to be continued bestie… this was only part 1 of 5, she's got so much more to say 💖

downscale

Ok so bestie, this one squishes your input image down by picking a block size that decides the downscale factor 💅. But nerd alert: before it scales anything it runs a smoothing filter over the image to kill off the high-frequency data so you don't get aliasing artifacts, okay? Obsessed with a filter that thinks ahead. Supported parameters are:

• b = [[1,1,1]]; 3dbounds — the blocksize, fr fr.
• bx = 1; uint in [1, inf) — blocksize in the x direction.
• by = 1; uint in [1, inf) — blocksize in the y direction.
• bz = 1; uint in [1, inf) — blocksize in the z direction.
• kernel = gauss; factory — the smoothing filter kernel that gets applied; the size of the filter is estimated based on the blocksize. For supported plug-ins see PLUGINS:1d/spacialkernel.

erode

A 3d image stack erode filter, iconic behavior honestly. Supported parameters are:

• hint = black; string — a hint at the main image content, and it's either black or white.
• shape = [sphere:r=2]; factory — the structuring element. For supported plug-ins see PLUGINS:3dimage/shape.

gauss

An isotropic 3D gauss filter — smooth brain energy but make it math ✨. Supported parameters are:

• w = 1; int in [0, inf) — filter width parameter.

gradnorm

3D image to gradient norm filter, slay.

• (no parameters) — yep, she takes zero arguments, she's just built different.

growmask

So here's the tea 🫖: you hand it an input binary mask plus a reference gray scale image, and it does region growing by adding the neighborhood pixels of a pixel that's already been added — but only if those pixels have a lower intensity that's still above the given threshold. Supported parameters are:

• min = 1; float — lower threshold for mask growing.
• ref =(input, required, io) — reference image for mask region growing. For supported file types see PLUGINS:3dimage/io.
• shape = 6n; factory — neighborhood mask. For supported plug-ins see PLUGINS:3dimage/shape.

invert

Intensity invert filter, the flipper of vibes 🌈.

• (no parameters) — nope, not a single one.

isovoxel

This filter scales an image so the voxel size becomes isometric, and it also scales the size to match the given value. Supported parameters are:

• interp = [bspline:d=3]; factory — interpolation kernel to be used . For supported plug-ins see PLUGINS:1d/splinekernel.
• size = 1; float in (0, inf) — isometric target voxel size.

kmeans

3D image k-means filter, lowkey a classic. In the output image the pixel value represents the class membership, and the class centers are stored as an attribute in the image — she keeps receipts 📝. Supported parameters are:

• c = 3; int in [2, inf) — number of classes.

label

A filter to label the connected components of a binary image. Supported parameters are:

• n = 6n; factory — neighborhood mask. For supported plug-ins see PLUGINS:3dimage/shape.

labelmap

Image filter to remap label id's. Heads up bestie: this one is only applicable to images with integer valued intensities/labels, no cap. Supported parameters are:

• map =(input, required, string) — Label mapping file.

labelscale

A filter that only creates output voxels that are already created in the input image. The scaling is done using a voting algorithm that selects the target pixel value based on the highest pixel count of a certain label in the corresponding source region. And if the region comprises two labels with the same count? The one with the lower number wins. Petty but fair 💅. Supported parameters are:

• out-size =(required, 3dbounds) — target size given as two coma separated values.

load

Load the input image from a file and use it to replace the current image in the pipeline. Main character behavior honestly. Supported parameters are:

• file =(input, required, io) — name of the input file to load from.. For supported file types see PLUGINS:3dimage/io.

lvdownscale

This is a label voting downscale filter. It downscales a 3D image by blocks. For each block, the (non-zero) label that appears the most times in the block gets issued as the output pixel in the target image. And if two labels appear the same number of times? The one with the lower absolute value wins 🏆. Supported parameters are:

• b = [[1,1,1]]; 3dbounds — blocksize for the downscaling. Each block will be represented by one pixel in the target image..

mask

Mask an image — one image is taken from the parameters list and the other from the normal filter input. Both images must be of the same dimensions and one must be binary, periodt. The attributes of the image coming through the filter pipeline are preserved. The output pixel type corresponds to the input image that is not binary. Supported parameters are:

• input =(input, required, io) — second input image file name. For supported file types see PLUGINS:3dimage/io.

mean

3D image mean filter, the average bestie of filters 🫶. Supported parameters are:

• w = 1; int in [1, inf) — half filter width.

median

Median 3d filter. Supported parameters are:

• w = 1; int in [1, inf) — filter width parameter.

mlv

Mean of Least Variance 3D image filter (MLV said what now 😭). Supported parameters are:

• w = 1; int in [1, inf) — filter width parameter.

msnormalizer

3D image mean-sigma normalizing filter. Supported parameters are:

• w = 1; int in [1, inf) — half filter width.

open

Morphological open. Supported parameters are:

• hint = black; string — a hint at the main image content, either black or white.
• shape = [sphere:r=2]; factory — structuring element. For supported plug-ins see PLUGINS:3dimage/shape.

reorient

3D image reorientation filter, she's giving glow-up transformation ✨. Supported parameters are:

• map = xyz; dict — oriantation mapping to be applied. Supported values are:
  • xyz ‐ keep orientation
  • p-yzx ‐ permutate x->z->y->x
  • p-zxy ‐ permutate x->y->z->x
  • f-yz ‐ flip y-z
  • f-xy ‐ flip x-y
  • f-xz ‐ flip x-z
  • r-x90 ‐ rotate around x-axis clockwise 90 degree
  • r-x180 ‐ rotate around x-axis clockwise 180 degree
  • r-x270 ‐ rotate around x-axis clockwise 270 degree
  • r-y90 ‐ rotate around y-axis clockwise 90 degree
  • r-y180 ‐ rotate around y-axis clockwise 180 degree
  • r-y270 ‐ rotate around y-axis clockwise 270 degree
  • r-z90 ‐ rotate around z-axis clockwise 90 degree
  • r-z180 ‐ rotate around z-axis clockwise 180 degree
  • r-z270 ‐ rotate around z-axis clockwise 270 degree

resize

Resize an image. The original data is centered within the new sized image — she's not squishing you into the corner, she's placing you in the middle 💖. Supported parameters are:

• size = [[0,0,0]]; streamable — new size of the image a size 0 indicates to keep the size for the corresponding dimension..

sandp

Salt and pepper 3d filter — seasoning the image, we love a chef 👩‍🍳. Supported parameters are:

• thresh = 100; float in [0, inf) — thresh value.
• w = 1; int in [1, inf) — filter width parameter.

scale

3D image filter that scales to a given target size. Supported parameters are:

• interp = [bspline:d=3]; factory — interpolation kernel to be used . For supported plug-ins see PLUGINS:1d/splinekernel.
• s = [[0,0,0]]; 3dbounds — target size to set all components at once (component 0: use input image size).
• sx = 0; uint in [0, inf) — target size in x direction (0: use input image size).
• sy = 0; uint in [0, inf) — target size in y direction (0: use input image size).
• sz = 0; uint in [0, inf) — target size in y direction (0: use input image size).

scharr

The 3D Scharr filter for gradient evaluation. Note bestie: the output pixel type of the filtered image is the same as the input pixel type, so converting the input beforehand to a floating point valued image is recommendable 📌. Supported parameters are:

• dir = x; dict — Gradient direction. Supported values are:
  • x ‐ gradient in x-direction
  • y ‐ gradient in y-direction
  • z ‐ gradient in z-direction

selectbig

A filter that creats a binary mask representing the intensity with the highest pixel count. The pixel value 0 will be ignored, and if two intensities have the same pixel count, then the result is undefined 💀. Also the input pixel must have an integral pixel type.

• (no parameters) — nothing to configure, she just decides.

sepconv

3D image intensity separaple convolution filter. Supported parameters are:

• kx = [gauss:w=1]; factory — filter kernel in x-direction. For supported plug-ins see PLUGINS:1d/spacialkernel.
• ky = [gauss:w=1]; factory — filter kernel in y-direction. For supported plug-ins see PLUGINS:1d/spacialkernel.
• kz = [gauss:w=1]; factory — filter kernel in z-direction. For supported plug-ins see PLUGINS:1d/spacialkernel.

sobel

The 2D Sobel filter for gradient evaluation. Same warning as before, bestie — the output pixel type of the filtered image is the same as the input pixel type, so converting the input beforehand to a floating point valued image is recommendable 🔥. Supported parameters are:

• dir = x; dict — Gradient direction. Supported values are:
  • x ‐ gradient in x-direction
  • y ‐ gradient in y-direction
  • z ‐ gradient in z-direction
• sws — seeded watershed 🫧. Bestie, this one pulls out exactly as many regions as you hand it initial labels in the seed image. No more, no less, it's giving precise. Its parameters:
  • grad = 0; bool — treat the input image as a gradient. Yes ma'am.
  • mark = 0; bool — mark the segmented watersheds with a special gray scale value.
  • n = [sphere:r=1]; factory — the neighborhood for watershed region growing. For the plug-ins that play nice here, peek at PLUGINS:3dimage/shape.
  • seed =(input, required, string) — the seed input image holding the labels for the initial regions. Required, so don't ghost it 🌸.
• tee — saves your input image to a file and passes it straight through to the next filter. Iconic middle-man behavior 💅. Parameters:
  • file =(output, required, io) — name of the output file to save the image to. For the file types it vibes with, see PLUGINS:3dimage/io.
• thinning — 3D morphological thinning ✨, based on: Lee and Kashyap, 'Building Skeleton Models via 3-D Medial Surface/Axis Thinning Algorithms', Graphical Models and Image Processing, 56(6):462-478, 1994. Heads up: this implementation only supports the 26 neighbourhood, periodt.
  • (no parameters) — yeah, she takes nothing 🎀
• transform — transforms the input image with the transformation you give it 🦋. Parameters:
  • file =(input, required, io) — name of the file containing the transformation. For supported file types see PLUGINS:3dtransform/io.
  • imgboundary = ; factory — override the image interpolation boundary conditions. For supported plug-ins see PLUGINS:1d/splinebc.
  • imgkernel = ; factory — override the image interpolator kernel. For supported plug-ins see PLUGINS:1d/splinekernel.
• variance — 3D image variance filter, lowkey a classic. Parameters:
  • w = 1; int in [1, inf) — half filter width.
• ws — basic watershed segmentation, the OG. Parameters:
  • evalgrad = 0; bool — set to 1 if your input image does not represent a gradient norm image 👀.
  • mark = 0; bool — mark the segmented watersheds with a special gray scale value.
  • n = [sphere:r=1]; factory — the neighborhood for watershed region growing. For supported plug-ins see PLUGINS:3dimage/shape.
  • thresh = 0; float in [0, 1) — relative gradient norm threshold. The actual threshold value is thresh * (max_grad - min_grad) + min_grad. Basins separated by gradients with a lower norm will get joined, fr fr.

---

🌈 PLUGINS: 3dimage/fullcost 🌈

• image — a generalized image similarity cost function that also handles multi-resolution processing 🧚. The actual similarity measure is given as an extra parameter. Parameters:
  • cost = ssd; factory — cost function kernel. For supported plug-ins see PLUGINS:3dimage/cost.
  • debug = 0; bool — save intermediate results for debugging 🐛.
  • ref =(input, io) — reference image. For supported file types see PLUGINS:3dimage/io.
  • src =(input, io) — study image. For supported file types see PLUGINS:3dimage/io.
  • weight = 1; float — weight of the cost function.
• labelimage — a similarity cost function that maps the labels of two images and handles label-preserving multi-resolution processing 🏷️. Parameters:
  • maxlabel = 256; int in [2, 32000] — maximum number of labels to consider.
  • ref =(input, io) — reference image. For supported file types see PLUGINS:3dimage/io.
  • src =(input, io) — study image. For supported file types see PLUGINS:3dimage/io.
  • weight = 1; float — weight of the cost function.
• maskedimage — a generalized masked image similarity cost function that also handles multi-resolution processing 🎭. Okay so listen: the masks you provide should be densely filled regions in multi-resolution processing, because otherwise the mask info can get lost when the image gets downscaled. The mask may be pre-filtered — but after pre-filtering the masks must be of bit-type. The reference mask and the transformed mask of the study image get combined by binary AND. The actual similarity measure is given as an extra parameter. Parameters:
  • cost = ssd; factory — cost function kernel. For supported plug-ins see PLUGINS:3dimage/maskedcost.
  • ref =(input, io) — reference image. For supported file types see PLUGINS:3dimage/io.
  • ref-mask =(input, io) — reference image mask (binary). For supported file types see PLUGINS:3dimage/io.
  • ref-mask-filter = ; factory — filter to prepare the reference mask image; the output must be a binary image. For supported plug-ins see PLUGINS:3dimage/filter.
  • src =(input, io) — study image. For supported file types see PLUGINS:3dimage/io.
  • src-mask =(input, io) — study image mask (binary). For supported file types see PLUGINS:3dimage/io.
  • src-mask-filter = ; factory — filter to prepare the study mask image; the output must be a binary image. For supported plug-ins see PLUGINS:3dimage/filter.
  • weight = 1; float — weight of the cost function.
• taggedssd — evaluates the Sum of Squared Differences similarity measure by using three tagged image pairs 🌟. The cost function value is evaluated based on all the image pairs, but the gradient gets composed by composing its component based on the tag direction. The way this works is so satisfying ngl. Parameters:
  • refx =(input, io) — reference image X-tag. For supported file types see PLUGINS:3dimage/io.
  • refy =(input, io) — reference image Y-tag. For supported file types see PLUGINS:3dimage/io.
  • refz =(input, io) — reference image Z-tag. For supported file types see PLUGINS:3dimage/io.
  • srcx =(input, io) — study image X-tag. For supported file types see PLUGINS:3dimage/io.
  • srcy =(input, io) — study image Y-tag. For supported file types see PLUGINS:3dimage/io.
  • srcz =(input, io) — study image Z-tag. For supported file types see PLUGINS:3dimage/io.
  • weight = 1; float — weight of the cost function.

✨ PLUGINS: 3dimage/io ✨

okay bestie, this is the whole ✨file format roster✨ — every single image type this plugin set knows how to read and write. each one tells you which file extensions it vibes with and which element types it can handle. no skipping, we're doing all of them 💅

🎀 analyze — Analyze 7.5 image

Recognized file extensions: .HDR, .hdr

Supported element types:

• unsigned 8 bit
• signed 16 bit
• signed 32 bit
• floating point 32 bit
• floating point 64 bit

🎀 datapool — Virtual IO to and from the internal data pool

Recognized file extensions: .@

(it doesn't list element types and honestly? iconic of it.)

🎀 dicom — Dicom image series as 3D

Recognized file extensions: .DCM, .dcm

Supported element types:

• signed 16 bit
• unsigned 16 bit

🎀 hdf5 — HDF5 3D image IO

Recognized file extensions: .H5, .h5

Supported element types:

• binary data
• signed 8 bit
• unsigned 8 bit
• signed 16 bit
• unsigned 16 bit
• signed 32 bit
• unsigned 32 bit
• signed 64 bit
• unsigned 64 bit
• floating point 32 bit
• floating point 64 bit

look at that list, it's giving "collect them all" energy 🔥

🎀 inria — INRIA image

Recognized file extensions: .INR, .inr

Supported element types:

• signed 8 bit
• unsigned 8 bit
• signed 16 bit
• unsigned 16 bit
• signed 32 bit
• unsigned 32 bit
• floating point 32 bit
• floating point 64 bit

🎀 mhd — MetaIO 3D image IO using the VTK implementation (experimental)

note the (experimental) bestie, that's not a drill, that's a whole vibe warning 🫶

Recognized file extensions: .MHA, .MHD, .mha, .mhd

Supported element types:

• signed 8 bit
• unsigned 8 bit
• signed 16 bit
• unsigned 16 bit
• signed 32 bit
• unsigned 32 bit
• floating point 32 bit
• floating point 64 bit

🎀 nifti — NIFTI-1 3D image IO

The orientation is transformed in the same way like it is done with dicomtonifti --no-reorder from the vtk-dicom package. (iykyk ✨)

Recognized file extensions: .NII, .nii

Supported element types:

• signed 8 bit
• unsigned 8 bit
• signed 16 bit
• unsigned 16 bit
• signed 32 bit
• unsigned 32 bit
• signed 64 bit
• unsigned 64 bit
• floating point 32 bit
• floating point 64 bit

🎀 vff — VFF Sun raster format

Recognized file extensions: .VFF, .vff

Supported element types:

• unsigned 8 bit
• signed 16 bit

short list, but she does what she does 💖

🎀 vista — Vista 3D

Recognized file extensions: .-, .V, .VISTA, .v, .vista

Supported element types:

• binary data
• signed 8 bit
• unsigned 8 bit
• signed 16 bit
• unsigned 16 bit
• signed 32 bit
• unsigned 32 bit
• floating point 32 bit
• floating point 64 bit

🎀 vti — 3D image VTK-XML in- and output (experimental)

experimental again, bestie, proceed with the cute caution 🌸

Recognized file extensions: .VTI, .vti

Supported element types:

• signed 8 bit
• unsigned 8 bit
• signed 16 bit
• unsigned 16 bit
• signed 32 bit
• unsigned 32 bit
• floating point 32 bit
• floating point 64 bit

🎀 vtk — 3D VTK image legacy in- and output (experimental)

yeah yeah, experimental too 🙈

Recognized file extensions: .VTK, .VTKIMAGE, .vtk, .vtkimage

Supported element types:

• signed 8 bit
• unsigned 8 bit
• signed 16 bit
• unsigned 16 bit
• signed 32 bit
• unsigned 32 bit
• floating point 32 bit
• floating point 64 bit

---

💖 PLUGINS: 3dimage/maskedcost 💖

this is the cost-function squad but with masking support — like, we only care about the pixels that matter, and the rest can go home 🫶

lncc — local normalized cross correlation with masking support.

supported parameters are:

• w = 5; uint in [1, 256] — half width of the window used for evaluating the localized cross correlation.

mi — Spline parzen based mutual information with masking.

supported parameters are:

• cut = 0; float in [0, 40] — Percentage of pixels to cut at high and low intensities to remove outliers.
• mbins = 64; uint in [1, 256] — Number of histogram bins used for the moving image.
• mkernel = [bspline:d=3]; factory — Spline kernel for moving image parzen hinstogram. For supported plug-ins see PLUGINS:1d/splinekernel
• rbins = 64; uint in [1, 256] — Number of histogram bins used for the reference image.
• rkernel = [bspline:d=0]; factory — Spline kernel for reference image parzen hinstogram. For supported plug-ins see PLUGINS:1d/splinekernel

(yes, "hinstogram" — that's literally what it says, we do not editorialize the typo, we respect the typo 💅)

ncc — normalized cross correlation with masking support.

(no parameters)

she literally needs nothing from you. main character energy 👑

ssd — Sum of squared differences with masking.

(no parameters)

also taking nothing, also slaying ✨

---

🦋 PLUGINS: 3dimage/shape 🦋

shape creators!! these build neighborhoods, aka "who counts as my neighbor" definitions, and there are exactly four of them 🎀

18n — 18n neighborhood 3D shape creator

(no parameters)

26n — 26n neighborhood 3D shape creator

(no parameters)

6n — 6n neighborhood 3D shape creator

(no parameters)

sphere — Closed spherical shape neighborhood including the pixels within a given radius r.

supported parameters are:

• r = 2; float in (0, inf) — sphere radius.

🩷 affine

Affine transformation (12 degrees of freedom), and the parameters it supports are:

• imgboundary = mirror; factory — the boundary conditions for image interpolation. For the plug-ins that are supported here, go peek at PLUGINS:1d/splinebc ✨
• imgkernel = [bspline:d=3]; factory — the image interpolator kernel. Supported plug-ins are listed in PLUGINS:1d/splinekernel 💫

🌀 axisrot

Restricted rotation transformation (1 degree of freedom). The way this works is: the transformation is restricted to rotating around the axis you give, about the rotation center you give. Parameters supported:

• axis = (required, 3dfvector) — the rotation axis.
• imgboundary = mirror; factory — image interpolation boundary conditions. Supported plug-ins live in PLUGINS:1d/splinebc ✨
• imgkernel = [bspline:d=3]; factory — image interpolator kernel. Supported plug-ins live in PLUGINS:1d/splinekernel 💫
• origin = (required, 3dfvector) — the center of the transformation.

🎀 raffine

Restricted affine transformation (3 degrees of freedom). The transformation is restricted to rotating around the given axis plus shearing along the two axes perpendicular to that one. Parameters:

• axis = (required, 3dfvector) — the rotation axis.
• imgboundary = mirror; factory — image interpolation boundary conditions. Supported plug-ins: PLUGINS:1d/splinebc ✨
• imgkernel = [bspline:d=3]; factory — image interpolator kernel. Supported plug-ins: PLUGINS:1d/splinekernel 💫
• origin = (required, 3dfvector) — the center of the transformation.

🦋 rigid

Rigid transformation, aka rotation and translation (six degrees of freedom) — and the params are:

• imgboundary = mirror; factory — image interpolation boundary conditions. Supported plug-ins: PLUGINS:1d/splinebc ✨
• imgkernel = [bspline:d=3]; factory — image interpolator kernel. Supported plug-ins: PLUGINS:1d/splinekernel 💫
• origin = [[0,0,0]]; 3dfvector — the relative rotation center, meaning <0.5,0.5,0.5> is literally the center of the volume 👑

🌸 rotation

Rotation transformation (three degrees of freedom), with these params:

• imgboundary = mirror; factory — image interpolation boundary conditions. Supported plug-ins: PLUGINS:1d/splinebc ✨
• imgkernel = [bspline:d=3]; factory — image interpolator kernel. Supported plug-ins: PLUGINS:1d/splinekernel 💫
• origin = [[0,0,0]]; 3dfvector — the relative rotation center, so <0.5,0.5,0.5> is the center of the volume ✨

🌈 rotbend

Restricted transformation (4 degrees of freedom). It's restricted to rotation around the x and y axes plus a bending along the x axis — independent in each direction — where the bending grows with the squared distance from the rotation axis. Params:

• imgboundary = mirror; factory — image interpolation boundary conditions. Supported plug-ins: PLUGINS:1d/splinebc ✨
• imgkernel = [bspline:d=3]; factory — image interpolator kernel. Supported plug-ins: PLUGINS:1d/splinekernel 💫
• norot = 0; bool — don't optimize the rotation. That's it, that's the whole job 🫶
• origin = (required, 3dfvector) — the center of the transformation.

💜 spline

Free-form transformation that you can describe with a set of B-spline coefficients plus an underlying B-spline kernel. Params:

• anisorate = [[0,0,0]]; 3dfvector — anisotropic coefficient rate in pixels. Heads up bestie: nonpositive values get overwritten by the rate value. 🫠
• debug = 0; bool — turns on extra debugging output 🐛
• imgboundary = mirror; factory — image interpolation boundary conditions. Supported plug-ins: PLUGINS:1d/splinebc ✨
• imgkernel = [bspline:d=3]; factory — image interpolator kernel. Supported plug-ins: PLUGINS:1d/splinekernel 💫
• kernel = [bspline:d=3]; factory — the transformation spline kernel. Supported plug-ins: PLUGINS:1d/splinekernel ⭐
• penalty = ; factory — the transformation penalty energy term. Supported plug-ins: PLUGINS:3dtransform/splinepenalty 🔥
• rate = 10; float in [1, inf) — isotropic coefficient rate in pixels.

💅 translate

Translation (three degrees of freedom), params below:

• imgboundary = mirror; factory — image interpolation boundary conditions. Supported plug-ins: PLUGINS:1d/splinebc ✨
• imgkernel = [bspline:d=3]; factory — image interpolator kernel. Supported plug-ins: PLUGINS:1d/splinekernel 💫

🧚 vf

This plug-in implements a transformation that defines a translation for every single point of the grid that defines the domain of the transformation. Params:

• imgboundary = mirror; factory — image interpolation boundary conditions. Supported plug-ins: PLUGINS:1d/splinebc ✨
• imgkernel = [bspline:d=3]; factory — image interpolator kernel. Supported plug-ins: PLUGINS:1d/splinekernel 💫

---

📦 PLUGINS: 3dtransform/io 📦

💾 bbs

Binary (non-portable) serialized IO of 3D transformations. Non-portable, ok? Say it with me: non-portable. 😭

Recognized file extensions: .bbs

🗄️ datapool

Virtual IO to and from the internal data pool ✨

Recognized file extensions: .@

🖼️ vista

Vista storage of 3D transformations 🌸

Recognized file extensions: .v, .v3dt

📝 xml

XML serialized IO of 3D transformations 💜

Recognized file extensions: .x3dt

---

🧮 PLUGINS: 3dtransform/splinepenalty 🧮

🌀 divcurl

divcurl penalty on the transformation. Supported params:

• curl = 1; float in [0, inf) — penalty weight on curl.
• div = 1; float in [0, inf) — penalty weight on divergence.
• norm = 0; bool — set it to 1 if the penalty should be normalized with respect to the image size.
• weight = 1; float in (0, inf) — weight of the penalty energy.

---

🔥 EXAMPLE 🔥

Register the images given as numbered files imagesXXXX.v by optimizing a spline based transformation with a coefficient rate of 16 pixel, using a weighted combination of normalized gradient fields and SSD as cost measure, and penalize the transformation using divcurl with a weight of 2.0. Store the resulting images in registeredXXXX.v.

mia-3dmany2one-nonrigid -i images0000.v -o  registered%04d.v -F
       spline:rate=16 image:cost=[ngf:eval=ds],weight=2.0
       image:cost=ssd,weight=0.1 divcurl:weight=2.0

---

🌟 AUTHOR(s) 🌟

Gert Wollny

📜 COPYRIGHT 📜

This software is Copyright (c) 1999‐2015 Leipzig, Germany and Madrid, Spain. It comes with ABSOLUTELY NO WARRANTY and you may redistribute it under the terms of the GNU GENERAL PUBLIC LICENSE Version 3 (or later). For more information run the program with the option --copyright.

Bestie, that "ABSOLUTELY NO WARRANTY" is not a vibe, it's a fact — this comes as-is, no promises, no cap 💀

---

okay that's the whole thing, we did it 🎉 that was the USER COMMANDS page for mia-3dmany2one-nonrigid(1), version v2.4.7 — and that copyright date range rolling from 1999 on through 2015 (Leipzig, Germany → Madrid, Spain, we love a multinational era 💖). love u, go register some scans, mwah 🫶✨