void DrawTest(Bitmap image) { // should always ensure .Dispose() is called when you are done with a Graphics or BitmapData object. // Test setting pixels directly using (var bd = image.Lock()) { var sz = image.Size / 5; for (int x = sz.Width; x < sz.Width * 2; x++) for (int y = sz.Height; y < sz.Height * 2; y++) bd.SetPixel(x, y, Colors.Green); } // Test using Graphics object using (var graphics = new Graphics(image)) { graphics.DrawLine(Pens.Blue, Point.Empty, new Point(image.Size)); graphics.DrawRectangle(Pens.Blue, new Rectangle(image.Size - 1)); } // should be able to set pixels after using graphics object using (var bd = image.Lock()) { var sz = image.Size / 5; for (int x = sz.Width * 3; x < sz.Width * 4; x++) for (int y = sz.Height * 3; y < sz.Height * 4; y++) bd.SetPixel(x, y, Colors.Red); } }
public static ed.Image ToEto(this IImage cImage) { var eImage = new ed.Bitmap(cImage.Size.Width, cImage.Size.Height, ed.PixelFormat.Format32bppRgba); using (var eData = eImage.Lock()) { if (eData.ScanWidth != cImage.Size.Width * 4) { throw new NotImplementedException(); } var rawData = cImage.GetRawData(); Marshal.Copy(rawData, 0, eData.Data, rawData.Length); } return(eImage); }
private ed.Bitmap LockEtoBitmap() { sdGraphics?.Flush(); var sdData = sdBuffer.LockBits(new sd.Rectangle(0, 0, sdBuffer.Width, sdBuffer.Height), sd.Imaging.ImageLockMode.ReadOnly, sdBuffer.PixelFormat); var bytesPerPixel = ((int)sdBuffer.PixelFormat >> 11) & 31; var byteLength = sdData.Height * sdData.Width * bytesPerPixel; var etoBuffer = new ed.Bitmap(sdBuffer.Width, sdBuffer.Height, ed.PixelFormat.Format32bppRgba); var etoData = etoBuffer.Lock(); if (sdData.Stride < 0) { throw new Exception("Negative stride value encountered!"); } unsafe { if (sdData.Stride > 0 && sdData.Stride == sdData.Width * bytesPerPixel) { Buffer.MemoryCopy((void *)sdData.Scan0, (void *)etoData.Data, byteLength, byteLength); } else // Slightly slower route using the given stride width { var switchColors = MColor.ShouldSwitchColors; var scan = (byte *)sdData.Scan0; var bytesPerScanLine = sdData.Width * bytesPerPixel; Parallel.For(0, sdData.Height, i => { var line = scan + (i * sdData.Stride); for (int j = 0; j < bytesPerScanLine; j += bytesPerPixel) { var b = line[j]; var g = line[j + 1]; var r = line[j + 2]; var a = line[j + 3]; var c = ed.Color.FromArgb(switchColors ? b : r, g, switchColors ? r : b, a); etoData.SetPixel(j / bytesPerPixel, i, c); } }); } } etoData.Dispose(); sdBuffer.UnlockBits(sdData); return(etoBuffer); }
static void ValidateImages(Bitmap image, Bitmap clone, Rectangle? rect = null) { var testRect = rect ?? new Rectangle(image.Size); using (var imageData = image.Lock()) using (var cloneData = clone.Lock()) { if (imageData.BytesPerPixel == 1) { unsafe { // test pixels directly byte* imageptr = (byte*)imageData.Data; imageptr += testRect.Top * imageData.ScanWidth + testRect.Left; byte* cloneptr = (byte*)cloneData.Data; for (int y = 0; y < testRect.Height; y++) { byte* imagerow = imageptr; byte* clonerow = cloneptr; for (int x = 0; x < testRect.Width; x++) { var imagePixel = *(imagerow++); var clonePixel = *(clonerow++); if (imagePixel != clonePixel) { Assert.Fail("Image pixels are not the same at position {0},{1} (source: {2}, clone: {3})", x, y, imagePixel, clonePixel); } } imageptr += imageData.ScanWidth; cloneptr += cloneData.ScanWidth; } } } else for (int x = 0; x < testRect.Width; x++) for (int y = 0; y < testRect.Height; y++) { var imagePixel = imageData.GetPixel(x + testRect.Left, y + testRect.Top); var clonePixel = cloneData.GetPixel(x, y); if (imagePixel != clonePixel) Assert.Fail("Image pixels are not the same at position {0},{1} (source: {2}, clone: {3})", x, y, imagePixel, clonePixel); } } }