public Bitmap GetBitmap() { uEye.Defines.Status statusRet = 0; // Get last image memory Int32 s32LastMemId; Int32 s32Width; Int32 s32Height; statusRet = m_Camera.Memory.GetLast(out s32LastMemId); statusRet = m_Camera.Memory.Lock(s32LastMemId); statusRet = m_Camera.Memory.GetSize(s32LastMemId, out s32Width, out s32Height); Bitmap MyBitmap; statusRet = m_Camera.Memory.ToBitmap(s32LastMemId, out MyBitmap); // clone bitmap Rectangle cloneRect = new Rectangle(0, 0, s32Width, s32Height); System.Drawing.Imaging.PixelFormat format = System.Drawing.Imaging.PixelFormat.Format32bppArgb; Bitmap cloneBitmap = MyBitmap.Clone(cloneRect, format); // unlock image buffer statusRet = m_Camera.Memory.Unlock(s32LastMemId); MyBitmap.Dispose(); return(cloneBitmap); }
public static Image ResampleBitmap(Image source, int imageWidth, int imageHeight) { if (source == null || source.Width == 0 || source.Height == 0) { return(null); } if (imageWidth == 0 || imageHeight == 0 || imageWidth == -1 || imageHeight == -1) { return(new Bitmap(source)); } float k = (float)source.Width / (float)imageWidth; float k2 = (float)source.Height / (float)imageHeight; int w; int h; if (k2 > k) { w = Math.Max(1, (int)Math.Round((double)((float)source.Width / k2))); h = imageHeight; } else { w = imageWidth; h = Math.Max(1, (int)Math.Round((double)((float)source.Height / k))); } System.Drawing.Imaging.PixelFormat format = IsIndexedFormat(source.PixelFormat) ? System.Drawing.Imaging.PixelFormat.Format32bppPArgb : source.PixelFormat; Bitmap dest = new Bitmap(w, h, format); using (Graphics g = Graphics.FromImage(dest)) { g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High; g.DrawImage(source, 0, 0, w, h); } return(dest); }
/// <summary> /// Copy constructor /// </summary> public Bitmap(Bitmap other) { _bitmap = other._bitmap; _width = other._width; _height = other._height; _format = other._format; }
/// <summary> /// Creates a new image with the specified width, height and format. /// /// Width and height are in pixels. /// </summary> public Bitmap(uint width, uint height, BitmapPixelFormat format, BitmapImage bmp) { _bitmap = bmp; _width = width; _height = height; _format = format; }
public Bitmap(int width, int height, System.Drawing.Imaging.PixelFormat format) { SetDGImage(new DotGNU.Images.Image (width, height, (DotGNU.Images.PixelFormat)format)); dgImage.AddFrame(); }
private int valueOfPixelFormat(System.Drawing.Imaging.PixelFormat pf) { int result = 0; switch (pf) { case System.Drawing.Imaging.PixelFormat.Format24bppRgb: result = 3; break; case System.Drawing.Imaging.PixelFormat.Format32bppArgb: result = 4; break; case System.Drawing.Imaging.PixelFormat.Format32bppPArgb: result = 4; break; case System.Drawing.Imaging.PixelFormat.Format32bppRgb: result = 4; break; case System.Drawing.Imaging.PixelFormat.Format8bppIndexed: result = 3; break; default: throw new ArgumentException("Unsupported pixel format"); } return(result); }
public Image RenderImage(ILUT lut) { bool render = false; if (_bitmap == null) { System.Drawing.Imaging.PixelFormat format = Components == 4 ? System.Drawing.Imaging.PixelFormat.Format32bppArgb : System.Drawing.Imaging.PixelFormat.Format32bppRgb; _pixels = new PinnedIntArray(ScaledData.Width * ScaledData.Height); _bitmap = new Bitmap(ScaledData.Width, ScaledData.Height, ScaledData.Width * 4, format, _pixels.Pointer); render = true; } if (_applyLut && lut != null && !lut.IsValid) { lut.Recalculate(); render = true; } _bitmap.RotateFlip(RotateFlipType.RotateNoneFlipNone); if (render) { ScaledData.Render((_applyLut ? lut : null), _pixels.Data); } _bitmap.RotateFlip(GetRotateFlipType()); return(_bitmap); }
private Bitmap SliceMainFrame(int _a, int _b) { //0 - 7 (64x128) - LEFT WING //8 - 15 (64x128) - RIGHT WING //16 - 18 - LOOK UPWARDS //19 - 21 - LOOK BACKWARDS //22 - 25 - BEFORE/AFTER LOOK UPWARDS //26 - 31 - USE MAGIC //32 - EMPTY //33 - 39 (64x128) - TURN AROUND //40 - 79 - EMPTY //80 - 158 - TAIL ANIMATION //160 - 238 - LOWER BODY ANIMATION //159 AND 239 - EMPTY Bitmap _MAINFRAMEb = (Bitmap)Var.MAINFRAME; int _size = 64; if ((_a < 16 && _b == 0) || (_a > 32 && _b == 0)) { _size = 128; } Rectangle _cloneRect = new Rectangle(_a * 64, _b * 64, 64, _size); System.Drawing.Imaging.PixelFormat _format = System.Drawing.Imaging.PixelFormat.Format32bppPArgb; Bitmap _result = _MAINFRAMEb.Clone(_cloneRect, _format); return(_result); }
public static Bitmap ToBitmap(this BitmapSource bitmapSource, System.Drawing.Imaging.PixelFormat pixelFormat) { int width = bitmapSource.PixelWidth; int height = bitmapSource.PixelHeight; int stride = width * ((bitmapSource.Format.BitsPerPixel + 7) / 8); // 行の長さは色深度によらず8の倍数のため var intPtr = IntPtr.Zero; try { intPtr = Marshal.AllocCoTaskMem(height * stride); bitmapSource.CopyPixels(new Int32Rect(0, 0, width, height), intPtr, height * stride, stride); using (var bitmap = new Bitmap(width, height, stride, pixelFormat, intPtr)) { // IntPtrからBitmapを生成した場合、Bitmapが存在する間、AllocCoTaskMemで確保したメモリがロックされたままとなる // (FreeCoTaskMemするとエラーとなる) // そしてBitmapを単純に開放しても解放されない // このため、明示的にFreeCoTaskMemを呼んでおくために一度作成したBitmapから新しくBitmapを // 再作成し直しておくとメモリリークを抑えやすい return(new Bitmap(bitmap)); } } finally { if (intPtr != IntPtr.Zero) { Marshal.FreeCoTaskMem(intPtr); } } }
private static System.Windows.Media.PixelFormat ConvertBmpPixelFormat(System.Drawing.Imaging.PixelFormat pixelformat) { System.Windows.Media.PixelFormat pixelFormats = System.Windows.Media.PixelFormats.Default; switch (pixelformat) { case System.Drawing.Imaging.PixelFormat.Format32bppArgb: pixelFormats = PixelFormats.Bgr32; break; case System.Drawing.Imaging.PixelFormat.Format8bppIndexed: pixelFormats = PixelFormats.Gray8; break; case System.Drawing.Imaging.PixelFormat.Format16bppGrayScale: pixelFormats = PixelFormats.Gray16; break; case System.Drawing.Imaging.PixelFormat.Format64bppArgb: pixelFormats = PixelFormats.Rgba64; break; case System.Drawing.Imaging.PixelFormat.Format32bppRgb: pixelFormats = PixelFormats.Bgra32; break; } return(pixelFormats); }
/// <summary> /// Deserialize image. /// </summary> /// <param name="reader">Buffer reader being used.</param> /// <param name="target">Target image into which to deserialize.</param> /// <param name="context">Serialization context.</param> public void Deserialize(BufferReader reader, ref Image target, SerializationContext context) { CompressionMethod methodOfCompression = CompressionMethod.None; if (this.schema.Version >= 4) { Serializer.Deserialize(reader, ref methodOfCompression, context); } if (methodOfCompression == CompressionMethod.None) { Serializer.Deserialize(reader, ref target.image, context); Serializer.Deserialize(reader, ref target.width, context); Serializer.Deserialize(reader, ref target.height, context); Serializer.Deserialize(reader, ref target.stride, context); if (this.schema.Version <= 2) { System.Drawing.Imaging.PixelFormat pixFmt = default(System.Drawing.Imaging.PixelFormat); Serializer.Deserialize(reader, ref pixFmt, context); target.pixelFormat = PixelFormatHelper.FromSystemPixelFormat(pixFmt); } else { Serializer.Deserialize(reader, ref target.pixelFormat, context); } } else { imageCompressor.Deserialize(reader, ref target, context); } }
// Lock a region of this bitmap. Use of this method is discouraged. // It assumes that managed arrays are fixed in place in memory, // which is true for ilrun, but maybe not other CLR implementations. // We also assume that "format" is the same as the bitmap's real format. public unsafe BitmapData LockBits (Rectangle rect, ImageLockMode flags, System.Drawing.Imaging.PixelFormat format) { BitmapData bitmapData = new BitmapData(); bitmapData.Width = rect.Width; bitmapData.Height = rect.Height; bitmapData.PixelFormat = format; if (dgImage != null) { Frame frame = dgImage.GetFrame(0); if (frame != null) { if (format != this.PixelFormat) { frame = frame.Reformat((DotGNU.Images.PixelFormat)format); } bitmapData.Stride = frame.Stride; byte[] data = frame.Data; bitmapData.dataHandle = GCHandle.Alloc(data); int offset = rect.X * GetPixelFormatSize(format) / 8; // TODO: will GCHandle.AddrOfPinnedObject work more // portably across GCs ? fixed(byte *pixel = &(data[rect.Y * frame.Stride])) { bitmapData.Scan0 = (IntPtr)(void *)(pixel + offset); } } } return(bitmapData); }
private void InitGrabber() { try { this.pixelFormat = PixelFormat.Format32bppRgb; boundsRect = new System.Drawing.Rectangle(0, 0, WIDTH, HEIGHT); var format = SharpDX.Direct3D9.Format.A8R8G8B8; SharpDX.Direct3D9.PresentParameters present_params = new SharpDX.Direct3D9.PresentParameters(); present_params.Windowed = true; present_params.BackBufferFormat = format; present_params.SwapEffect = SharpDX.Direct3D9.SwapEffect.Discard; present_params.BackBufferWidth = WIDTH; present_params.BackBufferHeight = HEIGHT; dx9Device = new SharpDX.Direct3D9.Device(new SharpDX.Direct3D9.Direct3D(), 0, SharpDX.Direct3D9.DeviceType.Hardware, IntPtr.Zero, SharpDX.Direct3D9.CreateFlags.HardwareVertexProcessing, present_params); dx9Device.SetRenderState(RenderState.CullMode, Cull.None); dx9Device.SetRenderState(RenderState.Lighting, false); dx9Device.SetRenderState(RenderState.AntialiasedLineEnable, false); } catch (SharpDX.SharpDXException dxe) { LdpLog.Error("SharpDX InitializeDX9\n" + dxe.Message); } catch (Exception ex) { LdpLog.Error("InitializeDX9\n" + ex.Message); } }
private GLTexture LoadGLTexture(string name, string filePath) { int id; GL.GenTextures(1, out id); GL.BindTexture(TextureTarget.Texture2D, id); using (var bitmap = new Bitmap(filePath)) { const System.Drawing.Imaging.PixelFormat pixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppArgb; var rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height); var data = bitmap.LockBits(rectangle, ImageLockMode.ReadOnly, pixelFormat); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, data.Width, data.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0); bitmap.UnlockBits(data); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge); return(new GLTexture(id, name, bitmap.Width, bitmap.Height, filePath)); } }
public byte GetBitsPerPixel(System.Drawing.Imaging.PixelFormat Pixelformat) { try { int BitsPerPixel; switch (Pixelformat) { case System.Drawing.Imaging.PixelFormat.Format8bppIndexed: BitsPerPixel = 8; break; case System.Drawing.Imaging.PixelFormat.Format24bppRgb: BitsPerPixel = 24; break; case System.Drawing.Imaging.PixelFormat.Format32bppArgb: case System.Drawing.Imaging.PixelFormat.Format32bppPArgb: BitsPerPixel = 32; break; default: BitsPerPixel = 0; break; } byte bitsPerPixel = (byte)((float)(BitsPerPixel + 7) / 8); return(bitsPerPixel); } catch (Exception) { throw; } }
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { BitmapSource bitmapSource = value as BitmapSource; if (bitmapSource == null) { return(null); } int width = bitmapSource.PixelWidth; int height = bitmapSource.PixelHeight; int stride = width * ((bitmapSource.Format.BitsPerPixel + 7) / 8); IntPtr pointer = IntPtr.Zero; try { System.Drawing.Imaging.PixelFormat pixelFormat = this.GetPixelFormat(bitmapSource.Format); pointer = Marshal.AllocHGlobal(height * stride); bitmapSource.CopyPixels(new Int32Rect(0, 0, width, height), pointer, height * stride, stride); using (var bitmap = new Bitmap(width, height, stride, pixelFormat, pointer)) { return(new Bitmap(bitmap)); } } finally { if (pointer != IntPtr.Zero) { Marshal.FreeHGlobal(pointer); } } }
public uint instantiate(uint FrameWidth, uint FrameHeight, uint BitDepth, uint Orientation) { VideoInfoStruct videoInfo; videoInfo.FrameWidth = FrameWidth; videoInfo.FrameHeight = FrameHeight; videoInfo.BitDepth = BitDepth; switch (BitDepth) { case (uint)PixelFormat.Format16bppRgb565: pixelFormat = System.Drawing.Imaging.PixelFormat.Format16bppRgb565; break; case (uint)PixelFormat.Format24bppRgb: pixelFormat = System.Drawing.Imaging.PixelFormat.Format24bppRgb; break; case (uint)PixelFormat.Format32bppArgb: pixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppArgb; break; default: pixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppArgb; break; } videoInfo.Orientation = Orientation; IntPtr ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(VideoInfoStruct))); Marshal.StructureToPtr(videoInfo, ptr, true); uint ret = InvokeFunc(plugMainAddr, 11, (uint)ptr.ToInt32(), 0); Marshal.FreeCoTaskMem(ptr); return(ret); }
/// <summary> /// Converts BitmapSource to Bitmap. /// </summary> /// <param name="sourceWpf">BitmapSource</param> /// <returns>Bitmap</returns> private static Bitmap ConvertToBitmap(BitmapSource sourceWpf) { BitmapSource bmpWpf = sourceWpf; // PixelFormat settings/conversion System.Drawing.Imaging.PixelFormat formatBmp = System.Drawing.Imaging.PixelFormat.Format32bppArgb; if (sourceWpf.Format == PixelFormats.Bgr24) { formatBmp = System.Drawing.Imaging.PixelFormat.Format24bppRgb; } else if (sourceWpf.Format == System.Windows.Media.PixelFormats.Pbgra32) { formatBmp = System.Drawing.Imaging.PixelFormat.Format32bppPArgb; } else if (sourceWpf.Format != System.Windows.Media.PixelFormats.Bgra32) { // Convert BitmapSource FormatConvertedBitmap convertWpf = new FormatConvertedBitmap(); convertWpf.BeginInit(); convertWpf.Source = sourceWpf; convertWpf.DestinationFormat = PixelFormats.Bgra32; convertWpf.EndInit(); bmpWpf = convertWpf; } // Copy/Convert to Bitmap Bitmap bmp = new Bitmap(bmpWpf.PixelWidth, bmpWpf.PixelHeight, formatBmp); Rectangle rect = new Rectangle(Point.Empty, bmp.Size); BitmapData data = bmp.LockBits(rect, ImageLockMode.WriteOnly, formatBmp); bmpWpf.CopyPixels(System.Windows.Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride); bmp.UnlockBits(data); return(bmp); }
public static Bitmap ColorImageFrameToBitmap(ColorImageFrame colorFrame) { byte[] pixelBuffer = new byte[colorFrame.PixelDataLength]; colorFrame.CopyPixelDataTo(pixelBuffer); System.Drawing.Imaging.PixelFormat pixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppRgb; if (colorFrame.Format == ColorImageFormat.InfraredResolution640x480Fps30) { pixelFormat = System.Drawing.Imaging.PixelFormat.Format16bppRgb565; } Bitmap bitmapFrame = new Bitmap(colorFrame.Width, colorFrame.Height, pixelFormat); System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, bitmapFrame.Width, bitmapFrame.Height); BitmapData bitmapData = bitmapFrame.LockBits(rect, ImageLockMode.WriteOnly, bitmapFrame.PixelFormat); IntPtr intPointer = bitmapData.Scan0; Marshal.Copy(pixelBuffer, 0, intPointer, colorFrame.PixelDataLength); bitmapFrame.UnlockBits(bitmapData); bitmapData = null; pixelBuffer = null; return(bitmapFrame); }
static void ConvertPixelFormat(PixelLayout from, out System.Drawing.Imaging.PixelFormat to, out int flags) { switch (from) { case PixelLayout.R8: to = System.Drawing.Imaging.PixelFormat.Format8bppIndexed; flags = (int)ImageFlags.ColorSpaceGray; break; case PixelLayout.R16: to = System.Drawing.Imaging.PixelFormat.Format16bppGrayScale; flags = (int)ImageFlags.ColorSpaceGray; break; case PixelLayout.BGR15: to = System.Drawing.Imaging.PixelFormat.Format16bppRgb555; flags = (int)ImageFlags.ColorSpaceRgb; break; case PixelLayout.BGR16: to = System.Drawing.Imaging.PixelFormat.Format16bppRgb565; flags = (int)ImageFlags.ColorSpaceRgb; break; case PixelLayout.BGR24: to = System.Drawing.Imaging.PixelFormat.Format24bppRgb; flags = (int)ImageFlags.ColorSpaceRgb; break; case PixelLayout.BGRA32: to = System.Drawing.Imaging.PixelFormat.Format32bppArgb; flags = (int)ImageFlags.ColorSpaceRgb; break; default: throw new ArgumentException(String.Format("pixel format {0} not supported", from)); } }
internal static Bitmap FromStream(Stream stream) { Bitmap bitmap = null; Task.Run(async() => { using (var raStream = new InMemoryRandomAccessStream()) { await stream.CopyToAsync(raStream.AsStream()); var decoder = await BitmapDecoder.CreateAsync(raStream); var pixelData = await decoder.GetPixelDataAsync(); var width = (int)decoder.OrientedPixelWidth; var height = (int)decoder.OrientedPixelHeight; const PixelFormat format = PixelFormat.Format32bppArgb; var bytes = pixelData.DetachPixelData(); bitmap = new Bitmap(width, height, format); var data = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, format); Marshal.Copy(bytes, 0, data.Scan0, bytes.Length); bitmap.UnlockBits(data); } }).Wait(); return(bitmap); }
private void GetMediaType(System.Drawing.Imaging.PixelFormat pixelFormat, out Guid mediaSubType, out short bitCount) { switch (pixelFormat) { case System.Drawing.Imaging.PixelFormat.Format32bppArgb: mediaSubType = MediaSubType.RGB32; bitCount = 32; break; case System.Drawing.Imaging.PixelFormat.Format32bppRgb: mediaSubType = MediaSubType.RGB32; bitCount = 32; break; case System.Drawing.Imaging.PixelFormat.Format24bppRgb: mediaSubType = MediaSubType.RGB24; bitCount = 24; break; case System.Drawing.Imaging.PixelFormat.Format16bppRgb565: mediaSubType = MediaSubType.RGB565; bitCount = 16; break; default: throw new Exception("Unrecognized Pixelformat in bitmap"); } }
public Bitmap CopyToBitmap(int width, int height, ImagingPixelFormat pixelFormat) { if (width <= 0) { throw new ArgumentOutOfRangeException("width", "width must be greater than zero."); } if (height <= 0) { throw new ArgumentOutOfRangeException("height", "height must be greater than zero."); } Bitmap bitmap = new Bitmap(width, height, pixelFormat); BitmapData lockedPixels = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.WriteOnly, bitmap.PixelFormat); int sizeInBytes = lockedPixels.Stride * lockedPixels.Height; Bind(); GL.GetBufferSubData(_type, new IntPtr(), new IntPtr(sizeInBytes), lockedPixels.Scan0); bitmap.UnlockBits(lockedPixels); // // OpenGL had rows bottom to top. Bitmap wants them top to bottom. // bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY); return(bitmap); }
public static Bitmap ToBitmap(VideoFrame frame) { var bytes = new byte[frame.Stride * frame.Height]; frame.CopyTo <byte>(bytes); var bpp = frame.BitsPerPixel; PixelFormat pf = PixelFormat.Format24bppRgb; switch (bpp) { case 16: pf = PixelFormat.Format16bppGrayScale; break; case 24: pf = PixelFormat.Format24bppRgb; break; case 32: pf = PixelFormat.Format32bppArgb; break; } var bs = new Bitmap(frame.Width, frame.Height, pf); var BoundsRect = new System.Drawing.Rectangle(0, 0, frame.Width, frame.Height); BitmapData bmpData = bs.LockBits(BoundsRect, ImageLockMode.WriteOnly, pf); System.Runtime.InteropServices.Marshal.Copy(bytes, 0, bmpData.Scan0, frame.Stride * frame.Height); bs.UnlockBits(bmpData); return(bs); }
/// <summary> /// Saves to file. /// </summary> /// <param name="texture">The texture.</param> /// <param name="fileName">Name of the file.</param> /// <param name="format">The format.</param> public static void SaveToFile(this ITexture2D texture, string fileName, SysDraw.PixelFormat format = SysDraw.PixelFormat.Format32bppArgb) { using (var bitmap = SaveToBitmap(texture, format)) { bitmap.Save(fileName); } }
public static int BitsPerPixel(this sdi.PixelFormat format) { switch (format) { case sdi.PixelFormat.Format1bppIndexed: return(1); case sdi.PixelFormat.Format4bppIndexed: return(4); case sdi.PixelFormat.Format8bppIndexed: return(8); case sdi.PixelFormat.Format24bppRgb: return(24); case sdi.PixelFormat.Format32bppArgb: case sdi.PixelFormat.Format32bppPArgb: case sdi.PixelFormat.Format32bppRgb: return(32); default: throw new NotSupportedException(); } }
public Bitmap GetPicThumbnail(Bitmap iSource, int dHeight, int dWidth, System.Drawing.Imaging.PixelFormat flag, int initHeight, int intFromTop) { System.Drawing.Image initImage = iSource; //原图宽高均小于模版,不作处理,直接保存 if (initImage.Width <= dWidth && initImage.Height <= dHeight) { return(iSource); } else { //原始图片的宽 int initWidth = initImage.Width; //截图对象 System.Drawing.Image pickedImage = null; System.Drawing.Graphics pickedG = null; pickedImage = new System.Drawing.Bitmap(initWidth, initHeight); pickedG = System.Drawing.Graphics.FromImage(pickedImage); //设置质量 pickedG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic; pickedG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality; //定位 Rectangle fromR = new Rectangle(0, intFromTop, initWidth, initHeight); Rectangle toR = new Rectangle(0, 0, initWidth, initHeight); //画图 pickedG.DrawImage(initImage, toR, fromR, System.Drawing.GraphicsUnit.Pixel); //将截图对象赋给原图 initImage = (System.Drawing.Image)pickedImage.Clone(); //释放截图资源 pickedG.Dispose(); pickedImage.Dispose(); //缩略图对象 System.Drawing.Image resultImage = new System.Drawing.Bitmap(dWidth, dHeight); System.Drawing.Graphics resultG = System.Drawing.Graphics.FromImage(resultImage); //设置质量 resultG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic; resultG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality; //用指定背景色清空画布 resultG.Clear(Color.White); //绘制缩略图 resultG.DrawImage(initImage, new System.Drawing.Rectangle(0, 0, dWidth, dHeight), new System.Drawing.Rectangle(0, 0, initWidth, initHeight), System.Drawing.GraphicsUnit.Pixel); //关键质量控制 //获取系统编码类型数组,包含了jpeg,bmp,png,gif,tiff ImageCodecInfo[] icis = ImageCodecInfo.GetImageEncoders(); ImageCodecInfo ici = null; foreach (ImageCodecInfo i in icis) { if (i.MimeType == "image/jpeg" || i.MimeType == "image/bmp" || i.MimeType == "image/png" || i.MimeType == "image/gif") { ici = i; } } EncoderParameters ep = new EncoderParameters(1); ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)flag); return((Bitmap)resultImage); } }
private static unsafe Bitmap CreateAlphaBitmap(Bitmap srcBitmap, PixelFormat targetPixelFormat) { var result = new Bitmap(srcBitmap.Width, srcBitmap.Height, targetPixelFormat); var bmpBounds = new Rectangle(0, 0, srcBitmap.Width, srcBitmap.Height); var srcData = srcBitmap.LockBits(bmpBounds, ImageLockMode.ReadOnly, srcBitmap.PixelFormat); var destData = result.LockBits(bmpBounds, ImageLockMode.ReadOnly, targetPixelFormat); var srcDataPtr = (byte *)srcData.Scan0; var destDataPtr = (byte *)destData.Scan0; try { for (var y = 0; y <= srcData.Height - 1; y++) { for (var x = 0; x <= srcData.Width - 1; x++) { //this is really important because one stride may be positive and the other negative var position = srcData.Stride * y + 4 * x; var position2 = destData.Stride * y + 4 * x; memcpy(destDataPtr + position2, srcDataPtr + position, (UIntPtr)4); } } } finally { srcBitmap.UnlockBits(srcData); result.UnlockBits(destData); } return(result); }
private Image FrameDraw(Image img) { int max = img.Height; int min = img.Height / 8; Graphics gp = Graphics.FromImage(img); Bitmap bmp = new Bitmap(img); System.Drawing.Imaging.PixelFormat Format = img.PixelFormat; for (int i = max; i >= min; i = i / 2) { for (int x = 0; x < img.Width; x += i) { for (int y = 0; y < max; y += i) { Rectangle rect = new Rectangle(0, 0, i, i); Bitmap clone = bmp.Clone(rect, Format); Bitmap32 bmp32 = new Bitmap32(clone); bmp32.LockBitmap(); bmp32.Robert(r, g, b); bmp32.UnlockBitmap(); } } } return(img); }
private static void CheckPixelFormat(System.Drawing.Imaging.PixelFormat pixelFormat) { if (pixelFormat != System.Drawing.Imaging.PixelFormat.Format16bppGrayScale) { throw new InvalidOperationException( $"Depth images can only be constructed from bitmaps with {nameof(System.Drawing.Imaging.PixelFormat.Format16bppGrayScale)} format."); } }
public UnmanagedImage(IntPtr imageData, int width, int height, int stride, System.Drawing.Imaging.PixelFormat pixelFormat) { this.imageData = imageData; this.width = width; this.height = height; this.stride = stride; this.pixelFormat = pixelFormat; }
public static void SaveMapAsImage(PixelFormat mapPiFormat, int mapLevel) { var frm = new FrmMapDownloader { _workMode = WorkMode.SaveToImageFile, _mapPiFormat = mapPiFormat, _mapLevel = mapLevel, Text = @"Save Map As Image", labelInfo = {Text = @"Save big map as one image"} }; frm.ShowDialog(); }
private void DisplayImage(int width, int height, float dpiX, float dpiY, WinFormsPixelFormat pixelFormat, byte[] imageData) { try { var wpfPixelFormat = getWpfPixelFormatFromWinformsPixelFormat(pixelFormat); var bitsPerPixel = wpfPixelFormat.BitsPerPixel; var stride = ((width*bitsPerPixel + (bitsPerPixel - 1)) & ~(bitsPerPixel - 1))/8; Parallel.For(0, imageData.Length / 3, index => { int i = index*3; byte r = imageData[i + 0]; byte g = imageData[i + 1]; byte b = imageData[i + 2]; //var yCbCr = new YCbCr(r / 255.0f, g / 255.0f, b / 255.0f); //var rgb = yCbCr.ToRGB(); imageData[i] = r; imageData[i + 1] = g; imageData[i + 2] = b;//(byte)(255 - b); } ); var bitmapSource = BitmapSource.Create( width, height, dpiX, dpiY, wpfPixelFormat, null, imageData, stride); rawRGB.Width = bitmapSource.Width; rawRGB.Height = bitmapSource.Height; rawRGB.Source = bitmapSource; } catch (TaskCanceledException) {} }
private void InitGrabber() { try { this.pixelFormat = PixelFormat.Format32bppRgb; boundsRect = new System.Drawing.Rectangle(0, 0, WIDTH, HEIGHT); uint numAdapter = 0; // # of graphics card adapter uint numOutput = 0; // # of output device (i.e. monitor) // create device and factory dx11Device = new SharpDX.Direct3D11.Device(SharpDX.Direct3D.DriverType.Hardware); dx11Factory = new Factory1(); dx11Output = new Output1(dx11Factory.Adapters1[numAdapter].Outputs[numOutput].NativePointer); // creating CPU-accessible texture resource dx11Texture2Ddescr = new SharpDX.Direct3D11.Texture2DDescription(); dx11Texture2Ddescr.CpuAccessFlags = SharpDX.Direct3D11.CpuAccessFlags.Read; dx11Texture2Ddescr.BindFlags = SharpDX.Direct3D11.BindFlags.None; dx11Texture2Ddescr.Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm; dx11Texture2Ddescr.Height = HEIGHT; dx11Texture2Ddescr.Width = WIDTH; dx11Texture2Ddescr.OptionFlags = SharpDX.Direct3D11.ResourceOptionFlags.None; dx11Texture2Ddescr.MipLevels = 1; dx11Texture2Ddescr.ArraySize = 1; dx11Texture2Ddescr.SampleDescription.Count = 1; dx11Texture2Ddescr.SampleDescription.Quality = 0; dx11Texture2Ddescr.Usage = SharpDX.Direct3D11.ResourceUsage.Staging; dx11ScreenTexture = new SharpDX.Direct3D11.Texture2D(dx11Device, dx11Texture2Ddescr); // duplicate output stuff dx11DuplicatedOutput = dx11Output.DuplicateOutput(dx11Device); } catch (SharpDX.SharpDXException dxe) { string error = "Directx 11 initializer error.\n" + dxe.Message; LdpLog.Error(error); MessageBox.Show(error, "Error", MessageBoxButton.OK, MessageBoxImage.Error); } catch (Exception ex) { string error = "Directx 11 initializer error.\n" + ex.Message; LdpLog.Error(error); MessageBox.Show(error, "Error", MessageBoxButton.OK, MessageBoxImage.Error); } }
public PixelFormatMap(Imaging.PixelFormat Format, OpenGL.PixelFormat GLFormat, OpenGL.PixelInternalFormat numbytes) { this.PixelFormat = Format; this.OpenGLPixelFormat = GLFormat; this.InternalFormat = numbytes; }
// Set the dgImage field within this object. internal void SetDGImage(DotGNU.Images.Image dgImage) { flags = 0; #if !ECMA_COMPAT switch(dgImage.LoadFormat) { case DotGNU.Images.Image.Png: rawFormat = ImageFormat.Png; break; case DotGNU.Images.Image.Jpeg: rawFormat = ImageFormat.Jpeg; break; case DotGNU.Images.Image.Gif: rawFormat = ImageFormat.Gif; break; case DotGNU.Images.Image.Tiff: rawFormat = ImageFormat.Tiff; break; case DotGNU.Images.Image.Bmp: rawFormat = ImageFormat.Bmp; break; case DotGNU.Images.Image.Icon: rawFormat = ImageFormat.Icon; break; case DotGNU.Images.Image.Exif: rawFormat = ImageFormat.Exif; break; } frameDimensionsList = new Guid [0]; this.dgImage = dgImage; // If we are loading an icon, set the size of the image // to the size of the first icon if (rawFormat == ImageFormat.Icon) { width = dgImage.GetFrame(0).Width; height = dgImage.GetFrame(0).Height; } else { width = dgImage.Width; height = dgImage.Height; } #else this.dgImage = dgImage; width = dgImage.GetFrame(0).Width; height = dgImage.GetFrame(0).Height; #endif horizontalResolution = Graphics.DefaultScreenDpi; verticalResolution = Graphics.DefaultScreenDpi; pixelFormat = (System.Drawing.Imaging.PixelFormat) (dgImage.PixelFormat); }
private PixelFormat getWpfPixelFormatFromWinformsPixelFormat(WinFormsPixelFormat pixelFormat) { switch (pixelFormat) { case WinFormsPixelFormat.Format24bppRgb: return PixelFormats.Rgb24; default: throw new InvalidCastException($"No mapping created for winforms pixel format {pixelFormat}"); } }
public uint instantiate(uint FrameWidth, uint FrameHeight, uint BitDepth, uint Orientation) { VideoInfoStruct videoInfo; videoInfo.FrameWidth = FrameWidth; videoInfo.FrameHeight = FrameHeight; videoInfo.BitDepth = BitDepth; switch(BitDepth) { case (uint) PixelFormat.Format16bppRgb565: pixelFormat = System.Drawing.Imaging.PixelFormat.Format16bppRgb565; break; case (uint) PixelFormat.Format24bppRgb: pixelFormat = System.Drawing.Imaging.PixelFormat.Format24bppRgb; break; case (uint) PixelFormat.Format32bppArgb: pixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppArgb; break; default: pixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppArgb; break; } videoInfo.Orientation = Orientation; IntPtr ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(VideoInfoStruct))); Marshal.StructureToPtr(videoInfo, ptr, true); uint ret = InvokeFunc(plugMainAddr, 11, (uint) ptr.ToInt32(), 0); Marshal.FreeCoTaskMem(ptr); return ret; }