Provided by: mia-tools_2.0.13-1_amd64 bug

NAME

       mia-2dstackfilter - Filter a series of 2D images in a 3D fashion.

SYNOPSIS

       mia-2dstackfilter -i <in-file> -o <out-file> -t <type> [options] <PLUGINS:2dstack/filter>

DESCRIPTION

       mia-2dstackfilter  This  program  is  used to filter and convert a series of 2D gray scale images in a 3D
       fashion by running filters (filter/2dimage) as given on the command line.

OPTIONS

              -i --in-file=(required)
                     input image(s) to be filtered  For supported file types see PLUGINS:2dimage/io

              -o --out-file=(required)
                     output file name base, the actual names is created by  adding  the  file  number  based  on
                     output  order and the extension bysed on the 'type' parameter  For supported file types see
                     PLUGINS:2dimage/io

              -t --type=(required)
                     output file type

                 --help-plugins
                     give some help about the filter plugins

   Help & Info
              -V --verbose=warning
                     verbosity of output, print  messages  of  given  level  and  higher  priorities.  Supported
                     priorities starting at lowest level are:
                        info ‐ Low level messages
                        warning ‐ Warnings
                        error ‐ Report errors
                        fail ‐ Report test failures
                        message ‐ Normal messages
                        fatal ‐ Report only fatal errors

                 --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,This number should be lower or equal to
                     the number of logical processor cores in the machine. (-1: automatic estimation).

PLUGINS: 1d/spacialkernel

       gauss     spacial Gauss filter kernel, supported parameters are:

                     w = 1 (int)
                       half filter width.  in [0, 2147483647]

PLUGINS: 1d/splinekernel

       bspline   B-spline kernel creation , supported parameters are:

                     d = 3 (int)
                       Spline degree.  in [0, 5]

       omoms     OMoms-spline kernel creation, supported parameters are:

                     d = 3 (int)
                       Spline degree.  in [3, 3]

PLUGINS: 2dimage/filter

       adaptmed  2D image adaptive median filter, supported parameters are:

                     w = 2 (int)
                       half filter width.  in [0, 2147483647]

       admean    An adaptive mean filter that works like a normal mean filter, if the intensity variation within
                 the filter mask is lower then the intensity variation in the  whole  image,  that  the  uses  a
                 special formula if the local variation is higher then the image intensity variation., supported
                 parameters are:

                     w = 1 (int)
                       half filter width.  in [0, 2147483647]

       aniso     2D Anisotropic image filter, supported parameters are:

                     epsilon = 1 (float)
                       iteration change threshold.  in [0.001, 100]

                     iter = 100 (int)
                       number of iterations.  in [1, 10000]

                     k = -1 (float)
                       k the noise threshold (<=0 -> adaptive).  in [0, 100]

                     n = 8 (set)
                       neighbourhood.  Supported values are:( 4,  8,  )

                     psi = tuckey (dict)
                       edge stopping function.  Supported values are:
                           guess ‐ test stopping function
                           tuckey ‐ tukey stopping function
                           pm1 ‐ stopping function 1
                           pm2 ‐ stopping function 2

       bandpass  intensity bandpass filter, supported parameters are:

                     max = 3.40282e+38 (float)
                       maximum of the band.  in [-3.40282e+38, 3.40282e+38]

                     min = 0 (float)
                       minimum of the band.  in [-3.40282e+38, 3.40282e+38]

       binarize  image binarize filter, supported parameters are:

                     max = 3.40282e+38 (float)
                       maximum of accepted range.  in [0, 3.40282e+38]

                     min = 0 (float)
                       minimum of accepted range.  in [0, 3.40282e+38]

       close     morphological close, supported parameters are:

                     hint = black (set)
                       a hint at the main image content.  Supported values are:( black,  white,  )

                     shape = [sphere:r=2] (factory)
                       structuring element.  For supported plug-ins see PLUGINS:2dimage/shape

       convert   image pixel format conversion filter, supported parameters are:

                     a = 1 (float)
                       linear conversion parameter a.  in [-3.40282e+38, 3.40282e+38]

                     b = 0 (float)
                       linear conversion parameter b.  in [-3.40282e+38, 3.40282e+38]

                     map = opt (dict)
                       conversion mapping.  Supported values are:
                           opt ‐ apply a linear transformation that maps the real input range to the full output
                           range
                           range ‐ apply linear transformation that maps the input data type range to the output
                           data type range
                           copy ‐ copy data when converting
                           linear ‐ apply linear transformation x -> a*x+b
                           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:
                           float ‐ floating point 32 bit
                           sbyte ‐ signed 8 bit
                           ulong ‐ unsigned 64 bit
                           double ‐ floating point 64 bit
                           sint ‐ signed 32 bit
                           ushort ‐ unsigned 16 bit
                           sshort ‐ signed 16 bit
                           uint ‐ unsigned 32 bit
                           slong ‐ signed 64 bit
                           bit ‐ binary data
                           ubyte ‐ unsigned 8 bit

       crop      Crop  a region of an image, the region is always clamped to the original image size., supported
                 parameters are:

                     end = [[-1,-1]] (streamable)
                       end of crop region.

                     start = [[0,0]] (streamable)
                       start of crop region.

       dilate    2d image stack dilate filter, supported parameters are:

                     hint = black (set)
                       a hint at the main image content.  Supported values are:( black,  white,  )

                     shape = [sphere:r=2] (factory)
                       structuring element.  For supported plug-ins see PLUGINS:2dimage/shape

       distance  2D image distance filter, evaluates the distance map for a binary mask.

                     (no parameters)

       downscale Downscale the input image by using a given block size to define the downscale factor. Prior  to
                 scaling  the image is filtered by a smoothing filter to eliminate high frequency data and avoid
                 aliasing artifacts., supported parameters are:

                     b = [[1,1]] (2dbounds)
                       blocksize.

                     bx = 1 (uint)
                       blocksize in x direction.  in [1, 2147483647]

                     by = 1 (uint)
                       blocksize in y direction.  in [1, 2147483647]

                     kernel = gauss (factory)
                       smoothing filter kernel to be applied, the size of the filter is estimated based  on  the
                       blocksize..  For supported plug-ins see PLUGINS:1d/spacialkernel

       erode     2d image stack erode filter, supported parameters are:

                     hint = black (set)
                       a hint at the main image content.  Supported values are:( black,  white,  )

                     shape = [sphere:r=2] (factory)
                       structuring element.  For supported plug-ins see PLUGINS:2dimage/shape

       gauss     isotropic 2D gauss filter, supported parameters are:

                     w = 1 (int)
                       filter width parameter.  in [0, 2147483647]

       gradnorm  2D image to gradient norm filter, supported parameters are:

                     normalize = 0 (bool)
                       Normalize the gradient norms to range [0,1]..

       invert    intensity invert filter

                     (no parameters)

       kmeans    2D  image  k-means  filter. In the output image the pixel value represents the class membership
                 and the class centers are stored as attribute in the image., supported parameters are:

                     c = 3 (int)
                       number of classes.  in [2, 255]

       label     Label connected components in a binary 2D image., supported parameters are:

                     n = 4n (factory)
                       Neighborhood   mask   to   describe   connectivity..    For   supported   plug-ins    see
                       PLUGINS:2dimage/shape

       labelmap  2D image filter to remap label id's., supported parameters are:

                     map = (required, string)
                       Label mapping file.

       load      Load  the  input  image  from  a file and use it to replace the current image in the pipeline.,
                 supported parameters are:

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

       mask      2D masking, one of the two input images must by of type bit., supported parameters are:

                     fill = min (dict)
                       fill style for pixels outside of the mask.  Supported values are:
                           max ‐ set values outside the mask to the maximum value found in the image..
                           zero ‐ set the values outside the mask to zero.
                           min ‐ set values outside the mask to the minimum value found in the image.

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

                     inverse = 0 (bool)
                       set to true to use the inverse of the mask for masking.

       mean      2D image mean filter, supported parameters are:

                     w = 0 (int)
                       half filter width.  in [0, 2147483647]

       median    2D image median filter, supported parameters are:

                     w = 0 (int)
                       half filter width.  in [0, 2147483647]

       mlv       Mean of Least Variance 2D image filter, supported parameters are:

                     w = 1 (int)
                       filter width parameter.  in [0, 2147483647]

       ngfnorm   2D image to normalized-gradiend-field-norm filter

                     (no parameters)

       noise     2D image noise filter: add additive or modulated noise to an image, supported parameters are:

                     g = [gauss:mu=0,sigma=10] (factory)
                       noise generator.  For supported plug-ins see PLUGINS:generator/noise

                     mod = 0 (bool)
                       additive or modulated noise.

       open      morphological open, supported parameters are:

                     hint = black (set)
                       a hint at the main image content.  Supported values are:( black,  white,  )

                     shape = [sphere:r=2] (factory)
                       structuring element.  For supported plug-ins see PLUGINS:2dimage/shape

       pruning   Morphological pruning. Pruning until convergence will  erase  all  pixels  but  closed  loops.,
                 supported parameters are:

                     iter = 0 (int)
                       Number of iterations to run, 0=until convergence.  in [1, 1000000]

       regiongrow
                 Region  growing startin from a seed until only along increasing gradients, supported parameters
                 are:

                     n = 8n (factory)
                       Neighborhood shape.  For supported plug-ins see PLUGINS:2dimage/shape

                     seed = (required, io)
                       seed image (bit valued).  For supported file types see PLUGINS:2dimage/io

       sandp     salt and pepper  3d filter, supported parameters are:

                     thresh = 100 (float)
                       thresh value.  in [0, 3.40282e+38]

                     w = 1 (int)
                       filter width parameter.  in [0, 2147483647]

       scale     2D image downscale filter, supported parameters are:

                     interp = [bspline:d=3] (factory)
                       interpolation method to be used .  For supported plug-ins see PLUGINS:1d/splinekernel

                     s = [[0,0]] (2dbounds)
                       target size as 2D vector.

                     sx = 0 (uint)
                       target size in x direction, 0: use input size.  in [0, 4294967295]

                     sy = 0 (uint)
                       target size in y direction, 0: use input size.  in [0, 4294967295]

       selectbig 2D label select biggest component filter

                     (no parameters)

       sepconv   2D 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

       shmean    2D image filter that evaluates the mean over a given neighborhood shape,  supported  parameters
                 are:

                     shape = 8n (factory)
                       neighborhood    shape    to    evaluate   the   mean.    For   supported   plug-ins   see
                       PLUGINS:2dimage/shape

       sort-label
                 This plug-in sorts the labels of a gray-scale image so that the lowest label value  corresponts
                 to the lable with themost pixels. The background (0) is not touched

                     (no parameters)

       sws       seeded  watershead. The algorithm extracts exactly so many reagions as initial labels are given
                 in the seed image., supported parameters are:

                     grad = 0 (bool)
                       Interpret the input image as gradient. .

                     mark = 0 (bool)
                       Mark the segmented watersheds with a special gray scale value.

                     n = [sphere:r=1] (factory)
                       Neighborhood   for   watershead   region   growing.    For   supported    plug-ins    see
                       PLUGINS:2dimage/shape

                     seed = (required, string)
                       seed input image containing the lables for the initial regions.

       tee       Save  the  input  image  to  a  file  and  also  pass  it through to the next filter, supported
                 parameters are:

                     file = (required, io)
                       name of the  output  file  to  save  the  image  too..   For  supported  file  types  see
                       PLUGINS:2dimage/io

       thinning  Morphological  thinning.  Thinning  until  convergence  will  result in a 8-connected skeleton,
                 supported parameters are:

                     iter = 0 (int)
                       Number of iterations to run, 0=until convergence.  in [1, 1000000]

       thresh    This filter sets all pixels of an image to zero that fall below a certain threshhold and  whose
                 neighbours  in  a  given  neighborhood  shape  also  fall  below  a  this threshhold, supported
                 parameters are:

                     shape = 4n (factory)
                       neighborhood   shape   to   take   into   account.    For    supported    plug-ins    see
                       PLUGINS:2dimage/shape

                     thresh = 5 (double)
                       The threshhold value.  in [-1.79769e+308, 1.79769e+308]

       transform Transform the input image with the given transformation., supported parameters are:

                     file = (required, io)
                       Name  of  the  file  containing  the  transformation..   For  supported  file  types  see
                       PLUGINS:2dtransform/io

       ws        basic watershead segmentation., supported parameters are:

                     evalgrad = 0 (bool)
                       Set to 1 if the 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)
                       Neighborhood   for   watershead   region   growing.    For   supported    plug-ins    see
                       PLUGINS:2dimage/shape

                     thresh = 0 (float)
                       Relative gradient norm threshold. The actual value threshhold value is thresh * (max_grad
                       -  min_grad) + min_grad. Bassins separated by gradients with a lower norm will be joined.
                       in [0, 1]

PLUGINS: 2dimage/io

       bmp       BMP 2D-image input/output support

                     Recognized file extensions:  .BMP, .bmp

                     Supported element types:
                       binary data, unsigned 8 bit, unsigned 16 bit

       datapool  Virtual IO to and from the internal data pool

                     Recognized file extensions:  .@

       dicom     2D image io for DICOM

                     Recognized file extensions:  .DCM, .dcm

                     Supported element types:
                       unsigned 16 bit

       exr       a 2dimage io plugin for OpenEXR images

                     Recognized file extensions:  .EXR, .exr

                     Supported element types:
                       unsigned 32 bit, floating point 32 bit

       jpg       a 2dimage io plugin for jpeg gray scale images

                     Recognized file extensions:  .JPEG, .JPG, .jpeg, .jpg

                     Supported element types:
                       unsigned 8 bit

       png       a 2dimage io plugin for png images

                     Recognized file extensions:  .PNG, .png

                     Supported element types:
                       binary data, unsigned 8 bit, unsigned 16 bit

       raw       RAW 2D-image output support

                     Recognized file extensions:  .RAW, .raw

                     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

       tif       TIFF 2D-image input/output support

                     Recognized file extensions:  .TIF, .TIFF, .tif, .tiff

                     Supported element types:
                       binary data, unsigned 8 bit, unsigned 16 bit, unsigned 32 bit

       vista     a 2dimage io plugin for vista images

                     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

PLUGINS: 2dimage/shape

       1n        A shape that only contains the central point

                     (no parameters)

       4n        4n neighborhood 2D shape

                     (no parameters)

       8n        8n neighborhood 2D shape

                     (no parameters)

       rectangle rectangle shape mask creator, supported parameters are:

                     fill = 1 (bool)
                       create a filled shape.

                     height = 2 (int)
                       height of rectangle.  in [0, 2147483647]

                     width = 2 (int)
                       width of rectangle.  in [0, 2147483647]

       sphere    Closed spherical neighborhood shape of radius r., supported parameters are:

                     r = 2 (float)
                       sphere radius.  in [0, 3.40282e+38]

       square    square shape mask creator, supported parameters are:

                     fill = 1 (bool)
                       create a filled shape.

                     width = 2 (int)
                       width of rectangle.  in [0, 2147483647]

PLUGINS: 2dstack/filter

       byslice   Runs a filter on a per slice basis. In essence, this is a wrapper that makes it possible to add
                 pure 2D filters  to  the  stack  filter  pipeline  without  ducplicating  the  implementation.,
                 supported parameters are:

                     filter = (required, factory)
                       2D filter to be applied.  For supported plug-ins see PLUGINS:2dimage/filter

       close     2D Stack morphological filter 'close', supported parameters are:

                     shape = 6n (factory)
                       structuring element.  For supported plug-ins see PLUGINS:3dimage/shape

       dilate    2D Stack morphological filter 'dilate', supported parameters are:

                     shape = 6n (factory)
                       structuring element.  For supported plug-ins see PLUGINS:3dimage/shape

       erode     2D Stack morphological filter 'erode', supported parameters are:

                     shape = 6n (factory)
                       structuring element.  For supported plug-ins see PLUGINS:3dimage/shape

       gauss     Gauss 2D fifo filter, supported parameters are:

                     w = 1 (int)
                       filter width parameter (2*w+1).  in [0, 2147483647]

       label     Stack Label filter, supported parameters are:

                     map = (required, string)
                       Mapfile to save label numbers that are joined.

                     n = 4n (factory)
                       2D   neighbourhood   shape   to   define   connectedness.   For  supported  plug-ins  see
                       PLUGINS:2dimage/shape

       median    median 2D fifo filter, supported parameters are:

                     w = 1 (int)
                       filter width parameter.  in [0, 2147483647]

       mlv       Mean of Least Variance 2D stack image filter, supported parameters are:

                     w = 1 (int)
                       filter width parameter.  in [0, 2147483647]

       open      2D Stack morphological filter 'open', supported parameters are:

                     shape = 6n (factory)
                       structuring element.  For supported plug-ins see PLUGINS:3dimage/shape

       regiongrow
                 Run a region-growing filter on a stack of images that comprise a 3D image.  The region  growing
                 is  based  on  class  probabilities  obtained  from  a  c-means  classification  of  the  pixel
                 intensities. One seed thresh is use to initiate a region, and another (lower) threshold is used
                 to stop the region growing. By holding a number of 3D slices in the working memory to allow the
                 region to grow "backwards " in the stack a  Quasi-3D  processing  is  achieved.  However,  with
                 complex structures the region growing may not properly be segmented., supported parameters are:

                     class = 2 (int)
                       class to be segmented.  in [0, 2147483647]

                     depth = 10 (int)
                       number of slices to keep during processing.  in [5, 2147483647]

                     low = 0.5 (float)
                       low threshold for acceptance probability.  in [0, 1]

                     map = (required, string)
                       seed class map.

                     seed = 0.98 (float)
                       threshold for seed probability.  in [0, 1]

PLUGINS: 2dtransform/io

       bbs       Binary (non-portable) serialized IO of 2D transformations

                     Recognized file extensions:  .bbs

       datapool  Virtual IO to and from the internal data pool

                     Recognized file extensions:  .@

       vista     Vista storage of 2D transformations

                     Recognized file extensions:  .v2dt

       xml       XML serialized IO of 2D transformations

                     Recognized file extensions:  .x2dt

PLUGINS: 3dimage/shape

       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)
                       sphere radius.  in [0, 3.40282e+38]

PLUGINS: generator/noise

       gauss     This noise generator creates random  values  that  are  distributed  according  to  a  Gaussien
                 distribution by using the Box-Muller transformation., supported parameters are:

                     mu = 0 (float)
                       mean of distribution.  in [-3.40282e+38, 3.40282e+38]

                     seed = 0 (uint)
                       set random seed (0=init based on system time).  in [0, 4294967295]

                     sigma = 1 (float)
                       standard derivation of distribution.  in [0, 3.40282e+38]

       uniform   Uniform noise generator using C stdlib rand(), supported parameters are:

                     a = 0 (float)
                       lower bound if noise range.  in [-3.40282e+38, 3.40282e+38]

                     b = 1 (float)
                       higher bound if noise range.  in [-3.40282e+38, 3.40282e+38]

                     seed = 0 (uint)
                       set random seed (0=init based on system time).  in [0, 4294967295]

EXAMPLE

       Run  a  mean-least-varaiance filter on a series of images that follow the numbering pattern imageXXXX.exr
       and store the output in images filteredXXXX.exr

       mia-2dstackfilter -i image0000.exr -o filtered -t exr mlv:w=2

AUTHOR(s)

       Gert Wollny

COPYRIGHT

       This software is Copyright (c) 1999‐2013 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'.

2.0.10                                           25 January 2014                            mia-2dstackfilter(1)