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

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

NAME

       mia-2dseries2dordermedian - Evaluate time-intensity median 2nd order derivative of a series.

SYNOPSIS

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

DESCRIPTION

       mia-2dseries2dordermedian  This  program  evaluates  the  pixel-wise median of the absolute values of the
       gauss filtered 2nd order temporal derivative of a series of images. In addition, it can be used to output
       the time-intensity curve of a given pixel.The program supports slice-wise spacial pre-filtering by giving
       additional filters as free parameters (filter/2dimage).

OPTIONS

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

              -o --out-file=(output, required); io
                     output image 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

              -g --gauss=1
                     gauss filter width for moothing the gradientgauss filter width for moothing the gradient

                 --itc-file=
                     intensity time curve output file

                 --itc-loc=[0,0]
                     intensity time curve output pixel coordinatesintensity time curve output pixel coordinates

   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 median of the 2nd order derivative of the series given in segmentation set segment.set after
       filtering with a Gaussian of width 3. In addition write the time intensity curve  of  pixel  <128,64>  to
       curve.txt.

       mia-2dseries2dordermedian -i segment.set -o gradmedian.exr -g 1 --itc-file curve.txt --itc-loc "<128,64>"

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