minccalc - Online nel cloud

PROGRAMMA:

NOME

minccalc: esegue complesse operazioni matematiche su file minc

SINOSSI

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

DESCRIZIONE

Mincal eseguirà complesse operazioni matematiche voxel per voxel, su uno o più file minc
della stessa forma e aventi le stesse coordinate di campionamento, producendo un unico file di output.
Le operazioni da eseguire vengono immesse utilizzando il tasto -espressione argomento (vedi ESPRESSIONI).
Per impostazione predefinita, il file di output è l'ultimo argomento non di opzione. Tuttavia, se il -file di uscita
viene utilizzata l'opzione, quindi tutti gli argomenti non di opzione sono considerati file di input e output
i nomi dei file provengono da -file di uscita opzioni, di cui possono 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 di intestazione dal primo file di input (impostazione predefinita per un input
file).

-nessuna intestazione_copia
Non copiare tutta l'intestazione dal primo file di input; copia solo coordinate
informazioni (impostazione predefinita 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 in formato a virgola mobile a 32 bit.

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

-firmato
Usa il formato intero con segno, 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
Usa 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_max_buffer_in_kb Taglia
Specificare la dimensione massima dei buffer interni (in kbyte). Il valore predefinito è 4096
(4MB).

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

-controlla_dimensioni
Verifica che tutti i file di input abbiano un campionamento corrispondente nelle dimensioni del mondo (impostazione predefinita).

-nocheck_dimensioni
Ignora eventuali differenze nel campionamento delle dimensioni del mondo per i file di input.

-propaga_nan
Per operazioni vettoriali cumulative (somma, pungolo ed avg), dati non validi (Non-A-Number
o NaN) in qualsiasi elemento del vettore produrrà dati non validi nel risultato
(predefinito).

-ignora_nan
Per le operazioni vettoriali cumulative, i dati non validi (NaN) nel vettore vengono ignorati, ad es.
trattata come se non fosse presente.

- nonna Quando si tenta un'operazione illegale su un voxel (come dividere per zero), il
il risultato sono dati non validi (NaN) (predefinito). Non avere dati di input validi per un cumulativo
l'operazione è considerata illegale anche quando -ignora_nan viene utilizzato.

-zero Quando si tenta un'operazione illegale su un voxel (come dividere per zero), il
il risultato è il valore zero.

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

-espressione stringa
Specificare l'espressione da valutare ad ogni voxel (vedi ESPRESSIONI).

-expfile Nome del file
Specificare un file contenente un'espressione da valutare ad ogni voxel (vedi
ESPRESSIONI). Se viene fornito il nome del file ``-'', l'espressione viene letta da stdin.
L'unica differenza rispetto alle espressioni della riga di comando è che i commenti possono essere inseriti in
il file. Una riga di commento viene specificata inserendo un ``#'' come primo non
carattere di spazio bianco della riga. Gli script Minccalc possono essere creati impostando il
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 da
simbolo che dovrebbe essere creato nell'espressione (vedi il ESEMPI sezione). Se
questa opzione è data, quindi tutti gli argomenti non di opzione vengono presi come file di input. Questo
l'opzione può essere utilizzata più volte per più file di output.

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

ESPRESSIONI

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

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

LA[0] + LA[1]

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

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

Un elenco di espressioni tra parentesi graffe è un'espressione valida e restituisce il valore di last
espressione nella lista. Ciò è particolarmente utile in per ed 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 /, anche il linguaggio delle espressioni
supporta l'operatore di elevamento a potenza infisso ^ , i soliti operatori relazionali <, <=, >,
>=, ==, != così come gli operatori booleani && (e), || (o) e ! (non). Nota che il
&& e || gli operatori booleani valutano sempre entrambi gli operandi, a differenza di C. Scalar matematico
le funzioni includono abs, sqrt, exp, ceppo, peccato, cos, abbronzatura, asin, aco ed 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]
segment(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, ... ]

o utilizzando le seguenti notazioni generatrici di 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, per 'intenzione'. 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
sum - 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 sono introdotti in una tabella dei simboli globale dalle espressioni di assegnazione del
modulo

a = A[2] * ceppo(2)

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

Sono forniti alcuni costrutti di controllo:

È possibile creare cicli For per eseguire il ciclo su un vettore, assegnando ciascun valore a un simbolo e quindi
valutare un'espressione Questo viene fatto con espressioni della forma

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

che è equivalente a sum(A). Nota che è simile all'uso

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

poiché l' per costrutto è in realtà un operatore (anche se di solito è usato solo per
modifica dei valori dei simboli). Nota anche 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
}

Ci sono anche alcune forme di se-allora-altro costruire:

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

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

I 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 la altro l'espressione è mancante, viene restituito il valore 0
quando l'espressione di test è 0 (falso).

La principale stranezza con il per ed if costrutti è che, a differenza delle istruzioni C, devono
essere separato dall'espressione successiva da un punto e virgola anche quando un elenco di espressioni in
ricci è usato:

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

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

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

Questi sono stati originariamente progettati per creare variabili solo all'interno dell'espressione valutata,
ma sono state apportate modifiche in modo che la tabella dei simboli globale sia cambiata.

ESEMPI

Ecco un'espressione per calcolare la deviazione standard, tenendo conto del
possibilità di dati di input non validi, che vengono ignorati:

s0 = s1 = s2 = 0;

for { io in [0:len(A)) } {
v=LA[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. Rilasciamo anche il curly
parentesi quadre, ma non deve esserci un ";" tra il se e l'altro

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 il -file di uscita opzione,
invocando il comando con

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

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

s0 = s1 = s2 = 0;

per {i in [0:len(A))} {
v=LA[i];
se (!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;

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 if devono sempre essere separati dall'espressione successiva da a
punto e virgola.

La tabella dei simboli è globale.

Operatori booleani && e || valuta sempre entrambi gli operandi.

Una nota sul parallelismo: per motivi di efficienza, le valutazioni vengono eseguite su più voxel contemporaneamente
(il numero di voxel è indicato come la larghezza della valutazione e viene modificato con
, il -valore_larghezza opzione). Una strana conseguenza di ciò è che entrambi i lati di un if-else
l'istruzione viene sempre valutata (a meno che tutti i voxel non diano lo stesso risultato del test), ma
le dichiarazioni 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. UN
l'effetto collaterale di ciò è che qualsiasi simbolo vettoriale impostato in un conseguente if-else non deve cambiare
la lunghezza del simbolo (sebbene possa crearlo) ed entrambi i lati del conseguente mosto
concordare la lunghezza di eventuali simboli vettoriali che entrambi modificano. Se questo non è chiaro,
provalo - il programma si lamenterà se non è felice.

Usa minccalc online utilizzando i servizi onworks.net