Wie die Anzeige der raw-Daten als Bild (Visual Studio c#)

Ich erhalten einige raw-Daten, gespeichert in einem byte-array, wobei jeweils 2 Byte ein pixel mit dem Wert (16 bit/px). So starten Sie mit, das array enthält 100x100*2 bytes (genug für ein 100x100 pixel großes Bild). Ich möchte die Anzeige dieser Daten in das Formular-Fenster. Schließlich möchte ich das Bild aktualisieren mit den neuen Daten, sodass es aussieht wie ein video-stream. Keine Feste frame-rate erforderlich ist. Wie kann das getan werden? Alle code-Beispiele in C#?

EDIT:
Nach einigen Anregungen und Kritiken von zig ähnliche Fragen, die ich noch nicht bekommen kann dies geht. Hier ist die Allgemeine Vorstellung von dem, was ich versuche zu tun, aber das Bild wird nicht angezeigt in der Bild-box auf dem Formular. Was ist spezifisch falsch mit meiner Umsetzung und wie man es beheben?

//array of data I collected
byte[] dataArray = new byte[100 * 100 * 2]; 
//create a pointer to the data
IntPtr hglobal = Marshal.AllocHGlobal(100 * 100 * 2);

//copy my array to global
Marshal.Copy(dataArray, 0, hglobal, dataArray.Length);
//create a bitmap: 100x100 pixels, 2bytes/pixel, 16bitgrayscale
Bitmap newBitmap = new Bitmap(100, 100, 2 * 100, PixelFormat.Format16bppGrayScale, hglobal);

//display bitmap
pictureBox1.Image = newBitmap;

//free the memory
Marshal.FreeHGlobal(hglobal);
InformationsquelleAutor Nazar | 2015-08-29
  1. 8

    Das Hauptproblem ist, dass PixelFormat.Format16bppGrayScale wird nicht unterstützt (zumindest auf meinem Win 8.1 x64 system). So haben Sie zu konvertieren image to rgb vor der Anzeige:

    private void Form1_Load(object sender, EventArgs e)
{
    //Create pixel data to put in image, use 2 since it is 16bpp
    Random r = new Random();
    int width = 100;
    int height = 100;
    byte[] pixelValues = new byte[width * height * 2];
    for (int i = 0; i < pixelValues.Length; ++i)
    {
        //Just creating random pixel values for test
        pixelValues[i] = (byte)r.Next(0, 256);
    }

    var rgbData = Convert16BitGrayScaleToRgb48(pixelValues, width, height);
    var bmp = CreateBitmapFromBytes(rgbData, width, height);

    //display bitmap
    pictureBox1.Image = bmp;
}

private static byte[] Convert16BitGrayScaleToRgb48(byte[] inBuffer, int width, int height)
{
    int inBytesPerPixel = 2;
    int outBytesPerPixel = 6;

    byte[] outBuffer = new byte[width * height * outBytesPerPixel];
    int inStride = width * inBytesPerPixel;
    int outStride = width * outBytesPerPixel;

    //Step through the image by row
    for (int y = 0; y < height; y++)
    {
        //Step through the image by column
        for (int x = 0; x < width; x++)
        {
            //Get inbuffer index and outbuffer index
            int inIndex = (y * inStride) + (x * inBytesPerPixel);
            int outIndex = (y * outStride) + (x * outBytesPerPixel);

            byte hibyte = inBuffer[inIndex + 1];
            byte lobyte = inBuffer[inIndex];

            //R
            outBuffer[outIndex] = lobyte;
            outBuffer[outIndex + 1] = hibyte;

            //G
            outBuffer[outIndex + 2] = lobyte;
            outBuffer[outIndex + 3] = hibyte;

            //B
            outBuffer[outIndex + 4] = lobyte;
            outBuffer[outIndex + 5] = hibyte;
        }
    }
    return outBuffer;
}

private static Bitmap CreateBitmapFromBytes(byte[] pixelValues, int width, int height)
{
    //Create an image that will hold the image data
    Bitmap bmp = new Bitmap(width, height, PixelFormat.Format48bppRgb);

    //Get a reference to the images pixel data
    Rectangle dimension = new Rectangle(0, 0, bmp.Width, bmp.Height);
    BitmapData picData = bmp.LockBits(dimension, ImageLockMode.ReadWrite, bmp.PixelFormat);
    IntPtr pixelStartAddress = picData.Scan0;

    //Copy the pixel data into the bitmap structure
    System.Runtime.InteropServices.Marshal.Copy(pixelValues, 0, pixelStartAddress, pixelValues.Length);

    bmp.UnlockBits(picData);
    return bmp;
}

    Idee stammt von dieser thread.

    • Zum Schluss habe ich noch etwas auf dem Bildschirm angezeigt! Vielen Dank für die Hilfe. Ist das generell eine gute Lösung? Meine Bilder werden mit 2048 x 2048 pix mit eingehenden Frequenz von etwa 10 fps. Ich fürchte, dass so viel Daten-manipulation, nur um eine bitmap erstellen, werden nicht in der Lage, um aufzuholen mit dem Datenfluss. Was sagt Ihr dazu?
    • Naja, Umwandlung von bytes zu 48bpp ist so schnell, wie es sein kann, und erstellen bitmap kann nicht schneller sein äther. Also muss man versuchen, zu füttern, mit 10 Bildern pro Sekunde und sehen, wie es geht. Der Teil, den ich ändern würde, ist, wo die endgültige Zeichnung fertig ist (Image-control) - Zeichnung bitmap, die sich auf die form der OnPaint-Ereignis und double buffering sollte helfen.
    • Könntest du, bitte, erklären, was Sie bedeuten, durch , Zeichnung bitmap, die sich auf die form der OnPaint-Ereignis? Ich habe derzeit eine pictureBox-Komponente auf meine form. Ist das nicht, was sollte verwendet werden, um die Bilder anzuzeigen?
    • PictureBox ist für statische Bilder, seine Umlackierung wird langsam sein. Bessere option wird unter Verwendung der Platte als Basisklasse für benutzerdefinierte Steuerelement, das die Zeichnung. Wie hier: stackoverflow.com/a/6712720/635410 , aber ignorieren Bild-morphing-Zeug.
    • Also entfernte ich die pictureBox und legte ein panel auf meine form. Aber ist es notwendig, dieses Feld als eine Klasse? Wie rufe ich die Farbe - event?
    • Ja, Sie haben, um es als Klasse in der Lage sein zu überschreiben, seine OnPaint-Ereignis. Zu zwingen, streichen Sie verwenden können, Refresh-Methode: msdn.microsoft.com/en-us/library/...
    • Trotzdem, zeichnen von Bildern auf einer Tafel ist eine andere Sache, von dem, was war hier gefragt, so können zu stoppen.
    • Eine Menge von Optimierungen durchgeführt werden kann, die für Ihren konkreten Fall. Aber das wäre eine andere Geschichte, so dass, wenn Sie Hilfe benötigen, öffnen Sie ein weiteres Problem, mit dem Sie Ihre Bedürfnisse mit, und wir werden froh sein zu helfen. Für diesen einen, ich denke, Sie sollten akzeptieren, Eldarien Antwort.
    • Eldarien, gibt Es eine Bemerkung unter PixelFormat Enumeration und er sagt, dass für 48RGB format das Bild tatsächlich angezeigt als 8bit Bild. So, es ist nicht wirklich sinnvoll für mich, zur Bereitstellung von Daten als 16bit, wie es erhöht nur die Anzahl der Operationen führt aber nicht zu einer höheren bitdepth Bild. Verstand ich das richtig?
    • Ok, ich habe endlich den Punkt, wo ich tun müssen, um einige performance-Optimierung. Wenn Sie Kommentare haben, bitte, teilen Sie mit mir here

    InformationsquelleAutor Eldarien
  2. 5

    Verwenden Sie diese Bitmap Konstruktor:

    public Bitmap(
    int width,
    int height,
    int stride,
    PixelFormat format,
    IntPtr scan0
)

    Übergeben Sie es der Form der bitmap, die Schrittlänge (wie viele bytes pro Zeile, einschließlich der Polsterung), pixel-format und die pixel-Daten als void * Zeiger. Können Sie erstellen, die letztere mit Marshal.AllocHGlobal und füllen Sie es in als mit dem normalen Zeiger-Operationen. Vergessen Sie nicht, diesen Speicher freizugeben, nach dem erstellen der bitmap.

    Bearbeiten, um Konto für die aktualisierte Frage:

    Rufen Sie einfach IntPtr.ToPointer() um wieder ein Zeiger ist. Wenn Sie vertraut mit C, der rest sollte Kuchen:

    var p=(char *)hglobal.ToPointer();  //bad name by the way, it's not a handle, it's a pointer
p[0]=0;                             //access it like any normal pointer

    Allerdings können Sie mit der Marshaller zum kopieren von Speicher für Sie von verwalteten an nicht verwaltete (sich die Hände schmutzig, ist in der Regel verpönt in C#):

    Marshal.Copy(dataArray, 0, hglobal, dataArray.Length); //again, terrible name

    Einen Bitmap ist ein Image (wie in, es stammt von ihm), aber du bist mit Graphics.DrawImage() falsch. Wie der Fehler sagt, es ist nicht eine statische Methode, die Sie es ziehen, um einen spezifischen graphischen Kontext. Nun, was das Grafik-Kontext ist, das ist bis zu Ihnen:

    • Wenn Sie wollen, es zu malen in Reaktion auf WM_PAINT verwenden Sie die Paint Ereignis-es bietet Ihnen mit einem speziellen Graphics Objekt mit clipping und alles, wie angewiesen, durch das windowing-system.
    • Wenn Sie möchten, malen Sie auf eine bitmap, die dann später angezeigt, irgendwie (die gemeinsame Nutzung, die auch als "double buffering"), verwenden Sie Graphics.FromImage() auf die Quell-bitmap zeichnen Sie die bitmap über es.

    Kann (und sollte) löschen Sie den virtuellen Speicher-Puffer, sobald Sie das Ergebnis wieder aus der Bitmap Konstruktor. Nicht-Leck-Speicher, verwenden Sie eine try..finally konstruieren.

    • Danke. Würden Sie, bitte, geben Sie ein wenig mehr Informationen darüber, wie man mit dieser Bitmap. Was zu tun ist. Wie um das Bild anzuzeigen? Ich bin ganz neu hier. Vielleicht haben Sie auch einige Verweis auf ein Beispiel?
    • Sie erhalten eine Graphics Rahmen aus einem Bild oder aus dem framework Paint Veranstaltung und zeichnen Sie Ihr Bild mit Graphics.DrawImage.
    • Gerade aktualisiert meine Frage. Dies ist, was ich kam mit, so weit, und dies ist, wo meine macht endet. Bitte, helfen.
    • Aktualisierte Antwort zu, hoffe, das hilft. Sollten Sie wirklich Lesen Sie einen ausführlichen Artikel auf GDI/GDI+, aber die meisten Anfänger finden die Tatsache, dass Sie nicht den eigenen Bildschirm des Benutzers völlig verwirrend.
    • Ok, danke dir. Ich werde weiter daran gearbeitet. In Bezug auf die "Grafik-Kontext" - ich will einfach nur das Bild in dem Fenster app-form (in der PictureBox?), oder auf einem separaten Formular. Ist es möglich, um das Bild anzuzeigen, wenn ich will, statt als eine Reaktion auf ein Ereignis?
    • Ja, aber es wäre nutzlos, es zu tun so. Das erste mal ein redraw passiert (windows verschieben zum Beispiel) gegangen wäre.
    • Dann, was ist der richtige Weg, es zu tun? Ich möchte die Reihenfolge der Bilder wurde ständig aktualisiert, auf die form, die ähnlich zu video.

    InformationsquelleAutor Blindy
Schreibe einen Kommentar