Skip site navigation (1)Skip section navigation (2)

  
 
  

home | help
MINCCALC(1)			MINC User's Guide		     MINCCALC(1)

NAME
     minccalc - perform complex math operations on minc files

SYNOPSIS
     mincalc [<options>] <in1>.mnc [<in2>.mnc...] <out>.mnc

DESCRIPTION
     Minccalc  will  perform  complex, voxel-by-voxel math operations, on one or
     more minc files of the same shape and having the same coordinate  sampling,
     producing	a  single  output file. The operations to be performed are input
     using the -expression argument (see EXPRESSIONS). By  default,  the  output
     file  is  the  last non-option argument. However, if the -outfile option is
     used, then all non-option arguments are considered input files and the out-
     put file names come from the -outfile options, of which there can	be  more
     than one.

OPTIONS
     Note that options can be specified in abbreviated form (as long as they are
     unique) and can be given anywhere on the command line.

     -2     Create MINC 2.0 format output files.

     -help  Print summary of command-line options and exit.

     -version
	    Print the program's version number and exit.

     -clobber
	    Overwrite an existing file.

     -noclobber
	    Don't overwrite an existing file (default).

     -no_clobber
	    Synonym for -noclobber.

     -verbose
	    Print  out	progress  information for each chunk of data copied (de-
	    fault).

     -quiet
	    Do not print out progress information.

     -debug
	    Print out debugging information.

     -copy_header
	    Copy all of the header information from the first  input  file  (de-
	    fault for one input file).

     -nocopy_header
	    Do	not  copy all of the header from the first input file; copy only
	    coordinate information (default for more than one input file).

     -filetype
	    Create an output file with the same type as  the  first  input  file
	    (default).

     -byte  Store output voxels in 8-bit integer format.

     -short
	    Store output voxels in 16-bit integer format.

     -int   Store output voxels in 32-bit integer format.

     -long  Superseded by -int.

     -float
	    Store output voxels in 32-bit floating point format.

     -double
	    Store output voxels in 64-bit floating point format.

     -signed
	    Use  signed,  two's  complement  integer format. Applies only if the
	    output voxel type is specified to be an integer type (one of  -byte,
	    -short, -int or -long).

     -unsigned
	    Use  unsigned  integer format. Applies only if the output voxel type
	    is specified to be an integer type (one of -byte,  -short,	-int  or
	    -long).

     -range min max
	    Restrict  the  valid  range of integer data.  Applies only if one of
	    the -byte, -short, -int or -long options is specified.

     -max_buffer_size_in_kb size
	    Specify the maximum size of the internal buffers  (in  kbytes).  De-
	    fault is 4096 (4MB).

     -dimension dimname
	    Specify  a dimension along which we wish to perform a cumulative op-
	    eration.

     -check_dimensions
	    Check that all input files have matching sampling  in  world  dimen-
	    sions (default).

     -nocheck_dimensions
	    Ignore any differences in world dimensions sampling for input files.

     -propagate_nan
	    For  cumulative  vector operations (sum, prod and avg), invalid data
	    (Not-A-Number or NaN) in any element of the vector will produce  in-
	    valid data in the result (default).

     -ignore_nan
	    For  cumulative  vector operations, invalid data (NaN) in the vector
	    is ignored, ie. treated as though it is not present.

     -nan   When an illegal operation is attempted at a voxel (such as divide by
	    zero), the result is invalid data (NaN) (default). Having  no  valid
	    input  data for a cumulative operation is also considered an illegal
	    operation when -ignore_nan is used.

     -zero  When an illegal operation is attempted at a voxel (such as divide by
	    zero), the result is value zero.

     -illegal_value value
	    When an illegal operation is attempted at a voxel (such as divide by
	    zero), the result is the value specified by this option.

     -expression string
	    Specify the expression to evaluate at each voxel (see EXPRESSIONS).

     -expfile filename
	    Specify a file containing an expression to evaluate  at  each  voxel
	    (see  EXPRESSIONS).  If filename ``-'' is given, then the expression
	    is read from stdin. The only difference  from  command-line  expres-
	    sions  is  that comments can be given in the file. A comment line is
	    specified by placing a ``#'' as the first  non-whitespace  character
	    of	the  line.  Minccalc scripts can be created by setting the first
	    line to

	       #! /usr/local/mni/bin/minccalc -expfile

     -outfile symbol output-file
	    Specify that output should be written to the specified file,  taking
	    values  from  the  symbol  which should be created in the expression
	    (see the EXAMPLES section). If this option is given, then  all  non-
	    option  arguments  are taken as input files. This option can be used
	    multiple times for multiple output files.

     -eval_width value
	    Specify the number of voxels to process in parallel. Default is 200.

EXPRESSIONS
     The -expression argument is a single string that describes the function  to
     evaluate.	 The  function	expression  is typically written in terms of the
     vector A.

     For example, the following expression will sum the first  two  input  files
     together:

	A[0] + A[1]

     Multiple  expressions  can  be given separated by semicolons, in which case
     only the value of the last expression is used. These expression  lists  can
     be used with assignment expressions to make the syntax very C-like:

	ratio = A[0]/A[1]; A[2]*exp(-ratio)

     An  expression list in curly brackets is a valid expression and returns the
     value of last expression in the list. This is particularly  useful  in  for
     and if expressions (see below).

     There  are  two  types  of  values  in  the  language: vectors and scalars.
     Scalars literals are floating point numbers or may appear as symbols  whose
     name starts with a lowercase letter.

     Besides  normal scalar operators such as +, -, * and /, the expression lan-
     guage also supports the infix exponentiation operator ^ , the  usual  rela-
     tional  operators	<, <=, >, >=, ==, != as well as the boolean operators &&
     (and), || (or) and ! (not). Note that the && and || boolean  operators  al-
     ways  evaluate  both  operands, unlike C. Scalar mathematical functions in-
     clude abs, sqrt, exp, log, sin, cos, tan, asin, acos and  atan.  There  are
     also some specialized functions:

	isnan(v) - 1 if v is invalid and 0 otherwise
	clamp(v1,v2,v3) - v1 bounded by [v2, v3]
	segment(v1,v2,v3) - tests if v1 is in [v2, v3]

     The scalar constant NaN is defined such that isnan(NaN) return 1.

     Vectors can be written in the following `extensional' form

	[ value1, value2, ... ]

     or by using the following range-generating notations:

	[ a : b ]     generates {a, a+1, ..., b-1, b}
	[ a : b )     generates {a, a+1, ..., b-1}
	( a : b ]     generates {a+1, ..., b-1, b}
	( a : b )     generates {a+1, ..., b-1}

     or  be generated, by `intension'. The following intension expression gener-
     ates the vector {3,2,1}:

	{ i in [1:3] | 4 - i }

     Vectors may also appear as symbols whose name starts with an uppercase let-
     ter.

     In addition to the scalar operators, the  following  vector  operators  are
     supplied:

	avg  - the average value of the scalars in vector
	len  - the length of
	sum  - the sum of the elements of
	prod - the product of the elements of
	max  - the maximum value of
	min  - the minimum value of
	imax - the index of the maximum value of
	imin - the index of the minimum value of
	V[s] - the s'th element of vector V with origin 0.

     Symbol  names  are  introduced into a global symbol table by assignment ex-
     pressions of the form

	a = A[2] * log(2)

     Symbols starting with a lowercase	letter	represent  scalars  while  those
     starting  with  an uppercase letter represent vectors. Since = is an opera-
     tor, its result can be used in an expression (as in C).

     A few control constructs are provided:

     For loops can be created to loop over a vector, assigning each value  to  a
     symbol  and then evaluating an expression. This is done with expressions of
     the form

	total=0; for{i in [0:len(A))} total=total+A[i]; total

     which is equivalent to sum(A). Note that this is similar to using

	total=0; len{i in [0:len(A)) | total=total+A[i]}; total

     since the for construct is actually an operator  (although  it  is  usually
     only  used  for  changing	symbol values). Note also that without the final
     "total", the expression would not be very useful since it would only return
     the length of the vector.

     As in C, a list of expressions can be specified in curlies:

	total=total2 = 0;
	for {i in [0:len(A))} {
	   total  = total  + A[i];
	   total2 = total2 + A[i]^2
	}

     There are also a few forms of the if-then-else construct:

	A[0]<0 ? 0 : A[0]

	if (A[0]<0) result=0 else result=A[0]

     The else is optional. Again, the if construct is an operator, and the  then
     or  else expressions can be expression lists in curlies, in which	case the
     value of the last expression is returned. If the else expression  is  miss-
     ing, then the value 0 is returned when the test expression is 0 (false).

     The principal oddity with the for and if constructs is that unlike C state-
     ments,  they must be separated from the next expression by a semicolon even
     when an expression list in curlies is used:

	for i in [0:len(A)) {total=total+A[i]} ; total/len(A)
	if (A[i]>0) {result=2;} else {result=1} ; result*5

     An alternative way to introduce symbol names  is  through	let-expressions.
     For example, the following expression will always evaluate to 3:

	let a = 1, b = 2 in a + b

     These  were  originally designed to create variables only within the evalu-
     ated expression, but modifications have been made so that the global symbol
     table is changed.

EXAMPLES
     Here is an expression for calculating standard deviation, taking  into  ac-
     count the possibility of invalid input data, which is ignored:

	  s0 = s1 = s2 = 0;

	  for { i in [0:len(A)) } {
	     v=A[i];
	     if (!isnan(v)) {
		s0 = s0 + 1;
		s1 = s1 + v;
		s2 = s2 + v*v;
	     }
	  };

	  if (s0 > 1) {
	     sqrt((s2 - s1*s1/s0) / (s0-1));
	  }
	  else {
	     NaN;
	  };

     The  last	if  could  be changed to return 0 if s0 is > 0 but <= 1. We also
     drop the curly brackets, but then there must not be a ";"	between  the  if
     and the else

	  if (s0 > 1)
	     sqrt((s2 - s1*s1/s0) / (s0-1))
	  else if (s0 > 0)
	     0
	  else
	     NaN

     If  we  want both the mean and the standard deviation, we can use the -out-
     file option, invoking the command with

	  minccalc -expfile stdev \
	     -outfile mean mean.mnc \
	     -outfile stdev stdev.mnc \
	     infile1.mnc infile2.mnc ...

     And using the expression file (with yet another form of if expression):

	  s0 = s1 = s2 = 0;

	  for {i in [0:len(A))} {
	     v=A[i];
	     if (!isnan(v)) {
		s0 = s0 + 1;
		s1 = s1 + v;
		s2 = s2 + v*v;
	     }
	  };

	  stdev = (s0 > 1) ? sqrt((s2 - s1*s1/s0) / (s0-1)) :
			       (s0 > 0) ? 0 : NaN ;
	  mean	= (s0 > 0) ? s1 / s0 : NaN ;

CAVEATS
     A few things you should remember...

     Vector variables must start with an uppercase letter.

     Vector variable names must not be one of the function keywords,
      sum, len, prod, ... etc

     For loops and if expressions always need to be separated from the next  ex-
     pression by a semicolon.

     The symbol table is global.

     Boolean operators && and || always evaluate both operands.

     A note on parallelism: For efficiency reasons, evaluations are done on many
     voxels  at  once  (the  number of voxels is referred to as the width of the
     evaluation and is changed with the -eval_width option). An odd  consequence
     of  this  is  that  both sides of an if-else statement are always evaluated
     (unless all voxels give the same test result), but statements  within  each
     consequent are only evaluated on the appropriate voxels. In particular, en-
     tries  in	the symbol table are only modified according to a voxel mask.  A
     side-effect of this is that any vector symbol set in an if-else  consequent
     must  not	change	the length of the symbol (although it can create it) and
     both sides of the consequent must agree on the length of any vector symbols
     that they both modify. If this is not clear, just try it - the program will
     complain if it is not happy.

AUTHOR
     Andrew Janke - a.janke@gmail.com

COPYRIGHTS
     Copyright (C) 2000 by Andrew Janke

SEE ALSO
     mincmath(1)

			  $Date: 2008-01-11 04:24:16 $		     MINCCALC(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=minccalc&sektion=1&manpath=FreeBSD+Ports+15.1.quarterly>

home | help