Dessin Pixels dans WPF

comment pourrais-je gérer pixel-par-pixel rendering en WPF (comme, par exemple, pour un raytracer)? Mon estimation initiale était de créer un BitmapImage, de modifier la mémoire tampon, et d'afficher dans un contrôle Image, mais je ne pouvais pas comprendre comment créer une (la méthode de création nécessite un bloc de mémoire non géré)

InformationsquelleAutor Jimmy | 2009-01-14

.net wpf

38

Je recommande fortement contre les deux précédentes suggestions. La classe WriteableBitmap fournit ce dont vous avez besoin en supposant que vous utilisez 3.5 SP1. Avant le SP1 il n'y a pas vraiment de bonne réponse à cette question dans WPF, sauf si vous recourir à certaines graves supercherie.
- La classe WriteableBitmap est disponible depuis .NET 3.0 et c'est la première version de WPF. Vous n'avez pas besoin .NET 3.5 utilisation de cette classe.
InformationsquelleAutor

Si vous envisagez de faire quelque chose comme un traceur de rayon où vous aurez besoin de complot en beaucoup de points, vous aurez probablement envie de tirer dans le bitmap de l'espace mémoire directement au lieu de passer par les couches d'abstraction. Ce code vous donnera nettement mieux les temps de rendu, mais c'est au prix d'avoir besoin de "dangereux" de code, qui peut ou peut ne pas être une option pour vous.


            unsafe
            {
                System.Drawing.Point point = new System.Drawing.Point(320, 240);
                IntPtr hBmp;
                Bitmap bmp = new Bitmap(640, 480);
                Rectangle lockRegion = new Rectangle(0, 0, 640, 480);
                BitmapData data = bmp.LockBits(lockRegion, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
                byte* p;

                p = (byte*)data.Scan0 + (point.Y * data.Stride) + (point.X * 3);
                p[0] = 0; //B pixel
                p[1] = 255; //G pixel
                p[2] = 255; //R pixel

                bmp.UnlockBits(data);

                //Convert the bitmap to BitmapSource for use with WPF controls
                hBmp = bmp.GetHbitmap();
                Canvas.Source = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(hbmpCanvas, IntPtr.Zero, Int32Rect.Empty, System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
                Canvas.Source.Freeze();
                DeleteObject(hBmp); //Clean up original bitmap
            }

Pour nettoyer la hBitmap vous devez déclarer à proximité de la tête de votre fichier de classe:


        [System.Runtime.InteropServices.DllImport("gdi32.dll")]
        public static extern bool DeleteObject(IntPtr hObject);

Notez également que vous devez définir les propriétés du projet pour permettre le code unsafe. Vous pouvez le faire par un clic droit sur le projet dans l'explorateur de solutions, puis en sélectionnant propriétés. Rendez-vous sur l'onglet créer. Cochez la case "Autoriser le code unsafe" boîte. Aussi je crois que vous aurez besoin d'ajouter une référence à System.De dessin.

Merci une tonne pour cette solution.

InformationsquelleAutor Mr Bell

vous pouvez placer 1X1 objets Rectangle sur une Toile de

  private void AddPixel(double x, double y)
  {
     Rectangle rec = new Rectangle();
     Canvas.SetTop(rec, y);
     Canvas.SetLeft(rec, x);
     rec.Width = 1;
     rec.Height = 1;
     rec.Fill = new SolidColorBrush(Colors.Red);
     myCanvas.Children.Add(rec);
  }

Qui devrait être assez proche de ce que vous voulez

InformationsquelleAutor wegrata

Vous pouvez ajouter des petits rectangles si vous voulez, mais chacune de celles-ci est une FrameworkElement, donc c'est probablement un peu lourd. L'autre option est de vous créer un DrawingVisual, tirer sur elle, la rendre ensuite le coller dans une image:

private void DrawRubbish()
{
    DrawingVisual dv = new DrawingVisual();
    using (DrawingContext dc = dv.RenderOpen())
    {
        Random rand = new Random();

        for (int i = 0; i < 200; i++)
            dc.DrawRectangle(Brushes.Red, null, new Rect(rand.NextDouble() * 200, rand.NextDouble() * 200, 1, 1));

        dc.Close();
    }
    RenderTargetBitmap rtb = new RenderTargetBitmap(200, 200, 96, 96, PixelFormats.Pbgra32);
    rtb.Render(dv);
    Image img = new Image();
    img.Source = rtb;
    MainGrid.Children.Add(img);
}

Excellente solution. A travaillé comme un charme. Juste une petite chose: dc.Close(); n'est pas nécessaire. L'utilisation d'appels Dispose(), qui est en train de faire la même chose que pour les Fermer(). J'ai vérifié WPF code source:-)

InformationsquelleAutor Steven Robbins

Voici une méthode à l'aide de WritableBitmap.

public void DrawRectangle(WriteableBitmap writeableBitmap, int left, int top, int width, int height, Color color)
{
    //Compute the pixel's color
    int colorData = color.R << 16; //R
    colorData |= color.G << 8; //G
    colorData |= color.B << 0; //B
    int bpp = writeableBitmap.Format.BitsPerPixel / 8;

    unsafe
    {
        for (int y = 0; y < height; y++)
        {
            //Get a pointer to the back buffer
            int pBackBuffer = (int)writeableBitmap.BackBuffer;

            //Find the address of the pixel to draw
            pBackBuffer += (top + y) * writeableBitmap.BackBufferStride;
            pBackBuffer += left * bpp;

            for (int x = 0; x < width; x++)
            {
                //Assign the color data to the pixel
                *((int*)pBackBuffer) = colorData;

                //Increment the address of the pixel to draw
                pBackBuffer += bpp;
            }
        }
    }

    writeableBitmap.AddDirtyRect(new Int32Rect(left, top, width, height));
}

Et de l'utiliser:

private WriteableBitmap bitmap = new WriteableBitmap(1100, 1100, 96d, 96d, PixelFormats.Bgr24, null);

private void Button_Click(object sender, RoutedEventArgs e)
{
    int size = 10;

    Random rnd = new Random(DateTime.Now.Millisecond);
    bitmap.Lock(); //Lock() and Unlock() could be moved to the DrawRectangle() method. Just do some performance tests.

    for (int y = 0; y < 99; y++)
    {
        for (int x = 0; x < 99; x++)
        {
            byte colR = (byte)rnd.Next(256);
            byte colG = (byte)rnd.Next(256);
            byte colB = (byte)rnd.Next(256);

            DrawRectangle(bitmap, (size + 1) * x, (size + 1) * y, size, size, Color.FromRgb(colR, colG, colB));
        }
    }

    bitmap.Unlock(); //Lock() and Unlock() could be moved to the DrawRectangle() method. Just do some performance tests.

  image.Source = bitmap; //This should be done only once
}

InformationsquelleAutor reflog

Vous devez vous connecter pour publier un commentaire.