xenial (1) mia-2dseriesgradMAD.1.gz

Provided by: mia-tools_2.2.7-3_amd64 bug

NAME

       mia-2dseriesgradMAD - Evaluate the time-intensity gradient MAD in a series of images.

SYNOPSIS

       mia-2dseriesgradMAD -i <in-file> -o <out-file> [options] <PLUGINS:2dimage/filter>

DESCRIPTION

       mia-2dseriesgradMAD  Given  a  set  of  images  of  temporal sucession, evaluates the pixel-wise temporal
       gradient and then its median average distance (MAD) and stores the  result  in  an  image.  Spacial  pre-
       filtering may be applied as given additional plugin(s) (filter/2dimage).

OPTIONS

              -i --in-file=(input, required); string
                     input segmentation set

              -o --out-file=(output, required); io
                     output file name  For supported file types see PLUGINS:2dimage/io

              -k --skip=0
                     Skip files at the beginningSkip files at the beginning

              -e --enlarge-boundary=5
                     Enlarge cropbox by number of pixelsEnlarge cropbox by number of pixels

              -c --crop
                     crop image before running statistics

   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
                        trace ‐ Function call trace
                        fail ‐ Report test failures
                        warning ‐ Warnings
                        error ‐ Report errors
                        debug ‐ Debug output
                        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).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

       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.

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: 2dimage/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: 2dimage/filter

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

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

       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 in [1, inf)
                       half filter width.

       aniso     2D Anisotropic image filter, supported parameters are:

                     epsilon = 1; float in (0, inf)
                       iteration change threshold.

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

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

                     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.

                     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; 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

       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, string)
                       second image that is needed in the combiner.

                     op =(required, factory)
                       Image   combiner   to   be   applied   to   the   images.   For  supported  plug-ins  see
                       PLUGINS:2dimage/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:
                           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:
                           none ‐ no pixel type defined
                           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 in [1, inf)
                       blocksize in x direction.

                     by = 1; uint in [1, inf)
                       blocksize in y direction.

                     kernel = gauss; string
                       smoothing filter kernel to be applied, the size of the filter is estimated based  on  the
                       blocksize..

       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 in [0, inf)
                       filter width parameter.

       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 in [2, inf)
                       number of classes.

       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  Image   filter   to   remap   label  id's.  Only  applicable  to  images  with  integer  valued
                 intensities/labels., 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.  Scaling
                 is  done  by using a voting algorithms that selects the target pixel value based on the highest
                 pixel count of a certain label in the corresponding source region. If the region comprises  two
                 labels with the same count, the one with the lower number wins., supported parameters are:

                     out-size =(required, 2dbounds)
                       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.,
                 supported parameters are:

                     file =(input, required, string)
                       name of the input file to load from..

       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 =(input, required, string)
                       second input image file name.

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

       maxflow   This filter implements the uses the max-flow min-cut algorithmfor image segmentation, supported
                 parameters are:

                     sink-flow =(input, required, string)
                       Image of float type to define the per-pixel flow to the sink.

                     source-flow =(input, required, string)
                       Image of float type to define the per-pixel flow to the source.

       mean      2D image mean filter, supported parameters are:

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

       median    2D image median filter, supported parameters are:

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

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

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

       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 in [1, 1000000]
                       Number of iterations to run, 0=until convergence.

       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 =(input, required, string)
                       seed image (bit valued).

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

                     thresh = 100; float in (0, inf)
                       thresh value.

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

       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 in [0, inf)
                       target size in x direction, 0: use input size.

                     sy = 0; uint in [0, inf)
                       target size in y direction, 0: use input size.

       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

       sobel     The  2D  Sobel  filter for gradient evaluation. Note that 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:
                           y ‐ gradient in y-direction
                           x ‐ gradient in x-direction

       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 =(input, 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 =(output, required, string)
                       name of the output file to save the image too..

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

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

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

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

                     thresh = 5; double
                       The threshold value.

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

                     file =(input, required, string)
                       Name of the file containing the transformation..

       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 in [0, 1)
                       Relative gradient norm threshold. The actual value threshold value is thresh *  (max_grad
                       - min_grad) + min_grad. Bassins separated by gradients with a lower norm will be joined.

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:
                       signed 16 bit, 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 in [1, inf)
                       height of rectangle.

                     width = 2; int in [1, inf)
                       width of rectangle.

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

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

       square    square shape mask creator, supported parameters are:

                     fill = 1; bool
                       create a filled shape.

                     width = 2; int in [1, inf)
                       width of rectangle.

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: 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.

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

                     sigma = 1; float in (0, inf)
                       standard derivation of distribution.

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

                     a = 0; float
                       lower bound if noise range.

                     b = 1; float
                       higher bound if noise range.

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

EXAMPLE

       Evaluate the MAD-image of the bounding box surrounding the segmentation from  a  series  segment.set.  No
       spacial filtering will be applied. The bounding box will be enlarged by 3 pixels in all directions. Store
       the image in OpenEXR format.

       mia-2dseriesgradMAD  -i segment.set -o mad.exr -c -e 3

AUTHOR(s)

       Gert Wollny

       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'.