getpixel() Farbpipette erstellen aber wie?



  • Hallo zusammen.

    Für ein vorhandenes Zeichenprogramm soll ich ein Tool erstellen, über das man die Farbe eines Pixel auslesen und per Linksklick an den Stift oder Rechtsklick an den Pinsel übergeben kann.

    Als Hinweis gab es nur das man es über die getpixel() Methode machen soll.
    Kann mir das jemand erklären?



  • Mit den Infos, nein.



  • Aufgrund deiner wenigen Infos werfe ich dir einfach mal folgenden Code zu:

    private void PictureBox_MouseClick(object sender, MouseEventArgs e)
    {
        using(Bitmap bmp = new Bitmap(this.pbx.BackgroundImage, this.pbx.Width, this.pbx.Height))
        {
            Color c = bmp.GetPixel(e.Location.X, e.Location.Y);
            this.txtColor.BackColor = c;
            this.txtHex.Text = ColorTranslator.ToHtml(c);
        }
    }
    

    Der macht folgendes:
    - Bitmap aus dem Hintergrundbild der Picturebox erstellen
    - Farbe an Mausklick Position ermitteln mit Bitmap.GetPixel
    - Ausgabe der Farbe und des Hexadezimal codes



  • Ok das macht es mir schon etwas deutlicher.
    Welche Infos müsst ihr haben damit ihr was genaueres sagen könnt?

    Ich poste einfach mal den ganzen Hauptteil

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace Zeichnen
    {
        public partial class Form1 : Form
        {
            //ein Feld für das Zeichenwerkzeug
            int zeichenwerkzeug;
            //für die Zeichenfläche
            Graphics zeichenflaeche;
            //für den Stift
            Pen stift, stiftKopie;
            //für den einfachen Pinsel
            SolidBrush pinsel, pinselKopie;
            //für einen Pinsel mit Muster
            System.Drawing.Drawing2D.HatchBrush musterPinsel, musterPinselKopie;
            //die Positionsdaten
            Point startpunkt;
            //mit oder ohne Füllung
            bool fuellung;
            //für das Bild
            Bitmap bild;
            //gibt es änderungen?
            bool geaendert;
            //für den Dateinamen
            string dateiname;
            //für das Format
            System.Drawing.Imaging.ImageFormat format;
    
            public Form1()
            {
                InitializeComponent();
                //die Standardeinstellungen setzen
                neuesBild();
            }
    
            //zum Speichern und Wiederherstellen der Einstellungen
            void einstellungSpeichern()
            {
                stiftKopie = (Pen)stift.Clone();
                pinselKopie = (SolidBrush)pinsel.Clone();
                musterPinselKopie = (System.Drawing.Drawing2D.HatchBrush)musterPinsel.Clone();
            }
    
            void einstellungSetzen()
            {
                stift = (Pen)stiftKopie.Clone();
                pinsel = (SolidBrush)pinselKopie.Clone();
                musterPinsel = (System.Drawing.Drawing2D.HatchBrush)musterPinselKopie.Clone();
            }
    
            private void beendenToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Close();
            }
    
            private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
            {
                toolStripStatusLabelMausPos.Text = "X: " + e.X + " Y: " + e.Y;
                //wenn die linke Maustaste gedrückt ist
                if (e.Button == MouseButtons.Left)
                {
                    //beim Stift und Radiergummi direkt zeichnen
                    if ((zeichenwerkzeug == 0) || (zeichenwerkzeug == 6))
                    {
                        zeichenflaeche.DrawLine(stift, startpunkt.X, startpunkt.Y, e.X, e.Y);
                        //den neuen Startpunkt sichern
                        startpunkt.X = e.X;
                        startpunkt.Y = e.Y;
                    }
                    //Text in der Statusleiste ausgeben
                    toolStripStatusLabelBis.Text = "Bis X: " + e.X + " Y: " + e.Y;
                    //neu zeichnen
                    pictureBox1.Refresh();
                    geaendert = true;
                }
            }
    
            private void toolStripButtonStift_Click(object sender, EventArgs e)
            {
                zeichenwerkzeug = 0;
                toolStripStatusLabelWerkzeug.Text = "Stift";
                einstellungSetzen();
            }
    
            private void toolStripButtonLinie_Click(object sender, EventArgs e)
            {
                zeichenwerkzeug = 1;
                toolStripStatusLabelWerkzeug.Text = "Linie";
                einstellungSetzen();
            }
    
            private void toolStripButtonRechteck_Click(object sender, EventArgs e)
            {
                zeichenwerkzeug = 2;
                toolStripStatusLabelWerkzeug.Text = "Rechteck";
                einstellungSetzen();
            }
    
            private void toolStripButton4_Click(object sender, EventArgs e)
            {
                zeichenwerkzeug = 3;
                toolStripStatusLabelWerkzeug.Text = "Gefülltes Rechteck";
                einstellungSetzen();
            }
    
            private void Form1_Load(object sender, EventArgs e)
            {
                //eine neue Instanz der Klasse Bitmap in der Größe der PictureBox erzeugen
                bild = new Bitmap(pictureBox1.Width, pictureBox1.Height);
                //die Zeichenfläche auf die Bitmap setzen
                zeichenflaeche = Graphics.FromImage(bild);
                //das Bild der pictureBox zuweisen
                pictureBox1.Image = bild;
                //ein weißes gefülltes Rechteck in die Bitmap zeichnen
                pinsel.Color = Color.White;
                zeichenflaeche.FillRectangle(pinsel, pictureBox1.ClientRectangle);
                //den Pinsel wieder auf Schwarz
                pinsel.Color = Color.Black;
                //die Einstellung speichern
                einstellungSpeichern();
            }
    
            private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
            {
                //wenn die linke Maustaste gedrückt ist, sichern wir den Startpunkt
                //und geben die Position in der Statusleiste aus
                if (e.Button == MouseButtons.Left)
                {
                    startpunkt.X = e.X;
                    startpunkt.Y = e.Y;
                    toolStripStatusLabelVon.Text = "Start X: " + e.X + " Y: " + e.Y;
                }
            }
    
            private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
            {
                //ist die linke Maustaste benutzt worden?
                if (e.Button == MouseButtons.Left)
                {
                    //kein Stift und kein Radiergummi?
                    if ((zeichenwerkzeug != 0) && (zeichenwerkzeug != 6))
                        //dann zeichnen
                        figurZeichnen(new Point(e.X, e.Y), zeichenwerkzeug);
                    //die Texte in der Statusleiste wieder löschen
                    toolStripStatusLabelBis.Text = string.Empty;
                    toolStripStatusLabelVon.Text = string.Empty;
                    //neu zeichnen
                    pictureBox1.Refresh();
                    geaendert = true;
                    //den Standard-Cursor benutzen
                    pictureBox1.Cursor = Cursors.Default;
                }
            }
    
            //eine eigene Methode zum zeichnen der Figuren
            void figurZeichnen(Point ende, int figur)
            {
                switch (figur)
                {
                    case 1:
                        zeichenflaeche.DrawLine(stift, startpunkt.X, startpunkt.Y, ende.X, ende.Y);
                        break;
    
                    case 2:
                        zeichenflaeche.DrawRectangle(stift, startpunkt.X, startpunkt.Y, ende.X - startpunkt.X, ende.Y - startpunkt.Y);
                        break;
    
                    case 3: //entweder mit Farbe oder mit Muster füllen
                        if (fuellung == false)
                            zeichenflaeche.FillRectangle(pinsel, startpunkt.X, startpunkt.Y, ende.X - startpunkt.X, ende.Y - startpunkt.Y);
                        else
                            zeichenflaeche.FillRectangle(musterPinsel, startpunkt.X, startpunkt.Y, ende.X - startpunkt.X, ende.Y - startpunkt.Y);
                        break;
    
                    case 4:
                        zeichenflaeche.DrawEllipse(stift, startpunkt.X, startpunkt.Y, ende.X - startpunkt.X, ende.Y - startpunkt.Y);
                        break;
    
                    case 5: //entweder mit Farbe oder mit Muster füllen
                        if (fuellung == false)
                            zeichenflaeche.FillEllipse(pinsel, startpunkt.X, startpunkt.Y, ende.X - startpunkt.X, ende.Y - startpunkt.Y);
                        else
                            zeichenflaeche.FillEllipse(musterPinsel, startpunkt.X, startpunkt.Y, ende.X - startpunkt.X, ende.Y - startpunkt.Y);
                        break;
                }
            }
    
            private void neuToolStripMenuItem_Click(object sender, EventArgs e)
            {
                zeichenflaeche.Clear(BackColor);
            }
    
            private void neuToolStripButton_Click(object sender, EventArgs e)
            {
                zeichenflaeche.Clear(BackColor);
            }
    
            private void toolStripButtonLinienFarbe_Click(object sender, EventArgs e)
            {
                //nur wenn nicht der Radiergummi aktiv ist
                if (zeichenwerkzeug != 6)
                {
                    //die ausgewählte Farbe für den Dialog setzen
                    colorDialog1.Color = stift.Color;
                    //wurde der Dialog über OK verlassen?
                    //die Farben setzen und die Einstellungen speichern
                    if (colorDialog1.ShowDialog() == DialogResult.OK)
                    {
                        stift.Color = colorDialog1.Color;
                        einstellungSpeichern();
                    }
                }
            }
    
            private void toolStripButtonLinienStil_Click(object sender, EventArgs e)
            {
                //ist der Radiergummi aktiv?
                //dann verlassen wir die Methode sofort wieder
                if (zeichenwerkzeug == 6)
                    return;
                //den Dialog erzeugen
                //Dicke und Stil werden übergeben
                LinienStilDialog stiftEinstellungen = new LinienStilDialog(stift.Width, stift.DashStyle);
                stiftEinstellungen.ShowDialog();
                //wurde Übernehmen angeklickt?
                //die Einstellungen setzen und speichern
                if (stiftEinstellungen.DialogResult == DialogResult.OK)
                {
                    stift.Width = stiftEinstellungen.LiefereStaerke();
                    stift.DashStyle = stiftEinstellungen.LiefereStil();
                    stiftEinstellungen.Close();
                    einstellungSpeichern();
                }
            }
    
            private void toolStripButtonFuellung_Click(object sender, EventArgs e)
            {
                //nur wenn der Radiergummi nicht ausgewählt ist
                if (zeichenwerkzeug == 6)
                    return;
                //den Dialog erzeugen und die Werte für Farbe/Muster, Farbe und Muster übergeben
                Fuellung fuellungEinstellungen = new Fuellung(fuellung, pinsel.Color, musterPinsel.HatchStyle);
                fuellungEinstellungen.ShowDialog();
                //wurde Übernehmen angeklickt?
                //dann die Einstellungen setzen und speichern
                if (fuellungEinstellungen.DialogResult == DialogResult.OK)
                {
                    fuellung = fuellungEinstellungen.LiefereFuellung();
                    pinsel.Color = fuellungEinstellungen.LiefereFarbe();
                    //einen lokalen Pinsel mit den Einstellungen erzeugen
                    System.Drawing.Drawing2D.HatchBrush tempPinsel = new System.Drawing.Drawing2D.HatchBrush(fuellungEinstellungen.LiefereMuster(), pinsel.Color, Color.White);
                    //den lokalen Pinsel kopieren
                    musterPinsel = (System.Drawing.Drawing2D.HatchBrush)tempPinsel.Clone();
                    fuellungEinstellungen.Close();
                    einstellungSpeichern();
                }
            }
    
            private void toolStripButtonFuellung_MouseMove(object sender, MouseEventArgs e)
            {
    
            }
    
            private void toolStripButtonKreis_Click(object sender, EventArgs e)
            {
                zeichenwerkzeug = 4;
                toolStripStatusLabelWerkzeug.Text = "Kreis";
                einstellungSetzen();
            }
    
            private void saveFileDialog1_FileOk(object sender, CancelEventArgs e)
            {
                //den Namen aus dem Dialog holen
                dateiname = saveFileDialog1.FileName;
                //je nach Filter das Format setzen
                switch (saveFileDialog1.FilterIndex)
                {
                    case 1:
                        format = System.Drawing.Imaging.ImageFormat.Bmp;
                        break;
                    case 2:
                        format = System.Drawing.Imaging.ImageFormat.Jpeg;
                        break;
                    case 3:
                        format = System.Drawing.Imaging.ImageFormat.Tiff;
                        break;
                }
                //das Bild unter dem Namen und  dem angegebenen Format speichern
                bild.Save(dateiname, format);
                //den neuen Namen in die Titelleiste setzen
                this.Text = "Zeichnen -- " + dateiname;
                //geaendert auf false setzne
                geaendert = false;
            }
    
            private void speichernunterToolStripMenuItem_Click(object sender, EventArgs e)
            {
                saveFileDialog1.ShowDialog();
            }
    
            private void speichern(object sender, EventArgs e)
            {
                //wenn der Dateiname nicht leer ist
                //speichern wir die Datei direkt
                if (dateiname != string.Empty)
                {
                    bild.Save(dateiname, System.Drawing.Imaging.ImageFormat.Bmp);
                    geaendert = false;
                }
                else
                    saveFileDialog1.ShowDialog();
            }
    
            private void speichernToolStripButton_Click(object sender, EventArgs e)
            {
                saveFileDialog1.ShowDialog();
            }
    
            private void laden(object sender, EventArgs e)
            {
                //wenn nicht gespeicherte Änderungen vorliegen
                if (geaendert == true)
                {
                    //Meldung mit Ja und Nein erzeugen
                    //und überprüfen ob Ja angeklickt wurde
                    if (MessageBox.Show("Wollen Sie die Änderungen speichern?", "Abfrage", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                        speichern(sender, e);
                }
                //den Öffnendialog anzeigen
                openFileDialog1.ShowDialog();
            }
    
            private void openFileDialog1_FileOk(object sender, CancelEventArgs e)
            {
                //das aktuelle Bild freigeben
                bild.Dispose();
                //eine neue temporäre Bitmap aus der Datei erzeugen
                Bitmap tempBild = new Bitmap(openFileDialog1.FileName);
                //das Format setzen
                format = tempBild.RawFormat;
                //bild neu aus tempBild erzeugen
                bild = new Bitmap(tempBild);
                //die Zeichenfläche wieder beschaffen
                zeichenflaeche = Graphics.FromImage(bild);
                //das Bild zuweisen
                pictureBox1.Image = bild;
                //und die Anzeige aktualisieren
                pictureBox1.Refresh();
                //den Dateinamen setzen
                dateiname = openFileDialog1.FileName;
                //geaendert wird wieder false
                geaendert = false;
                //den Text in der Titelleiste ändern
                this.Text = "Zeichnen -- " + dateiname;
            }
    
            private void toolStripButtonKreisGefuellt_Click(object sender, EventArgs e)
            {
                zeichenwerkzeug = 5;
                toolStripStatusLabelWerkzeug.Text = "Gefüllter Kreis";
                einstellungSetzen();
            }
    
            private void Form1_FormClosing(object sender, FormClosingEventArgs e)
            {
                //wenn nicht gespeicherte Änderungen vorliegen
                if (geaendert == true)
                {
                    //Meldung mit Ja, Nein und Abbrechen erzeugen und auswerten
                    switch (MessageBox.Show("Wollen Sie die Änderungen speichern?", "Abfrage", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question))
                    {
                        case DialogResult.Yes:
                            speichern(sender, e);
                            break;
                        case DialogResult.Cancel:
                            e.Cancel = true;
                            break;
                    }
                }
            }
    
            //die Info anzeigen lassen
            private void infoToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Info info = new Info(stift, fuellung, pinsel, musterPinsel);
                info.ShowDialog();
            }
    
            private void toolStripButtonRadierer_Click(object sender, EventArgs e)
            {
                zeichenwerkzeug = 6;
                toolStripStatusLabelWerkzeug.Text = "Radiergummi";
                //die Einstellung speichern
                einstellungSpeichern();
                //die Farbe auf die Hintergrundfarbe der PictureBox setzen
                stift.Color = pictureBox1.BackColor;
                //die Breite auf 5
                stift.Width = 5;
            }
    
            //eine Methode zum setzen der Standardeinstellungen
            void neuesBild()
            {
                //das Zeichenwerkzeug auf den Stift setzen
                zeichenwerkzeug = 0;
                //den Text in der Statusleiste ebenfalls
                toolStripStatusLabelWerkzeug.Text = "Stift";
                //erst einmal wird nicht gefüllt
                fuellung = false;
                //Instanzen für die Stifte und die Pinsel erzeugen
                stift = new Pen(Color.Black);
                stiftKopie = new Pen(Color.Black);
                pinsel = new SolidBrush(Color.Black);
                pinselKopie = new SolidBrush(Color.Black);
                musterPinsel = new System.Drawing.Drawing2D.HatchBrush(System.Drawing.Drawing2D.HatchStyle.Cross, Color.Black);
                musterPinselKopie = new System.Drawing.Drawing2D.HatchBrush(System.Drawing.Drawing2D.HatchStyle.Cross, Color.Black);
                //das Bild ist erst einmal nicht geändert
                geaendert = false;
                //der Dateiname ist leer
                dateiname = string.Empty;
                //den Text in der Titelleiste setzen
                this.Text = "Zeichnen -- ohne Name";
                //das Format auf bmp setzen
                format = System.Drawing.Imaging.ImageFormat.Bmp;
            }
    
            private void bildNeu(object sender, EventArgs e)
            {
                //wenn nicht gespeicherte Änderungen vorliegen
                if (geaendert == true)
                    //Meldung mit Ja und Nein erzeugen und überprüfen, ob 
                    //Ja angeklickt wurde
                    if (MessageBox.Show("Wollen Sie die Änderungen speichern?", "Abfrage", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                        speichern(sender, e);
                //das aktuelle Bild freigeben
                bild.Dispose();
                //eine neue Instanz von Bitmap in der Größe der PictureBox erzeugen
                bild = new Bitmap(pictureBox1.Width, pictureBox1.Height);
                //die Zeichenfläche setzen
                zeichenflaeche = Graphics.FromImage(bild);
                //das Bild der PictureBox zuweisen
                pictureBox1.Image = bild;
                //alle Pinsel und Stifte freigeben
                stift.Dispose();
                pinsel.Dispose();
                musterPinsel.Dispose();
                stiftKopie.Dispose();
                pinselKopie.Dispose();
                musterPinselKopie.Dispose();
                //Standard-Einstellungen setzen und speichern
                neuesBild();
                einstellungSpeichern();
            }
        }   
    }
    


  • Sorry aber jetzt bin ich erschlagen.

    Aufgaben für dich:

    1. Beschreibe dein Problem genauer.
    2. Beschreibe was du bisher versucht hast.
      2.1) Woran lag es das deine Versuche fehlschlugen?
      2.2) Hast du dir meinen Code tatsächlich angesehen und darauf aufbauend probiert dein Problem zu lösen?


  • Danke hab es ...

    //das Werkzeug Pipette
            private void toolStripButtonPipette_Click(object sender, EventArgs e)
            {
                zeichenwerkzeug = 7;
                toolStripStatusLabelWerkzeug.Text = "Pipette";
            }
    
            //die Methode um die Farbe aus einem Pixel zu übernehmen
            private void pictureBox1_MouseClick(object sender, MouseEventArgs e)
            {
                //Ist die Pipette markiert?
                if (zeichenwerkzeug == 7)
                {
                    //wurde die linke Taste benutzt?
                    if (e.Button == MouseButtons.Left)
                    {
                        //dem Stift die Farbe des Pixels zuweisen
                        //über die GetPixel() Methode, übergeben werden die Koordinaten des Pixels
                        stift.Color = bild.GetPixel(e.X, e.Y);
                        //Einstellungen speichern
                        einstellungSpeichern();
                    }
                    //wurde die rechte Taste benutzt?
                    if (e.Button == MouseButtons.Right)
                    {
                        //dem Pinsel die Farbe des Pixels zuweisen
                        //über die GetPixel() Methode, übergeben werden die Koordinaten des Pixel
                        pinsel.Color = bild.GetPixel(e.X, e.Y);
                        //Einstellungen speichern
                        einstellungSpeichern();
                    }
                }
            }
    

Log in to reply