Calcolo della dimensione del buffer richiesta per il metodo WriteableBitmap.WritePixels

Question

Come si calcola la dimensione del buffer richiesta per il metodo WriteableBitmap.WritePixels?

Sto utilizzando il sovraccarico con quattro parametri, il primo è un Int32Rect, il successivo è un array di byte contenente i numeri RGBA per il colore, il terzo è il passo (che è la larghezza della mia bitmap scrivibile moltiplicata per il bit per pixel diviso per 8) e l'ultimo è il buffer (indicato come offset in Intellisense).

sto ottenendo la dimensione buffer non è sufficiente errore runtime nel codice qui sotto:

byte[] colourData = { 0, 0, 0, 0 }; 

var xCoordinate = 1; 
var yCoordinate = 1; 

var width = 2; 
var height = 2; 

var rect = new Int32Rect(xCoordinate, yCoordinate, width, height); 

var writeableBitmap = new WriteableBitmap(MyImage.Source as BitmapSource); 

var stride = width*writeableBitmap.Format.BitsPerPixel/8; 

writeableBitmap.WritePixels(rect, colourData, stride,0); 

Qual è la formula che ho bisogno di utilizzare per calcolare il valore del tampone necessario nel codice sopra?

Answer 1

Il valore del passo viene calcolato come numero di byte per "linea pixel" nel rettangolo scrittura:

var stride = (rect.Width * bitmap.Format.BitsPerPixel + 7)/8; 

La dimensione di buffer richiesto è il numero di byte per linea moltiplicato per il numero di righe:

var bufferSize = rect.Height * stride; 

A condizione che si disponga di un rettangolo di scrittura 2x2 e un formato a 32 bit per pixel, ad es. PixelFormats.Pbgra32, si ottiene stride come 8 e bufferSize come 16.

Answer 2

Non sono sicuro, ma provo questo funziona per 24 bit RGB

{ 
    //your code 
     var stride = width * 3; 
     WriteableBitmap bmp = new WriteableBitmap(width, height, 96, 96, PixelFormats.Bgr24, null); 
     bmp.WritePixels(new System.Windows.Int32Rect(0, 0, width , height),byte[],stride,0)); 

    } 

Answer 3

Il passo è semplicemente la larghezza in byte del buffer di input. Si chiama falcata, perché a volte c'è una memoria extra dietro ogni linea di un'immagine, che rende impossibile usare la larghezza dell'immagine per leggere ogni riga di un'immagine.

Quindi nel vostro esempio, questo è 2. Non è necessario calcolare nulla con i bit per pixel della bitmap, il metodo WritePixels conosce tutte queste informazioni. È necessario fornire le informazioni su come sono strutturati i dati di input.

Tuttavia, come indicato nell'altra risposta, il tuo esempio non funzionerà se la bitmap è anch'essa 2x2. Quindi la coordinata di partenza sarebbe 0,0.

EDIT:

Quando guardo più da vicino il tuo esempio, vedo l'errore. Tu dici il coloreData è l'input color. Ma questo è input per pixel. Quindi, se si desidera modificare un rettangolo di 2x2, è necessario quanto segue InputData:

byte[] colourData = { 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0 }; 

E poi il byte per pixel è uguale a quello della bitmap, in modo che sia 4, volte la larghezza di ogni riga (2), rende totale 8.

Answer 4

Io lavoro con questo. 60Z fs

this.playerOpacityMaskImage.WritePixels(
       new Int32Rect(0, 0, this.depthWidth, this.depthHeight), 
       this.greenScreenPixelData, 
       this.depthWidth * ((this.playerOpacityMaskImage.Format.BitsPerPixel + 7)/8), 
       0); 

Answer 5

Ecco Microsoft del codice che esegue il controllo all'interno CopyPixels

 int num = ((sourceRect.Width * this.Format.BitsPerPixel) + 7)/8; 
     if (stride < num) 
     { 
      throw new ArgumentOutOfRangeException("stride", MS.Internal.PresentationCore.SR.Get("ParameterCannotBeLessThan", new object[] { num })); 
     } 
     int num2 = (stride * (sourceRect.Height - 1)) + num; 
     if (bufferSize < num2) 
     { 
      throw new ArgumentOutOfRangeException("buffer", MS.Internal.PresentationCore.SR.Get("ParameterCannotBeLessThan", new object[] { num2 })); 
     } 

Answer 6

Sebbene utente Clemens ha risposto alla domanda relativa alla dimensione del buffer riflessa, l'interrogante non era a conoscenza che egli calcolata la dimensione del buffer già corretto e il problema era da qualche altra parte.

Mentre i dettagli vengono forniti e discussi nei commenti, manca uno snippet completo (e completo esempio di utilizzo di .WritePixels (senza .CopyPixels)). Qui è (ho scansionato domande simili, ma questo è stato il posto migliore):

var dpiX = 96; 

var writeableBitmap = new WriteableBitmap(width, height, dpiX, dpiX, PixelFormats.Bgra32, null); // Pixelformat of Bgra32 results always in 4 bytes per pixel 
int bytesPerPixel = (writeableBitmap.Format.BitsPerPixel + 7)/8; // general formula 
int stride = bytesPerPixel * width; // general formula valid for all PixelFormats 

byte[] pixelByteArrayOfColors = new byte[stride * height]; // General calculation of buffer size 

// The numbers in the array are indices to the used BitmapPalette, 
//  since we initialized it with null in the writeableBitmap init, they refer directly to RGBA, but only in this case. 
// Choose a light green color for whole bitmap (for not easy to find commented MSDN example with random colors, see https://msdn.microsoft.com/en-us/library/system.windows.media.imaging.writeablebitmap(VS.85).aspx 
for (int pixel = 0; pixel < pixelByteArrayOfColors.Length; pixel += bytesPerPixel) 
{ 
    pixelByteArrayOfColors[pixel] = 0;  // blue (depends normally on BitmapPalette) 
    pixelByteArrayOfColors[pixel + 1] = 255; // green (depends normally on BitmapPalette) 
    pixelByteArrayOfColors[pixel + 2] = 0; // red (depends normally on BitmapPalette) 
    pixelByteArrayOfColors[pixel + 3] = 50; // alpha (depends normally on BitmapPalette) 
} 

writeableBitmap.WritePixels(new Int32Rect(0, 0, width, height), pixelByteArrayOfColors, stride, 0);