mincgen - Online sa Cloud

PROGRAMA:

NAME

mincgen - Bumuo ng MINC file mula sa CDL file.

SINOPSIS

mincgen [-b] [-n] [-o minc_filename] input_file

DESCRIPTION

mincgen bumubuo ng MINC file. Ang input sa mincgen ay isang paglalarawan ng isang MINC file sa a
maliit na wika na kilala bilang CDL (network Common Data form Language), na inilarawan sa ibaba. Kung hindi
ang mga opsyon ay tinukoy sa pag-invoke mincgen, sinusuri lamang nito ang syntax ng input CDL
file, na gumagawa ng mga mensahe ng error para sa anumang mga paglabag sa CDL syntax. Ang iba pang mga pagpipilian ay maaaring
ginamit upang lumikha ng kaukulang MINC file.

mincgen maaaring gamitin sa kasamang programa mincdump upang magsagawa ng ilang simpleng operasyon
sa MINC file. Halimbawa, upang palitan ang pangalan ng isang dimensyon sa isang MINC file, gamitin mincdump upang makakuha ng isang
CDL na bersyon ng MINC file, i-edit ang CDL file para baguhin ang pangalan ng mga dimensyon, at
gamitin mincgen upang bumuo ng kaukulang MINC file mula sa na-edit na CDL file.

Opsyon

-b Gumawa ng (binary) MINC file. Kung ang -o Ang opsyon ay wala, ang isang default na pangalan ng file ay
mabuo mula sa pangalan ng MINC (tinukoy pagkatapos ng netcdf or hdf5 keyword sa
ang input) sa pamamagitan ng pagdaragdag ng `.mnc' extension. Kung mayroon nang file na may
tinukoy na pangalan, ito ay mapapatungan.

-o minc_filename
Pangalan para sa binary MINC file na ginawa. Kung ang pagpipiliang ito ay tinukoy, ito ay nagpapahiwatig ng
"-b" opsyon. (Kailangan ang opsyong ito dahil hindi maisusulat ang mga MINC file
direkta sa karaniwang output, dahil hindi mahahanap ang karaniwang output.)

HALIMBAWA

Suriin ang syntax ng CDL file `foo.cdl':

mincgen foo.cdl

Mula sa CDL file `foo.cdl', bumuo ng katumbas na binary MINC file na pinangalanang `x.mnc':

mincgen -o x.mnc foo.cdl

PAGGAMIT

CDL palaugnayan Buod
Nasa ibaba ang isang halimbawa ng CDL syntax, na naglalarawan ng MINC file na may ilang pinangalanang dimensyon
(xspace, yspace, at zspace), mga variable (zspace, image), mga variable na attribute (valid_range,
signtype), at ilang data. Ang mga keyword ng CDL ay naka-boldface. (Ang halimbawang ito ay inilaan upang
ilarawan ang syntax; ang isang tunay na CDL file ay magkakaroon ng mas kumpletong hanay ng mga katangian kaya
na ang data ay magiging mas ganap na naglalarawan sa sarili.)

netcdf foo { // isang halimbawang detalye ng MINC sa CDL

sukat:
xspace = 8;
yspace = 8;
zspace = 5;

mga variable:
lumutang xspace;
lumutang yspace;
lumutang zspace(zspace);
maikli larawan(zspace,yspace,xspace);
double image-min(zspace)
double image-max(zspace)

// variable na mga katangian
larawan:valid_range = 0,5;
data:
image-min = -1,-1,-1,-1,-1;
image-max = 1,1,1,1,1;
larawan =
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5;
zspace = 0,2,3.5,7,10;
}

Ang lahat ng mga pahayag ng CDL ay winakasan ng isang tuldok-kuwit. Maaaring gamitin ang mga puwang, tab, at bagong linya
malayang para mabasa. Maaaring sundin ng mga komento ang mga character na `//' sa anumang linya.

Ang paglalarawan ng CDL ay binubuo ng tatlong opsyonal na bahagi: sukat, mga variable, at data,
simula sa keyword sukat:, variable, at data, ayon sa pagkakabanggit. Ang variable
bahagi ay maaaring maglaman nagbabago deklarasyon at katangian mga takdang-aralin.

Isang MINC sukat ay ginagamit upang tukuyin ang hugis ng isa o higit pa sa multidimensional
mga variable na nakapaloob sa MINC file. Ang isang dimensyon ng MINC ay may pangalan, laki, at posibleng
ilang iba pang mga katangian.

A nagbabago kumakatawan sa isang multidimensional na hanay ng mga halaga ng parehong uri. Ang isang variable ay may
isang pangalan, isang uri ng data, at isang hugis na inilalarawan ng listahan ng mga sukat nito. Ang bawat variable ay maaaring
mayroon ding nauugnay mga katangian (tingnan sa ibaba) pati na rin ang mga halaga ng data. Ang pangalan, uri ng data,
at hugis ng isang variable ay tinukoy sa pamamagitan ng deklarasyon nito sa nagbabago seksyon ng isang CDL
paglalarawan. Ang isang variable ay maaaring may parehong pangalan bilang isang dimensyon; sa pamamagitan ng kumbensyon tulad ng a
ang variable ay isang-dimensional at naglalaman ng mga coordinate ng dimensyon na pinangalanan nito.
Ang mga sukat ay hindi kailangang may kaukulang mga variable.

Isang netCDF katangian naglalaman ng impormasyon tungkol sa isang variable ng netCDF o tungkol sa buong netCDF
dataset. Ginagamit ang mga katangian upang tukuyin ang mga katangian tulad ng mga yunit, espesyal na halaga, maximum
at pinakamababang valid na value, scaling factor, offset, at parameter. Impormasyon ng katangian
ay kinakatawan ng mga solong halaga o array ng mga halaga. Halimbawa, ang "mga yunit" ay isang katangian
kinakatawan ng isang array ng character tulad ng "celsius". Ang isang katangian ay may nauugnay
variable, isang pangalan, isang uri ng data, isang haba, at isang halaga. Sa kaibahan sa mga variable na
nilayon para sa data, ang mga katangian ay inilaan para sa metadata (data tungkol sa data).

Sa CDL, ang isang katangian ay itinalaga ng isang variable at pangalan ng katangian, na pinaghihiwalay ng `:'. Ito
ay posibleng italaga global mga attribute na hindi nauugnay sa anumang variable sa file bilang a
buo sa pamamagitan ng paggamit ng `:' bago ang pangalan ng katangian. Ang uri ng data ng isang katangian sa CDL ay
nagmula sa uri ng halagang itinalaga dito. Ang haba ng isang katangian ay ang
bilang ng mga halaga ng data na itinalaga dito, o ang bilang ng mga character sa string ng character
nakatalaga dito. Maraming value ang itinalaga sa mga hindi character na attribute sa pamamagitan ng paghihiwalay
ang mga halaga na may mga kuwit. Ang lahat ng mga halaga na itinalaga sa isang katangian ay dapat na pareho ang uri.

Ang mga pangalan para sa mga dimensyon, variable, at attribute ng CDL ay dapat magsimula sa alphabetic
character o `_', at ang mga kasunod na character ay maaaring alphanumeric o `_' o `-'.

Ang opsyonal data seksyon ng isang detalye ng CDL ay kung saan maaaring masimulan ang mga variable.
Ang syntax ng isang initialization ay simple: isang variable na pangalan, isang katumbas na sign, at isang kuwit.
tinapos na listahan ng mga constant (maaaring pinaghihiwalay ng mga puwang, tab at bagong linya)
na may semicolon. Para sa mga multi-dimensional na array, ang huling dimensyon ay pinakamabilis na nag-iiba. Sa gayon
row-order kaysa column order ang ginagamit para sa mga matrice. Kung mas kaunting halaga ang ibinibigay
kaysa sa kinakailangan upang punan ang isang variable, ito ay pinalawig ng isang nakadepende sa uri na `fill value',
na maaaring ma-override sa pamamagitan ng pagbibigay ng halaga para sa isang kilalang variable na attribute na pinangalanan
`_FillValue'. Ang mga uri ng mga constant ay hindi kailangang tumugma sa uri na idineklara para sa isang variable;
Ang mga pamimilit ay ginagawa upang i-convert ang mga integer sa floating point, halimbawa. Ang pare-pareho `_'
ay maaaring gamitin upang italaga ang halaga ng punan para sa isang variable.

Noong unang panahon data Uri
tangke character
byte 8-bit na data
maikli 16-bit signed integers
mahaba 32-bit signed integers
int (kasingkahulugan ng mahaba)
lumutang IEEE single precision floating point (32 bits)
tunay (kasingkahulugan ng lumutang)
double IEEE double precision floating point (64 bits)

Maliban sa idinagdag na uri ng data byte at ang kakulangan ng hindi naka -ignign, pareho ang sinusuportahan ng CDL
primitive data type bilang C. Ang mga pangalan para sa primitive data type ay nakalaan sa mga salita
CDL, kaya hindi dapat mga pangalan ng uri ang mga pangalan ng mga variable, dimensyon, at attribute. Sa
mga deklarasyon, maaaring tukuyin ang mga uri ng pangalan sa alinman sa malaki o maliit na titik.

Ang mga byte ay naiiba sa mga character dahil ang mga ito ay nilayon na magkaroon ng buong walong piraso ng data,
at ang zero byte ay walang espesyal na kahalagahan, tulad ng para sa data ng character.

Ang mga short ay maaaring magkaroon ng mga halaga sa pagitan ng -32768 at 32767.

Ang mga long ay maaaring magkaroon ng mga halaga sa pagitan ng -2147483648 at 2147483647. int at kabuuan ay tinatanggap bilang
kasingkahulugan ng mahaba sa mga deklarasyon ng CDL. Ngayon na mayroong mga platform na may 64-bit
representasyon para sa C longs, maaaring mas mahusay na gamitin ang int kasingkahulugan upang maiwasan ang kalituhan.

Ang mga float ay maaaring magkaroon ng mga halaga sa pagitan ng mga -3.4+38 at 3.4+38. Ang kanilang panlabas na representasyon ay
bilang 32-bit IEEE normalized single-precision lumulutang point numero. tunay ay tinatanggap bilang a
kasingkahulugan ng lumutang sa mga deklarasyon ng CDL.

Ang mga double ay maaaring magkaroon ng mga halaga sa pagitan ng mga -1.7+308 at 1.7+308. Ang kanilang panlabas na representasyon
ay bilang 64-bit na IEEE standard na normalized na double-precision floating point na mga numero.

CDL Constants
Ang mga constant na itinalaga sa mga attribute o variable ay maaaring alinman sa mga pangunahing uri ng MINC. Ang
Ang syntax para sa mga constant ay katulad ng C syntax, maliban kung ang mga uri ng suffix ay dapat idugtong sa
shorts at floats upang makilala ang mga ito mula sa longs at doubles.

A byte ang pare-pareho ay kinakatawan ng isang solong character o maramihang character na pagkakasunud-sunod ng pagtakas
nakapaloob sa mga solong panipi. Halimbawa,
'a' // ASCII `a'
'\0' // isang zero byte
'\n' // ASCII newline na character
'\33' // ASCII escape character (33 octal)
'\x2b' // ASCII plus (2b hex)
'\377' // 377 octal = 255 decimal, hindi ASCII

Ang mga character constant ay nakapaloob sa double quotes. Maaaring kinakatawan ang array ng character
bilang isang string na nakapaloob sa double quotes. Ang karaniwang C string escape convention ay pinarangalan.
Halimbawa
"a" // ASCII `a'
"Dalawang\nlinya\n" // isang 10-character na string na may dalawang naka-embed na bagong linya
"a bell:\007" // isang string na naglalaman ng ASCII bell
Tandaan na ang array ng character na "a" ay magkakasya sa isang variable na isang elemento, dahil hindi
ang pagwawakas ng NULL na character ay ipinapalagay. Gayunpaman, ang isang zero byte sa isang array ng character ay
binibigyang kahulugan bilang pagtatapos ng mga makabuluhang tauhan ng mincdump programa, sumusunod
ang C convention. Samakatuwid, ang isang NULL byte ay hindi dapat naka-embed sa isang string ng character
maliban kung sa dulo: gamitin ang byte uri ng data sa halip para sa mga byte array na naglalaman ng zero
byte. Ang MINC at CDL ay walang uri ng string, ngunit mga fixed-length na array ng character lang, na maaaring
maging multi-dimensional.

maikli integer constants ay inilaan para sa kumakatawan sa 16-bit sign na dami. Ang porma
ng maikli ang constant ay isang integer na pare-pareho na may `s' o `S' na nakadugtong. Kung ang maikli
ang pare-pareho ay nagsisimula sa `0', ito ay binibigyang kahulugan bilang octal, maliban na kung ito ay nagsisimula sa `0x',
ito ay binibigyang kahulugan bilang isang hexadecimal constant. Halimbawa:
-2s // isang maikling -2
0123s // octal
0x7ffs //hexadecimal

Mahaba integer constants ay inilaan para sa kumakatawan sa 32-bit sign na dami. Ang porma
ng mahaba Ang constant ay isang ordinaryong integer na pare-pareho, bagama't ito ay katanggap-tanggap na magdagdag ng isang
opsyonal na `l' o `L'. Kung ang mahaba ang pare-pareho ay nagsisimula sa `0', ito ay binibigyang kahulugan bilang octal,
maliban na kung ito ay nagsisimula sa `0x', ito ay binibigyang kahulugan bilang isang hexadecimal constant. Mga halimbawa
ng balido mahaba ang mga constant ay kinabibilangan ng:
-2
1234567890L
0123 // octal
0x7ff // hexadecimal

Floating point constants ng uri lumutang ay angkop para sa kumakatawan sa lumulutang na punto
data na may humigit-kumulang pitong makabuluhang digit ng katumpakan. Ang anyo ng a lumutang pare-pareho ay
kapareho ng isang C floating point constant na may `f' o `F' na nakadugtong. Halimbawa ang
katanggap-tanggap ang mga sumusunod lumutang constants:
-2.0f
3.14159265358979f // ay puputulin sa hindi gaanong katumpakan
1. f

Floating point constants ng uri double ay angkop para sa kumakatawan sa lumulutang na punto
data na may humigit-kumulang labing anim na makabuluhang digit ng katumpakan. Ang anyo ng a double pare-pareho ay
kapareho ng isang C floating point constant. Maaaring magdagdag ng opsyonal na `d' o `D'. Para sa
halimbawa ang mga sumusunod ay lahat ay katanggap-tanggap double constants:
-2.0
3.141592653589793
1.0st-20
1d

Gamitin ang mincgen online gamit ang mga serbisyo ng onworks.net