Discussion :

[janyoura]

Bonjour,
Dans mon application j'ai des images dans pictureBox et l'utilisateur en cliquant sur le bouton enregistrer, normalement l'image sélectionnée avec un rectangle sera enregistrée, mais le problème c'est que je n'arrive pas à faire le test sur la position du rectangle, c'est à dire sur quel pictureBox il est.
Quelqu'un pourra-il me donner une manière de le faire?
J'ai utilisé MouseDown pour dessiner le rectangle
Merci

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
   private void saveBtn_Click(object sender, EventArgs e)
        {
            if (picture1.Image != null)
            {
 
                rect = new Rectangle(540, 325, 235, 210);
                Graphics g = this.CreateGraphics();
                g.DrawRectangle(pen, rect);
 
                this.Invalidate();     
                Save(picture1);
 
            }
 
 
        }
 
 
 
 
 
 
 
 
        private void picture1_MouseDown(object sender, MouseEventArgs e)
        {
 
 
                if (picture1.Image != null)
                {
                   // MessageBox.Show("mouse down");
                     rect = new Rectangle(545, 325, 235, 210);
                     Graphics g = this.CreateGraphics();
                     g.DrawRectangle(pen, rect);
 
             //this.Invalidate();     
                   //  painting = true;
                     this.Invalidate();
 
                }
 
            }

[lead8209]

Salut,
bon en fait je te propose un code tout fait...
Pas terrible question apprentissage mais bon. C'est toute une logique ce que tu veux faire et même si on trouve facilement sur google des éléments morceau par morceau il faut faire l'effort de bien distinguer les différentes étapes ce que je pense tu n'as pas fait.

Bref pour le code qui suit il suffit juste d'abonner les événements MouseDown, MouseMove, MouseUp des picturesboxes dont tu souhaites extraite l'image aux fonctions éponymes.
Attention : ceci ne fonctionne que si l'image des pictureboxes est en pleine echelle (this.pictureBox.SizeMode = PictureBoxSizeMode.AutoSize). Pour gérer cela il faut mettre chaque picturebox dans un panel qui lui a une taille fixe et mettre sa propriété panel.autoScroll = true.

Pour la partie enregistrement moi je garde dans une variable le nom du fichier qui est chargé dans ma picturebox et je sauvegarde à la volée sur le mouseUp (nom_1.bmp, nom_2.bmp, etc...) sans ouvrir le "SaveFileDialog".. question de confort utilisateur; mais on allait pas compliquer encore plus les choses

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
 
public partial class Form1 : Form
    {
        /// <summary>
        /// Stocke le point cliqué par l'utilisateur lors du mouseDown.
        /// </summary>
        Point m_Point = Point.Empty;
        /// <summary>
        /// Stocke le retangle dessiné par l'utilisateur lors du mouseMove.
        /// </summary>
        Rectangle m_Rectangle = Rectangle.Empty;
        /// <summary>
        /// Indique si la touche CTRL est enfoncée.
        /// </summary>
        bool m_CtrlDown = false;
        /// <summary>
        /// Objet utilisé pour dessiner le rectangle de sélection
        /// </summary>
        Pen m_Pen = new Pen(new SolidBrush(Color.Red));
 
        public Form1()
        {
            InitializeComponent();
 
        }
 
        private void pictureBox_MouseDown(object sender, MouseEventArgs e)
        {
            m_Point = e.Location;
        }
 
        private void pictureBox_MouseMove(object sender, MouseEventArgs e)
        {
            var pb = sender as PictureBox; //l'argument sender est en fait la picturebox sur laquelle est délanchée l'événement mouseMove.          
 
            //dessin uniquement si l'utilisateur a cliqué gauche et maintien le clic et que la position actuelle du curseur ne sort pas de la zone cliente de la picturebox
            if (m_Point != Point.Empty && pb.ClientRectangle.Contains(e.Location))
            {
                /*création du rectangle selon que l'utilisation monte vers la gauche, monte vers la droite descend vers la gauche ou descend vers la droite.*/
                if (e.X - m_Point.X > 0 && e.Y - m_Point.Y > 0)
                {
                    m_Rectangle = new Rectangle(new Point(m_Point.X, m_Point.Y), new Size(e.X - m_Point.X, e.Y - m_Point.Y));
                }
                else if (e.X - m_Point.X < 0 && e.Y - m_Point.Y > 0)
                {
                    m_Rectangle = new Rectangle(new Point(e.X, m_Point.Y), new Size(m_Point.X - e.X, e.Y - m_Point.Y));
                }
                else if (e.X - m_Point.X > 0 && e.Y - m_Point.Y < 0)
                {
                    m_Rectangle = new Rectangle(new Point(m_Point.X, e.Y), new Size(e.X - m_Point.X, m_Point.Y - e.Y));
                }
                else if (e.X - m_Point.X < 0 && e.Y - m_Point.Y < 0)
                {
                    m_Rectangle = new Rectangle(new Point(e.X, e.Y), new Size(m_Point.X - e.X, m_Point.Y - e.Y));
                }
 
                pb.Refresh(); //on raffraichi la picturebox (effacement de l'ancien tracé du rectangle)
                using (Graphics graph = pb.CreateGraphics()) //on créé un graph à partir de la picturebox dans un using --> comme ça il est correctement libéré (IDisposable)
                {
                    graph.DrawRectangle(m_Pen, m_Rectangle); //on dessine le rectangle de sélection
                }
            }
        }
 
        private void pictureBox_MouseUp(object sender, MouseEventArgs e)
        {
            m_Point = Point.Empty; //on vide le point dès que l'utilisateur relache son clic.
 
            var pb = sender as PictureBox; //l'argument sender est en fait la picturebox sur laquelle est délanchée l'événement mouseUp.          
            pb.Refresh(); //on raffraichi la picturebox (effacement de l'ancien tracé du rectangle)
 
            /*si un rectangle est tracé, si la touche CTRL est enfoncée et si on a une image dans notre picturebox alors on peut extraire la nouvelle image.*/
            if (m_Rectangle != Rectangle.Empty && m_CtrlDown && pb.Image != null) 
            {
 
                using (var bmp = new Bitmap(m_Rectangle.Width, m_Rectangle.Height)) //création du bitmap (dans un using pour les mêmes raisons)
                {
                    using (var graph = Graphics.FromImage(bmp))//Création du graph à partir du bitmap (dans un using pour les mêmes raisons)
                    {
                        graph.DrawImage(pb.Image, new Rectangle(0, 0, bmp.Width, bmp.Height), m_Rectangle, GraphicsUnit.Pixel); //Dessin de l'image contenue dans le rectangle de sélection
 
                        m_Rectangle = Rectangle.Empty; //on vide le rectangle de sélection car plus besoin
 
                        using (SaveFileDialog sfd = new SaveFileDialog()) //sauvegarde de l'image
                        {
                            sfd.Title = "Sauvegarde de l'image.";
                            sfd.Filter = "Fichier bitmap (*.bmp)|*.bmp";
                            sfd.AddExtension = true;
                            if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                            {
                                bmp.Save(sfd.FileName);
                            }
                        }                        
                    }
                }
            }
        }
 
        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.ControlKey)
            {
                m_CtrlDown = true;
            }
        }
 
        private void Form1_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.ControlKey)
            {
                m_CtrlDown = false;
            }
        }
    }

Bonne digestion.