/// <summary> /// Creates a System.Drawing.Bitmap image from a WPF source. /// </summary> /// <param name="source"></param> /// <returns></returns> /// <remarks></remarks> public static Bitmap MakeBitmapFromWPF(System.Windows.Media.Imaging.BitmapSource source) { var mm = new MemPtr(); Bitmap bmp = null; if (System.Windows.Application.Current is object) { System.Windows.Application.Current.Dispatcher.Invoke(() => { bmp = new Bitmap(source.PixelWidth, source.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb); mm.Alloc(bmp.Width * bmp.Height * 4); var bm = new System.Drawing.Imaging.BitmapData(); bm.Scan0 = mm.Handle; bm.Stride = bmp.Width * 4; bm = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite | System.Drawing.Imaging.ImageLockMode.UserInputBuffer, System.Drawing.Imaging.PixelFormat.Format32bppArgb, bm); source.CopyPixels(System.Windows.Int32Rect.Empty, mm.Handle, (int)mm.Length, bmp.Width * 4); bmp.UnlockBits(bm); mm.Free(); }); } else { bmp = new Bitmap(source.PixelWidth, source.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb); mm.Alloc(bmp.Width * bmp.Height * 4); var bm = new System.Drawing.Imaging.BitmapData(); bm.Scan0 = mm.Handle; bm.Stride = bmp.Width * 4; bm = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite | System.Drawing.Imaging.ImageLockMode.UserInputBuffer, System.Drawing.Imaging.PixelFormat.Format32bppArgb, bm); source.CopyPixels(System.Windows.Int32Rect.Empty, mm.Handle, (int)mm.Length, bmp.Width * 4); bmp.UnlockBits(bm); mm.Free(); } return(bmp); }
/// <summary> /// Returns an average color from a presented Bitmap /// </summary> /// <param name="bitmap">The bitmap to be evaluated</param> /// <returns>An average color from the bitmap</returns> public static Color GetAverageColor(System.Windows.Media.Imaging.BitmapSource bitmap) { var format = bitmap.Format; if (format != System.Windows.Media.PixelFormats.Bgr24 && format != System.Windows.Media.PixelFormats.Bgr32 && format != System.Windows.Media.PixelFormats.Bgra32 && format != System.Windows.Media.PixelFormats.Pbgra32) { throw new InvalidOperationException("BitmapSource must have Bgr24, Bgr32, Bgra32 or Pbgra32 format"); } var width = bitmap.PixelWidth; var height = bitmap.PixelHeight; var numPixels = width * height; var bytesPerPixel = format.BitsPerPixel / 8; var pixelBuffer = new byte[numPixels * bytesPerPixel]; bitmap.CopyPixels(pixelBuffer, width * bytesPerPixel, 0); long blue = 0; long green = 0; long red = 0; for (int i = 0; i < pixelBuffer.Length; i += bytesPerPixel) { blue += pixelBuffer[i]; green += pixelBuffer[i + 1]; red += pixelBuffer[i + 2]; } return(Color.FromArgb((byte)(red / numPixels), (byte)(green / numPixels), (byte)(blue / numPixels))); }
/// <summary> /// Converts a Wpf <see cref="System.Windows.Media.Imaging.BitmapSource"/> to a Gdi <see cref="System.Drawing.Bitmap"/>. /// Note that this works only with 32 bits BRGA bitmaps. /// </summary> /// <param name="wpfBitmapSource">The Wpf bitmap source.</param> /// <returns>The Gdi bitmap.</returns> public static System.Drawing.Bitmap ToGdi(System.Windows.Media.Imaging.BitmapSource wpfBitmapSource) { if (null == wpfBitmapSource) { throw new ArgumentNullException(nameof(wpfBitmapSource)); } var gdiBitmap = new System.Drawing.Bitmap( wpfBitmapSource.PixelWidth, wpfBitmapSource.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); var bitmapData = gdiBitmap.LockBits( new System.Drawing.Rectangle(System.Drawing.Point.Empty, gdiBitmap.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); wpfBitmapSource.CopyPixels( Int32Rect.Empty, bitmapData.Scan0, bitmapData.Height * bitmapData.Stride, bitmapData.Stride); gdiBitmap.UnlockBits(bitmapData); return(gdiBitmap); }
public static MemoryBitmap ToMemoryBitmap(WIC_READABLE src) { var binfo = src.GetBitmapInfo(); var dst = new MemoryBitmap(binfo); src.CopyPixels(dst.ToByteArray(), binfo.StepByteSize, 0); return(dst); }
public static Emgu.CV.Mat BitmapSourceToEmguCvMat(System.Windows.Media.Imaging.BitmapSource source) { if (source.Format == PixelFormats.Bgra32) { Emgu.CV.Mat result = new Emgu.CV.Mat(); result.Create(source.PixelHeight, source.PixelWidth, Emgu.CV.CvEnum.DepthType.Cv8U, 4); source.CopyPixels(Int32Rect.Empty, result.DataPointer, result.Step * result.Rows, result.Step); return(result); } else if (source.Format == PixelFormats.Bgr24) { Emgu.CV.Mat result = new Emgu.CV.Mat(); result.Create(source.PixelHeight, source.PixelWidth, Emgu.CV.CvEnum.DepthType.Cv8U, 3); source.CopyPixels(Int32Rect.Empty, result.DataPointer, result.Step * result.Rows, result.Step); return(result); } else { throw new Exception(String.Format("Convertion from BitmapSource of format {0} is not supported.", source.Format)); } }
internal static Bitmap GetBitmap(System.Windows.Media.Imaging.BitmapSource source) { Bitmap bmp = new Bitmap(source.PixelWidth, source.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); System.Drawing.Rectangle rect = new System.Drawing.Rectangle(System.Drawing.Point.Empty, bmp.Size); System.Drawing.Imaging.BitmapData data = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); source.CopyPixels(System.Windows.Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride); bmp.UnlockBits(data); return(bmp); }
private Bitmap getBitmapFromSource(System.Windows.Media.Imaging.BitmapSource source) { Bitmap bmp = new Bitmap(source.PixelWidth, source.PixelHeight, PixelFormat.Format32bppPArgb); BitmapData data = bmp.LockBits( new Rectangle(System.Drawing.Point.Empty, bmp.Size), ImageLockMode.WriteOnly, PixelFormat.Format32bppPArgb); source.CopyPixels( Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride); bmp.UnlockBits(data); return(bmp); }
/// <summary> /// Creates a GDI bitmap from a WPF bitmap. /// </summary> /// <param name="img">WPF bitmap source.</param> /// <param name="ignoreAlpha">True = creates a bitmap without alpha.</param> /// <returns>GDI bitmap.</returns> public static Bitmap CreateBitmap(System.Windows.Media.Imaging.BitmapSource img, bool ignoreAlpha) { var rect = new Rectangle(0, 0, img.PixelWidth, img.PixelHeight); Bitmap bmp = new Bitmap(img.PixelWidth, img.PixelHeight, ignoreAlpha ? PixelFormat.Format32bppRgb : PixelFormat.Format32bppArgb); BitmapData data; if (ignoreAlpha) { data = bmp.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb); } else { data = bmp.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); } img.CopyPixels(new System.Windows.Int32Rect(0, 0, img.PixelWidth, img.PixelHeight), data.Scan0, 4 * img.PixelWidth * img.PixelHeight, 4 * img.PixelWidth); bmp.UnlockBits(data); return(bmp); }
/// <remarks> /// Stolen and adapted from /// <seealso href="http://stackoverflow.com/questions/2284353/is-there-a-good-way-to-convert-between-bitmapsource-and-bitmap"> /// Is there a good way to convert between BitmapSource and Bitmap? /// </seealso> /// </remarks> internal static GdiPlus.Bitmap ConvertToGdiPlusBitmap(this Wpf.Media.Imaging.BitmapSource bitmapSource) { var bmp = new GdiPlus.Bitmap( bitmapSource.PixelWidth, bitmapSource.PixelHeight, GdiPlus.Imaging.PixelFormat.Format32bppPArgb); var rectangle = new GdiPlus.Rectangle(GdiPlus.Point.Empty, bmp.Size); var data = bmp.LockBits( rectangle, GdiPlus.Imaging.ImageLockMode.WriteOnly, GdiPlus.Imaging.PixelFormat.Format32bppPArgb ); bitmapSource.CopyPixels( Wpf.Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride); bmp.UnlockBits(data); return(bmp); }
public static System.Drawing.Bitmap BitmapSourceToBitmap(System.Windows.Media.Imaging.BitmapSource srs) { var width = srs.PixelWidth; var height = srs.PixelHeight; var stride = width * ((srs.Format.BitsPerPixel + 7) / 8); var ptr = System.IntPtr.Zero; try { ptr = System.Runtime.InteropServices.Marshal.AllocHGlobal(height * stride); srs.CopyPixels(new System.Windows.Int32Rect(0, 0, width, height), ptr, height * stride, stride); using (var btm = new System.Drawing.Bitmap(width, height, stride, System.Drawing.Imaging.PixelFormat.Format32bppArgb, ptr)) { // Clone the bitmap so that we can dispose it and // release the unmanaged memory at ptr return(new System.Drawing.Bitmap(btm)); } } finally { if (ptr != System.IntPtr.Zero) { System.Runtime.InteropServices.Marshal.FreeHGlobal(ptr); } } }
/// <summary> /// Converts from WPF BitmapSource type to Windows forms (GDI+) Bitmap. /// </summary> public static Bitmap ToBitmap(this System.Windows.Media.Imaging.BitmapSource source) { var bmp = new Bitmap(source.PixelWidth, source.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); var data = bmp.LockBits( new Rectangle(System.Drawing.Point.Empty, bmp.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); source.CopyPixels(Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride); bmp.UnlockBits(data); return(bmp); /* This code might be "better" for different formats but it requires unsafe code. * System.Drawing.Bitmap bitmap = null; * * int width = source.PixelWidth; * int height = source.PixelHeight; * int stride = width * ((source.Format.BitsPerPixel + 7) / 8); * * byte[] bits = new byte[height * stride]; * * source.CopyPixels(bits, stride, 0); * * unsafe * { * fixed (byte* pB = bits) * { * IntPtr ptr = new IntPtr(pB); * * bitmap = new System.Drawing.Bitmap(width, height, stride, System.Drawing.Imaging.PixelFormat.Format32bppPArgb, ptr); * } * } * * return bitmap; */ }
/// <summary> /// Returns the glyph associated with a combo entry. /// </summary> /// <param name="iCombo">[in] The drop-down bar/Window combo.</param> /// <param name="iIndex">[in] Index of item of interest.</param> /// <param name="piImageIndex">[out] Index of glyph in the image list.</param> /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns> /// <remarks> /// GetImage will only be called if you specified ENTRY_IMAGE for the entry attributes of the given combo. There are two expected return codes from GetImage: /// S_OK: Draw the glyph indicated in *piImageIndex. Use this for entries that should have a glyph. /// S_FALSE: Set aside space for a glyph, but don't draw anything. Use this for entries that don't have a glyph but might have sibling entries in the same combo with glyphs. /// Other: Some other failure occurred. /// /// Glyphs in your image lists are assumed to be of the same height. /// </remarks> public int GetEntryImage(int iCombo, int iIndex, out int piImageIndex) { piImageIndex = 0; if (!ValidateIndex(iCombo, iIndex)) { return(VSConstants.E_INVALIDARG); } var targetGlyph = _navigationControls[iCombo].Item2[iIndex].Glyph; if (targetGlyph == null) { return(VSConstants.S_FALSE); } int index; if (!_glyphIndexes.TryGetValue(new WeakReference <ImageSource>(targetGlyph), out index)) { index = -1; // add the image to the image list BitmapSource bitmapSource = targetGlyph as BitmapSource; if (bitmapSource != null) { if (bitmapSource.Format != PixelFormats.Pbgra32 && bitmapSource.Format != PixelFormats.Bgra32) { var formattedBitmapSource = new FormatConvertedBitmap(); formattedBitmapSource.BeginInit(); formattedBitmapSource.Source = bitmapSource; formattedBitmapSource.DestinationFormat = PixelFormats.Pbgra32; formattedBitmapSource.EndInit(); bitmapSource = formattedBitmapSource; } int bytesPerPixel = bitmapSource.Format.BitsPerPixel / 8; byte[] data = new byte[bitmapSource.PixelWidth * bitmapSource.PixelHeight * bytesPerPixel]; int stride = bitmapSource.PixelWidth * bytesPerPixel; bitmapSource.CopyPixels(data, stride, 0); IntPtr nativeData = Marshal.AllocHGlobal(data.Length); try { Marshal.Copy(data, 0, nativeData, data.Length); PixelFormat pixelFormat = (bitmapSource.Format == PixelFormats.Bgra32) ? PixelFormat.Format32bppArgb : PixelFormat.Format32bppPArgb; Bitmap bitmap = new Bitmap(bitmapSource.PixelWidth, bitmapSource.PixelHeight, stride, pixelFormat, nativeData); _imageList.Images.Add(bitmap); index = _imageList.Images.Count - 1; _glyphIndexes.Add(new WeakReference <ImageSource>(targetGlyph), index); } finally { Marshal.FreeHGlobal(nativeData); } } } if (index >= 0) { piImageIndex = index; } return(index >= 0 ? VSConstants.S_OK : VSConstants.S_FALSE); }
public static Texture2D CreateTexture2DFromMediaBitamp(Device device,MediaBitmapSource bitmapSource) { int stride = bitmapSource.PixelWidth * 4; using (var buffer = new DataStream(bitmapSource.PixelHeight * stride, true, true)) { // Copy the content of the WIC to the buffer byte[] array = new byte[bitmapSource.PixelHeight * stride]; bitmapSource.CopyPixels(array, stride, 0); buffer.Write(array, 0, bitmapSource.PixelHeight * stride); return new Texture2D(device, new Texture2DDescription() { Width = bitmapSource.PixelWidth, Height = bitmapSource.PixelHeight, ArraySize = 1, BindFlags = BindFlags.ShaderResource, Usage = ResourceUsage.Immutable, CpuAccessFlags = CpuAccessFlags.None, Format = Format.R8G8B8A8_UNorm, MipLevels = 1, OptionFlags = ResourceOptionFlags.None, SampleDescription = new SampleDescription(1, 0), }, new DataRectangle(buffer.DataPointer, stride)); } }