minccalc - En ligne dans le Cloud

PROGRAMME:

Nom

minccalc - effectuer des opérations mathématiques complexes sur les fichiers minc

SYNOPSIS

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

DESCRIPTION

Minccalc effectuera des opérations mathématiques complexes, voxel par voxel, sur un ou plusieurs fichiers minc
de même forme et ayant le même échantillonnage de coordonnées, produisant un seul fichier de sortie.
Les opérations à effectuer sont saisies à l'aide de la -expression argumentation (voir EXPRESSIONS).
Par défaut, le fichier de sortie est le dernier argument non optionnel. Cependant, si le -fichier de sortie
option est utilisée, alors tous les arguments non optionnels sont considérés comme des fichiers d'entrée et la sortie
les noms de fichiers proviennent du -fichier de sortie options, dont il peut y avoir plusieurs.

OPTIONS

Notez que les options peuvent être spécifiées sous forme abrégée (tant qu'elles sont uniques) et
peut être donné n'importe où sur la ligne de commande.

-2 Créez des fichiers de sortie au format MINC 2.0.

-Aide Imprimez le résumé des options de la ligne de commande et quittez.

-version
Imprimez le numéro de version du programme et quittez.

-tabasser
Écraser un fichier existant.

-noclobber
N'écrase pas un fichier existant (par défaut).

-no_clobber
Synonyme de -noclobber.

-verbeux
Imprimez les informations de progression pour chaque bloc de données copié (par défaut).

-silencieux N'imprimez pas les informations de progression.

-déboguer Imprimez les informations de débogage.

-copie_en-tête
Copiez toutes les informations d'en-tête du premier fichier d'entrée (par défaut pour une entrée
fichier).

-nocopy_header
Ne copiez pas tout l'en-tête du premier fichier d'entrée ; copier uniquement les coordonnées
informations (par défaut pour plus d'un fichier d'entrée).

-Type de fichier
Créez un fichier de sortie avec le même type que le premier fichier d'entrée (par défaut).

-octet Stockez les voxels de sortie au format entier 8 bits.

-court Stockez les voxels de sortie au format entier 16 bits.

-int Stockez les voxels de sortie au format entier 32 bits.

-longue Remplacé par -int.

-flotter Stockez les voxels de sortie au format à virgule flottante 32 bits.

-double
Stockez les voxels de sortie au format à virgule flottante 64 bits.

-signé
Utilisez le format d'entier en complément à deux signé. S'applique uniquement si le type de voxel de sortie
est spécifié comme étant un type entier (l'un des -octet, -court, -int or -longue).

-non signé
Utilisez le format d'entier non signé. S'applique uniquement si le type de voxel de sortie est spécifié sur
être un type entier (l'un des -octet, -court, -int or -longue).

-gamme m. max
Restreindre la plage valide de données entières. S'applique uniquement si l'un des -octet,
-court, -int or -longue options est spécifié.

-max_buffer_size_in_ko taille
Spécifiez la taille maximale des tampons internes (en kilo-octets). La valeur par défaut est 4096
(4MB).

-dimension nom dim
Spécifiez une dimension le long de laquelle nous souhaitons effectuer une opération cumulative.

-check_dimensions
Vérifiez que tous les fichiers d'entrée ont un échantillonnage correspondant dans les dimensions mondiales (par défaut).

-nocheck_dimensions
Ignorez toutes les différences dans l'échantillonnage des dimensions mondiales pour les fichiers d'entrée.

-propagate_nan
Pour les opérations vectorielles cumulatives (somme, poussée ainsi que avg), données invalides (Not-A-Number
ou NaN) dans n'importe quel élément du vecteur produira des données invalides dans le résultat
(défaut).

-ignorer_nan
Pour les opérations vectorielles cumulatives, les données invalides (NaN) dans le vecteur sont ignorées, c'est-à-dire.
traité comme s'il n'était pas présent.

- nan Lorsqu'une opération illégale est tentée sur un voxel (comme une division par zéro), le
le résultat est une donnée invalide (NaN) (par défaut). N'ayant pas de données d'entrée valides pour un cumul
opération est également considérée comme une opération illégale lorsque -ignorer_nan est utilisé.

-zéro Lorsqu'une opération illégale est tentée sur un voxel (comme une division par zéro), le
le résultat est la valeur zéro.

-valeur_illégal Plus-value
Lorsqu'une opération illégale est tentée sur un voxel (comme une division par zéro), le
result est la valeur spécifiée par cette option.

-expression un magnifique
Spécifiez l'expression à évaluer à chaque voxel (voir EXPRESSIONS).

-fichierexp nom de fichier
Spécifiez un fichier contenant une expression à évaluer à chaque voxel (voir
EXPRESSIONS). Si le nom de fichier ``-'' est donné, alors l'expression est lue à partir de stdin.
La seule différence avec les expressions de ligne de commande est que les commentaires peuvent être donnés dans
le fichier. Une ligne de commentaire est spécifiée en plaçant un ``#'' comme premier non-
caractère d'espacement de la ligne. Les scripts Minccalc peuvent être créés en définissant le
première ligne à

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

-fichier de sortie symbole fichier de sortie
Spécifiez que la sortie doit être écrite dans le fichier spécifié, en prenant les valeurs du
symbole qui doit être créé dans l'expression (voir le EXEMPLES section). Si
cette option est donnée, alors tous les arguments non optionnels sont pris comme fichiers d'entrée. Cette
L'option peut être utilisée plusieurs fois pour plusieurs fichiers de sortie.

-eval_width Plus-value
Spécifiez le nombre de voxels à traiter en parallèle. La valeur par défaut est 200.

EXPRESSIONS

La -expression argument est une chaîne unique qui décrit la fonction à évaluer. Les
l'expression de la fonction est généralement écrite en termes du vecteur A.

Par exemple, l'expression suivante additionnera les deux premiers fichiers d'entrée :

UNE[0] + UNE[1]

Plusieurs expressions peuvent être séparées par des points-virgules, auquel cas seule la valeur de
la dernière expression est utilisée. Ces listes d'expressions peuvent être utilisées avec l'affectation
expressions pour rendre la syntaxe très proche du C :

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

Une liste d'expressions entre accolades est une expression valide et renvoie la valeur de last
expression dans la liste. Ceci est particulièrement utile dans en ainsi que if expressions (voir ci-dessous).

Il existe deux types de valeurs dans le langage : les vecteurs et les scalaires. Les littéraux scalaires sont
nombres à virgule flottante ou peuvent apparaître sous forme de symboles dont le nom commence par une lettre minuscule.

Outre les opérateurs scalaires normaux tels que +, -, * et /, le langage d'expression
prend en charge l'opérateur d'exponentiation infixe ^ , les opérateurs relationnels habituels <, <=, >,
>=, ==, != ainsi que les opérateurs booléens && (et), || (ou et ! (ne pas). Notez que le
&& et || les opérateurs booléens évaluent toujours les deux opérandes, contrairement à C. Mathématique scalaire
les fonctions incluent Abdos, sqrt, exp, enregistrer, sans, cos, bronzage, un péché, aços ainsi que un bronzage. Il y a aussi
quelques fonctions spécialisées :

isnan(v) - 1 si v est invalide et 0 sinon
clamp(v1,v2,v3) - v1 borné par [v2, v3]
segment(v1,v2,v3) - teste si v1 est dans [v2, v3]

La constante scalaire NaN est définie de telle sorte que isnan(NaN) renvoie 1.

Les vecteurs peuvent être écrits sous la forme "extensionnelle" suivante

[ valeur1, valeur2, ... ]

ou en utilisant les notations génératrices de plage suivantes :

[ a : b ] génère {a, a+1, ..., b-1, b}
[ a : b ) génère {a, a+1, ..., b-1}
( a : b ] génère {a+1, ..., b-1, b}
( a : b ) génère {a+1, ..., b-1}

ou être généré, par « intension ». L'expression d'intension suivante génère le vecteur
{3,2,1} :

{ je dans [1:3] | 4 - je }

Les vecteurs peuvent également apparaître sous forme de symboles dont le nom commence par une lettre majuscule.

En plus des opérateurs scalaires, les opérateurs vectoriels suivants sont fournis :

avg - la valeur moyenne des scalaires dans le vecteur
len - la longueur de
somme - la somme des éléments de
prod - le produit des éléments de
max - la valeur maximale de
min - la valeur minimale de
imax - l'indice de la valeur maximale de
imin - l'indice de la valeur minimale de
V[s] - le sième élément du vecteur V d'origine 0.

Les noms de symboles sont introduits dans une table de symboles globale par des expressions d'affectation du
formulaire

un = A[2] * enregistrer(2)

Les symboles commençant par une lettre minuscule représentent des scalaires tandis que ceux commençant par un
la lettre majuscule représente les vecteurs. Puisque = est un opérateur, son résultat peut être utilisé dans un
expression (comme en C).

Quelques constructions de contrôle sont fournies :

Des boucles For peuvent être créées pour boucler sur un vecteur, en attribuant chaque valeur à un symbole, puis
évaluer une expression. Cela se fait avec des expressions de la forme

total=0 ; pour{i dans [0:len(A))} total=total+A[i] ; le total

ce qui équivaut à somme(A). Notez que cela est similaire à l'utilisation

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

depuis l' en construct est en fait un opérateur (bien qu'il ne soit généralement utilisé que pour
changer les valeurs des symboles). Notez également que sans le « total » final, l'expression serait
pas très utile car il ne retournerait que la longueur du vecteur.

Comme en C, une liste d'expressions peut être spécifiée en curlies :

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

Il existe également quelques formes de si-alors-sinon construction:

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

si (A[0]<0) résultat=0 sinon résultat=A[0]

La d'autre est facultatif. Encore une fois, la construction if est un opérateur, et la puis or d'autre
les expressions peuvent être des listes d'expressions en boucles, auquel cas la valeur du dernier
expression est renvoyée. Si la d'autre l'expression est manquante, alors la valeur 0 est retournée
lorsque l'expression de test est 0 (faux).

La principale bizarrerie avec le en ainsi que if est que contrairement aux instructions C, elles doivent
être séparé de l'expression suivante par un point-virgule même lorsqu'une liste d'expressions dans
bouclés est utilisé:

pour i dans [0:len(A)) {total=total+A[i]} ; total/long(A)
if (A[i]>0) {result=2;} else {result=1} ; résultat*5

Une autre façon d'introduire des noms de symboles consiste à laisser-expressions. Par exemple, le
l'expression suivante sera toujours évaluée à 3 :

soit a = 1, b = 2 dans a + b

Ceux-ci ont été conçus à l'origine pour créer des variables uniquement dans l'expression évaluée,
mais des modifications ont été apportées pour que la table des symboles globale soit modifiée.

EXEMPLES

Voici une expression pour calculer l'écart type, en tenant compte de la
possibilité de données d'entrée invalides, qui sont ignorées :

s0 = s1 = s2 = 0 ;

pour { i dans [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 {
NaN ;
};

Le dernier if pourrait être modifié pour retourner 0 si s0 est > 0 mais <= 1. Nous supprimons également le bouclé
crochets, mais alors il ne doit pas y avoir de ";" entre le si et le sinon

si (s0 > 1)
carré((s2 - s1*s1/s0) / (s0-1))
sinon si (s0 > 0)
0
d'autre
NaN

Si nous voulons à la fois la moyenne et l'écart type, nous pouvons utiliser le -fichier de sortie option,
en invoquant la commande avec

minccalc -expfile stdev \
-outfile signifie signifie.mnc \
-outfile stdev stdev.mnc \
fichier_entrée1.mnc fichier_entrée2.mnc ...

Et en utilisant le fichier d'expression (avec encore une autre forme d'expression if) :

s0 = s1 = s2 = 0 ;

pour {i dans [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 ;
moyenne = (s0 > 0) ? s1 / s0 : NaN ;

MISES EN GARDE

Quelques points à retenir...

Les variables vectorielles doivent commencer par une lettre majuscule.

Les noms de variables vectorielles ne doivent pas être l'un des mots-clés de la fonction,
somme, len, prod, ... etc

Pour les boucles et si les expressions doivent toujours être séparées de l'expression suivante par un
point-virgule.

La table des symboles est globale.

Opérateurs booléens && et || toujours évaluer les deux opérandes.

Remarque sur le parallélisme : pour des raisons d'efficacité, les évaluations sont effectuées sur plusieurs voxels à la fois
(le nombre de voxels est appelé la largeur de l'évaluation et est modifié avec
le -eval_width option). Une conséquence étrange de ceci est que les deux côtés d'un if-else
sont toujours évalués (à moins que tous les voxels donnent le même résultat de test), mais
les déclarations dans chaque conséquent ne sont évaluées que sur les voxels appropriés. Dans
en particulier, les entrées de la table des symboles ne sont modifiées qu'en fonction d'un masque de voxel. UNE
l'effet secondaire de ceci est que tout symbole vectoriel défini dans un conséquent if-else ne doit pas changer
la longueur du symbole (bien qu'il puisse le créer) et les deux côtés du conséquent doivent
d'accord sur la longueur des symboles vectoriels qu'ils modifient tous les deux. Si ce n'est pas clair,
essayez simplement - le programme se plaindra s'il n'est pas content.

Utilisez minccalc en ligne en utilisant les services onworks.net