private IEnumerable <Bitmap> ReadRowChunk(PngReader reader, int chunkIndex) { if (!reader.ImgInfo.Indexed) { throw new ArgumentException("Only indexed color PNGs are supported."); } var lines = new byte[32][]; var pal = reader.GetMetadata().GetPLTE(); for (var i = 0; i < 32; i++) { lines[i] = reader.ReadRowByte( new byte[reader.ImgInfo.Cols], (chunkIndex * 32) + i); } var bitmapsPerRow = reader.ImgInfo.Cols / 32; for (var i = 0; i < bitmapsPerRow; i++) { var bmp = ReadBitmap(i, lines, pal); this.tileCache.GetOrAddBitmap(bmp); yield return(bmp); } }
private static void additionalTestInterlaced(string orig, string origni) { // tests also read/write in packed format PngReader pngr = FileHelper.CreatePngReader(orig); string copy = TestsHelper.addSuffixToName(orig, "_icopy"); pngr.SetUnpackedMode(false); PngWriter pngw = FileHelper.CreatePngWriter(copy, pngr.ImgInfo, true); pngw.CopyChunksFirst(pngr, ChunkCopyBehaviour.COPY_ALL); pngw.SetUseUnPackedMode(false); Random random = new Random(); bool useByte = random.NextDouble() > 0.5 && pngr.ImgInfo.BitDepth < 16; for (int row = 0; row < pngr.ImgInfo.Rows; row++) { if (useByte) { ImageLine line = pngr.ReadRowByte(row); pngw.WriteRow(line, row); } else { ImageLine line = pngr.ReadRowInt(row); pngw.WriteRow(line, row); } } pngr.End(); pngw.End(); TestsHelper.testEqual(copy, origni); System.IO.File.Delete(copy); }
/// <summary> /// Saves the PNGFile to disk. /// </summary> /// <param name="path">Output path for the PNGFile.</param> public void SaveAs(string path) { PngReader reader = FileHelper.CreatePngReader(originalFile); PngWriter writer = FileHelper.CreatePngWriter(path, reader.ImgInfo, true); writer.CopyChunksFirst(reader, ChunkCopyBehaviour.COPY_ALL_SAFE); for (var x = 0; x < reader.ImgInfo.Rows; x++) { ImageLine line = reader.ReadRowByte(x); for (var y = 0; y < line.ScanlineB.Length; y += reader.ImgInfo.BytesPixel) { line.ScanlineB[y] = lines[x][y / reader.ImgInfo.BytesPixel].Red; line.ScanlineB[y + 1] = lines[x][(y + 1) / reader.ImgInfo.BytesPixel].Green; line.ScanlineB[y + 2] = lines[x][(y + 2) / reader.ImgInfo.BytesPixel].Blue; if (reader.ImgInfo.Alpha) { line.ScanlineB[y + 3] = lines[x][(y + 3) / reader.ImgInfo.BytesPixel].Alpha; } } writer.WriteRow(line, x); } writer.CopyChunksLast(reader, ChunkCopyBehaviour.COPY_ALL_SAFE); writer.End(); reader.End(); }
private void LoadRGBAImage(PngReader source) { byte[] buffer = null; for (int dataY = 0; dataY < pixelHeight; dataY++) { buffer = source.ReadRowByte(buffer, dataY); for (int dataX = 0, bufX = 0; bufX < buffer.Length;) { imgData[dataY, dataX++] = buffer[bufX++]; imgData[dataY, dataX++] = buffer[bufX++]; imgData[dataY, dataX++] = buffer[bufX++]; imgData[dataY, dataX++] = buffer[bufX++]; } } }
public void Decode(ExtendedImage image, Stream stream) { using (MemoryStream ms = new MemoryStream()) { PngReader reader = new PngReader(stream); for (int row = 0; row < reader.ImgInfo.Rows; row++) { ImageLine line = reader.ReadRowByte(row); //int[] scline1 = line.Scanline; byte[] buffers = line.ScanlineB; ms.Write(buffers, 0, buffers.Length); } ms.Flush(); image.SetPixels(ms.ToArray()); image.PixelHeight = reader.ImgInfo.Rows; image.PixelWidth = reader.ImgInfo.Cols; image.DensityXInt32 = image.DensityYInt32 = 96; } }
bool ReadImage(PngReader _png) { /* * ImageLine line = pngr.ReadRowInt( y ); * int[] scanline = line.Scanline; * * string l = ""; * for( int x=0; x<scanline.Length; x++ ) * { * int ci = scanline[ x ]; * l += ci.ToString() + ","; * } * * Debug.Log ("line " + y + ": " + l ); */ int x, y; for (y = 0; y < m_height; y++) { ImageLine line = _png.ReadRowByte(y); //byte[] lineBytes = _png.ReadRowByte( y ); byte[] lineBytes = line.ScanlineB; // GetScanlineInt(); for (x = 0; x < m_width; x++) { byte src_c = lineBytes[x]; byte remapped_c = src_c; if (m_config.m_colorRemapSourceToDest.ContainsKey((int)src_c)) { remapped_c = (byte)m_config.m_colorRemapSourceToDest[src_c]; } m_colorUsed[remapped_c] = true; int dst_i = (y * m_width) + x; m_image[dst_i] = remapped_c; } } return(true); }
public Texture(string filename, bool multiplyAlpha = false) { using (FileStream stream = File.OpenRead(filename)) { PngReader reader = new PngReader(stream); byte[] data = new byte[reader.ImgInfo.Rows * reader.ImgInfo.Cols * 4]; int widx = 0; for (int row = 0; row < reader.ImgInfo.Rows; row++) { ImageLine line = reader.ReadRowByte(row); int idx = 0; for (int col = 0; col < reader.ImgInfo.Cols; col++) { byte R = line.ScanlineB[idx++]; byte G = line.ScanlineB[idx++]; byte B = line.ScanlineB[idx++]; byte A = line.ScanlineB[idx++]; if (multiplyAlpha) { float alpha = A / 255.0f; R = (byte)Math.Round(R * alpha); G = (byte)Math.Round(G * alpha); B = (byte)Math.Round(B * alpha); } data[widx++] = R; data[widx++] = G; data[widx++] = B; data[widx++] = A; } } m_Id = GL.GenTexture(); GL.BindTexture(TextureTarget.Texture2D, m_Id); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear); GL.TexImage2D <byte>(TextureTarget2d.Texture2D, 0, TextureComponentCount.Rgba, reader.ImgInfo.Cols, reader.ImgInfo.Rows, 0, PixelFormat.Rgba, PixelType.UnsignedByte, data); GL.BindTexture(TextureTarget.Texture2D, 0); } }
static void Test1() { using (System.IO.FileStream fs = new System.IO.FileStream("d:\\WImageTest\\a01_4_1.png", System.IO.FileMode.Open)) { PngReader reader1 = new PngReader(fs); var imgInfo = reader1.ImgInfo; int j = imgInfo.Rows; using (System.Drawing.Bitmap newBMP = new System.Drawing.Bitmap(imgInfo.Cols, imgInfo.Rows, System.Drawing.Imaging.PixelFormat.Format32bppArgb)) { System.Drawing.Imaging.BitmapData data = newBMP.LockBits( new System.Drawing.Rectangle(0, 0, imgInfo.Cols, imgInfo.Rows), System.Drawing.Imaging.ImageLockMode.ReadWrite, newBMP.PixelFormat); byte[] buffer = new byte[imgInfo.Cols * 4 * imgInfo.Rows]; int rowLen = data.Stride; int targetpos = 0; for (int i = 0; i < j; ++i) { ImageLine imgline = reader1.ReadRowByte(i); byte[] scanlineBytes = imgline.ScanlineB; //copy System.Buffer.BlockCopy( scanlineBytes, 0, buffer, targetpos, scanlineBytes.Length); targetpos += rowLen; } System.Runtime.InteropServices.Marshal.Copy( buffer, 0, data.Scan0, buffer.Length); newBMP.UnlockBits(data); newBMP.Save("d:\\WImageTest\\pngcs1.png"); } } }
private unsafe void ReadPng(Stream bitmapStream, BitmapCreateOptions createOptions, BitmapCacheOption cacheOption) { var pngr = new PngReader(bitmapStream); if (pngr.ImgInfo.Channels > 4 || pngr.ImgInfo.Channels < 3 || pngr.ImgInfo.BitDepth != 8) { throw new NotSupportedException("PNG must be RGB8/RGBA8"); } var channels = pngr.ImgInfo.Channels; var data = new byte[pngr.ImgInfo.Cols * pngr.ImgInfo.Rows * channels]; var alpha = (channels == 4); if (alpha) { fixed(byte *dataStart = &data[0]) { var d = dataStart; for (var i = 0; i < pngr.ImgInfo.Rows; i++) { var line = pngr.ReadRowByte(i); for (var j = 0; j < pngr.ImgInfo.Cols; j++) { var j2 = j * channels; * d++ = line.ScanlineB[j2 + 2]; * d++ = line.ScanlineB[j2 + 1]; * d++ = line.ScanlineB[j2]; * d++ = line.ScanlineB[j2 + 3]; } } Source = BitmapSource.Create(pngr.ImgInfo.Cols, pngr.ImgInfo.Rows, 100, 100, PixelFormats.Bgra32, null, (IntPtr)dataStart, pngr.ImgInfo.Cols * pngr.ImgInfo.Rows * channels, pngr.ImgInfo.Cols * channels); } //for (int i = 0; i < pngr.ImgInfo.Rows; i++) //{ // var i1 = i * pngr.ImgInfo.Cols * channels; // ImageLine line = pngr.ReadRowInt(i); // for (int j = 0; j < pngr.ImgInfo.Cols; j++) // { // var j1 = i1 + j * channels; // var j2 = j * channels; // data[j1+2] = (byte)line.Scanline[j2++]; // data[j1 + 1] = (byte)line.Scanline[j2++]; // data[j1] = (byte)line.Scanline[j2++]; // data[j1 + 3] = (byte)line.Scanline[j2]; // } //} //Source = BitmapSource.Create(pngr.ImgInfo.Cols, pngr.ImgInfo.Rows, 100, 100, PixelFormats.Bgra32, null, data, pngr.ImgInfo.Cols * channels); //Source = BitmapSource.Create(pngr.ImgInfo.Cols, pngr.ImgInfo.Rows, 100, 100, PixelFormats.Bgra32, null, data, stride); } else { fixed(byte *dataStart = &data[0]) { var d = dataStart; for (var i = 0; i < pngr.ImgInfo.Rows; i++) { var line = pngr.ReadRowInt(i); for (var j = 0; j < pngr.ImgInfo.Cols; j++) { var j2 = j * channels; * d++ = (byte)line.Scanline[j2 + 2]; * d++ = (byte)line.Scanline[j2 + 1]; * d++ = (byte)line.Scanline[j2]; } } Source = BitmapSource.Create(pngr.ImgInfo.Cols, pngr.ImgInfo.Rows, 100, 100, PixelFormats.Bgr24, null, data, pngr.ImgInfo.Cols * channels); } } pngr.End(); //double dpi = 96; //int width = 128; //int height = 128; //byte[] pixelData = new byte[width * height]; //for (int y = 0; y < height; ++y) //{ // int yIndex = y * width; // for (int x = 0; x < width; ++x) // { // pixelData[x + yIndex] = (byte)(x + y); // } //} //Source = BitmapSource.Create(width, height, dpi, dpi, // PixelFormats.Gray8, null, pixelData, width); //Source = source; Source.Freeze(); }
public sprite_params setup(PngReader _png_reader, bool _apply_palette, bool _crop_image, int _palette_slot) { sprite_params spr_params = new sprite_params(this); if (_png_reader == null) { return(spr_params); } int img_width = _png_reader.ImgInfo.Cols; int img_height = _png_reader.ImgInfo.Rows; List <byte[]> lines_arr = new List <byte[]>(img_height); int i; int j; int min_x = 0; int max_x = img_width - 1; int min_y = 0; int max_y = img_height - 1; byte[] pixels_line = null; PngChunkPLTE plte = _png_reader.GetMetadata().GetPLTE(); PngChunkTRNS trns = _png_reader.GetMetadata().GetTRNS(); ImageLine line = null; int alpha_ind = -1; int num_colors = plte.GetNentries(); // detect useful image borders { if (trns != null) { int size; alpha_ind = trns.GetPalletteAlpha().Length - 1; if (_crop_image) { min_x = img_width + 1; max_x = -1; min_y = img_height + 1; max_y = -1; } bool transp_line = false; for (i = 0; i < img_height; i++) { line = _png_reader.ReadRowByte(i); if (line.ImgInfo.Packed) { line = line.unpackToNewImageLine(); } pixels_line = new byte[img_width]; Array.Copy(line.GetScanlineByte(), pixels_line, img_width); lines_arr.Add(pixels_line); size = pixels_line.Length; transp_line = true; for (j = 0; j < size; j++) { // if pixel is not transparent if (_crop_image && (pixels_line[j] != alpha_ind)) { if (min_x > j) { min_x = j; } if (max_x < j) { max_x = j; } transp_line = false; } } // if line is not transparent if (_crop_image && !transp_line) { if (min_y > i) { min_y = i; } if (max_y < i) { max_y = i; } } } } // find nearest colors if (_apply_palette) { #if DEF_FIXED_LEN_PALETTE16_ARR palettes_array plt_arr = palettes_array.Instance; plt_arr.palette_index = _palette_slot; #endif for (i = 0; i < num_colors; i++) { #if DEF_FIXED_LEN_PALETTE16_ARR plt_arr.update_color(_palette_slot, i, utils.find_nearest_color_ind(plte.GetEntry((trns != null) ? (i + alpha_ind) % num_colors:i))); #else palette_group.Instance.get_palettes_arr()[i / utils.CONST_NUM_SMALL_PALETTES].get_color_inds()[i % utils.CONST_NUM_SMALL_PALETTES] = utils.find_nearest_color_ind(plte.GetEntry((trns != null) ? (i + alpha_ind) % num_colors:i)); #endif } #if DEF_FIXED_LEN_PALETTE16_ARR plt_arr.update_palette(); #else for (i = 0; i < utils.CONST_NUM_SMALL_PALETTES; i++) { palette_group.Instance.get_palettes_arr()[i].update(); } #endif #if DEF_NES palette_group.Instance.active_palette = 0; #endif } // fill the lines_arr if sprite has no transparency if (lines_arr.Count == 0) { for (i = 0; i < img_height; i++) { line = _png_reader.ReadRowByte(i); if (line.ImgInfo.Packed) { line = line.unpackToNewImageLine(); } pixels_line = new byte[img_width]; Array.Copy(line.GetScanlineByte(), pixels_line, img_width); lines_arr.Add(pixels_line); } } } return(cut_CHRs(spr_params, min_x, max_x, min_y, max_y, lines_arr, (trns != null), alpha_ind, num_colors, _crop_image, _palette_slot)); }
/// <summary> Reads samples using given reader </summary> static void ReadSamples(PngReader reader, ReadColorsResult results) { var info = reader.ImgInfo; int channels = info.Channels; int bitDepth = info.BitDepth; int numCols = results.width; int numRows = results.height; Color[] pixels = results.pixels; float max = GetBitDepthMaxValue(bitDepth); if (!info.Indexed) { if (!info.Packed) { for (int row = 0; row < numRows; row++) { ImageLine imageLine = reader.ReadRow(row); ProcessNByteRow(imageLine, pixels); } } else { if (bitDepth == 4) { for (int row = 0; row < numRows; row++) { ImageLine imageLine = reader.ReadRowByte(row); Process4BitRow(imageLine, pixels); } } else if (bitDepth == 2) { throw new System.Exception($"bit depth {bitDepth} for {channels} channels not implemented\n"); } else if (bitDepth == 1) { for (int row = 0; row < numRows; row++) { ImageLine imageLine = reader.ReadRowByte(row); Process1BitRow(imageLine, pixels); } } else { throw new System.Exception($"bit depth {bitDepth} for {channels} channels not implemented\n"); } } } else { var plte = reader.GetMetadata().GetPLTE(); if (bitDepth == 8) { if (info.Alpha) { var trns = reader.GetMetadata().GetTRNS(); // transparency metadata, can be null for (int row = 0; row < numRows; row++) { ImageLine imageLine = reader.ReadRow(row); Process8BitIndexedRow(imageLine, plte, trns, pixels); } } else { for (int row = 0; row < numRows; row++) { ImageLine imageLine = reader.ReadRow(row); Process8BitIndexedRow(imageLine, plte, pixels); } } } else if (bitDepth == 4) { for (int row = 0; row < numRows; row++) { ImageLine imageLine = reader.ReadRow(row); Process4BitIndexedRow(imageLine, plte, pixels); } } else { throw new System.Exception($"bit depth {bitDepth} for {channels} channels not implemented\n"); } } }