classe Bitmap et LockBitmap.

Version imprimable

Bonjour à tous,

j'ai un petit soucis, lorsque j'essai de dessiner sur une pictureBox dans ma fenêtre windowsForm.

J'instancie ma classe FractalDrawer aux dimensions de ma pictureBox :
Code:

1 2 _fractalDrawer = new FractaleDrawer(pictureBox1.Width, pictureBox1.Height);
puis j'utiliser une méthode Resize qui sera utilisée lorsque je redimensionnerai ma fenetre :
Code:

1 2 3 4 5 6 7 8 9 10 public void Resize(int pWidth, int pHeight) { _bmp = new Bitmap(pWidth, pHeight); _bmpData = LockBitmap(); // Declare an array to hold the bytes of the bitmap. int bytes = Math.Abs(_bmpData.Stride) * _bmp.Height; _rgbValues = new byte[bytes]; UnlockBitmap(); }
Ma méthode LockBitmap, est une sucharge de la méthode LockBitmap de la classe Bitmap, que voici :
Code:

1 2 3 4 5 private BitmapData LockBitmap() { return _bmp.LockBits(_rect, ImageLockMode.ReadWrite, _bmp.PixelFormat); }
mon erreur survient lors de la compilation, il semblerait que le _bmp.PixelFormat ne soit pas bon, le format n'est pas correct, et je ne vois pas comment je pourrais le trouver ...
En fouillant un peu j'ai vu que c'est une énumération, mais je ne sais pas du tout quoi mettre ...

des idées sur quoi mettre ? et surtout comment le savoir ?

Merci d'avance,

Error.

18/12/2012, 14h49
synolog

Citation:

Envoyé par Error407

mon erreur survient lors de la compilation, il semblerait que le _bmp.PixelFormat ne soit pas bon, le format n'est pas correct, et je ne vois pas comment je pourrais le trouver ...

Une erreur? et quelle est-elle?
Peux tu nous montrer aussi comment est déclaré _rect? Il a bien la même hauteur et largeur que _bmp?

mes excuses, bien sûr :

Code:

1
2
 
Rectangle rect = new Rectangle(0, 0, pictureBox1.Width, pictureBox1.Height);*

L'erreur est :

Code:

1
2
3
 
Argument exception was unhandled
Le paramètre n'est pas valide.

18/12/2012, 15h24
synolog

:ccool:
Mais par curiosité... quel est l'intérêt de recadrer une bitmap vide? Le but serait d'ajouter directement le chemin de l'image dans _bmp afin de recadrer l'image...
J'ai un peu de mal à saisir :?

Edit : pWidth != pictureBox1.Width ?? Si true, je doute que ca fonctionne :aie:
18/12/2012, 15h37
Error407
l’intérêt est qu'a chaque fois que je fait appel à l’évènement resize je passe par cette méthode qui me permettra de redimensionner le graphe et de recalculer l'échelle ...

Bon choix ou pas, dans un premier temps j'essai de voir comment je peux faire fonctionner le bousin ;D

Sinon, on a bien pWidth = pictureBox1.Width , et idem pour height :p
Code:

1 2 3 4 5 6 public FractaleDrawer(int pWidth, int pHeight) { Resize(pWidth, pHeight); }
18/12/2012, 15h58
synolog

Ok, il est possible alors que ce soit le format pixel qui n'est pas supporté.
Il peut être de 8, 24 ou 32... bits par pixel (le reste ici). Pour vérifier:

Code:

int BytePixel = GetPixelFormatSize(_bmp.PixelFormat);

bonjour error407

Une instance du class BitmapData acquise par la methode Bitmap.Locks te permettra de definir le format de pixel souhaite et les dimensions du buffer image..
la methode Bitmap.Locks verrouille une zone memoire (via marshalling) reserve aux octets du bitmap pour traitement au format pixel desiree...

voici un exemple de class denomme LockImage
-qui recoit soit une image d'un picturebox(button1)....
-qui recoit soit un bitmap vide(button2)....
- cree un buffer image au format :PixelFormat.Format32bppRgb
- met l'image en niveau de gris(MakeGray)
- illustre l'utilisation du "right siftting" (division binaire) pour acceder à chaque octet alpha,r,g,b.....
code .cs du class LockImage

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
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
 
namespace WinMirrorImageSpeedCSharp
{
    public class LockImage
    {
            private Bitmap BaseImage; 
            private int BaseImageWidth;
            private int BaseImageHeight;
            private int TotalPixels;
            private IntPtr ImageAddress ;
            private BitmapData ImageContent ;
            private int[] ImageBuffer;
 
            // ----- User access to the relevant image.
            public Bitmap Image
            {
                get { return BaseImage; }
                set 
                { 
                    Graphics canvas ; 
                    BaseImage = new Bitmap(value.Width,  value.Height, value.PixelFormat);
                    canvas = Graphics.FromImage(BaseImage);
                    canvas.DrawImage(value, 0, 0, value.Width, value.Height);
                    canvas.Dispose();
                } 
            }
 
            private void LockTheImage()
            { 
                //      ----- Lock the image in memory. How much room
                //       do we need?
                BaseImageWidth = BaseImage.Width;
                BaseImageHeight = BaseImage.Height;
                TotalPixels = BaseImageWidth * BaseImageHeight;
 
                /*  Create a stable (locked) area in memory. It will store 32-bit color images. */
                ImageBuffer=new int [TotalPixels ];
                ImageContent = BaseImage.LockBits( 
                new Rectangle(0, 0, BaseImageWidth, 
                BaseImageHeight), ImageLockMode.ReadWrite, 
                PixelFormat.Format32bppRgb);
                ImageAddress = ImageContent.Scan0;
 
                // ----- Associate the buffer and the locked memory.
                Marshal.Copy(ImageAddress, ImageBuffer, 0, TotalPixels);
 
            }
            private void UnlockTheImage()
            { 
                // ----- Unlock the memory area.
                Marshal.Copy(ImageBuffer, 0, ImageAddress, TotalPixels);
                Image.UnlockBits(ImageContent);
                ImageContent = null;
                ImageBuffer = new int[0];
            }
 
            // 256 shades of gray are created
            public void MakeGray()
            {
             // ----- Make a grayscale version of the image.
            int pixelIndex ;
            int onePixel ;
            int alphaPart ;
            int redPart ;
            int greenPart ;
            int bluePart;
            int maxColor ;
            int minColor ;
            int down ;
            int across;
             // ----- Lock the image for speed.
            LockTheImage();
 
                // ----- Process each pixel in the grid.
            for( down = 0; down < BaseImageHeight ;down++)
            {
                for (across = 0  ;across< BaseImageWidth ;across++)
                {
                    // ----- Locate the pixel's color.
                    pixelIndex = down * BaseImageWidth + across;
                    onePixel = ImageBuffer[pixelIndex];
 
                    // ----- Extract the color values.
                    alphaPart = (onePixel >> 24) & 0xFF;
                    redPart = (onePixel >> 16) & 0xFF;
                    greenPart = (onePixel >> 8) & 0xFF;
                    bluePart = onePixel &  0xFF;
 
                    // ----- Get the general color intensity.
                    maxColor = Math.Max(redPart, Math.Max(greenPart, bluePart));
                    minColor = Math.Min(redPart, Math.Min(greenPart, bluePart));
                    onePixel = (maxColor + minColor) / 2;
 
                    // ----- Use a common intensity for all colors.
                    bluePart = onePixel;
                    greenPart = onePixel;
                    redPart = onePixel;
 
                    // ----- Set the pixel to the new color. Retain
                    //       the original alpha channel.
                    ImageBuffer[pixelIndex] = (alphaPart << 24) + (redPart << 16) + (greenPart << 8) + bluePart;
                }
            }
 
            // ----- Finished. Unlock the image.
            UnlockTheImage();
 
        }
 
    }
}

code .cs du winform qui l'utilise:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace WinMirrorImageSpeedCSharp
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            //charge une image en ressources
            pictureBox1.Image = WinMirrorImageSpeedCSharp.Properties.Resources.Nenuphars;
            this.Text = this.pictureBox1.Image.PixelFormat.ToString();
        }
 
        //met en niveau de gris l'image charge
        private void button1_Click(object sender, EventArgs e)
        {
            LockImage mirrorIt = new LockImage();
            mirrorIt.Image = (Bitmap)pictureBox1.Image;
            mirrorIt.MakeGray();
            pictureBox1.Image = mirrorIt.Image;
 
        }
        //charge un bitmap vide ,le traite et l'affiche dans pictureBox
        private void button2_Click(object sender, EventArgs e)
        {
            LockImage mirrorIt = new LockImage();
            mirrorIt.Image = new Bitmap(pictureBox1.Width, pictureBox1.Height);
            mirrorIt.MakeGray();
            pictureBox1.Image = mirrorIt.Image;
        }
 
 
    }
}

Il va de soi que tout le traitement (y compris fractalisation) doit se faire dans le class LockImage.....et donc le redimensionnement est indepenant et doit etre gere au niveau de l'interface UI ce me semble......
bon code..............

19/12/2012, 09h14
Error407

merci beaucoup pour toutes ces réponses.

MABROUKI, tu dis que la fractalisation doit se faire dans le lock image, ne voudrais tu pas plutôt dire entre un lock et un unlock ?

Une chose que je n'arrive pas à comprendre.

Dans les exemples que vous me donnez, vous créer votre bitmap à partir d'une image existante, ce que vous impose le pixel.format.

Moi j'essai de créer l'image, donc logiquement je devrais avoir le choix du format .... peut être que je n'utilise pas les bonnes méthodes ....

voici mon code :

mon form.cs

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
    public partial class Form1 : Form
    {
        private FractaleDrawer _fractalDrawer;
        private Fractale _fractale = new Fractale();
 
        public Form1()
        {
            InitializeComponent();
            _fractalDrawer = new FractaleDrawer(pictureBox1.Width, pictureBox1.Height);
            //_fractalDrawer.Bmp;
            Rectangle rect = new Rectangle(0, 0, pictureBox1.Width, pictureBox1.Height);
            label1.Text = _fractalDrawer.pixelFormat().ToString();
            _fractalDrawer.InitialiseDessin(rect);
        }
}

ma classe fractalDrawer :

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
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
 
namespace FractalTest
{
    class FractaleDrawer
    {
        #region variables
        private Bitmap _bmp;
        BitmapData _bmpData;
        IntPtr _ptr;
        private Rectangle _rect;
        private int _color;
        private byte[] _rgbValues;
        //Fractale fractale = new Fractale();
        #endregion
 
        #region Propriété
        public byte[] RgbValues
        {
            get { return _rgbValues; }
            set { _rgbValues = value; }
        }
 
        public Bitmap Bmp
        {
            get { return _bmp; }
            set { _bmp = value; }
        }
 
        public int Color
        {
            get { return Color; }
            set { Color = value; }
        }
        #endregion
 
        #region dessin
        public Bitmap dessin()
        {
            //implémentation du code de la couleur 
            for (int indexLargeur = 0; indexLargeur < _rgbValues.Length; indexLargeur += 4)
            {
                #region degradé vertical
                //int ligneEnCours = indexLargeur / bmpData.Stride;
                //level = 255 * ligneEnCours / DLigne;
                #endregion
 
                #region dégradé horizontal
                //if (indexLargeur == 0)
                //{
                //    color = 0;
                //}
                //else
                //{
                //    color = (int)(255 * (indexLargeur % bmpData.Stride) / bmpData.Stride);
                //}
                //if ((indexLargeur % Math.Abs(bmpData.Stride)) == 0)
                //{
                //    color = 0;
                //}
                //else
                //{
                //    color++;
                //}
                #endregion
 
                _rgbValues[indexLargeur] = 0;
                _rgbValues[indexLargeur + 1] = 0;
                _rgbValues[indexLargeur + 2] = (byte)this.Color;
                _rgbValues[indexLargeur + 3] = 255;
            }
 
            _bmpData = LockBitmap();
            _ptr = _bmpData.Scan0;
            // Copy the RGB values into the array.
            System.Runtime.InteropServices.Marshal.Copy(_ptr, _rgbValues, 0, _rgbValues.Length);
 
            UnlockBitmap();
            return Bmp;
        }
        #endregion
 
        #region ctor FractaleDrawer
        public FractaleDrawer(int pWidth, int pHeight)
        {
            Resize(pWidth, pHeight);
        }
        #endregion       
 
        #region Resize
        public void Resize(int pWidth, int pHeight)
        {
            _bmp = new Bitmap(pWidth, pHeight);//Bitmap(pWidth, pHeight);
            _bmpData = LockBitmap();
            // Declare an array to hold the bytes of the bitmap. 
            int bytes = pWidth * pHeight;
            _rgbValues = new byte[bytes];
            UnlockBitmap();
        }
        #endregion
 
        #region InitialiseDessin
        public void InitialiseDessin(Rectangle rect)
        {
            _rect = rect;
            Resize(_rect.Width, _rect.Height);
        }
        #endregion
 
        #region UnLockBitmap
        private void UnlockBitmap()
        {
            _bmp.UnlockBits(_bmpData);
        }
        #endregion
 
        #region LockBitmap
        private BitmapData LockBitmap()
        {
            return _bmp.LockBits(_rect, ImageLockMode.ReadWrite, PixelFormat.Format32bppRgb);
        }
        #endregion
    }
}

L'erreur survient donc à la dernière ligne :
return _bmp.LockBits(_rect, ImageLockMode.ReadWrite, PixelFormat.Format32bppRgb);

Rebonjour Error407

Citation:

Dans les exemples que vous me donnez, vous créer votre bitmap à partir d'une image existante, ce que vous impose le pixel.format.

Tu n'as pas lu ou mal compris le code puisque :
- dans le button2 je cree un nouveau bitmap avec seulement les 2 dimensions width et height du picturebox......et le pixelformat est defini dans le constructeur de bitmapdata......

Ensuite ton code comporte des references circulaires (prop color) ,des prop non initialisees correctement et necessite un serieux lifting du point de vue design:ton class FractaleDrawer doit etre revu comme suit:
-manque la declaration de variable PixelFormat utilisee....
-le constructeur doit initiliaser correctement (valeurs defaults)toutes les variables privees utilisees....
-verrouiller le bitmap manage(sinon le GC qui passerait par là pourrait le deplacer ....gare) car son tableau correspondant RgbValues lui est geree par interop c.à.d fixe en memoire........
- faire le dessin dans RgbValues en memoire interop(Hors de ma vue le class Dessin ...un function DessineFractal suffit) ..
- recopier en memoire manage(bitmap) le RgbValues....
-deverrouiller le bitmap manage....

Architecture simple:
-Init FractaleDrawer()
-DessineFractal()
-Resize().....
Et dans le forme n'oublie pas de mettre à jour le image du picturebox...
code .cs du FractaleDrawer()

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
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
 
namespace FractalTest
{
    public class FractaleDrawer
    {
        #region variables
        private Bitmap _bmp;
        //RAJOUT LE PIXELFORMAT
        private PixelFormat pf;
        private BitmapData _bmpData;
        private IntPtr _ptr;
        //UNE DENOMINATION MOINS IMPROVISEE...SVP
        private Rectangle _rectBmp;
        //
        private int _color;
        private byte[] _rgbValues;
        //Fractale fractale = new Fractale();
 
        #endregion
 
        #region Propriété
        public byte[] RgbValues
        {
            get { return _rgbValues; }
            set { _rgbValues = value; }
        }
        public Bitmap Bmp
        {
            get { return _bmp; }
            set { _bmp = value; }
        }
        //CORRIGE REFERENCE CIRCULAIRE
        public int Color
        {
            get { return _color; }
            set { _color = value; }
        }
        #endregion
 
 
 
        #region ctor FractaleDrawer
        public FractaleDrawer(int pWidth, int pHeight)
        {
            //INIT PROP 
            _color = 0;
            //INIT YOUR _RECT 
            _rectBmp = new Rectangle(0, 0, pWidth, pHeight);
 
            //APPEL À DESSIN
            InitialiseDessin();
        }
        #endregion       
 
 
 
        #region InitialiseDessin
        public void InitialiseDessin()
        {
            //init your Bitmap(pWidth, pHeight) WITH  SUITABLE PIXELFORMAT
            pf = PixelFormat.Format32bppRgb;
            _bmp = new Bitmap(_rectBmp.Width, _rectBmp.Height, pf);
 
            //verouille le bmp
             _bmpData = LockBitmap();
            _ptr = _bmpData.Scan0;
 
            // Declare an array to hold the bytes of the bitmap. 
            int bytes = _rectBmp.Width * _rectBmp.Height;
            _rgbValues = new byte[bytes];
 
            // Copy the RGB values into the array(vers la memoire non managee)
            System.Runtime.InteropServices.Marshal.Copy(_ptr, _rgbValues, 0, _rgbValues.Length );
 
 
            // dessine dans le tableau de bytes
            DessineFractal();
 
            // Copy the RGB values back to the bitmap(rapatrie vers la memoire managee)
            System.Runtime.InteropServices.Marshal.Copy(_rgbValues, 0, _ptr, _rgbValues.Length);
 
            //deverouille bmp
            UnlockBitmap();
 
        }
        #endregion
        #region dessin
        public byte[] DessineFractal()
        {
            //implémentation du code de la couleur 
            for (int indexLargeur = 0; indexLargeur < _rgbValues.Length; indexLargeur += 4)
            {
                #region degradé vertical
                int ligneEnCours = indexLargeur / _bmpData.Stride;
                //level = 255 * ligneEnCours / DLigne;
                #endregion
 
                #region dégradé horizontal
                for (int j = indexLargeur; j < 4; j++)
                {
 
 
                    if (j == 0)
                    {
                        Color = 0;
                    }
                    else
                    {
                        Color = (int)(255 * (j % _bmpData.Stride) / _bmpData.Stride);
                    }
                    if ((j % Math.Abs(_bmpData.Stride)) == 0)
                    {
                        Color = 0;
                    }
                    else
                    {
                        Color++;
                    }
                #endregion
 
                    _rgbValues[j] = 0;
                    _rgbValues[j + 1] = 0;
                    _rgbValues[j + 2] = (byte)this.Color;
                    _rgbValues[j + 3] = 255;
                }
 
            }
 
            //renvoi le tableau de bytes
            return _rgbValues;
        }
        #endregion
 
        //OUT LE CLASS DESSIN :ICI UN PROC SUFFIT SVP
        #region Resize
        public void Resize(int pWidth, int pHeight)
        {
            //SVP INIT YOUR _RECT 
            _rectBmp = new Rectangle(0, 0, pWidth, pHeight);
 
            //APPEL À DESSIN
            InitialiseDessin();
        }
        #endregion
 
        #region UnLockBitmap
        private void UnlockBitmap()
        {
            _bmp.UnlockBits(_bmpData);
        }
        #endregion
 
        #region LockBitmap
        private BitmapData LockBitmap()
        {
            //ON UTILISE NOTRE PF
            return _bmp.LockBits(_rectBmp, ImageLockMode.ReadWrite, pf);
        }
        #endregion
    }
}

code .cs du form:

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
26
27
28
29
30
31
32
33
34
35
36
37
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace FractalTest
{
    public partial class Form1 : Form
    {
        private FractaleDrawer _fractalDrawer;
        public Form1()
        {
            InitializeComponent();
            _fractalDrawer = new FractaleDrawer(pictureBox1.Width, pictureBox1.Height);
            label1.Text = _fractalDrawer.Bmp.PixelFormat.ToString();
            //Update your pictureBox1
            this.pictureBox1.Image = _fractalDrawer.Bmp;
 
        }
        //ICI ON RESIZE LE BITMAP  AU GRE DU  PICTUREBOX 
        private void pictureBox1_SizeChanged(object sender, EventArgs e)
        {
            if (_fractalDrawer != null)
            {
                _fractalDrawer.Resize(pictureBox1.Width, pictureBox1.Height);
                //Update your pictureBox1
                this.pictureBox1.Image = _fractalDrawer.Bmp;
            }
        }
 
    }
}

Rappel :les classes ,structures et tableaux manages comme par exemple -notre bitmap-,sont gerees dans le tas (Heap) et peuvent etre deplacees librement pendant la duree d'application par GC(garbage collector) suivant les besoins ......
Quand on leur associe des classes interop qui par definition ont une adresse fixe (statique),il faut les verouiller en memoire managee pour garder une corresspondance correcte des adressses(elles sont "pinned")...........
bon code................