minccalc - Online en la nube

PROGRAMA:

NOMBRE

minccalc: realiza operaciones matemáticas complejas en archivos minc

SINOPSIS

mincalc [ ] .mnc [ .mnc ...] .mnc

DESCRIPCIÓN

Minccalc realizará operaciones matemáticas complejas, voxel por voxel, en uno o más archivos minc
de la misma forma y con el mismo muestreo de coordenadas, produciendo un solo archivo de salida.
Las operaciones a realizar se ingresan usando el -expresión argumento (ver EXPRESIONES).
De forma predeterminada, el archivo de salida es el último argumento sin opción. Sin embargo, si el -archivo de salida
se utiliza la opción, entonces todos los argumentos que no son de opción se consideran archivos de entrada y la salida
los nombres de los archivos provienen del -archivo de salida opciones, de las cuales puede haber más de una.

CAMPUS

Tenga en cuenta que las opciones se pueden especificar en forma abreviada (siempre que sean únicas) y
se puede dar en cualquier lugar de la línea de comando.

-2 Cree archivos de salida en formato MINC 2.0.

-ayuda Imprima un resumen de las opciones de la línea de comandos y salga.

-versión
Imprima el número de versión del programa y salga.

-golpear
Sobrescribe un archivo existente.

-noclobber
No sobrescriba un archivo existente (predeterminado).

-no_clobber
Sinónimo de -noclobber.

-verboso
Imprima la información de progreso para cada fragmento de datos copiados (predeterminado).

-tranquilo No imprima información de progreso.

-depurar Imprime la información de depuración.

-copiar_encabezado
Copie toda la información del encabezado del primer archivo de entrada (predeterminado para una entrada
de archivo).

-nocopy_header
No copie todo el encabezado del primer archivo de entrada; copiar solo coordenada
información (predeterminado para más de un archivo de entrada).

-Tipo de archivo
Cree un archivo de salida con el mismo tipo que el primer archivo de entrada (predeterminado).

-byte Almacene los vóxeles de salida en formato entero de 8 bits.

-corto Almacene los vóxeles de salida en formato entero de 16 bits.

-En t Almacene los vóxeles de salida en formato entero de 32 bits.

-largo Sustituida por -En t.

-flotador Almacene los vóxeles de salida en formato de coma flotante de 32 bits.

-doble
Almacene los vóxeles de salida en formato de coma flotante de 64 bits.

-firmado
Utilice el formato entero con signo y complemento a dos. Se aplica solo si el tipo de vóxel de salida
se especifica para ser un tipo entero (uno de -byte, -corto, -En t or -largo).

-no firmado
Utilice formato de entero sin signo. Se aplica solo si el tipo de vóxel de salida se especifica para
ser un tipo entero (uno de -byte, -corto, -En t or -largo).

-rango min max
Restrinja el rango válido de datos enteros. Se aplica solo si uno de los -byte,
-corto, -En t or -largo se especifican las opciones.

-max_buffer_size_in_kb tamaño
Especifique el tamaño máximo de los búferes internos (en kbytes). El valor predeterminado es 4096
(4MB).

-dimensión nombre oscuro
Especifique una dimensión a lo largo de la cual deseamos realizar una operación acumulativa.

-verificar_dimensiones
Compruebe que todos los archivos de entrada tengan un muestreo coincidente en las dimensiones mundiales (predeterminado).

-nocheck_dimensiones
Ignore las diferencias en el muestreo de dimensiones mundiales para los archivos de entrada.

-propagar_nan
Para operaciones vectoriales acumulativas (suma, pinchar y avg), datos inválidos (Not-A-Number
o NaN) en cualquier elemento del vector producirá datos no válidos en el resultado
(defecto).

-ignorar_nan
Para operaciones de vector acumulativo, los datos no válidos (NaN) en el vector se ignoran, es decir.
tratado como si no estuviera presente.

-yaya Cuando se intenta una operación ilegal en un vóxel (como dividir por cero), el
el resultado son datos no válidos (NaN) (predeterminado). No tener datos de entrada válidos para un acumulado
La operación también se considera una operación ilegal cuando -ignorar_nan se utiliza.

-cero Cuando se intenta una operación ilegal en un vóxel (como dividir por cero), el
el resultado es el valor cero.

-valor_ilegal propuesta de
Cuando se intenta una operación ilegal en un vóxel (como dividir por cero), el
resultado es el valor especificado por esta opción.

-expresión cadena
Especifique la expresión para evaluar en cada vóxel (consulte EXPRESIONES).

-exparchivo nombre de archivo
Especifique un archivo que contenga una expresión para evaluar en cada vóxel (consulte
EXPRESIONES). Si se da el nombre de archivo `` - '', entonces la expresión se lee desde stdin.
La única diferencia con las expresiones de la línea de comandos es que los comentarios se pueden dar en
el archivo. Una línea de comentario se especifica colocando un `` # '' como el primer mensaje no
carácter de espacio en blanco de la línea. Los scripts de Minccalc se pueden crear configurando el
primera línea a

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

-archivo de salida símbolo archivo de salida
Especifique que la salida debe escribirse en el archivo especificado, tomando valores del
símbolo que debe crearse en la expresión (ver el EJEMPLOS sección). Si
se da esta opción, entonces todos los argumentos que no son de opción se toman como archivos de entrada. Esta
La opción se puede utilizar varias veces para varios archivos de salida.

-eval_ancho propuesta de
Especifique el número de vóxeles a procesar en paralelo. El valor predeterminado es 200.

EXPRESIONES

El -expresión El argumento es una sola cadena que describe la función a evaluar. los
La expresión de función se escribe típicamente en términos del vector A.

Por ejemplo, la siguiente expresión sumará los dos primeros archivos de entrada:

A [0] + A [1]

Se pueden dar varias expresiones separadas por punto y coma, en cuyo caso solo el valor de
se utiliza la última expresión. Estas listas de expresiones se pueden utilizar con asignación
expresiones para hacer que la sintaxis sea muy parecida a C:

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

Una lista de expresiones entre corchetes es una expresión válida y devuelve el valor de la última
expresión en la lista. Esto es particularmente útil en para y if expresiones (ver más abajo).

Hay dos tipos de valores en el lenguaje: vectores y escalares. Los literales escalares son
números de coma flotante o pueden aparecer como símbolos cuyo nombre comienza con una letra minúscula.

Además de los operadores escalares normales como +, -, * y /, el lenguaje de expresión también
admite el operador de exponenciación infijo ^, los operadores relacionales habituales <, <=,>,
> =, ==,! = así como los operadores booleanos && (y), || (o y ! (no). Tenga en cuenta que el
&& y || Los operadores booleanos siempre evalúan ambos operandos, a diferencia de C. Matemáticas escalares
las funciones incluyen abs, sqrt, exp, log, el pecado, carro, broncearse, como en, acos y un bronceado. Tambien hay
algunas funciones especializadas:

isnan (v) - 1 si v no es válido y 0 en caso contrario
abrazadera (v1, v2, v3) - v1 limitada por [v2, v3]
segmento (v1, v2, v3): prueba si v1 está en [v2, v3]

La constante escalar NaN se define de manera que isnan (NaN) devuelve 1.

Los vectores se pueden escribir en la siguiente forma 'extensional'

[valor1, valor2, ...]

o utilizando las siguientes notaciones generadoras de rango:

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

o ser generado, por 'intensión'. La siguiente expresión de intensión genera el vector
{3,2,1}:

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

Los vectores también pueden aparecer como símbolos cuyo nombre comienza con una letra mayúscula.

Además de los operadores escalares, se proporcionan los siguientes operadores vectoriales:

avg - el valor promedio de los escalares en vector
len - la longitud de
suma - la suma de los elementos de
prod - el producto de los elementos de
max - el valor máximo de
min - el valor mínimo de
imax - el índice del valor máximo de
imin - el índice del valor mínimo de
V [s] - el s'ésimo elemento del vector V con origen 0.

Los nombres de los símbolos se introducen en una tabla de símbolos global mediante expresiones de asignación de
formulario

a = A [2] * log(2)

Los símbolos que comienzan con una letra minúscula representan escalares, mientras que los que comienzan con una
la letra mayúscula representa los vectores. Dado que = es un operador, su resultado se puede utilizar en un
expresión (como en C).

Se proporcionan algunas construcciones de control:

Se pueden crear bucles for para recorrer un vector, asignando cada valor a un símbolo y luego
evaluar una expresión. Esto se hace con expresiones de la forma

total = 0; para {i en [0: len (A))} total = total + A [i]; total

que es equivalente a la suma (A). Tenga en cuenta que esto es similar a usar

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

ya que el para constructo es en realidad un operador (aunque generalmente solo se usa para
cambiar los valores de los símbolos). Tenga en cuenta también que sin el "total" final, la expresión sería
no sería muy útil ya que solo devolvería la longitud del vector.

Como en C, se puede especificar una lista de expresiones en curlies:

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

También hay algunas formas de si-entonces-otro construir:

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

si (A [0] <0) resultado = 0 en caso contrario resultado = A [0]

El más es opcional. Nuevamente, el constructo if es un operador, y el luego or más
Las expresiones pueden ser listas de expresiones en curlies, en cuyo caso el valor de la última
se devuelve la expresión. Si el más Falta la expresión, se devuelve el valor 0.
cuando la expresión de prueba es 0 (falsa).

La principal rareza con el para y if constructos es que, a diferencia de los enunciados de C, deben
separarse de la siguiente expresión por un punto y coma incluso cuando una lista de expresiones en
rizos se utiliza:

para i en [0: len (A)) {total = total + A [i]}; total / len (A)
if (A [i]> 0) {resultado = 2;} más {resultado = 1}; resultado * 5

Una forma alternativa de introducir nombres de símbolos es a través de dejar-expresiones. Por ejemplo, el
La siguiente expresión siempre se evaluará a 3:

sea ​​a = 1, b = 2 en a + b

Estos fueron diseñados originalmente para crear variables solo dentro de la expresión evaluada,
pero se han realizado modificaciones para que se cambie la tabla de símbolos global.

EJEMPLOS

Aquí hay una expresión para calcular la desviación estándar, teniendo en cuenta la
posibilidad de datos de entrada no válidos, que se ignoran:

s0 = s1 = s2 = 0;

para {i en [0: len (A))} {
v = A [i];
si (! isnan (v)) {
s0 = s0 + 1;
s1 = s1 + v;
s2 = s2 + v * v;
}
};

si (s0> 1) {
sqrt ((s2 - s1 * s1 / s0) / (s0-1));
}
else {
Yaya;
};

El último if podría cambiarse para devolver 0 si s0 es> 0 pero <= 1. También eliminamos el rizado
corchetes, pero no debe haber un ";" entre el if y el else

si (s0> 1)
sqrt ((s2 - s1 * s1 / s0) / (s0-1))
si no (s0> 0)
0
más
Yaya

Si queremos tanto la desviación estándar como la media, podemos usar la -archivo de salida opción,
invocando el comando con

minccalc -expfile stdev\
-outfile media media.mnc \
-archivo de salida stdev stdev.mnc \
archivo1.mnc archivo2.mnc ...

Y usando el archivo de expresión (con otra forma de expresión if):

s0 = s1 = s2 = 0;

para {i en [0: len (A))} {
v = A [i];
si (! 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;
media = (s0> 0)? s1 / s0: NaN;

AVISOS

Algunas cosas que debes recordar ...

Las variables vectoriales deben comenzar con una letra mayúscula.

Los nombres de las variables vectoriales no deben ser una de las palabras clave de la función,
suma, len, prod, ... etc

Para bucles y si las expresiones siempre deben estar separadas de la siguiente expresión por un
punto y coma.

La tabla de símbolos es global.

Operadores booleanos && y || evalúe siempre ambos operandos.

Una nota sobre el paralelismo: por razones de eficiencia, las evaluaciones se realizan en muchos vóxeles a la vez
(el número de vóxeles se conoce como el ancho de la evaluación y se cambia con
las -eval_ancho opción). Una consecuencia extraña de esto es que ambos lados de un if-else
las declaraciones siempre se evalúan (a menos que todos los vóxeles den el mismo resultado de prueba), pero
Las declaraciones dentro de cada consecuente solo se evalúan en los vóxeles apropiados. En
en particular, las entradas en la tabla de símbolos solo se modifican de acuerdo con una máscara de vóxel. A
El efecto secundario de esto es que cualquier símbolo vectorial establecido en un consecuente if-else no debe cambiar
la longitud del símbolo (aunque puede crearlo) y ambos lados del consecuente deben
acordar la longitud de cualquier símbolo vectorial que ambos modifiquen. Si esto no está claro,
Pruébelo, el programa se quejará si no está satisfecho.

Use minccalc en línea usando los servicios de onworks.net