Bonsoir
Je travail sur la génération de ville et pour un cas spécifique j'ai besoin d'un format d'image particulier.
J'ai besoin de pas grand chose, une image HD, avec plusieurs calque et différent canaux possible pour chaque calque.
Le fichier se présenterais sous la forme :
8 octets la largeur de l'image
8 octets la hauteur de l'image
1 octet le nombre de calque
1 octet le nombre de canaux
data calque_1
1 octet le nombre de canaux
data calque_2
1 octet le nombre de canaux
data calque_3
..
1 octet le nombre de canaux
data calque_n

Et les données sont stockées avec 2 octets par canaux.

Par exemple pour une image avec 2 calques le premiers noir et blanc (donc un canal) puis le second RGBA (donc 3) et l'image 2x2 l'image se présenterais sous la forme suivante :
00000002 // largeur
00000002 // hauteur
02 // nombre de calque
01 // nombre de canaux du premier calque
0001 121A // data du premier calque avec 2 octets par canal
0AF0 DFFF
04 // nombres de canaux du second calque
0000 0000 0000 0000 0000 0000 0000 FFFF
FDFF 1234 4223 5142 0023 023C BABE 000A

Voilà pour l'idée.
Mais le problème c'est la structuration des données. Comment je fais pour faire comprendre à ma classe que les données sont soit 1 unsigned short soit 4 unsigned short, ... L'idée des unions trotte dans ma tête mais ça ne tient pas la route.
Voilà pour l'instant la tête de ma classe :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
struct _1_channel
{
	unsigned short b; // black noir et blanc
};
 
struct _2_channel // DDS texture
{
	unsigned short b; // blue
	unsigned short p; // pink
};
 
struct _3_channel
{
	unsigned short r; // red
	unsigned short g; // green
	unsigned short b; // blue
};
 
struct _4_channel
{
	unsigned short r; // red
	unsigned short g; // green
	unsigned short b; // blue
	unsigned short a; // alpha
};
 
union pixel
{
	_1_channel _1_;
	_2_channel _2_;
	_3_channel _3_;
	_4_channel _4_;
};
 
class hd_pic
{
	public :
		hd_pic();
		hd_pic(const hd_pic&);
		virtual ~hd_pic();
 
		unsigned char channel;
		unsigned char calque;
		unsigned long long width;
		unsigned long long height;
		pixel **data;
		std::list<pixel**> list_calque;
 
		void load(const std::string&);
		void save(const std::string&);
 
		hd_pic operator=(const hd_pic&);
};
Pour l'instant j'ai essayé dès la lecture des canaux du calque courant de bricoler un truc mais cela ne marche pas et c'est normal :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
26
27
void hd_pic::load(const std::string& filename)
{
	std::ifstream file;
	file.open(filename.c_str());
	if (file.good())
	{
		file >> width;
		file >> height;
		file >> calque;
		file >> channel;
		switch (channel)
		{
			case 1 :
					data = new _1_channel*[width];
					for (unsigned long long i = 0; i < width; i++)
						data[i] = new pixel._1_channel[height];
					for (unsigned char k = 0; k < calque; k++)
					{
						for (unsigned long long j = 0; j < height; j++)
							for (unsigned long long i = 0; i < width; i++)
								file >> data[i][j].b;
						list_calque.push_back(data);
					}
				break;
			case 2 :
					data = new _2_channel*[width];
// ........
Le problème avec l'union c'est que si mon image contient qu'un seul canal donc un unsigned short par pixel (2 octets) cela prendra malgré tout 8 octets un unsigned long long.

Donc je fais appel a votre aide pour m'aider à trouver une méthode pour structure mes données et cette pluralité des canaux des calques.
Merci

PS : Ce format d'image me sert à stocker différente donnée sur la ville générer, densité de population Noir et blanc, height map noir et blanc, Textures RGBA 8 octets, ... 1 octet par canaux n'est pas suffisante puisque nous générons des maps (ville) relativement grande...