private static double GetBytesPerPixel(ImagePixelFormat format) { switch (format) { case ImagePixelFormat.Bgr24: return(3); case ImagePixelFormat.Bgra32: return(4); case ImagePixelFormat.Rgb24: return(3); case ImagePixelFormat.Rgba32: return(4); case ImagePixelFormat.Argb32: return(4); case ImagePixelFormat.Uyvy422: return(2); case ImagePixelFormat.Yuv420: return(1.5); case ImagePixelFormat.Yuv422: return(2); case ImagePixelFormat.Yuv444: return(3); default: return(0); } }
private static int GetBitsPerPixel(ImagePixelFormat format) { switch (format) { case ImagePixelFormat.Bgr24: return(24); case ImagePixelFormat.Bgra32: return(32); case ImagePixelFormat.Rgb24: return(24); case ImagePixelFormat.Rgba32: return(32); case ImagePixelFormat.Argb32: return(32); case ImagePixelFormat.Uyvy422: return(16); case ImagePixelFormat.Yuv420: return(12); case ImagePixelFormat.Yuv422: return(16); case ImagePixelFormat.Yuv444: return(24); default: return(0); } }
public static Array2D <T> LoadImageData <T>(ImagePixelFormat format, byte[] data, uint rows, uint columns, uint steps) where T : struct { if (data == null) { throw new ArgumentNullException(nameof(data)); } if (!Array2D <T> .TryParse <T>(out var type)) { throw new NotSupportedException(); } var srcType = ImageTypes.UInt8.ToNativeArray2DType(); var dstType = type.ToNativeArray2DType(); var pixelType = format.ToImagePixelType(); var ret = NativeMethods.extensions_load_image_data2(dstType, srcType, pixelType, data, rows, columns, steps); if (ret == IntPtr.Zero) { throw new ArgumentException($"Can not import from {ImageTypes.UInt8} to {dstType}."); } return(new Array2D <T>(ret, type)); }
/// <summary> /// Converts this video frame to the <see cref="ImageData"/> with the specified pixel format. /// </summary> /// <param name="scaler">A <see cref="ImageConverter"/> object, used for caching the FFMpeg <see cref="SwsContext"/> when converting many frames of the same video.</param> /// <param name="targetFormat">The output bitmap pixel format.</param> /// <returns>A <see cref="ImageData"/> instance containg converted bitmap data.</returns> public ImageData ToBitmap(ImageConverter scaler, ImagePixelFormat targetFormat) { var bitmap = ImageData.CreatePooled(Layout, targetFormat); scaler.AVFrameToBitmap(this, bitmap); return(bitmap); }
internal NetImage(Size size, Size resolution, ImagePixelFormat pixFormat) { var pf = System.Drawing.Imaging.PixelFormat.Format32bppArgb; // xlator.xlat(pixFormat); 20180108 SPOL: PixelFormat hardcoded for .NET m_Bitmap = new Bitmap(size.Width, size.Height, pf); m_Bitmap.SetResolution(resolution.Width, resolution.Height); }
/// <summary> /// Rents a memory buffer from pool and creates a new instance of <see cref="ImageData"/> class from it. /// </summary> /// <param name="imageSize">The image dimensions.</param> /// <param name="pixelFormat">The bitmap pixel format.</param> /// <returns>The new <see cref="ImageData"/> instance.</returns> public static ImageData CreatePooled(Size imageSize, ImagePixelFormat pixelFormat) { var size = EstimateStride(imageSize.Width, pixelFormat) * imageSize.Height; var pool = MemoryPool <byte> .Shared; var memory = pool.Rent(size); return(new ImageData(memory, imageSize, pixelFormat)); }
private ImageData(IMemoryOwner <byte> memory, Size size, ImagePixelFormat pixelFormat) { span = null; pooledMemory = memory; ImageSize = size; PixelFormat = pixelFormat; }
/// <summary> /// Constructor takes the pixelData byte array, width and height dimensions in pixels and the <see cref="ImagePixelFormat"/>. /// </summary> /// <param name="pixelData">The pixelData byte array contains all bitmap pixels.</param> /// <param name="width">Width in pixels.</param> /// <param name="height">Height in pixels.</param> /// <param name="colorFormat"><see cref="ImagePixelFormat"/> provides additional information about pixel Encoding.</param> public ImageData(byte[] pixelData, int width, int height, ImagePixelFormat colorFormat) { PixelData = pixelData; Width = width; Height = height; PixelFormat = colorFormat; }
/// <summary> /// Constructor initializes a Texture from a pixelData byte buffer, width and height in pixels and <see cref="ImagePixelFormat"/>. /// </summary> /// <param name="pixelData">The raw pixelData byte buffer that makes up the texture.</param> /// <param name="width">Width in pixels.</param> /// <param name="height">Height in pixels.</param> /// <param name="colorFormat">Provides additional information about pixel encoding.</param> /// <param name="generateMipMaps">Defines if mipmaps are created.</param> /// <param name="filterMode">Defines the filter mode <see cref="TextureFilterMode"/>.</param> /// <param name="wrapMode">Defines the wrapping mode <see cref="TextureWrapMode"/>.</param> public Texture(byte[] pixelData, int width, int height, ImagePixelFormat colorFormat, bool generateMipMaps = true, TextureFilterMode filterMode = TextureFilterMode.Linear, TextureWrapMode wrapMode = TextureWrapMode.Repeat) { SessionUniqueIdentifier = Suid.GenerateSuid(); _imageData = new ImageData(pixelData, width, height, colorFormat); DoGenerateMipMaps = generateMipMaps; FilterMode = filterMode; WrapMode = wrapMode; }
/// <summary> /// Creates a new instance of type ImageData. /// </summary> /// <param name="format">The <see cref="ColorFormat"/>.</param> /// <param name="width">Width in px.</param> /// <param name="height">Height in px.</param> public ImageData(ColorFormat format, int width = 2048, int height = 2048) { Width = width; Height = height; PixelFormat = new ImagePixelFormat(format); int byteSize = Width * Height * PixelFormat.BytesPerPixel; PixelData = new byte[byteSize]; }
public ScanLineEnumerator(byte[] pixelData, ImagePixelFormat pixelFormat, int xSrc, int ySrc, int width, int height, int maxWidth) { _pixelData = pixelData; _pixelFormat = pixelFormat; _xSrc = xSrc; _ySrc = ySrc; _width = width; _height = height; _maxWidth = maxWidth; _currentPosition = _ySrc - 1; // decreased by one for initial call of MoveNext }
/// <summary> /// Converts this video frame to the <see cref="ImageData"/> with the specified pixel format. /// </summary> /// <param name="converter">A <see cref="ImageConverter"/> object, used for caching the FFMpeg <see cref="SwsContext"/> when converting many frames of the same video.</param> /// <param name="targetFormat">The output bitmap pixel format.</param> /// /// <param name="targetSize">The output bitmap size.</param> /// <returns>A <see cref="ImageData"/> instance containing converted bitmap data.</returns> public ImageData ToBitmap(ImageConverter converter, ImagePixelFormat targetFormat, Size targetSize) { var bitmap = ImageData.CreatePooled(targetSize, targetFormat); // Rents memory for the output bitmap. fixed(byte *ptr = bitmap.Data) { // Converts the raw video frame using the given size and pixel format and writes it to the ImageData bitmap. converter.AVFrameToBitmap(this, ptr, bitmap.Stride); } return(bitmap); }
/// <summary> /// Creates a new instance of type "WritableTexture". /// </summary> /// <param name="texType">Defines the type of the render texture.</param> /// <param name="colorFormat">The color format of the texture, <see cref="ImagePixelFormat"/></param> /// <param name="width">Width in px.</param> /// <param name="height">Height in px.</param> /// <param name="generateMipMaps">Defines if mipmaps are created.</param> /// <param name="filterMode">Defines the filter mode <see cref="TextureFilterMode"/>.</param> /// <param name="wrapMode">Defines the wrapping mode <see cref="TextureWrapMode"/>.</param> /// <param name="compareMode">The textures compare mode. If uncertain, leaf on NONE, this is only important for depth (shadow) textures (<see cref="TextureCompareMode"/>).</param> /// <param name="compareFunc">The textures compare function. If uncertain, leaf on LEESS, this is only important for depth (shadow) textures and if the CompareMode isn't NONE (<see cref="Compare"/>)</param> public WritableTexture(RenderTargetTextureTypes texType, ImagePixelFormat colorFormat, int width, int height, bool generateMipMaps = true, TextureFilterMode filterMode = TextureFilterMode.Linear, TextureWrapMode wrapMode = TextureWrapMode.Repeat, TextureCompareMode compareMode = TextureCompareMode.None, Compare compareFunc = Compare.Less) { SessionUniqueIdentifier = Suid.GenerateSuid(); PixelFormat = colorFormat; Width = width; Height = height; DoGenerateMipMaps = generateMipMaps; FilterMode = filterMode; WrapMode = wrapMode; TextureType = texType; CompareMode = compareMode; CompareFunc = compareFunc; }
/// <summary> /// Initializes a new instance of the <see cref="ImageData"/> struct using a <see cref="Span{T}"/> as the data source. /// </summary> /// <param name="data">The bitmap data.</param> /// <param name="pixelFormat">The pixel format.</param> /// <param name="imageSize">The image dimensions.</param> /// <exception cref="ArgumentException">When data span size doesn't match size calculated from width, height and the pixel format.</exception> public ImageData(Span <byte> data, ImagePixelFormat pixelFormat, Size imageSize) { var size = EstimateStride(imageSize.Width, pixelFormat) * imageSize.Height; if (data.Length != size) { throw new ArgumentException("Pixel buffer size doesn't match size required by this image format."); } span = data; pooledMemory = null; ImageSize = imageSize; PixelFormat = pixelFormat; }
public static Image ToImage(this Color[,] map, ImagePixelFormat format = ImagePixelFormat.RGBA32) { var H = map.GetLength(0); var W = map.GetLength(1); var result = Image.Of(W, H); for (int h = 0; h < H; h++) { for (int w = 0; w < W; w++) { result.SetPixel(w, h, map[h, w]); } } return(result); }
/// <summary> /// Creates a new instance of type ImageData. /// </summary> /// <param name="width">Width in px.</param> /// <param name="height">Height in px.</param> public ImageData(int width = 2048, int height = 2048) { Width = width; Height = height; PixelFormat = new ImagePixelFormat(ColorFormat.RGBA); int byteSize = Width * Height * PixelFormat.BytesPerPixel; PixelData = new byte[byteSize]; //4k = 67108864 for (int i = 0; i < byteSize; i += PixelFormat.BytesPerPixel) { PixelData[i] = 255; PixelData[i + 1] = 127; PixelData[i + 2] = 127; PixelData[i + 3] = 255; } }
internal static NativeMethods.ImagePixelType ToImagePixelType(this ImagePixelFormat type) { switch (type) { case ImagePixelFormat.Bgr: return(NativeMethods.ImagePixelType.Bgr); case ImagePixelFormat.Bgra: return(NativeMethods.ImagePixelType.Bgra); case ImagePixelFormat.Rgb: return(NativeMethods.ImagePixelType.Rgb); case ImagePixelFormat.Rgba: return(NativeMethods.ImagePixelType.Rgba); default: throw new ArgumentOutOfRangeException(nameof(type), type, null); } }
private static int GetBytesPerPixel(ImagePixelFormat format) { switch (format) { case ImagePixelFormat.Bgr24: return(3); case ImagePixelFormat.Bgra32: return(4); case ImagePixelFormat.Rgb24: return(3); case ImagePixelFormat.Argb32: return(4); default: return(0); } }
internal static System.Drawing.Imaging.PixelFormat xlat(ImagePixelFormat pf) { switch (pf) { case ImagePixelFormat.BPP1Indexed: return(System.Drawing.Imaging.PixelFormat.Format1bppIndexed); case ImagePixelFormat.BPP4Indexed: return(System.Drawing.Imaging.PixelFormat.Format4bppIndexed); case ImagePixelFormat.BPP8Indexed: return(System.Drawing.Imaging.PixelFormat.Format8bppIndexed); case ImagePixelFormat.BPP16Gray: return(System.Drawing.Imaging.PixelFormat.Format16bppGrayScale); case ImagePixelFormat.RGB24: return(System.Drawing.Imaging.PixelFormat.Format24bppRgb); case ImagePixelFormat.RGB32: return(System.Drawing.Imaging.PixelFormat.Format32bppRgb); case ImagePixelFormat.RGBA32: return(System.Drawing.Imaging.PixelFormat.Format32bppArgb); default: return(System.Drawing.Imaging.PixelFormat.Canonical); } }
public static Bitmap GetBitmap(int width, int height, ImagePixelFormat format, byte[] data) { Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb); if (!pixelDecoders.ContainsKey(format)) { throw new NotImplementedException(string.Format("Unimplemented format {0}", format)); } using (BinaryReader reader = new BinaryReader(new MemoryStream(data))) { if (format == ImagePixelFormat.ETC1 || format == ImagePixelFormat.ETC1A4) { throw new NotImplementedException("FIXME: ETC1/ETC1A4 not implemented"); } else { BitmapData bmpData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat); byte[] pixelData = new byte[bmpData.Height * bmpData.Stride]; Marshal.Copy(bmpData.Scan0, pixelData, 0, pixelData.Length); for (int y = 0; y < bitmap.Height; y += 8) { for (int x = 0; x < bitmap.Width; x += 8) { for (int t = 0; t < tileOrder.Length; t++) { pixelDecoders[format](reader, pixelData, (int)(((((tileOrder[t] / 8) + y) * bitmap.Width) + ((tileOrder[t] % 8) + x)) * 4)); } } } Marshal.Copy(pixelData, 0, bmpData.Scan0, pixelData.Length); bitmap.UnlockBits(bmpData); } } return(bitmap); }
/// <summary> /// Creates a new instance of the <see cref="ImageData"/> class using a pointer to the unmanaged memory as the data source. /// </summary> /// <param name="pointer">The byte array containing bitmap data.</param> /// <param name="pixelFormat">The bitmap pixel format.</param> /// <param name="imageSize">The image dimensions.</param> /// <returns>A new <see cref="ImageData"/> instance.</returns> public static ImageData FromPointer(IntPtr pointer, ImagePixelFormat pixelFormat, Size imageSize) { var span = CreateSpan(pointer, imageSize, pixelFormat); return(new ImageData(span, pixelFormat, imageSize)); }
/// <summary>Creates a new image instance of the specified properties</summary> public static Image Of(Size size, Size resolution, ImagePixelFormat format) => new Image(PlatformAbstractionLayer.Graphics.CreateImage(size, resolution, format));
/// <summary> /// Creates a new instance of the <see cref="ImageData"/> class using a byte array as the data source. /// </summary> /// <param name="pixels">The byte array containing bitmap data.</param> /// <param name="pixelFormat">The bitmap pixel format.</param> /// <param name="width">The image width.</param> /// <param name="height">The image height.</param> /// <returns>A new <see cref="ImageData"/> instance.</returns> public static ImageData FromArray(byte[] pixels, ImagePixelFormat pixelFormat, int width, int height) => FromArray(pixels, pixelFormat, new Size(width, height));
/// <summary>Creates a new image instance of the specified properties</summary> public static Image Of(int width, int height, int xDPI, int yDPI, ImagePixelFormat pixFormat) => new Image(PlatformAbstractionLayer.Graphics.CreateImage( new Size(width, height), new Size(xDPI, yDPI), pixFormat));
/// <summary>Creates a new image instance of the specified properties</summary> public static Image Of(Size size, ImagePixelFormat pixFormat) => new Image(PlatformAbstractionLayer.Graphics.CreateImage( size, new Size(DEFAULT_RESOLUTION_PPI, DEFAULT_RESOLUTION_PPI), pixFormat));
/// <summary>Creates a new image instance of the specified properties</summary> public static Image Of(int width, int height, ImagePixelFormat pixFormat) => new Image(PlatformAbstractionLayer.Graphics.CreateImage( new Size(width, height), new Size(DEFAULT_RESOLUTION_PPI, DEFAULT_RESOLUTION_PPI), pixFormat));
/// <summary> /// Creates a new instance of the <see cref="ImageData"/> class using a pointer to the unmanaged memory as the data source. /// </summary> /// <param name="pointer">The byte array containing bitmap data.</param> /// <param name="pixelFormat">The bitmap pixel format.</param> /// <param name="width">The image width.</param> /// <param name="height">The image height.</param> /// <returns>A new <see cref="ImageData"/> instance.</returns> public static ImageData FromPointer(IntPtr pointer, ImagePixelFormat pixelFormat, int width, int height) => FromPointer(pointer, pixelFormat, new Size(width, height));
/// <summary> /// Gets the estimated image line size based on the pixel format and width. /// </summary> /// <param name="width">The image width.</param> /// <param name="format">The image pixel format.</param> /// <returns>The size of a single line of the image measured in bytes.</returns> public static int EstimateStride(int width, ImagePixelFormat format) => (int)(GetBytesPerPixel(format) * width);
/// <summary> /// Initializes a new instance of the <see cref="ImageData"/> struct using a <see cref="Span{T}"/> as the data source. /// </summary> /// <param name="data">The bitmap data.</param> /// <param name="pixelFormat">The pixel format.</param> /// <param name="width">The image width.</param> /// <param name="height">The image height.</param> /// <exception cref="ArgumentException">When data span size doesn't match size calculated from width, height and the pixel format.</exception> public ImageData(Span <byte> data, ImagePixelFormat pixelFormat, int width, int height) : this(data, pixelFormat, new Size(width, height)) { }
private static unsafe Span <byte> CreateSpan(IntPtr pointer, Size imageSize, ImagePixelFormat pixelFormat) { var size = EstimateStride(imageSize.Width, pixelFormat) * imageSize.Height; return(new Span <byte>((void *)pointer, size)); }