Modifier les premières données de pixels de WriteableBitmap?

Pour répondre à votre question, vous pouvez directement accéder à un bitmap accessible en écriture de données à l'aide de la Lock, écrire, Unlock motif, tel que démontré ci-dessous, mais il n'est généralement pas nécessaire, sauf si vous basez votre dessin sur le contenu de l'image. Plus généralement, il vous suffit de créer un nouveau tampon et d'en faire une image bitmap, plutôt que l'inverse.

Cela étant dit, il ya beaucoup de points d'extensibilité dans WPF pour effectuer innovantes dessin sans avoir recours à la manipulation de pixels. Pour la plupart des contrôles de l'existant WPF primitives (Frontière, une Ligne, un Rectangle, une Image, etc...) sont plus que suffisantes - ne vous préoccupez pas de l'aide de beaucoup d'entre eux, ils sont plutôt bon marché à utiliser. Pour les commandes complexes, vous pouvez utiliser le DrawingContext pour dessiner D3D primitives. Pour les effets d'image, vous pouvez mettre en œuvre des GPU assistée shaders à l'aide de la Effet de la classe ou utiliser le construit en effets (Flou et de l'Ombre).

Mais, si votre situation l'exige l'accès direct aux pixels, choisissez un format de pixel et de commencer à écrire. Je suggère BGRA32 parce que c'est facile à comprendre et est probablement le plus commun d'être discuté.

BGRA32 signifie que les données de pixel est stocké dans la mémoire de 4 octets représentant le bleu, le vert, le rouge, et les canaux alpha d'une image, dans cet ordre. C'est pratique, car chaque pixel se termine sur une frontière d'octet 4, de le prêter à un stockage dans un entier de 32 bits. Lorsque vous traitez avec un entier de 32 bits, gardez à l'esprit l'ordre sera inversé sur la plupart des plateformes (vérifier BitConverter.IsLittleEndian pour déterminer le bon ordre des octets lors de l'exécution si vous avez besoin de prendre en charge plusieurs plates-formes x86 et x86_64 sont à la fois little endian)

Les données d'image sont stockées dans des bandes horizontales qui sont un stride large qui composent une seule ligne de la largeur d'une image. Le stride la largeur est toujours supérieure ou égale à la largeur en pixels de l'image multiplié par le nombre d'octets par pixel dans le format sélectionné. Certaines situations peuvent entraîner la foulée à plus long que le width * bytesPerPixel qui sont spécifiques à certains architechtures, de sorte que vous devez utiliser la foulée de la largeur pour calculer le début d'une ligne, plutôt que de multiplier la largeur. Puisque nous sommes à l'aide d'un 4 octets de large format de pixel, notre rythme de croisière arrive à être width * 4, mais vous ne devriez pas compter sur elle.

Comme mentionné, le seul cas je conseille un WritableBitmap est si vous accédez à une image existante, de sorte que c'est l'exemple ci-dessous:

Avant /Après:

//must be compiled with /UNSAFE
//get an image to draw on and convert it to our chosen format
BitmapSource srcImage = JpegBitmapDecoder.Create(File.Open("img13.jpg", FileMode.Open),
BitmapCreateOptions.None, BitmapCacheOption.OnLoad).Frames[0];
if (srcImage.Format != PixelFormats.Bgra32)
srcImage = new FormatConvertedBitmap(srcImage, PixelFormats.Bgra32, null, 0);
//get a writable bitmap of that image
var wbitmap = new WriteableBitmap(srcImage);
int width = wbitmap.PixelWidth;
int height = wbitmap.PixelHeight;
int stride = wbitmap.BackBufferStride;
int bytesPerPixel = (wbitmap.Format.BitsPerPixel + 7) / 8;
wbitmap.Lock();
byte* pImgData = (byte*)wbitmap.BackBuffer;
//set alpha to transparent for any pixel with red < 0x88 and invert others
int cRowStart = 0;
int cColStart = 0;
for (int row = 0; row < height; row++)
{
cColStart = cRowStart;
for (int col = 0; col < width; col++)
{
byte* bPixel = pImgData + cColStart;
UInt32* iPixel = (UInt32*)bPixel;
if (bPixel[2 /* bgRa */] < 0x44)
{
//set to 50% transparent
bPixel[3 /* bgrA */] = 0x7f;
}
else
{
//invert but maintain alpha
*iPixel = *iPixel ^ 0x00ffffff;
}
cColStart += bytesPerPixel;
}
cRowStart += stride;
}
wbitmap.Unlock();
//if you are going across threads, you will need to additionally freeze the source
wbitmap.Freeze();

Cependant, il n'est vraiment pas nécessaire si vous n'êtes pas modifier une image existante. Par exemple, vous pouvez dessiner un motif en damier à l'aide de tous les coffre-fort à code:

De sortie:

//draw rectangles
int width = 640, height = 480, bytesperpixel = 4;
int stride = width * bytesperpixel;
byte[] imgdata = new byte[width * height * bytesperpixel];
int rectDim = 40;
UInt32 darkcolorPixel = 0xffaaaaaa;
UInt32 lightColorPixel = 0xffeeeeee;
UInt32[] intPixelData = new UInt32[width * height];
for (int row = 0; row < height; row++)
{
for (int col = 0; col < width; col++)
{
intPixelData[row * width + col] = ((col / rectDim) % 2) != ((row / rectDim) % 2) ?
lightColorPixel : darkcolorPixel;
}
}
Buffer.BlockCopy(intPixelData, 0, imgdata, 0, imgdata.Length);
//compose the BitmapImage
var bsCheckerboard = BitmapSource.Create(width, height, 96, 96, PixelFormats.Bgra32, null, imgdata, stride);

Et vous n'avez pas vraiment besoin même un Int32 intermédiaire, si vous écrivez au tableau d'octets directement.

De sortie:

//draw using byte array
int width = 640, height = 480, bytesperpixel = 4;
int stride = width * bytesperpixel;
byte[] imgdata = new byte[width * height * bytesperpixel];
//draw a gradient from red to green from top to bottom (R00 -> ff; Gff -> 00)
//draw a gradient of alpha from left to right
//Blue constant at 00
for (int row = 0; row < height; row++)
{
for (int col = 0; col < width; col++)
{
//BGRA
imgdata[row * stride + col * 4 + 0] = 0;
imgdata[row * stride + col * 4 + 1] = Convert.ToByte((1 - (col / (float)width)) * 0xff);
imgdata[row * stride + col * 4 + 2] = Convert.ToByte((col / (float)width) * 0xff);
imgdata[row * stride + col * 4 + 3] = Convert.ToByte((row / (float)height) * 0xff);
}
}
var gradient = BitmapSource.Create(width, height, 96, 96, PixelFormats.Bgra32, null, imgdata, stride);

---

Edit: apparemment, vous essayez d'utiliser WPF pour faire une sorte d'image de l'éditeur. Je serais toujours à l'aide de WPF primitives pour des formes et des bitmaps, puis de mettre en œuvre des traductions, mise à l'échelle, rotation, comme RenderTransform's, les effets bitmap comme Effect's et de tout garder dans le modèle WPF. Mais, si cela ne fonctionne pas pour vous, nous avons de nombreuses autres options.

Vous pouvez utiliser WPF primitives à rendre à un RenderTargetBitmap qui a choisi PixelFormat à utiliser avec WritableBitmap comme ci-dessous:

Canvas cvRoot = new Canvas();
//position primitives on canvas
var rtb = new RenderTargetBitmap(width, height, dpix, dpiy, PixelFormats.Bgra32);
var wb = new WritableBitmap(rtb);

Vous pouvez utiliser WPF DrawingVisual à la question GDI style de commandes, puis rendu à une image bitmap comme le montre l'exemple sur le RenderTargetBitmap page.

Vous pourriez utiliser l'interface graphique à l'aide d'un InteropBitmap créé à l'aide de System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap à partir d'un HBITMAP récupérées à partir d'un Bitmap.GetHBitmap méthode. Assurez-vous que vous n'avez pas de fuite de la HBITMAP, si.

Vous pouvez accéder aux premières données de pixels en appelant le Lock() méthode et à l'aide de la BackBuffer de la propriété par la suite. Lorsque vous avez terminé, n'oubliez pas d'appeler AddDirtyRect et Unlock.
Pour un exemple simple, vous pouvez prendre un coup d'oeil à ceci: http://cscore.codeplex.com/SourceControl/latest#CSCore.Visualization/WPF/Utils/PixelManipulationBitmap.cs