Discussion :

[Dark Raph]

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 :

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
 
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

[neptune]

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 :

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

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));
        }

[Dark Raph]

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 :

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

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

[smyley]

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

[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 !

[neptune]

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

[Dark Raph]

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 !

[Dark Raph]

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

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

[neptune]

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 :

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
 
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é.