[C#] Parcourir les bits d'un octet (byte)

Bonjour à tous,

Je cherche à faire du traitement d'image sous C#, j'utilise le mode unsafe afin de gagner en temps de calcul.
Néanmoins, étant nouveau, je n'ai pas encore trouvé comment parcourir les bits d'une image binaire (format 1bpp).
J'utilise la classe bitmap et bitmapData.

Voici un petit bout de mon code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 unsafe { BitmapData bmpData = image1.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, PixelFormat.Format1bppIndexed); Byte* pix = (Byte*)bmpData.Scan0; // traverses of each pixel > negative it for (int i = 0; i < height ; i++) { for (int j = 0; j < width ; j++) { pix[0] = 0 ; // pix pointe sur l'octet courant pix++; } } image1.UnlockBits(bmpData); } System.Console.WriteLine("parcours termine");
Ici je peux parcourir mon image octet par octet, mais j'aimerais pouvoir travailler sur les bits de mon image, étant donné que celle ci est binaire ... Est ce que quelqu'un a une idée ? Je me doute que cette question parait simple, mais cela fait plusieurs heures que je cherche, et je n'ai toujours pas trouvé :(

Merci à la bonne âme qui me viendra en aide !

Raph

J'ai écrit il y a quelques années deux fonctions pour manipuler les bits d'un byte, jettes-y un coup d'oeil.

Code:

1
2
3
4
5
6
7
8
9
10
 
public static bool IsBitSet(byte b, byte pos)
        {
            return (b & (1 << pos)) != 0;
        }
 
        public static void SetBit(ref byte b, byte pos)
        {
            b = (byte)(b | (1 << pos));
        }

Merci l'ami,

Effectivement en regardant tes fonctions j'ai bien compris comment on parcourait les bits d'un octet. J'ai complété tes fonctions avec celles ci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 // permet de recuperer le bit a la position pos de l'octet b public static byte GetBit (byte b, byte pos) { return (b & (1 << pos)) >> pos; } // permet de mettre le bit a la position pos à 0 dans l'octet b public static void UnsetBit(ref byte b, byte pos) { b = (byte)(b & (~( 1 << pos)); }
peut être que cela fera gagner du temps à un futur nouveau en C# comme moi ;)

++

Raph

Il existe une classe toute faite ici.
M'enfin bon, n'aurai tu pas oublié le tag :resolu: ? :roll:

Pourquoi ne pas utiliser la classe BitArray, présente de base dans le framework .Net ? Tu lui donnes un tableau d'octets à manger, et rulez !

Citation:

Envoyé par GroXx

Pourquoi ne pas utiliser la classe BitArray, présente de base dans le framework .Net ? Tu lui donnes un tableau d'octets à manger, et rulez !

Bonne remarque, pour ma part, je ne me rapelle plus pourquoi le choix de le faire manuellement plutot que via BitArray mais il devait bien y avoir une bonne raison :D

Hello smyley & GroXx,

merci pour vos réponses.
Effectivement, je ne connaissais pas la classe bitArray (je ne connais pas encore toutes les classes du framework .net ! yen a tellement :))
je n'avais pas non plus la connaissance de la classe présentée ici, qui a l'air encore plus complète que les méthodes que j'ai utilisé jusqu'à présent.

Etant donné que je fais du traitement d'image, il me faut des méthodes les plus optimales possibles. Je pense pour l'instant que les petites méthodes que j'utilise : celles proposées par neptune et celle de la classe proposée par smyley sont plus optimales que celle du framework .net : Bitarray.

Merci donc, ça répond entièrement à ma question ;)
Raph.

PS : oui, j'avais un chtit peu oublié le tag :resolu: !

Citation:

Envoyé par neptune

Bonne remarque, pour ma part, je ne me rapelle plus pourquoi le choix de le faire manuellement plutot que via BitArray mais il devait bien y avoir une bonne raison :D

Je pense que les petites méthodes que tu as présenté utilisant des opérateurs binaires de décalage de bit sont plus optimales. Car en utilisant les classes du framework, certes le code est bien managé, mais je ne pense pas qu'il soit optimal ... tes méthodes doivent sans doute être plus rapide :)

Citation:

Envoyé par Dark Raph

Je pense que les petites méthodes que tu as présenté utilisant des opérateurs binaires de décalage de bit sont plus optimales. Car en utilisant les classes du framework, certes le code est bien managé, mais je ne pense pas qu'il soit optimal ... tes méthodes doivent sans doute être plus rapide :)

Et bien, la classe BitArray fait exactement la meme chose que moi dans le cas du SetBit:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public void Set(int index, bool value) { if ((index < 0) || (index >= this.m_length)) { throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index")); } if (value) { this.m_array[index / 0x20] |= ((int) 1) << (index % 0x20); } else { this.m_array[index / 0x20] &= ~(((int) 1) << (index % 0x20)); } this._version++; }
Sinon, je crois que pour du traitement d'image, la rapidité d'exécution pourrait être améliorée en utilisant une partie de code non-managé.