Discussion :

[Darick]

Bonjours a tous. J'aurais besoin d'un petit coup de mains au sujet
d'une optimisation que je suis en train de réalisé.
Je vous fait un petit résumé pour que vous compreniez mieux:
Je travail dans le traitement d'image et l'application de ces traitements dans le commerce vers des produits innovant et de haute technologie.Je ne suis donc pas débutant en développement.
Actuellement je m'acharne a mettre en place un traitement d'image rapide efficace et peu cher, et surtout rapide et tenant le moins de place possible en mémoire(oui si on veut que se soit pas cher ^^).
Après plusieurs test concluant le traitement est totalement en place et en cours d'optimisation dans l'objectif d'une réduction de cout.

Le principe:
Après analyse d'une image on crée un prototype de l'image sous un format de
2 tableau de 4*20 pour les x et 4*15 pour les y. ces tableaux sont des tableaux contenant une structure sous formes de champs de bites:

struct Pixel
{
char bit0:1;
char bit1:1;
char bit2:1;
char bit3:1;
char bit4:1;
char bit5:1;
char bit6:1;
char bit7:1;
};

cette structure permet de stocker 8 pixels qui sont tous en binaire (donc au final on a 2 tableau de 4*160 et 4*120 bit)
Ce format a été tester et montre qu'il est bien plus light en mémoire que un tableau de caractère, car bien plus simple a initialisé.

Le seul souci actuel est que je doit parcourir l'intégralité du tableau et tester chaque pixel par rapport au 4 précédents.

Donc un souci se passe quand on est sur :bit0,bit1 et bit3.

J'ai donc penser a concaténer 2 structures en convertissant chacune de ses structures en char. Seulement le hic est la: est il possible simplement de convertir cette structure en char par cast ou autre.

Merci de vos réponses.

[Thierry Chappuis]

Les champs de bits ne s'utilisent en principe qu'avec les type int, signed int ou unsigned int.

Thierry

[diogene]

J'ai donc penser a concaténer 2 structures en convertissant chacune de ses structures en char. Seulement le hic est la: est il possible simplement de convertir cette structure en char par cast ou autre.

Je ne pense pas qu'on puisse convertir par un cast une structure en un entier. Il faudra passer par des pointeurs. On peut aussi envisager une union.

La difficulté réside dans la portabilité du code vu que l'ordre des champs de bits est dépendant de l'implantation (du LSB ->MSB ou l'inverse)

[Darick]

Les champs de bits ne s'utilisent en principe qu'avec les type int, signed int ou unsigned int

en effet seulement on peu également les utiliser avec des char ou les short cela ne pose aucun soucie, seulement la plupart des gens préfere prendre un char et le décalé plutot que d'utiliser un champ de bite. Le probleme de plus ne réside pas dans la possibilité de faire un champ de bite en char mais sur la concaténation de deux de ces champs de bite.

Je ne pense pas qu'on puisse convertir par un cast une structure en un entier.

oui sinon sa serais bien trop simple j'ai envie de dire. Et j'ai déjà expérimenté les cast et tenté de faire ma propre fonction de cast mais sans grand succès.

La difficulté réside dans la portabilité du code

oui les bitefield pose des problemes de portabilités, seulement dans mon cas il n'y a pas besoin de portabilité car tout ce fait en interne du programme et il n'y a qu'une affectation de données dans ces bitefields.


J'ai tenter également de convertir à l'instant les 8 bits disponible en un char
mais sans aucun succes non plus.

[Darick]

Il faudra passer par des pointeurs. On peut aussi envisager une union.

faire une union des 2 structures peu être interressante, peu tu développé ton idée stp.
Mais je ne sais pas si cela est un peu risqué et long en temps de traitement.

[Emmanuel Delahaye]

soucie, <...> champ de bite <...> champs de bite. <...> oui les bitefield <...> bitefields.

Attention à cette sale manie de mettre des 'e' en plus un peu partout... Sur certains mots, ça fait un peu... étrange...

[Thierry Chappuis]

en effet seulement on peu également les utiliser avec des char ou les short cela ne pose aucun soucie,

La norme ne pense pas comme toi. Si tu veux manipuler des bits, utilises plutôt un tableau de unsigned chars et les opérateurs de manipulation de bits, c'est fait pour.

Thierry

[Emmanuel Delahaye]

Je ne pense pas qu'on puisse convertir par un cast une structure en un entier. Il faudra passer par des pointeurs.

Pas de pointeurs sur les champs de bits.

[diogene]

Pas de pointeurs sur les champs de bits.

Pas sur les champs de bit bien sûr, sur la structure et le unsigned char.

Darick

oui les bitefield pose des problemes de portabilités, seulement dans mon cas il n'y a pas besoin de portabilité car tout ce fait en interne du programme et il n'y a qu'une affectation de données dans ces bitefields.

Mais il peut y avoir une incohérence entre la position (présumée) des bits dans la structure et celle dans le unsigned char.

faire une union des 2 structures peu être interressante, peu tu développé ton idée stp.
Mais je ne sais pas si cela est un peu risqué et long en temps de traitement.

Je ne pense pas que cela affecte le temps de traitement, la différentiation se faisant au moment de la compilation. Mais, cela n'enlève pas le problème de portabilité.

C'est sûr qu'Emmanuel a raison en te disant de coder sur un unsigned char au lieu d'une structure avec champ de bits. Je suis d'ailleurs un peu étonné que tu obtiennes ainsi des performances notoirement meilleures.

[coyotte507]

Bonjour,

voilà un morceau de code qui montre comment effectuer un cast Pixel->char, puis char->Pixel.

On retombe bien sur la même valeur d'origine, mais la valeur de char* intermédiaire dépend de ton système/architecture/etc...

Par contre, si char a == char b, alors Pixel a == Pixel b, et si char a != char b, alors Pixel a != Pixel b.

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include <string.h>
#include <stdio.h>
 
typedef struct
{
    char bit0:1;
    char bit1:1;
    char bit2:1;
    char bit3:1;
    char bit4:1;
    char bit5:1;
    char bit6:1;
    char bit7:1;
} Pixel;
 
int main()
{
    Pixel px[4];
    int i = 0;
 
    /* On met différentes valeurs dans chaque pixel, la flemme de faire long */
    *(char*)(void*)(px) = 'h';
    *((char*)(void*)(px)+1) = 'e';
    *((char*)(void*)(px)+2) = 'l';
    *((char*)(void*)(px)+3) = 'l';
 
    for (i = 0; i < 4; i++)
    {
        printf("Pixel %d:\n", i);
        printf("\t%d\n", px[i].bit0);
        printf("\t%d\n", px[i].bit1);
        printf("\t%d\n", px[i].bit2);
        printf("\t%d\n", px[i].bit3);
        printf("\t%d\n", px[i].bit4);
        printf("\t%d\n", px[i].bit5);
        printf("\t%d\n", px[i].bit6);
        printf("\t%d\n", px[i].bit7);
    }
 
    /* On met dans un tableau char */
    char ch_px[4];
    memcpy(ch_px, px, 4); /* strncpy(ch_px, (char*)(void*)(px), 4) */
 
    puts("==================================");
    puts("==================================");
    /* affiche hell */
    printf("Chaine de char: %c%c%c%c\n", ch_px[0], ch_px[1], ch_px[2], ch_px[3]);
 
    /* On remet ça dans un tableau de Pixels */
    Pixel px_2[4];
    memcpy(px_2, ch_px, 4); /* strncpy((char*)(void*)(px_2), ch_px, 4) */
 
    puts("==================================");
    puts("==================================");
 
    for (i = 0; i < 4; i++)
    {
        printf("Pixel %d:\n", i);
        printf("\t%d\n", px_2[i].bit0);
        printf("\t%d\n", px_2[i].bit1);
        printf("\t%d\n", px_2[i].bit2);
        printf("\t%d\n", px_2[i].bit3);
        printf("\t%d\n", px_2[i].bit4);
        printf("\t%d\n", px_2[i].bit5);
        printf("\t%d\n", px_2[i].bit6);
        printf("\t%d\n", px_2[i].bit7);
    }
 
    return 0;
}

Regarde le code, les résultats sont ceux attendus.

Edit: Bien sûr, si jamais il existe des architectures ou un char ne fait pas 8 bits, alors ce code a toutes les chances de planter sur ces architectures.

[Emmanuel Delahaye]

Le principe:
Après analyse d'une image on crée un prototype de l'image sous un format de
2 tableau de 4*20 pour les x et 4*15 pour les y. ces tableaux sont des tableaux contenant une structure sous formes de champs de bites:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
	struct Pixel
	{
		char bit0:1;
		char bit1:1;
		char bit2:1;
		char bit3:1;
		char bit4:1;
		char bit5:1;
		char bit6:1;
		char bit7:1;
	};

Mauvais choix. Utilise plutôt des tableaux de unsigned char et les opérateurs binaires, c'est fait pour et c'est portable. Comment crois-tu que sont implémentés les accès aux champs de bits sur une machine où l'unité de mémoire est l'octet, si ce n'est à coup de bitwise operators ?

Autant le faire soit même et garder la main sur le mécanisme et son optimisation (c'est aussi un peu à ça que sert le C...).