C++ NetCDF et chaine de caractères

Version imprimable

Bonjour,
Je cherche à faire des chaines de caractères de longueurs non constantes, par exemple:

Ce cas là fonctionne bien:

Code:

1
2
3
4
5
6
7
8
static const int NX = 12;
static const int NY = 7;
NcFile dataFile("simple_xy.nc", NcFile::Replace);
NcDim* xDim = dataFile.add_dim("x", NX);
NcDim* yDim = dataFile.add_dim("y", NY);
NcVar *monChar = dataFile.add_var("monChar", ncChar, xDim, yDim);
char* monCharUn[] = {"aaaaaa","bbbbbb","cccccc","dddddd", "eeeeee", "ffffff", "gggggg", "hhhhhh", "iiiiii", "jjjjjj", "kkkkkk", "llllll"};
monChar->put(&monCharUn[0][0], NX, NY);

J'obtiens dans le NetCDF:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 monChar =
  "aaaaaa",
  "bbbbbb",
  "cccccc",
  "dddddd",
  "eeeeee",
  "ffffff",
  "gggggg",
  "hhhhhh",
  "iiiiii",
  "jjjjjj",
  "kkkkkk",
  "llllll" ;

Par contre si je fais :

Code:

1
2
3
4
5
6
7
8
static const int NX = 12;
static const int NY = 7;
NcFile dataFile("simple_xy.nc", NcFile::Replace);
NcDim* xDim = dataFile.add_dim("x", NX);
NcDim* yDim = dataFile.add_dim("y", NY);
NcVar *monChar = dataFile.add_var("monChar", ncChar, xDim, yDim);
char* monCharUn[] = {"aaaaaa","bbb","cccccc","dddddd", "eeeeee", "ffffff", "gggggg", "hhhhhh", "iiiiii", "jjjjjj", "kkkkkk", "llllll"};
monChar->put(&monCharUn[0][0], NX, NY);

ça me donne:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 monChar =
  "aaaaaa",
  "bbb\000ccc",
  "ccc\000ddd",
  "ddd\000eee",
  "eee\000fff",
  "fff\000ggg",
  "ggg\000hhh",
  "hhh\000iii",
  "iii\000jjj",
  "jjj\000kkk",
  "kkk\000lll",
  "lll\000\000\000*" ;

snif, comment faire pour avoir des éléments de longueurs différentes, sachant que quand je fais le NetCDF à la main (ncgen) ça marche bien :/

merci d'avance!!

J 'ai un peu avancé mais c'est moche moche moche: J'ai ajouté des \0 pour compléter la longueur de la chaîne
Code:

1 2 3 4 5 6 7 8 static const int NX = 12; static const int NY = 7; NcFile dataFile("simple_xy.nc", NcFile::Replace); NcDim* xDim = dataFile.add_dim("x", NX); NcDim* yDim = dataFile.add_dim("y", NY); NcVar *monChar = dataFile.add_var("monChar", ncChar, xDim, yDim); char* monCharUn[] = {"aaaaaa","bbb\0\0\0","cccccc","dddddd", "eeeeee", "ffffff", "gggggg", "hhhhhh", "iiiiii", "jjjjjj", "kkkkkk", "llllll"}; monChar->put(&monCharUn[0][0], NX, NY);
ça fonctionne, je ne l'explique pas mais je trouve ça hyper laid... vous en pensez quoi?

15/02/2013, 17h03
Médinoc

J'ai l'impression que l'original était déjà super-sale:

Citation:

Envoyé par [URL=http://www.unidata.ucar.edu/software/netcdf/docs/netcdf-cxx/Class-NcVar.html]La doc[/URL]

NcBool put(const char* vals, long c0, long c1, long c2, long c3, long c4) Write scalar or 1 to 5-dimensional arrays by providing enough arguments. The vals argument points to a contiguous block of values in memory to be written. This means if you allocate each row of an array with a “new” call for example, you must not write more than one row at a time, because the rows may not be contiguous in memory. Other arguments are edge lengths, and their number must not exceed variable's dimensionality. Start corner is [0,0,..., 0] by default, but may be reset using the set_cur() member function for this variable. FALSE is returned if type of values does not match type for variable. For more than 5 dimensions, use the overloaded n-dimensional form of the put member function.

(mise en gras par moi)

Ta déclaration char* monCharUn[] = {"aaaaaa","bbbbbb" ... } est équivalent à plusieurs allocations séparées: le fait que ça ait marché avec ce compilateur-là sur cette plate-forme là est une pure coïncidence.

Par contre, ceci devrait être fiable:

Code:

char monCharUn[][7] = {"aaaaaa","bbb","cccccc","dddddd", "eeeeee", "ffffff", "gggggg", "hhhhhh", "iiiiii", "jjjjjj", "kkkkkk", "llllll"};

PS: Cette question, qu'a-t-elle à voir avec le langage C++/CLI utilisé pour .Net?

Citation:

Envoyé par Médinoc

J'ai l'impression que l'original était déjà super-sale:

(mise en gras par moi)

Ta déclaration char* monCharUn[] = {"aaaaaa","bbbbbb" ... } est équivalent à plusieurs allocations séparées: le fait que ça ait marché avec ce compilateur-là sur cette plate-forme là est une pure coïncidence.

Ça ne m'étonne pas trop

Citation:

Envoyé par Médinoc

Par contre, ceci devrait être fiable:

Code:

char monCharUn[][7] = {"aaaaaa","bbb","cccccc","dddddd", "eeeeee", "ffffff", "gggggg", "hhhhhh", "iiiiii", "jjjjjj", "kkkkkk", "llllll"};

malheureusement ça ne fonctionne pas non plus pourtant je trouve ta solution logique!
Voici le résultat:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 monChar = "aaaaaa", "\000bbb", "\000\000cccc", "cc\000ddd", "ddd\000ee", "eeee\000f", "fffff", "gggggg", "\000hhhhh", "h\000iiii", "ii\000jjj", "jjj\000kk" ;
Citation:

Envoyé par Médinoc

PS: Cette question, qu'a-t-elle à voir avec le langage C++/CLI utilisé pour .Net?

Exact, je me suis trompé :/

20/02/2013, 12h38
Médinoc

Comment obtiens-tu ce résultat? En rechargeant le fichier ensuite?

Puis-je voir ton code de chargement?

Citation:

Envoyé par Médinoc

Comment obtiens-tu ce résultat? En rechargeant le fichier ensuite?

Puis-je voir ton code de chargement?

bonjour,
ok je montre tout:
le fichier cpp:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
     #include <iostream>
     #include <netcdfcpp.h>
 
     using namespace std;
 
     static const int NX = 12;
     static const int NY = 6;
     static const int NZ = 1;
 
int main(void)
{
    NcFile dataFile("testTabChar.nc", NcFile::Replace);
 
    NcDim* xDim = dataFile.add_dim("x", NX);
    NcDim* yDim = dataFile.add_dim("y", NY);
    NcDim* zDim = dataFile.add_dim("z", NZ);
 
    NcVar *monChar = dataFile.add_var("monChar", ncChar, xDim, yDim);
 
    char monCharUn[][7] = {"aaaaaa","bbb","cccccc","dddddd", "eeeeee", "ffffff", "gggggg", "hhhhhh", "iiiiii", "jjjjjj", "kkkkkk", "llllll"};
 
    monChar->put(&monCharUn[0][0], NX, NY);
 
    return 0;
}

le script de compilation/édition des liens/execution/édition ^^:

Code:

1
2
3
#!/bin/sh
 
g++ -c -g -I $HOME/local/netcdf_cxx/cxx4/ testTabChar.cpp && g++ -o testTabChar testTabChar.o -L $HOME/local/netcdf_cxx/cxx4/.libs/ -lnetcdf_c++ -lnetcdf -lm && ./testTabChar && ncdump testTabChar.nc > testTabChar.cdl && gedit testTabChar.cdl&

Je suis sous linux et je compile avec g++ (Debian 4.4.5-8) 4.4.5

le résultat:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
netcdf testTabChar {
dimensions:
	x = 12 ;
	y = 6 ;
	z = 1 ;
variables:
	char monChar(x, y) ;
data:
 
 monChar =
  "aaaaaa",
  "\000bbb",
  "\000\000cccc",
  "cc\000ddd",
  "ddd\000ee",
  "eeee\000f",
  "fffff",
  "gggggg",
  "\000hhhhh",
  "h\000iiii",
  "ii\000jjj",
  "jjj\000kk" ;
}

20/02/2013, 15h54
Médinoc

Donc c'est ncdump qui te donne cette sortie...

Enfin, je pense avoir trouvé la cause de l'erreur: NY est mystérieusement passé de 7 à 6...

Citation:

Envoyé par Médinoc

Donc c'est ncdump qui te donne cette sortie...

Enfin, je pense avoir trouvé la cause de l'erreur: NY est mystérieusement passé de 7 à 6...

Ouaaaaaa! merci, c'est exact! je comprend mieux et ça marche !!!
par contre je ne comprend pas pourquoi il faut mettre 7 alors que la chaine la plus longue ne fait que 6 caractères de long. Je pense que c'est lié au \0 mais je trouve ça tellement étrange !

Mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 #include <iostream> #include <netcdfcpp.h> using namespace std; static const int NX = 12; static const int NY = 7; static const int NZ = 1; int main(void) { NcFile dataFile("testTabChar.nc", NcFile::Replace); NcDim* xDim = dataFile.add_dim("x", NX); NcDim* yDim = dataFile.add_dim("y", NY); NcDim* zDim = dataFile.add_dim("z", NZ); NcVar *monChar = dataFile.add_var("monChar", ncChar, xDim, yDim); char monCharUn[][NY] = {"aaaaaa","bbb","cccccc","dddddd", "eeeeee", "ffffff", "gggggg", "hhhhhh", "iiiiii", "jjjjjj", "kkkkkk", "llllll"}; monChar->put(&monCharUn[0][0], NX, NY); return 0; }

20/02/2013, 16h53
Médinoc

C'est bien ça, c'est lié au \0.