mincgen - En ligne dans le Cloud

PROGRAMME:

Nom

mincgen - Génère un fichier MINC à partir d'un fichier CDL.

SYNOPSIS

mingen [-b] [-n] [-o nom_fichier minc] fichier_entrée

DESCRIPTION

mingen génère un fichier MINC. L'entrée à mingen est une description d'un fichier MINC dans un
petit langage appelé CDL (Network Common Data form Language), décrit ci-dessous. Sinon
les options sont spécifiées lors de l'appel mingen, il vérifie simplement la syntaxe du CDL d'entrée
fichier, produisant des messages d'erreur pour toute violation de la syntaxe CDL. D'autres options peuvent être
utilisé pour créer le fichier MINC correspondant.

mingen peut être utilisé avec le programme compagnon dépotoir pour effectuer quelques opérations simples
sur les fichiers MINC. Par exemple, pour renommer une dimension dans un fichier MINC, utilisez dépotoir pour obtenir un
version CDL du fichier MINC, éditez le fichier CDL pour changer le nom des dimensions, et
utilisé mingen pour générer le fichier MINC correspondant à partir du fichier CDL édité.

OPTIONS

-b Créez un fichier MINC (binaire). Si la -o est absente, un nom de fichier par défaut sera
être construit à partir du nom MINC (spécifié après le netcdf or hdf5 mot-clé dans
l'entrée) en ajoutant l'extension `.mnc'. Si un fichier existe déjà avec le
nom spécifié, il sera écrasé.

-o nom_fichier minc
Nom du fichier binaire MINC créé. Si cette option est spécifiée, cela implique la
"-b". (Cette option est nécessaire car les fichiers MINC ne peuvent pas être écrits
directement à la sortie standard, puisque la sortie standard n'est pas recherchable.)

EXEMPLES

Vérifiez la syntaxe du fichier CDL `foo.cdl':

mincgen foo.cdl

À partir du fichier CDL `foo.cdl', génère un fichier MINC binaire équivalent nommé `x.mnc':

mincgen -o x.mnc foo.cdl

UTILISATION

CDL Syntaxe Résumé
Voici un exemple de syntaxe CDL, décrivant un fichier MINC avec plusieurs dimensions nommées
(xspace, yspace et zspace), variables (zspace, image), attributs de variable (valid_range,
type de signe) et quelques données. Les mots-clés CDL sont en gras. (Cet exemple est destiné à
illustrer la syntaxe ; un vrai fichier CDL aurait un ensemble plus complet d'attributs donc
que les données seraient plus complètement autodescriptives.)

netcdf foo { // un exemple de spécification MINC dans CDL

dimensions:
espace x = 8 ;
yespace = 8;
zespace = 5 ;

les variables:
flotter espacex ;
flotter yespace;
flotter zespace(zespace);
court image(zspace,yspace,xspace);
double image-min (zspace)
double image-max (zspace)

// attributs variables
image : plage_valide = 0,5 ;
données:
image-min = -1,-1,-1,-1,-1;
image-max = 1,1,1,1,1 ;
image =
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;
zespace = 0,2,3.5,7,10 ;
}

Toutes les instructions CDL se terminent par un point-virgule. Les espaces, les tabulations et les sauts de ligne peuvent être utilisés
librement pour la lisibilité. Les commentaires peuvent suivre les caractères `//' sur n'importe quelle ligne.

Une description CDL se compose de trois parties facultatives : dimensions, les variableset données,
commençant par le mot-clé dimensions:, variables:et données, respectivement. La variable
une partie peut contenir variable déclarations ainsi que attribuer missions.

UN MINC dimension est utilisé pour définir la forme d'un ou plusieurs des éléments multidimensionnels
variables contenues dans le fichier MINC. Une dimension MINC a un nom, une taille et éventuellement
plusieurs autres attributs.

A variable représente un tableau multidimensionnel de valeurs du même type. Une variable a
un nom, un type de données et une forme décrite par sa liste de dimensions. Chaque variable peut
ont également associé attributs (voir ci-dessous) ainsi que les valeurs des données. Le nom, le type de données,
et la forme d'une variable sont spécifiés par sa déclaration dans le variable section d'un CDL
la description. Une variable peut avoir le même nom qu'une dimension ; par convention un tel
La variable est unidimensionnelle et contient les coordonnées de la dimension qu'elle nomme.
Les dimensions n'ont pas besoin d'avoir des variables correspondantes.

Un netCDF attribuer contient des informations sur une variable netCDF ou sur l'ensemble du netCDF
base de données. Les attributs sont utilisés pour spécifier des propriétés telles que les unités, les valeurs spéciales, le maximum
et les valeurs valides minimales, les facteurs d'échelle, les décalages et les paramètres. Informations sur les attributs
est représenté par des valeurs uniques ou des tableaux de valeurs. Par exemple, « unités » est un attribut
représenté par un tableau de caractères tel que "celsius". Un attribut a un associé
variable, un nom, un type de données, une longueur et une valeur. Contrairement aux variables qui sont
destinés aux données, les attributs sont destinés aux métadonnées (données sur les données).

Dans CDL, un attribut est désigné par une variable et un nom d'attribut, séparés par `:'. Ce
est possible d'attribuer de défis attributs non associés à une variable du fichier en tant que
entier en utilisant `:' avant le nom de l'attribut. Le type de données d'un attribut dans CDL est
dérivé du type de la valeur qui lui est assignée. La longueur d'un attribut est la
nombre de valeurs de données qui lui sont affectées, ou le nombre de caractères dans la chaîne de caractères
lui est assigné. Plusieurs valeurs sont attribuées aux attributs non-caractères en séparant
les valeurs avec des virgules. Toutes les valeurs affectées à un attribut doivent être du même type.

Les noms des dimensions, variables et attributs CDL doivent commencer par une lettre alphabétique
caractère ou « _ », et les caractères suivants peuvent être alphanumériques ou « _ » ou « - ».

Le facultatif données La section d'une spécification CDL est l'endroit où les variables peuvent être initialisées.
La syntaxe d'une initialisation est simple : un nom de variable, un signe égal et une virgule.
liste délimitée de constantes (éventuellement séparées par des espaces, des tabulations et des sauts de ligne) terminée
avec un point-virgule. Pour les tableaux multidimensionnels, la dernière dimension varie le plus rapidement. Ainsi
l'ordre des lignes plutôt que l'ordre des colonnes est utilisé pour les matrices. Si moins de valeurs sont fournies
que nécessaire pour remplir une variable, il est étendu avec une "valeur de remplissage" dépendant du type,
qui peut être remplacé en fournissant une valeur pour un attribut de variable distinctif nommé
`_FillValue'. Les types de constantes n'ont pas besoin de correspondre au type déclaré pour une variable ;
des coercitions sont faites pour convertir des entiers en virgule flottante, par exemple. La constante '_'
peut être utilisé pour désigner la valeur de remplissage d'une variable.

Primitif Données Types
carboniser caractères
octet 8 bits de données
court Entiers signés 16 bits
Long Entiers signés 32 bits
int (synonyme de Long)
flotter Virgule flottante simple précision IEEE (32 bits)
réal (synonyme de flotter)
double Virgule flottante double précision IEEE (64 bits)

À l'exception du type de données ajouté octet et le manque de non signé, CDL prend en charge le même
types de données primitifs comme C. Les noms des types de données primitifs sont des mots réservés dans
CDL, donc les noms de variables, de dimensions et d'attributs ne doivent pas être des noms de type. Dans
déclarations, les noms de type peuvent être spécifiés en majuscules ou en minuscules.

Les octets diffèrent des caractères en ce qu'ils sont destinés à contenir huit bits complets de données,
et l'octet zéro n'a pas de signification particulière, comme c'est le cas pour les données de caractères.

Les shorts peuvent contenir des valeurs comprises entre -32768 et 32767.

Les longs peuvent contenir des valeurs comprises entre -2147483648 et 2147483647. int ainsi que entier sont acceptés comme
synonymes de Long dans les déclarations CDL. Maintenant qu'il existe des plates-formes avec 64 bits
représentations pour C longs, il peut être préférable d'utiliser le int synonyme pour éviter toute confusion.

Les flottants peuvent contenir des valeurs comprises entre environ -3.4+38 et 3.4+38. Leur représentation extérieure est
sous forme de nombres à virgule flottante simple précision normalisés IEEE 32 bits. réal est accepté comme un
synonyme de flotter dans les déclarations CDL.

Les doubles peuvent contenir des valeurs comprises entre environ -1.7+308 et 1.7+308. Leur représentation extérieure
est sous forme de nombres à virgule flottante double précision normalisés IEEE 64 bits.

CDL Constants
Les constantes affectées aux attributs ou aux variables peuvent être de n'importe quel type MINC de base. Les
la syntaxe des constantes est similaire à la syntaxe C, sauf que les suffixes de type doivent être ajoutés à
shorts et flotteurs pour les distinguer des longs et des doubles.

A octet la constante est représentée par un seul caractère ou une séquence d'échappement à plusieurs caractères
entre guillemets simples. Par exemple,
'a' // ASCII 'a'
'\0' // un octet nul
'\n' // Caractère de nouvelle ligne ASCII
'\33' // caractère d'échappement ASCII (33 octal)
'\x2b' // ASCII plus (2b hex)
'\377' // 377 octal = 255 décimal, non-ASCII

Les constantes de caractères sont entourées de guillemets doubles. Un tableau de caractères peut être représenté
sous forme de chaîne entre guillemets doubles. Les conventions d'échappement de chaîne C habituelles sont respectées.
Par exemple
"a" // ASCII `a'
"Deux\nlignes\n" // une chaîne de 10 caractères avec deux nouvelles lignes intégrées
"a bell:\007" // une chaîne contenant une cloche ASCII
Notez que le tableau de caractères "a" tiendrait dans une variable à un élément, car aucun
Le caractère NULL de fin est supposé. Cependant, un octet de zéro dans un tableau de caractères est
interprétée comme la fin des personnages significatifs par le dépotoir programme, suivant
la convention C. Par conséquent, un octet NULL ne doit pas être incorporé dans une chaîne de caractères
à moins qu'à la fin : utilisez le octet type de données à la place pour les tableaux d'octets qui contiennent le zéro
octet. MINC et CDL n'ont pas de type chaîne, mais uniquement des tableaux de caractères de longueur fixe, qui peuvent
être multidimensionnel.

court les constantes entières sont destinées à représenter des quantités signées de 16 bits. La forme
d'un court constante est une constante entière avec un « s » ou « S » ajouté. Si un court
constante commence par '0', elle est interprétée comme octale, sauf que si elle commence par '0x',
elle est interprétée comme une constante hexadécimale. Par exemple:
-2s // un court -2
0123s // octale
0x7ffs //hexadécimal

Location les constantes entières sont destinées à représenter des quantités signées de 32 bits. La forme
d'un Long constante est une constante entière ordinaire, bien qu'il soit acceptable d'ajouter un
'l' ou 'L' facultatif. Si un Long constante commence par '0', elle est interprétée comme octale,
sauf que s'il commence par « 0x », il est interprété comme une constante hexadécimale. Exemples
de valide Long les constantes comprennent :
-2
1234567890L
0123 // octale
0x7ff // hexadécimal

Constantes à virgule flottante de type flotter sont appropriés pour représenter la virgule flottante
données avec environ sept chiffres significatifs de précision. La forme d'un flotter constante est
identique à une constante à virgule flottante C avec un "f" ou un "F" ajouté. Par exemple le
suivants sont tous acceptables flotter constantes :
-2.0f
3.14159265358979f // sera tronqué avec moins de précision
xnumx.f

Constantes à virgule flottante de type double sont appropriés pour représenter la virgule flottante
données avec environ seize chiffres significatifs de précision. La forme d'un double constante est
identique à une constante à virgule flottante C. Un « d » ou « D » facultatif peut être ajouté. Pour
exemple, les éléments suivants sont tous acceptables double constantes :
- 2.0
3.141592653589793
1.0e-20
1.d

Utiliser mincgen en ligne en utilisant les services onworks.net