minccalc - Online nel Cloud

PROGRAMMA:

NOME

minccalc - esegue operazioni matematiche complesse sui file minc

SINOSSI

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

DESCRIZIONE

Minccalc eseguirà operazioni matematiche complesse, voxel per voxel, su uno o più file minc
della stessa forma e con lo stesso campionamento delle coordinate, producendo un singolo file di output.
Le operazioni da eseguire vengono inserite utilizzando il -espressione argomento (vedi ESPRESSIONI).
Per impostazione predefinita, il file di output è l'ultimo argomento non opzionale. Tuttavia, se -file di uscita
viene utilizzata l'opzione, tutti gli argomenti non opzionali vengono considerati file di input e l'output
i nomi dei file provengono da -file di uscita opzioni, di cui può essercene più di una.

VERSIONI

Nota che le opzioni possono essere specificate in forma abbreviata (purché siano uniche) e
può essere dato ovunque sulla riga di comando.

-2 Crea file di output in formato MINC 2.0.

-Aiuto Stampa il riepilogo delle opzioni della riga di comando ed esci.

-versione
Stampa il numero di versione del programma ed esci.

-picchiatore
Sovrascrivi un file esistente.

-noclobber
Non sovrascrivere un file esistente (impostazione predefinita).

-no_clobber
Sinonimo di -noclobber.

-verboso
Stampa le informazioni sullo stato di avanzamento per ogni blocco di dati copiato (impostazione predefinita).

-silenzioso Non stampare le informazioni sullo stato di avanzamento.

-debug Stampa le informazioni di debug.

-copia_intestazione
Copia tutte le informazioni dell'intestazione dal primo file di input (predefinito per un input
file).

-nocopy_header
Non copiare tutta l'intestazione dal primo file di input; copia solo le coordinate
informazioni (predefinito per più di un file di input).

-tipo di file
Crea un file di output con lo stesso tipo del primo file di input (impostazione predefinita).

-byte Memorizza i voxel di output in formato intero a 8 bit.

-corto Memorizza i voxel di output in formato intero a 16 bit.

-int Memorizza i voxel di output in formato intero a 32 bit.

-lungo Sostituito da -int.

-galleggiante Memorizza i voxel di output nel formato a virgola mobile a 32 bit.

-raddoppiare
Memorizza i voxel di output nel formato a virgola mobile a 64 bit.

-firmato
Utilizza il formato intero con segno in complemento a due. Si applica solo se il tipo di voxel di output
è specificato come un tipo intero (uno di -byte, -corto, -int or -lungo).

-non firmato
Utilizza il formato intero senza segno. Si applica solo se il tipo di voxel di output è specificato su
essere un tipo intero (uno di -byte, -corto, -int or -lungo).

-gamma verbale max
Limita l'intervallo valido di dati interi. Si applica solo se uno dei -byte,
-corto, -int or -lungo opzioni è specificato.

-dimensione_massima_del_buffer_in_kb Taglia
Specifica la dimensione massima dei buffer interni (in kbyte). Il valore predefinito è 4096
(4MB).

-Dimension nome dim
Specificare una dimensione lungo la quale si desidera eseguire un'operazione cumulativa.

-controlla_dimensioni
Verificare che tutti i file di input abbiano un campionamento corrispondente nelle dimensioni mondiali (predefinito).

-nocheck_dimensions
Ignora eventuali differenze nel campionamento delle dimensioni mondiali per i file di input.

-propagare_nan
Per le operazioni vettoriali cumulative (somma, pungolo e avg), dati non validi (non un numero
o NaN) in qualsiasi elemento del vettore produrrà dati non validi nel risultato
(predefinito).

-ignore_nan
Per le operazioni cumulative sui vettori, i dati non validi (NaN) nel vettore vengono ignorati, vale a dire.
trattato come se non fosse presente.

- nonna Quando si tenta un'operazione illegale su un voxel (ad esempio la divisione per zero), il
il risultato è un dato non valido (NaN) (predefinito). Non ci sono dati di input validi per un cumulativo
l'operazione è considerata un'operazione illegale anche quando -ignore_nan viene utilizzato.

-zero Quando si tenta un'operazione illegale su un voxel (ad esempio la divisione per zero), il
il risultato è il valore zero.

-valore_illegale APPREZZIAMO
Quando si tenta un'operazione illegale su un voxel (ad esempio la divisione per zero), il
risultato è il valore specificato da questa opzione.

-espressione stringa
Specificare l'espressione da valutare in ogni voxel (vedere ESPRESSIONI).

-file di estensione Nome del file
Specificare un file contenente un'espressione da valutare in ogni voxel (vedere
ESPRESSIONI). Se viene specificato il nome file ``-'', l'espressione viene letta da stdin.
L'unica differenza rispetto alle espressioni della riga di comando è che i commenti possono essere forniti in
il file. Una riga di commento viene specificata inserendo ``#'' come primo non-
carattere di spazio vuoto della riga. Gli script Minccalc possono essere creati impostando
prima riga a

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

-file di uscita simbolo file di uscita
Specificare che l'output deve essere scritto nel file specificato, prendendo i valori dal
simbolo che dovrebbe essere creato nell'espressione (vedere il ESEMPI sezione). Se
questa opzione è data, quindi tutti gli argomenti non-opzione vengono presi come file di input. Questo
l'opzione può essere utilizzata più volte per più file di output.

-eval_width APPREZZIAMO
Specifica il numero di voxel da elaborare in parallelo. Il valore predefinito è 200.

ESPRESSIONI

. -espressione argomento è una singola stringa che descrive la funzione da valutare. L'
l'espressione della funzione è in genere scritta in termini del vettore A.

Ad esempio, la seguente espressione sommerà i primi due file di input:

A[0] + A[1]

È possibile fornire più espressioni separate da punto e virgola, nel qual caso verrà visualizzato solo il valore di
viene utilizzata l'ultima espressione. Questi elenchi di espressioni possono essere utilizzati con l'assegnazione
espressioni per rendere la sintassi molto simile a C:

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

Un elenco di espressioni tra parentesi graffe è un'espressione valida e restituisce il valore dell'ultimo
espressione nell'elenco. Ciò è particolarmente utile in da e if espressioni (vedi sotto).

Ci sono due tipi di valori nel linguaggio: vettori e scalari. I letterali scalari sono
numeri in virgola mobile o possono apparire come simboli il cui nome inizia con una lettera minuscola.

Oltre ai normali operatori scalari come +, -, * e /, il linguaggio delle espressioni comprende anche
supporta l'operatore di esponenziale infisso ^ , i soliti operatori relazionali <, <=, >,
>=, ==, != così come gli operatori booleani && (e), || (o) e ! (non). Nota che
Gli operatori booleani && e || valutano sempre entrambi gli operandi, a differenza del C. Scalare matematico
le funzioni includono abs, sqrt, exp, ceppo, peccato, cos, abbronzatura, asin, aco e un'abbronzatura. Ci sono anche
alcune funzioni specializzate:

isnan(v) - 1 se v non è valido e 0 altrimenti
clamp(v1,v2,v3) - v1 delimitato da [v2, v3]
segmento(v1,v2,v3) - verifica se v1 è in [v2, v3]

La costante scalare NaN è definita in modo tale che isnan(NaN) restituisca 1.

I vettori possono essere scritti nella seguente forma `estensionale'

[ valore1, valore2, ... ]

oppure utilizzando le seguenti notazioni di generazione degli intervalli:

[ 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 essere generato, da `intensione'. La seguente espressione di intensione genera il vettore
{3,2,1}:

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

I vettori possono anche apparire come simboli il cui nome inizia con una lettera maiuscola.

Oltre agli operatori scalari, vengono forniti i seguenti operatori vettoriali:

avg - il valore medio degli scalari nel vettore
len - la lunghezza di
somma - la somma degli elementi di
prod - il prodotto degli elementi di
max - il valore massimo di
min - il valore minimo di
imax - l'indice del valore massimo di
imin - l'indice del valore minimo di
V[s] - l'elemento s-esimo del vettore V con origine 0.

I nomi dei simboli vengono introdotti in una tabella dei simboli globale tramite espressioni di assegnazione di
modulo

un = A[2] * ceppo(2)

I simboli che iniziano con una lettera minuscola rappresentano gli scalari mentre quelli che iniziano con una
le lettere maiuscole rappresentano i vettori. Poiché = è un operatore, il suo risultato può essere utilizzato in un
espressione (come in C).

Sono forniti alcuni costrutti di controllo:

I cicli For possono essere creati per eseguire un ciclo su un vettore, assegnando ogni valore a un simbolo e quindi
valutare un'espressione. Questo viene fatto con espressioni della forma

totale=0; per{i in [0:len(A))} totale=totale+A[i]; totale

che è equivalente a sum(A). Nota che questo è simile all'utilizzo di

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

poiché l' da Il costrutto è in realtà un operatore (anche se di solito viene utilizzato solo per
modificando i valori dei simboli). Si noti inoltre che senza il "totale" finale, l'espressione sarebbe
non sarebbe molto utile poiché restituirebbe solo la lunghezza del vettore.

Come in C, un elenco di espressioni può essere specificato in curlies:

totale=totale2 = 0;
per {i in [0:len(A))} {
totale = totale + A[i];
totale2 = totale2 + A[i]^2
}

Esistono anche alcune forme di se-allora-altro costruire:

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

se (A[0]<0) risultato=0 altrimenti risultato=A[0]

. altro è facoltativo. Di nuovo, il costrutto if è un operatore e il poi or altro
le espressioni possono essere elenchi di espressioni in curlies, nel qual caso il valore dell'ultimo
viene restituita l'espressione. Se l' altro se l'espressione è mancante, viene restituito il valore 0
quando l'espressione di prova è 0 (falso).

La principale stranezza con il da e if i costrutti sono che a differenza delle istruzioni C, devono
essere separato dall'espressione successiva da un punto e virgola anche quando un elenco di espressioni in
curlies viene utilizzato:

per i in [0:len(A)) {totale=totale+A[i]} ; totale/len(A)
se (A[i]>0) {risultato=2;} altrimenti {risultato=1} ; risultato*5

Un modo alternativo per introdurre i nomi dei simboli è attraverso lasciare-espressioni. Ad esempio, il
la seguente espressione verrà sempre valutata come 3:

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

Originariamente erano progettati per creare variabili solo all'interno dell'espressione valutata,
ma sono state apportate delle modifiche in modo che la tabella dei simboli globali sia cambiata.

ESEMPI

Ecco un'espressione per calcolare la deviazione standard, tenendo conto della
possibilità di dati di input non validi, che viene ignorata:

s0 = s1 = s2 = 0;

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

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

L'ultimo if potrebbe essere modificato per restituire 0 se s0 è > 0 ma <= 1. Eliminiamo anche il curly
parentesi, ma poi non deve esserci un ";" tra if e else

se (s0 > 1)
sqrt((s2 - s1*s1/s0) / (s0-1))
altrimenti se (s0 > 0)
0
altro
NaN

Se vogliamo sia la media che la deviazione standard, possiamo usare -file di uscita opzione,
invocando il comando con

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

E utilizzando il file di espressione (con un'altra forma di espressione if):

s0 = s1 = s2 = 0;

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

deviazione standard = (s0 > 1) ? radice quadrata((s2 - s1*s1/s0) / (s0-1)) :
(s0 > 0) ? 0 : NaN ;
media = (s0 > 0) ? s1/s0: NaN;

AVVERTENZE

Alcune cose che dovresti ricordare...

Le variabili vettoriali devono iniziare con una lettera maiuscola.

I nomi delle variabili vettoriali non devono essere una delle parole chiave della funzione,
somma, len, prod, ... ecc.

I cicli For e le espressioni if ​​devono sempre essere separati dall'espressione successiva da un
punto e virgola.

La tabella dei simboli è globale.

Gli operatori booleani && e || valutano sempre entrambi gli operandi.

Una nota sul parallelismo: per ragioni di efficienza, le valutazioni vengono eseguite su molti voxel contemporaneamente
(il numero di voxel è definito come larghezza della valutazione e viene modificato con
, il -eval_width opzione). Una strana conseguenza di questo è che entrambi i lati di un if-else
le affermazioni vengono sempre valutate (a meno che tutti i voxel non diano lo stesso risultato del test), ma
le affermazioni all'interno di ogni conseguente vengono valutate solo sui voxel appropriati. In
in particolare, le voci nella tabella dei simboli vengono modificate solo in base a una maschera voxel. A
l'effetto collaterale di questo è che qualsiasi set di simboli vettoriali in un conseguente if-else non deve cambiare
la lunghezza del simbolo (anche se può crearlo) ed entrambi i lati del conseguente devono
concordare sulla lunghezza di tutti i simboli vettoriali che entrambi modificano. Se questo non è chiaro,
Provalo e vedrai che il programma si lamenterà se non è soddisfatto.

Utilizzare minccalc online utilizzando i servizi onworks.net