Discussion :

[lyeshbc]

Bonjour,

Je me permets de poster ce message ici car je n'ai pas réussi à trouver une solution à mon souci à travers les différentes discussions et FAQ disponibles.

Dans un cadre professionnel je dois à l'aide de Visual studio 2013 développer un logiciel qui me permettrait de réaliser les choses suivante:

- Récupérer et lire une photo en niveaux de gris au format bitmap.

- Placer un curseur qui pourrait être piloter par l'utilisateur et qui permettrait de déplacer un axe vertical sur l'image pour la scinder en deux parties.

- "Scanner" ces deux parties en comptant le nombre de pixels allumés et le nombre de pixels éteints pour chaque partie.

- Afficher le résultat.

Je suis débutant et je n'ai jamais utiliser Visual studio dans ma scolarité. J'ai cependant suivi plusieurs tutoriels d'introduction (notamment celui ci http://www.yevol.com/vcsharp/Lesson15.htm) et je suis donc ouvert à toute forme d'aide la plus détaillée possible (code, lien, solutions etc..).

Si ce message manque de clarté ou si vous avez besoins de plus d'explications n'hésitez pas à me les demander

Je vous remercie de l'aide que vous pourrez m'apporter.

[ericlm128]

Lire la couleur des pixels

Code c# :

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

1
2
3
4
5
6
7
8
Bitmap myBitmap = new Bitmap(@"input.png");            
for (int x = 0; x < myBitmap.Width; x++)
{
	for (int y = 0; y < myBitmap.Height; y++)
	{                    
		Color pixelColor = myBitmap.GetPixel(x, y);
	}
}

Dessiner une ligne dans une PictureBox

Code c# :

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 drawline(PictureBox pb, Point p1, Point p2, float Bwidth,Color c1)
{
	//refresh the picture box
	pb.Refresh(); 
	//create a new Bitmap object
	Bitmap map=(Bitmap)pb.Image;  
	//create a graphics object
	Graphics g = Graphics.FromImage(map);  
	//create a pen object and setting the color and width for the pen
	Pen p = new Pen(c1, Bwidth);  
	//draw line between  point p1 and p2
	g.DrawLine(p, p1, p2);  
	pb.Image = map;  
	//dispose pen and graphics object
	p.Dispose();  
	g.Dispose();
}

[ebastien]

Bonjour,
Petite remarque concernant :

Dessiner une ligne dans une PictureBox

Code c# :

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 drawline(PictureBox pb, Point p1, Point p2, float Bwidth,Color c1)
{
	//refresh the picture box
	pb.Refresh(); 
	//create a new Bitmap object
	Bitmap map=(Bitmap)pb.Image;  
	//create a graphics object
	Graphics g = Graphics.FromImage(map);  
	//create a pen object and setting the color and width for the pen
	Pen p = new Pen(c1, Bwidth);  
	//draw line between  point p1 and p2
	g.DrawLine(p, p1, p2);  
	pb.Image = map;  
	//dispose pen and graphics object
	p.Dispose();  
	g.Dispose();
}

Pour dessiner dans le pictureBox, mieux vaut le faire dans le paint du control :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int SourisX = 0;
private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
{
    SourisX = e.X;
    pictureBox1.Invalidate();
}
private void pictureBox1_Paint(object sender, PaintEventArgs e)
{
    using (Pen p = new Pen(Color.Black))
    {
        e.Graphics.DrawLine(p, new Point(SourisX, 0), new Point(SourisX, pictureBox1.Height));
    }         
}

[MABROUKI]

Bonjour
En complement de la reponse donné par ericlm128,

- Récupérer et lire une photo en niveaux de gris au format bitmap.

Les images en niveau de gris sont en général au format de pixel "indexed" (indexé avec une palette intégré au fichier bitmap)
On peut lire avec Bitmap.GetPixel(x,y) mais on ne peut setter un pixel avec Bitmap.SetPixel(x,y) !!!
Pour ce faire il faut créer un nouveau bitmap à partir du bitmap source ,le nouveau bitmap est alors d'office au format de pixel Format32bppArgb ( soit 4 octets/pixel
code exemple :

Code :

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

1
2
 
myBitmap = new Bitmap(myBitmap);

- Placer un curseur qui pourrait être piloter par l'utilisateur et qui permettrait de déplacer un axe vertical sur l'image pour la scinder en deux parties.

Le dessin d'un axe vertical qui sert de "repère séparateur" est trivial et peut se faire dans l’Évent Paint du pictureBox (cet Event est déclenché en appelant pictureBox.Invalidate() )...
Mais ou l'appeler ?
dans l’Évent MouseClick du pictureBox car on peut récupérer l'abscisse X de départ de notre axe "repère séparateur" ...

code exemple (ici axe est une instance d'un Class perso désigné AxisVertical "armé de pied en cap") :

Code :

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

1
2
3
4
5
6
7
8
9
 
        private AxisVertical axis = new AxisVertical();
        private void pictureBox1_MouseClick(object sender, MouseEventArgs e)
        {
            axis.Point1 = new Point(e.X, 0);
            axis.Point2 = new Point(e.X, pictureBox1.Height);
 
            pictureBox1.Invalidate();
        }

Mais il subsiste une difficulté de taille : les points du pictureBox doivent correspondre "point par point" aux pixels de l'image..
Cette condition est remplie si le pictureBox a sa prop SizeMode = PictureBoxSizeMode.AutoSize,tout autre valeur sera facheuse...

Cette serie de difficultés resolues on peut ecrire le code complet suivant :
1/ code du Class AxisVertical:

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
 
 
 namespace WinDecouperBmp
{
    public class AxisVertical
    {
        public Point Point1 { get; set; }
        public Point Point2 { get; set; }
        public Pen PenLine { get; set; }
        public AxisVertical()
        {
            PenLine = new Pen(Brushes.Yellow, 1.0f);
            PenLine.DashStyle = System.Drawing.Drawing2D.DashStyle.DashDot;
        }
    }
}

2/ code du Form User:

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
71
72
73
74
75
76
77
78
79
80
81
 
 
  namespace WinDecouperBmp
{
    public partial class Form1 : Form
    {
        private AxisVertical axis = new AxisVertical();
        public Form1()
        {
            InitializeComponent();
        }
        private void Form1_SizeChanged(object sender, EventArgs e)
        {
            Bitmap bmp = new Bitmap(Application.StartupPath + "/Images/modern_arhitecture.bmp");
            bmp = new Bitmap(bmp);
 
            pictureBox1.SizeMode = PictureBoxSizeMode.AutoSize;
            pictureBox1.Image = bmp;
 
            axis.Point1 = new Point(-1, 0);
            axis.Point2 = new Point(-1, 0);
 
        }
        private void pictureBox1_MouseClick(object sender, MouseEventArgs e)
        {
            axis.Point1 = new Point(e.X, 0 );
            axis.Point2 = new Point(e.X, pictureBox1.Width  );
 
            pictureBox1.Invalidate();
        }
 
        private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {
            Graphics gr = e.Graphics;
            DrawAxis(gr);
            if (axis.Point1.X < 0 || axis.Point2.X < 0) return; 
            RepaintBitmap();
        }
 
 
        private void DrawAxis(Graphics gr)
        {
 
                gr.DrawLine(axis.PenLine, axis.Point1, axis.Point2);
 
        }
        private void RepaintBitmap()
        {
            int countLeftPixels = 0;
            int countRightPixels = 0;
            Bitmap bmp =(Bitmap) pictureBox1.Image;
            for (int y = 0; y < pictureBox1.Height; y++)
            {
                for (int x = 0; x < pictureBox1.Width; x++)
                {
                    Color clr =bmp.GetPixel(x, y);
 
                     if (x   <=axis.Point1.X)
                     {
                         countLeftPixels++;
                         clr=Color.FromArgb(clr.A ,Color.Red);
                         bmp.SetPixel(x, y, clr);
                     }
                     else if ( x > axis.Point1.X)
                     {
                         countRightPixels++;
                         clr = Color.FromArgb(clr.A, Color.Blue );
                         bmp.SetPixel(x, y, clr);
                     }
                }
                pictureBox1.Image = bmp;
                label1.Text = countLeftPixels.ToString();
                label2.Text = countRightPixels.ToString();
            }
 
 
        }
 
    }
 
}

Cette façon de coder avec Bitmap.GetPixel(x,y) et Bitmap.SetPixel(x,y,Color) est totalement inefficace,hélas , à cause de sa lenteur d’exécution en presence d'une image est de grande dimension -width * height)...

Aussi la version suivante avec BitmapData est plus rapide à l’exécution,mais il faut s'armer du class LockImage

1/code du Class LockImage

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
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.Drawing.Imaging;
using  System.Runtime.InteropServices;
using System.Drawing;
namespace WinDecouperBmp
{
 
 
    public class LockImage
    {
        private Bitmap BaseImage ;
        private int BaseImageWidth ;
        private int BaseImageHeight  ;
        private int TotalPixels ;
        private IntPtr ImageAddress ;
        private BitmapData ImageContent;
        private int[] ImageBuffer;
        //'comptage pixels
        public int CountLeftPixels { get; set; }
        public int CountRightPixels { get; set; }
 
        public Bitmap Image
	    {
            //  User access to the relevant 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];
        }
        public  void Colorize(AxisVertical axe,Color rightColor,Color leftColor)
        {   
            int pixelIndex ;
            int onePixel ;
            int alphaPart ;
            int redPart ;
            int greenPart ;
            int bluePart ;
 
 
 
            //----- Lock the image for speed.
            LockTheImage();
 
           //----- Process each pixel in the grid.
            for (int y = 0 ; y < BaseImageHeight;  y++)
            {
                for (int x = 0 ; x< BaseImageWidth;  x++)
                  {
                        // ----- Locate the pixel's color.
                        pixelIndex = y * BaseImageWidth + x;
                        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.
                     if ( x<= axe.Point1.X)
                     {
                         CountLeftPixels++;
                         redPart = rightColor.R;
                         greenPart = rightColor.G ;
                         bluePart = rightColor.B ;
                     }
                     else if ( x > axe.Point1.X)
                     {
                         CountRightPixels++;
                         redPart = leftColor .R;
                         greenPart = leftColor.G;
                         bluePart = leftColor.B;
                     }
 
                    // ----- 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();
    }
 
 
    }
 
 
}

2/code du Form User:

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
 
namespace WinDecouperBmp
{
    public partial class Form2 : Form
    {
        private AxisVertical axis = new AxisVertical();
        private LockImage lockedimage;
        public Form2()
        {
            InitializeComponent();
        }
 
        private void Form2_SizeChanged(object sender, EventArgs e)
        {
           Bitmap bmp = new Bitmap(Application.StartupPath + "/Images/modern_arhitecture.bmp");
           bmp = new Bitmap(bmp);
 
            pictureBox1.SizeMode = PictureBoxSizeMode.AutoSize;
            pictureBox1.Image = bmp;
 
            axis.Point1 = new Point(-1, 0);
            axis.Point2 = new Point(-1, 0);
 
        }
        private void pictureBox1_MouseClick(object sender, MouseEventArgs e)
        {
            axis.Point1 = new Point(e.X, 0);
            axis.Point2 = new Point(e.X, pictureBox1.Width);
 
            pictureBox1.Invalidate();
 
        }
        private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {
 
            Graphics gr = e.Graphics;
            DrawAxis(gr);
            if (axis.Point1.X < 0 || axis.Point2.X < 0) return;
            RepaintBitmap();
        }
 
        private void DrawAxis(Graphics gr)
        {
 
            gr.DrawLine(axis.PenLine, axis.Point1, axis.Point2);
 
        }
        private void RepaintBitmap()
        {
            lockedimage = new LockImage();
            lockedimage.Image =(Bitmap)pictureBox1.Image ;
 
            lockedimage.Colorize(axis, Color.Red, Color.Blue);
            pictureBox1.Image = lockedimage.Image;
            label1.Text = lockedimage.CountLeftPixels.ToString();
            label2.Text =lockedimage.CountRightPixels.ToString();
        }
    }
}

bon code...

[lyeshbc]

Bonsoir,

Merci pour toutes vos réponses. Je me penche des que possible dessus et vous fais un retour dès que possible

[lyeshbc]

Bonjour,

Tout d'abord je souhaiterais vous remercier encore une fois à tous pour vos superbes réponses.
Je reviens vers vous tous, et plus particulièrement vers toi Mabrouki au vu de ta réponse très pédagogique^^, avec mon lot de questions qui peuvent sembler un peu bêtes/triviales .Mais avec moins d'une semaine d'"expérience" sous Visual studio mes connaissances sont très légères donc en attendant de trouver et corriger les erreurs une par une par moi même je vais vous décrire la démarche que j'ai suivie pour faire fonctionner ce code.

Donc, J'ai ouvert une form dans laquelle j'ai insérer la picture box (logique) en rajoutant les events mouseclik et sizemode. J'ai copié les morceaux de code correspondant dans les différents blocs (Form,picturebox_mouseclick,...) et j'ai aussi rajouté au projet les 2 classes LockImage et Axisvertical nécessaires pour faire marcher la version plus rapide de ton code, en prenant bien soin de reporter les using et les codes à chaque fois et en changeant les déclarations si necessaires (class-->public class,...).

Au final je me retrouve avec 6 erreurs surement dues à ma maigre expérience . Je vous joint quelques captures d'écrans pour que vous puissiez y voir plus claire.

Donc voilà quelles sont les étapes que j'ai oubliées/manquées?

Merci.

[MABROUKI]

Rebonjour

A priori il manque deja 2 labels sur ton Form qu'il faut dropper vite ,vite...
Pour le Class AxisVertical c'est un problème accessibilité du probablement à une faute de frappe !!!

En l'absence de tes ficheirs de code vomplets il m'est impossible de t'aider sur la base de photos (capture d’écrans) !!!

[MABROUKI]

Rebonjour

il y a une faute de frappe(code tapé avec les pieds) dans la déclaration du Class AxisVertical !!!
la déclaration correcte est :

Code :

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

1
2
3
4
5
public class AxisVertical
    {
       etc...
    }

au lieu

Code :

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

1
2
3
4
5
public class_AxisVertical avec un tiret qui fout tout en l'air
    {
       etc...
    }

[lyeshbc]

Rebonjour,


Oui en effet je me suis aperçu de ça ce matin et je l'ai corrigée (je ne tape pas avec mes pieds mais j'ai des gros pouces donc ça a souvent le même effet^).
J'ai aussi rajouté les label et le code ne me met plus d'erreur. Cependant il y a un hic (encore )

J'ai donc essayé d'ouvrir un BMP en y insérant le chemin d'accès et impossible la Picture box s'ouvre mais avec aucune image alors que la partie du code censé ouvrir est présente et sans erreurs. J'ai essayé de déplacer l'image à plusieurs reprise dans différents dossiers et de changer d'image mais rien n'a fonctionné.

Pouvez vous m'aiguillez sur comment je devrais placer mon image et remplir le Bitmap bmp = new Bitmap("string Filename") pour pouvoir apprécier ce merveilleux code? J'ai du loupé une partie importante

[MABROUKI]

Rebonjour
il faut créer un dossier Images dans le Projet et y ajouter ton image ,via l'Explorateur de Solution...
1/Pointez sur l'image ainsi ajoutée et cliquer sur Propriétés
2/dans la fenêtre Propriétés en face de :

Copier dans le répertoire de sortie : Copier si plus récent (choisit cette option)...
Cela aura pour effet de copier le dossier Images dans le répertoire de sortie

Le répertoire de sortie est
1/ Mode Débogage: C:\Users\LYESHBC\Desktop\WinDecouperBmp\WinDecouperBmp ou se trouve généré L'executable WinDecouperBmp.exe
1/ Mode Release: C:\Users\LYESHBC\Desktop\WinDecouperBmp\WinDecouperBmp\bin\Release ou se trouve généré L'executable WinDecouperBmp.exe

A titre d' illustration simplement pour examiner ce dossier il suffit il suffit de pointer le dossier du projet après génération
->clic droit->Ouvrir le dossier dans l'Explorateur Windows....

[lyeshbc]

Rebonjour,

Tout d'abord je souhaiterai m'excuser pour cette longue absence (vacances y oblige).
J'ai suivi tes conseils et j'arrive donc à charger mon image et à y insérer le curseur voulu.
Mon seul souci est que lorsque je lance le code mon image se colorie immédiatement en bleu et je ne peux pas pointer avec "précision".
Pourriez vous m'indiquer comment faire pour que l'image reste telle quelle avant le pointage ?

Merci de votre aide.

[MABROUKI]

rebonjour

c'est bizarre ,bizarre et encore les fautes de frappe je suppose !!!
Puisque chez moi, au lancement c'est l'image originale qui s'affiche et le coloriage des pixels ne s'effectue qu'après l'event MouseClic !!!
De plus pour éviter toute complication pour l'utilisateur ,il faudrait utiliser 2 copies de ton Bitmap :
- l'original => dénommé bmp dans le code (ci-après)
- son Clone => dénommé bmpClone
- un bouton pour restaurer l'original !!!

code du form.cs revu:

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
71
72
73
74
75
76
77
78
79
80
 
namespace WinDecouperBmp
{
    public partial class Form3 : Form
    {
        private AxisVertical axis = new AxisVertical();
        private LockImage lockedimage=null ;
        private Bitmap bmp = null; // original
        private Bitmap bmpClone = null;// le clone
 
        public Form3()
        {
            InitializeComponent();
 
            //le picturebox
            this.pictureBox1.Location = new Point(0, 0);
            this.pictureBox1.SizeMode = PictureBoxSizeMode.AutoSize;
 
 
            // bouton  Restore
            this.button1.Enabled = false; // desactive la restauration ....!!!
        }
        void Form3_Load(object sender, EventArgs e)
        {
            bmp = new Bitmap(Application.StartupPath + "/Images/modern_architecture.bmp");
            bmp= new Bitmap(bmp);
            this.pictureBox1.Image = bmp;
            bmpClone = new Bitmap(bmp);
 
            axis.PenLine.Width = 2.0f;  // un axe epais
            axis.PenLine.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
            axis.Point1 = new Point(-1, 0);
            axis.Point2 = new Point(-1, 0);
        }
        void pic_MouseClick(object sender, MouseEventArgs e)
        {
            axis.Point1 = new Point(e.X, 0);
            axis.Point2 = new Point(e.X, this.pictureBox1.Width);
            if (axis.Point1.X < 0 || axis.Point2.X < 0) return;
            using (Graphics gr = this.pictureBox1.CreateGraphics()) // code en remplaxement de l'event paint
            {
                DrawAxis(gr);
            }
            RepaintBitmap();
 
            this.button1.Enabled = true; // active la restoration au cas ou !!!
        }
 
 
        private void DrawAxis(Graphics gr)
        {
 
            gr.DrawLine(axis.PenLine, axis.Point1, axis.Point2);
 
        }
        private void RepaintBitmap()
        {
            lockedimage = new LockImage();
            lockedimage.Image = (Bitmap)pictureBox1.Image;
 
            lockedimage.Colorize(axis, Color.Red, Color.Blue);
            this.pictureBox1.Image = lockedimage.Image;
            this.label1.Text = lockedimage.CountLeftPixels.ToString();
            this.label2.Text = lockedimage.CountRightPixels.ToString();
        }
 
        //Restore le BMP
        private void button1_Click(object sender, EventArgs e)
        {
            if (bmpClone != null)
            {
 
                this.pictureBox1.Image = bmpClone;
                this.button1.Enabled = false; 
            }
        }
 
 
    }
}

bon code...

[lyeshbc]

Rebonjour,

Merci de ta réponse. En effet c'était encore une faute de frappe qui faisait que après la toute première utilisation, le coloriage restait pour tout le reste .
L'utilisation d'une copie et d'un bouton est très bien pensée et très pratique ! Ce serait aussi intéressant d'ajouter un bouton permettant de changer d'image et de recréer directement la picturebox adapté à la nouvelle image. Merci pour cette initiative .

La prochaine étape serait de pouvoir enregistrer les deux parties que l'on aurait choisit de découper pour obtenir deux fichiers bmp distincts dans notre répertoire, afin de pouvoir constater la découpe.

Encore merci pour l'aide et le temps mis à ma disposition.

[lyeshbc]

Re-bonjour,

Pour revenir sur le code fourni, je viens de m'apercevoir d'une chose: Le code ne permet que de compter le nombre de pixels de part et d'autre de l'axe, sans faire la différence entre un pixel allumé ou éteint. Cette partie est très importante car c'est elle qui permet de vérifier que l'image est bien symétrique.

Pour mieux comprendre, si on regarde l'image du pingouin en pièce-jointe, on peut affirmer qu'il n'existe pas d'axe de symétrie vertical. Pourtant, on pourrait définir un axe qui séparerait la photo en deux parties, où chaque partie possèderait un nombre de pixel noir égal. En résumé, si notre image possédait 64 000 pixels noirs, on pourrait à priori placer un axe qui couperait la photo en deux parties possédant chacune un nombre de pixel de 32 000 à peu de choses près. Le but de ce code serait alors de trouver cette axe qui permettrait d'avoir une symétrie du nombre de pixel en tâtonnant avec la souris.

De plus, j'aimerai savoir s'il est possible de modifier le code afin d'utiliser la souris pour sélectionner directement sur une image la zone que l'on souhaiterait étudier et placer l'axe ensuite. Ceci éviterait de devoir travailler le format de l'image au préalable pour avoir une analyse correcte.

Merci de votre aide.

[lyeshbc]

Bonjour,

En changeant une condition dans le lockimage, j'ai pu résoudre le problème et réaliser mes analyses.

Cependant, J'aimerais changer le programme pour que le code effectue lui même le tracé de l'axe. En effet, sans passer par un mouseclick, j'aimerais parcourir l'abscisse de l'axe afin d'effectuer mon calcul et de déterminer la position optimale de l'axe qui permettrait d'avoir à peu près le même nombre de pixels de part et d'autre ( Tout du moins, minimiser l'écart entre ces deux valeurs).

Compte tenu de la lenteur d'un tel programme, j'aimerai savoir s'il était aussi possible de partir d'un mouse click comme position initiale et de balayer dans le sens des x positifs ( ou négatifs) suivant l'évolution d'une variable calculant la différence entre les pixels de droite et de gauche.

Je suis un peu perdu au niveau de la structure du code et de la syntaxe à adopter donc si vous pourriez m'éclairer cela m'arrangerait.

Merci de votre aide.

[MABROUKI]

bonjour

Compte tenu de la lenteur d'un tel programme, j'aimerai savoir s'il était aussi possible de partir d'un mouse click comme position initiale et de balayer dans le sens des x positifs ( ou négatifs) suivant l'évolution d'une variable calculant la différence entre les pixels de droite et de gauche.

La "lenteur" se situe ou ? [B]
Les pixels "allumés et éteints" sont je suppose coloriés et transparents !!!
Un tel programme peut trouver l'axe de de symétrie des pixels de droite et gauche aussi vite
que celui que tu suggère ( à partir d'un mouse click)

bref voici la version du Class LockImage revu et doté d'une fonction supplémentaire Symétrie à laquelle on fournit les paramètres suivants :
- la couleur du pixel "allume" à compter
- une instance de AxisVertical dont elle fixer l’abscisse X
- qui renvoie les pixels à droite et gauche ainsi que le total des pixels "allumés"

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
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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
 
public class LockImage
    {
        private Bitmap BaseImage;
        private int BaseImageWidth;
        private int BaseImageHeight;
        private int TotalPixels;
        private IntPtr ImageAddress;
        private BitmapData ImageContent;
        private int[] ImageBuffer;
        //'comptage pixels
        public int CountLeftPixels { get; set; }
        public int CountRightPixels { get; set; }
        public int TotalBlackPixels { get; set; } //rajouté
 
 
        public Bitmap Image
        {
            //  User access to the relevant 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];
        }
        public void Colorize(AxisVertical axe, Color rightColor, Color leftColor)
        {
            int pixelIndex;
            int onePixel;
            int alphaPart;
            int redPart;
            int greenPart;
            int bluePart;
 
            //----- Lock the image for speed.
            LockTheImage();
 
            //----- Process each pixel in the grid.
            for (int y = 0; y < BaseImageHeight; y++)
            {
                for (int x = 0; x < BaseImageWidth; x++)
                {
                    // ----- Locate the pixel's color.
                    pixelIndex = y * BaseImageWidth + x;
                    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.
                    if (x <= axe.Point1.X)
                    {
                        CountLeftPixels++;
                        redPart = rightColor.R;
                        greenPart = rightColor.G;
                        bluePart = rightColor.B;
                    }
                    else if (x > axe.Point1.X)
                    {
                        CountRightPixels++;
                        redPart = leftColor.R;
                        greenPart = leftColor.G;
                        bluePart = leftColor.B;
                    }
 
                    // ----- 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();
        }
        public void Symetrie(AxisVertical axe,Color black)
        {
 
            int pixelIndex;
            int onePixel;
            int alphaPart;
            int redPart;
            int greenPart;
            int bluePart;
 
            //----- Lock the image for speed.
            LockTheImage();
 
 
            TotalBlackPixels = 0;
            for (int y = 0; y < BaseImageHeight; y++)
            {
                for (int x = 0; x < BaseImageWidth; x++)
                {
                    // ----- Locate the pixel's color.
                    pixelIndex = y * BaseImageWidth + x;
                    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.
                    if (alphaPart == black.A
                        && redPart == black.R
                        && greenPart == black.G
                        && bluePart == black.B)
                    {
                        TotalBlackPixels++;
                    }
 
                }
 
            }
 
            CountLeftPixels = 0;
            bool found = false;
            //----- Process each pixel in the grid.
            for (int x = 0; x < BaseImageWidth; x++)
            {
                for (int y = 0; y < BaseImageHeight; y++)
                {
 
                    // ----- Locate the pixel's color.
                    pixelIndex = x * BaseImageHeight + y;
                    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.
                    if (alphaPart == black.A
                        && redPart == black.R
                        && greenPart == black.G
                        && bluePart == black.B)
                    {
                        CountLeftPixels++;
                        if ( x == axe.Point1.X )
                        {
                            CountRightPixels = TotalBlackPixels - CountLeftPixels;
                            found = true;
                        }
 
                    }
 
                    // ----- Set the pixel to the new color. Retain
                    //       the original alpha channel.
                    ImageBuffer[pixelIndex] = (alphaPart << 24) +
                        (redPart << 16) + (greenPart << 8) + bluePart;
                    if (found) break;
                }
                if (found) break;
            }
 
            //----- Finished. Unlock the image.
            UnlockTheImage();
 
        }
 
    }

Pour le Form User on utilise :
- PictureBox_MouseMove au lieu de PictureBox_MouseClick
- attention PictureBox_MouseMove est combiné avec appui sur le bouton MouseButtons.Left
- on utilise l'event PictureBox_Paint car on redessine à chaque mvt de souris l'axe vertical et l'image ...

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
71
72
73
74
75
76
77
 
 
public partial class Form2 : Form
    {
        private AxisVertical axis = new AxisVertical();
        private LockImage lockedimage = null;
        private Bitmap bmp = null; // original
        private Bitmap bmpClone = null;// le clone
        public Form2()
        {
            InitializeComponent();
       //le picturebox
            this.pictureBox1.Location = new Point(0, 0);
            this.pictureBox1.SizeMode = PictureBoxSizeMode.AutoSize;
 
 
            // bouton  Restore
            this.button1.Enabled = false; // desactive la restauration ....!!! 
        }
        private void Form2_Load(object sender, EventArgs e)
        {
            bmp = new Bitmap(Application.StartupPath + "/Images/Pingouin.png");
            bmp= new Bitmap(bmp);
            this.pictureBox1.Image = bmp;
            bmpClone = new Bitmap(bmp);
 
            axis.PenLine.Width = 2.0f;  // un axe epais
            axis.PenLine.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
            axis.Point1 = new Point(-1, 0);
            axis.Point2 = new Point(-1, 0);
        }
        private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                axis.Point1 = new Point(e.X, 0);
                axis.Point2 = new Point(e.X, this.pictureBox1.Width - 1);
                if (axis.Point1.X < 0 || axis.Point2.X < 0) return;
 
                this.pictureBox1.Invalidate();
 
                RepaintBitmap();
            }
        }
        private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {
            Graphics gr = e.Graphics;
            DrawAxis(gr);
        }
        private void DrawAxis(Graphics gr)
        {
 
            gr.DrawLine(axis.PenLine, axis.Point1, axis.Point2);
 
        }
        private void RepaintBitmap()
        {
            lockedimage = new LockImage();
            lockedimage.Image = (Bitmap)pictureBox1.Image;
 
            lockedimage.Symetrie(axis, Color.Black );
            this.pictureBox1.Image = lockedimage.Image;
            this.label1.Text = lockedimage.CountLeftPixels.ToString();
            this.label2.Text = lockedimage.CountRightPixels.ToString();
            this.label3.Text = lockedimage.TotalBlackPixels.ToString();
        }
        //Restore le BMP
        private void button1_Click(object sender, EventArgs e)
        {
            if (bmpClone != null)
            {
 
                this.pictureBox1.Image = bmpClone;
                this.button1.Enabled = false;
            }
        }
    }

bon code...

[lyeshbc]

Bonjour,

Tout d'abord merci pour cette réponse comme toujours pertinente. L'idée du Mouse Move est très intéressante pour montrer ce qu'on cherche à faire.
De mon côté, j'ai réussi à modifier le 1er LockImage pour avoir une détermination de l'axe automatisé. Je vais combiner les deux codes pour garder l'apport du mousemove et faire le traitement auto en utilisant le click de la souris.
La dernière étape serait d'ajouter un bouton pour choisir l'image avec un open file dialog. Pour récupérer le fichier, je devrais en théorie utiliser la propriété FileName pour avoir le chemin d'accès et l'insérer lors de la création du bitmap mais hélas je n'arrive pas à faire la liaison entre ces deux morceaux. Si vous pouviez m'indiquer la marche à suivre ça m'aiderait beaucoup.

Encore merci pour votre aide.

[MABROUKI]

rebonjour

voici le code ...
L' event Form2_Load devient inutile et son code est inutile
Voici le cide de remplacement dans l'event Click du button btnOpenFile :

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
 
  private void Form2_Load(object sender, EventArgs e)
        {
            //  aucun code
 
 
        }
 // CODE DE REMPLACEMENT
private void btnOpenFile_Click(object sender, EventArgs e)
        {
            string filename = GetFileName();
 
            if (string.IsNullOrEmpty(filename))
            {
                MessageBox.Show("selectionner un fichier image s.v.p");
                return;
            }
            bmp = (Bitmap)Image.FromFile(filename);
            bmp = new Bitmap(bmp);
            this.pictureBox1.Image = bmp;
            bmpClone = new Bitmap(bmp);
 
            axis.PenLine.Width = 2.0f;  // un axe epais
            axis.PenLine.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
            axis.Point1 = new Point(-1, 0);
            axis.Point2 = new Point(-1, 0);
 
        }
        private string GetFileName()
        {
            string filename = string.Empty;
            openFileDialog1.Filter = "bitmap files (*.bmp)|*.bmp|bitmap files (*.png)|*.png|bitmap files (*.jpg)|*.jpg";
            openFileDialog1.Multiselect=false;
            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                filename = openFileDialog1.FileName;
 
            }
            return filename;
        }

Et compte-tenu de cette modification il rajouter cette iigne de code dans l'event PictureBox_MouseMove:

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
 
private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
        {
            if (bmp == null) return; //LIGNE A RAJOUTER
            if (e.Button == MouseButtons.Left)
            {
                axis.Point1 = new Point(e.X, 0);
                axis.Point2 = new Point(e.X, this.pictureBox1.Width - 1);
                if (axis.Point1.X < 0 || axis.Point2.X < 0) return;
 
                this.pictureBox1.Invalidate();
 
                RepaintBitmap();
            }
        }

bon code...