minccalc - Online sa Cloud

PROGRAMA:

NAME

minccalc - magsagawa ng mga kumplikadong operasyon sa matematika sa mga minc file

SINOPSIS

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

DESCRIPTION

Minccalc gagawa ng kumplikado, voxel-by-voxel na mga operasyon sa matematika, sa isa o higit pang mga minc file
ng parehong hugis at pagkakaroon ng parehong coordinate sampling, na gumagawa ng isang solong output file.
Ang mga operasyon na isasagawa ay input gamit ang - pagpapahayag argumento (tingnan MGA PAGPAPAHAYAG).
Bilang default, ang output file ay ang huling argumento na hindi opsyon. Gayunpaman, kung ang -outfile
ang opsyon ay ginagamit, at ang lahat ng hindi opsyong argumento ay itinuturing na mga input file at ang output
ang mga pangalan ng file ay nagmula sa -outfile mga opsyon, kung saan maaaring mayroong higit sa isa.

Opsyon

Tandaan na ang mga opsyon ay maaaring tukuyin sa pinaikling anyo (hangga't ang mga ito ay natatangi) at
maaaring ibigay kahit saan sa command line.

-2 Lumikha ng MINC 2.0 format na mga output file.

-tulong I-print ang buod ng mga opsyon sa command-line at paglabas.

-version
I-print ang numero ng bersyon ng programa at lumabas.

- clobber
I-overwrite ang isang umiiral na file.

-noclobber
Huwag i-overwrite ang isang umiiral na file (default).

-walang_clobber
Kasingkahulugan ng -noclobber.

-salita
I-print ang impormasyon sa pag-unlad para sa bawat tipak ng data na nakopya (default).

-tahimik Huwag mag-print ng impormasyon sa pag-unlad.

-debug I-print ang impormasyon sa pag-debug.

-copy_header
Kopyahin ang lahat ng impormasyon ng header mula sa unang input file (default para sa isang input
file)

-nocopy_header
Huwag kopyahin ang lahat ng header mula sa unang input file; copy lang coordinate
impormasyon (default para sa higit sa isang input file).

-type ng file
Lumikha ng isang output file na may parehong uri ng unang input file (default).

-byte Mag-imbak ng mga output voxel sa 8-bit na integer na format.

-maikli Mag-imbak ng mga output voxel sa 16-bit na integer na format.

-int Mag-imbak ng mga output voxel sa 32-bit na integer na format.

-haba Pinalitan ng -int.

-lumutang Mag-imbak ng mga output voxel sa 32-bit na floating point na format.

-doble
Mag-imbak ng mga output voxel sa 64-bit na floating point na format.

-pinirmahan
Gumamit ng signed, two's complement integer format. Nalalapat lamang kung ang uri ng output voxel
ay tinukoy bilang isang uri ng integer (isa sa -byte, -maikli, -int or -haba).

-walang pirma
Gumamit ng unsigned integer na format. Nalalapat lamang kung ang uri ng output voxel ay tinukoy sa
maging isang uri ng integer (isa sa -byte, -maikli, -int or -haba).

-bago minuto max
Limitahan ang wastong hanay ng integer data. Nalalapat lamang kung isa sa mga -byte,
-maikli, -int or -haba ang mga pagpipilian ay tinukoy.

-max_buffer_size_in_kb laki
Tukuyin ang maximum na laki ng mga panloob na buffer (sa kbytes). Ang default ay 4096
(4MB).

-dimension dimname
Tumukoy ng dimensyon kung saan gusto naming magsagawa ng pinagsama-samang operasyon.

-check_dimensions
Suriin kung ang lahat ng mga input file ay may katugmang sampling sa mga sukat ng mundo (default).

-nocheck_dimensions
Huwag pansinin ang anumang pagkakaiba sa pagsa-sample ng mga sukat ng mundo para sa mga input file.

-propagate_nan
Para sa pinagsama-samang mga operasyon ng vector (kabuuan, prod at avg), di-wastong data (Not-A-Number
o NaN) sa anumang elemento ng vector ay gagawa ng di-wastong data sa resulta
(default).

-ignore_nan
Para sa pinagsama-samang mga pagpapatakbo ng vector, ang di-wastong data (NaN) sa vector ay binabalewala, ibig sabihin.
tinatrato na parang wala ito.

-nan Kapag ang isang iligal na operasyon ay sinubukan sa isang voxel (tulad ng hatiin sa zero), ang
ang resulta ay hindi wastong data (NaN) (default). Ang pagkakaroon ng walang wastong data ng pag-input para sa isang pinagsama-samang
ang operasyon ay itinuturing ding ilegal na operasyon kapag -ignore_nan Ginagamit.

-zero Kapag ang isang iligal na operasyon ay sinubukan sa isang voxel (tulad ng hatiin sa zero), ang
ang resulta ay ang halaga ng zero.

-illegal_value halaga
Kapag ang isang iligal na operasyon ay sinubukan sa isang voxel (tulad ng hatiin sa zero), ang
ang resulta ay ang halaga na tinukoy ng opsyong ito.

- pagpapahayag pisi
Tukuyin ang expression na susuriin sa bawat voxel (tingnan ang EXPRESSIONS).

-expfile filename
Tukuyin ang isang file na naglalaman ng isang expression na susuriin sa bawat voxel (tingnan
MGA PAGPAPAHAYAG). Kung ang filename na ``-'' ay ibinigay, ang expression ay babasahin mula sa stdin.
Ang pagkakaiba lamang sa mga expression ng command-line ay ang mga komento ay maaaring ibigay sa
ang file. Tinukoy ang isang linya ng komento sa pamamagitan ng paglalagay ng ``#'' bilang unang hindi-
whitespace na character ng linya. Maaaring malikha ang mga Minccalc script sa pamamagitan ng pagtatakda ng
unang linya sa

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

-outfile simbolo output-file
Tukuyin na ang output ay dapat isulat sa tinukoy na file, kumukuha ng mga halaga mula sa
simbolo na dapat gawin sa expression (tingnan ang HALIMBAWA seksyon). Kung
ang pagpipiliang ito ay ibinigay, pagkatapos ay ang lahat ng hindi opsyon na argumento ay kinuha bilang input file. Ito
ang opsyon ay maaaring gamitin ng maraming beses para sa maramihang mga output file.

-eval_width halaga
Tukuyin ang bilang ng mga voxel na ipoproseso nang magkatulad. Ang default ay 200.

MGA PAGPAPAHAYAG

Ang - pagpapahayag Ang argumento ay isang solong string na naglalarawan sa function na susuriin. Ang
Ang expression ng function ay karaniwang nakasulat sa mga tuntunin ng vector A.

Halimbawa, ang sumusunod na expression ay magsasama-sama ng unang dalawang input file:

A[0] + A[1]

Maaaring ibigay ang maramihang mga expression na pinaghihiwalay ng mga semicolon, kung saan ang halaga lamang ng
ginamit ang huling ekspresyon. Ang mga listahan ng expression na ito ay maaaring gamitin sa pagtatalaga
mga expression upang gawing C-like ang syntax:

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

Ang isang listahan ng expression sa mga kulot na bracket ay isang wastong expression at ibinabalik ang halaga ng huli
expression sa listahan. Ito ay partikular na kapaki-pakinabang sa para at if mga expression (tingnan sa ibaba).

Mayroong dalawang uri ng mga halaga sa wika: mga vector at scalar. Ang mga literal na scaler ay
floating point na mga numero o maaaring lumitaw bilang mga simbolo na ang pangalan ay nagsisimula sa maliit na titik.

Bukod sa mga normal na scalar operator tulad ng +, -, * at /, ang expression na wika din
sumusuporta sa infix exponentiation operator ^ , ang karaniwang relational operator <, <=, >,
>=, ==, != pati na rin ang mga boolean operator && (at), || (o) at ! (hindi). Tandaan na ang
&& at || Ang mga boolean operator ay palaging sinusuri ang parehong mga operand, hindi katulad ng C. Scalar mathematical
Kasama sa mga function abs, sqrt, exp, mag-log, kasalanan, kos, kaya, tulad ng sa, acos at magbigkis. Mayroon ding
ilang mga espesyal na pag-andar:

isnan(v) - 1 kung ang v ay hindi wasto at 0 kung hindi
clamp(v1,v2,v3) - v1 na nililimitahan ng [v2, v3]
segment(v1,v2,v3) - sumusubok kung ang v1 ay nasa [v2, v3]

Ang scalar constant NaN ay tinukoy na ang isnan(NaN) ay nagbabalik 1.

Maaaring isulat ang mga vector sa sumusunod na `extension' na anyo

[ value1, value2, ... ]

o sa pamamagitan ng paggamit ng mga sumusunod na notasyong bumubuo ng hanay:

[ a : b ] ay bumubuo ng {a, a+1, ..., b-1, b}
[ a : b ) ay bumubuo ng {a, a+1, ..., b-1}
( a : b ] ay bumubuo ng {a+1, ..., b-1, b}
( a : b ) ay bumubuo ng {a+1, ..., b-1}

o mabuo, sa pamamagitan ng `intensiyon'. Ang sumusunod na intension expression ay bumubuo ng vector
{3,2,1}:

{ ako sa [1:3] | 4 - ako }

Ang mga vector ay maaari ding lumitaw bilang mga simbolo na ang pangalan ay nagsisimula sa isang malaking titik.

Bilang karagdagan sa mga scalar operator, ang mga sumusunod na vector operator ay ibinibigay:

avg - ang average na halaga ng mga scalar sa vector
len - ang haba ng
kabuuan - ang kabuuan ng mga elemento ng
prod - ang produkto ng mga elemento ng
max - ang pinakamataas na halaga ng
min - ang pinakamababang halaga ng
imax - ang index ng pinakamataas na halaga ng
imin - ang index ng pinakamababang halaga ng
V[s] - ang s'th element ng vector V na may pinanggalingan 0.

Ang mga pangalan ng simbolo ay ipinakilala sa isang pandaigdigang talahanayan ng simbolo sa pamamagitan ng mga expression ng pagtatalaga ng
anyo

a = A[2] * mag-log(2)

Ang mga simbolo na nagsisimula sa maliit na titik ay kumakatawan sa mga scalar habang ang mga nagsisimula sa isang
ang malalaking titik ay kumakatawan sa mga vector. Dahil ang = ay isang operator, ang resulta nito ay maaaring gamitin sa isang
expression (tulad ng sa C).

Ang ilang mga control construct ay ibinigay:

Para sa mga loop ay maaaring malikha upang mag-loop sa isang vector, na nagtatalaga ng bawat halaga sa isang simbolo at pagkatapos
pagsusuri ng isang pagpapahayag. Ginagawa ito gamit ang mga expression ng form

kabuuan=0; para sa{i sa [0:len(A))} kabuuan=kabuuang+A[i]; kabuuan

na katumbas ng sum(A). Tandaan na ito ay katulad ng paggamit

kabuuan=0; len{i sa [0:len(A)) | kabuuan=kabuuan+A[i]}; kabuuan

dahil ang para construct ay talagang isang operator (bagaman ito ay karaniwang ginagamit lamang para sa
pagbabago ng mga halaga ng simbolo). Tandaan din na kung wala ang pangwakas na "kabuuan", gagawin ng expression
hindi masyadong kapaki-pakinabang dahil ibabalik lamang nito ang haba ng vector.

Tulad ng sa C, ang isang listahan ng mga expression ay maaaring tukuyin sa mga kulot:

kabuuan=kabuuan2 = 0;
para sa {i sa [0:len(A))} {
kabuuan = kabuuan + A[i];
kabuuang2 = kabuuang2 + A[i]^2
}

Mayroon ding ilang mga anyo ng kung sakali ay bumuo:

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

kung (A[0]<0) resulta=0 iba pang resulta=A[0]

Ang iba ay opsyonal. Muli, ang if construct ay isang operator, at ang pagkatapos or iba
Ang mga expression ay maaaring mga listahan ng expression sa mga kulot, kung saan ang halaga ng huli
ibinalik ang ekspresyon. Kung ang iba nawawala ang expression, pagkatapos ay ibinalik ang value na 0
kapag ang test expression ay 0 (false).

Ang pangunahing kakaiba sa para at if Ang mga konstruksyon ay hindi tulad ng mga pahayag ng C, dapat sila
ihihiwalay mula sa susunod na expression sa pamamagitan ng isang semicolon kahit na ang isang listahan ng expression ay nasa
ginagamit ang mga kulot:

para sa i sa [0:len(A)) {total=total+A[i]} ; kabuuan/len(A)
kung (A[i]>0) {result=2;} else {result=1} ; resulta*5

Ang isang alternatibong paraan upang ipakilala ang mga pangalan ng simbolo ay sa pamamagitan ng pabayaan-mga ekspresyon. Halimbawa, ang
ang sumusunod na expression ay palaging susuriin sa 3:

hayaan ang a = 1, b = 2 sa a + b

Ang mga ito ay orihinal na idinisenyo upang lumikha ng mga variable lamang sa loob ng nasuri na expression,
ngunit ang mga pagbabago ay ginawa upang ang talahanayan ng pandaigdigang simbolo ay nabago.

HALIMBAWA

Narito ang isang expression para sa pagkalkula ng standard deviation, isinasaalang-alang ang
posibilidad ng di-wastong data ng pag-input, na hindi pinansin:

s0 = s1 = s2 = 0;

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

kung (s0 > 1) {
sqrt((s2 - s1*s1/s0) / (s0-1));
}
tao {
NaN;
};

Ang huling kung ay maaaring baguhin upang bumalik ng 0 kung ang s0 ay > 0 ngunit <= 1. Binaba din namin ang kulot
mga bracket, ngunit pagkatapos ay hindi dapat magkaroon ng isang ";" sa pagitan ng kung at ng iba pa

kung (s0 > 1)
sqrt((s2 - s1*s1/s0) / (s0-1))
iba kung (s0 > 0)
0
iba
NaN

Kung gusto natin pareho ang mean at ang standard deviation, maaari nating gamitin ang -outfile pagpipilian,
pagtawag sa utos na may

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

At gamit ang expression file (na may isa pang anyo ng if expression):

s0 = s1 = s2 = 0;

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

MGA CAVEATS

Ilang bagay na dapat mong tandaan...

Ang mga variable ng vector ay dapat magsimula sa isang malaking titik.

Ang mga pangalan ng variable ng vector ay hindi dapat isa sa mga keyword ng function,
sum, len, prod, ... atbp

Para sa mga loop at kung ang mga expression ay palaging kailangang ihiwalay mula sa susunod na expression sa pamamagitan ng a
tuldok-kuwit.

Ang talahanayan ng simbolo ay pandaigdigan.

Mga operator ng Boolean && at || palaging suriin ang parehong operand.

Isang tala sa parallelism: Para sa mga dahilan ng kahusayan, ang mga pagsusuri ay ginagawa sa maraming voxel nang sabay-sabay
(ang bilang ng mga voxel ay tinutukoy bilang ang lapad ng pagsusuri at binago ng
ang -eval_width opsyon). Ang isang kakaibang kinahinatnan nito ay ang magkabilang panig ng isang if-else
Ang pahayag ay palaging sinusuri (maliban kung ang lahat ng mga voxel ay nagbibigay ng parehong resulta ng pagsubok), ngunit
ang mga pahayag sa loob ng bawat kahihinatnan ay sinusuri lamang sa naaangkop na mga voxel. Sa
partikular, ang mga entry sa talahanayan ng simbolo ay binago lamang ayon sa isang voxel mask. A
side-effect nito ay ang anumang simbolo ng vector na itinakda sa isang if-else consequent ay hindi dapat magbago
ang haba ng simbolo (bagaman maaari itong lumikha nito) at magkabilang panig ng kahihinatnan ay dapat
sumang-ayon sa haba ng anumang mga simbolo ng vector na pareho nilang binago. Kung ito ay hindi malinaw,
subukan lang - magrereklamo ang programa kung hindi ito masaya.

Gumamit ng minccalc online gamit ang mga serbisyo ng onworks.net