public void LoadFromP8PNG(Stream stream) { PngReader reader = new PngReader(stream); if (!validatePNG(reader.ImgInfo)) { throw new BadImageFormatException("Bad Cart"); } int offset = 0; for (int row = 0; row < reader.ImgInfo.Rows && offset < CART_SIZE; row++) { ImageLine line = reader.ReadRowInt(row); for (int col = 0; col < line.ImgInfo.Cols && offset < CART_SIZE; col++) { rom[offset] = decodeBytes(line.Scanline, col * 4); offset += 1; } } Version = rom[0x8000]; Build = (rom[0x8001] << 24) + (rom[0x8002] << 16) + (rom[0x8003] << 8) + rom[0x8004]; /* * Debug.Log(rom[0]); * Debug.Log(rom[1]); * Debug.Log(rom[2]); * Debug.Log(rom[3]); */ reader.End(); }
public static void testEqual(String image1, String image2) { PngReader png1 = FileHelper.CreatePngReader(image1); PngHelperInternal.InitCrcForTests(png1); PngReader png2 = FileHelper.CreatePngReader(image2); PngHelperInternal.InitCrcForTests(png2); if (png1.IsInterlaced() != png2.IsInterlaced()) { fatalError("Cannot compare, one is interlaced, the other not:" + png1 + " " + png2, png1, png2); } if (!png1.ImgInfo.Equals(png2.ImgInfo)) { fatalError("Image are of different type", png1, png2); } png1.ReadRow(png1.ImgInfo.Rows - 1); png2.ReadRow(png2.ImgInfo.Rows - 1); png1.End(); png2.End(); long crc1 = PngHelperInternal.GetCrctestVal(png1); long crc2 = PngHelperInternal.GetCrctestVal(png2); if (crc1 != crc2) { fatalError("different crcs " + image1 + "=" + crc1 + " " + image2 + "=" + crc2, png1, png2); } }
/// <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 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); }
public static void addMetadata(String origFilename, Dictionary <string, string> data) { String destFilename = "tmp.png"; PngReader pngr = FileHelper.CreatePngReader(origFilename); // or you can use the constructor PngWriter pngw = FileHelper.CreatePngWriter(destFilename, pngr.ImgInfo, true); // idem //Console.WriteLine(pngr.ToString()); // just information int chunkBehav = ChunkCopyBehaviour.COPY_ALL_SAFE; // tell to copy all 'safe' chunks pngw.CopyChunksFirst(pngr, chunkBehav); // copy some metadata from reader foreach (string key in data.Keys) { PngChunk chunk = pngw.GetMetadata().SetText(key, data[key]); chunk.Priority = true; } int channels = pngr.ImgInfo.Channels; if (channels < 3) { throw new Exception("This example works only with RGB/RGBA images"); } for (int row = 0; row < pngr.ImgInfo.Rows; row++) { ImageLine l1 = pngr.ReadRowInt(row); // format: RGBRGB... or RGBARGBA... pngw.WriteRow(l1, row); } pngw.CopyChunksLast(pngr, chunkBehav); // metadata after the image pixels? can happen pngw.End(); // dont forget this pngr.End(); File.Delete(origFilename); File.Move(destFilename, origFilename); }
public static void testWrite(string src, string target) { // for writing is not necesary to register DummyClass c = new DummyClass(); c.name = "Hernán"; c.age = 45; PngReader pngr = FileHelper.CreatePngReader(src); PngWriter pngw = FileHelper.CreatePngWriter(target, pngr.ImgInfo, true); pngw.CopyChunksFirst(pngr, ChunkCopyBehaviour.COPY_ALL_SAFE); PngChunkSERI mychunk = new PngChunkSERI(pngw.ImgInfo); mychunk.SetObj(c); mychunk.Priority = true; // if we want it to be written as soon as possible pngw.GetChunksList().Queue(mychunk); for (int row = 0; row < pngr.ImgInfo.Rows; row++) { ImageLine l1 = pngr.ReadRow(row); pngw.WriteRow(l1, row); } pngw.CopyChunksLast(pngr, ChunkCopyBehaviour.COPY_ALL); pngr.End(); pngw.End(); Console.Out.WriteLine("Done. Writen : " + target); }
private void btnOpen_Click(object sender, RoutedEventArgs e) { CommonOpenFileDialog openDialog = new CommonOpenFileDialog(); openDialog.ShowPlacesList = true; openDialog.Multiselect = false; openDialog.IsFolderPicker = false; openDialog.AddToMostRecentlyUsedList = true; openDialog.Filters.Add(new CommonFileDialogFilter("PNG images", "*.png")); if (openDialog.ShowDialog(this) == CommonFileDialogResult.Ok) { soureFilePath = openDialog.FileName; // get comment meta using (FileStream fileStream = new FileStream(soureFilePath, FileMode.Open, FileAccess.Read)) { pngReader = new PngReader(fileStream); // 参考自Hjg.Pngcs的SampleCustomChunk项目 // get last line: this forces loading all chunks pngReader.ReadChunksOnly(); tblkComment.Text = pngReader.GetMetadata().GetTxtForKey(Key_SemanticInfo); pngReader.End(); fileStream.Close(); } image.BeginInit(); image.Source = new BitmapImage(new Uri(soureFilePath)); image.EndInit(); } }
public static void doit(String orig) { string copy = TestsHelper.addSuffixToName(orig, "_tc"); PngReader pngr = FileHelper.CreatePngReader(orig); if (!pngr.ImgInfo.Indexed) { throw new Exception("Not indexed image"); } PngChunkPLTE plte = pngr.GetMetadata().GetPLTE(); PngChunkTRNS trns = pngr.GetMetadata().GetTRNS(); // transparency metadata, can be null bool alpha = trns != null; ImageInfo im2 = new ImageInfo(pngr.ImgInfo.Cols, pngr.ImgInfo.Rows, 8, alpha); PngWriter pngw = FileHelper.CreatePngWriter(copy, im2, true); pngw.CopyChunksFirst(pngr, ChunkCopyBehaviour.COPY_ALL_SAFE); int[] buf = null; for (int row = 0; row < pngr.ImgInfo.Rows; row++) { ImageLine line = pngr.ReadRowInt(row); buf = ImageLineHelper.Palette2rgb(line, plte, trns, buf); pngw.WriteRowInt(buf, row); } pngw.CopyChunksLast(pngr, ChunkCopyBehaviour.COPY_ALL_SAFE); pngr.End(); pngw.End(); Console.WriteLine("True color: " + copy); }
public sprite_data load_sprite_png(string _filename, string _name, bool _apply_palette, bool _crop_image, int _palette_slot) { PngReader png_reader = FileHelper.CreatePngReader(_filename); try { if (!png_reader.ImgInfo.Indexed) { throw new Exception(_filename + "\n\nNot indexed image!"); } if (png_reader.IsInterlaced()) { throw new Exception(_filename + "\n\nOnly non interlaced .PNG images are supported!"); } // if( ( png_reader.ImgInfo.Cols & 0x07 ) != 0 || ( png_reader.ImgInfo.Rows & 0x07 ) != 0 ) // { // png_reader.End(); // throw new Exception( _filename + "\n\nThe image size must be a multiple of 8 !" ); // } // if( ( ( png_reader.ImgInfo.Cols >> 3 ) * ( png_reader.ImgInfo.Rows >> 3 ) ) > utils.CONST_CHR_BANK_MAX_SPRITES_CNT ) // { // png_reader.End(); // throw new Exception( _filename + "\n\nThe imported image contains more than " + utils.CONST_CHR_BANK_MAX_SPRITES_CNT + " CHRs!" ); // } #if DEF_NES if (png_reader.GetMetadata().GetPLTE().MinBitDepth() != 2) { throw new Exception(_filename + "\n\nThe PNG image must have a 4 colors palette!"); } #elif DEF_SMS || DEF_PCE int img_bit_depth = png_reader.GetMetadata().GetPLTE().MinBitDepth(); if (img_bit_depth != 4 && img_bit_depth != 2) { throw new Exception(_filename + "\n\nThe PNG image must have a 4 or 2 bpp color depth!"); } if (png_reader.GetMetadata().GetPLTE().GetNentries() > 16) { throw new Exception(_filename + "\n\nThe PNG image must have a 16 or 4 colors palette!"); } #else ... #endif sprite_params spr_params = m_CHR_data_storage.create(png_reader, _apply_palette, _crop_image, _palette_slot); sprite_data spr = new sprite_data(_name); spr.setup(spr_params); spr.update_dimensions(); png_reader.End(); return(spr); }
public static void fatalError(String s, PngReader png1) { try { png1.End(); } catch (Exception) { } throw new PngjException(s); }
static void testmirror(string orig, string origni, string truecolor) { string mirror = TestsHelper.addSuffixToName(orig, "_mirror"); string recov = TestsHelper.addSuffixToName(orig, "_recov"); long crc0 = 0; bool interlaced; bool palete; { PngReader pngr = FileHelper.CreatePngReader(orig); palete = pngr.ImgInfo.Indexed; PngHelperInternal.InitCrcForTests(pngr); pngr.SetUnpackedMode(true); interlaced = pngr.IsInterlaced(); PngWriter pngw = FileHelper.CreatePngWriter(mirror, pngr.ImgInfo, true); pngw.SetFilterType(FilterType.FILTER_CYCLIC); // just to test all filters pngw.CopyChunksFirst(pngr, ChunkCopyBehaviour.COPY_ALL); pngw.SetUseUnPackedMode(true); for (int row = 0; row < pngr.ImgInfo.Rows; row++) { ImageLine line = pngr.ReadRowInt(row); mirrorLine(line); pngw.WriteRow(line, row); } pngr.End(); crc0 = PngHelperInternal.GetCrctestVal(pngr); pngw.CopyChunksFirst(pngr, ChunkCopyBehaviour.COPY_ALL); pngw.End(); } // mirror again, now with BYTE (if depth<16) and loading all rows { PngReader pngr2 = FileHelper.CreatePngReader(mirror); pngr2.SetUnpackedMode(true); PngWriter pngw = FileHelper.CreatePngWriter(recov, pngr2.ImgInfo, true); pngw.SetFilterType(FilterType.FILTER_AGGRESSIVE); pngw.CopyChunksFirst(pngr2, ChunkCopyBehaviour.COPY_ALL); pngw.SetUseUnPackedMode(true); ImageLines lines = pngr2.ImgInfo.BitDepth < 16 ? pngr2.ReadRowsByte() : pngr2 .ReadRowsInt(); for (int row = 0; row < pngr2.ImgInfo.Rows; row++) { ImageLine line = lines.GetImageLineAtMatrixRow(row); mirrorLine(line); pngw.WriteRow(line, row); } pngr2.End(); pngw.End(); } // now check if (orig[11] != 'i') { TestsHelper.testCrcEquals(recov, crc0); } //if (interlaced) // additionalTestInterlaced(orig, origni); //if (palete && System.IO.File.Exists(truecolor)) // additionalTestPalette(orig, truecolor); }
public string getMetadata(string file, string key) { PngReader pngr = FileHelper.CreatePngReader(file); //pngr.MaxTotalBytesRead = 1024 * 1024 * 1024L * 3; // 3Gb! //pngr.ReadSkippingAllRows(); string data = pngr.GetMetadata().GetTxtForKey(key); pngr.End(); return(data);; }
private void btnSave_Click(object sender, RoutedEventArgs e) { CommonSaveFileDialog saveDialog = new CommonSaveFileDialog(); saveDialog.ShowPlacesList = true; saveDialog.AddToMostRecentlyUsedList = true; saveDialog.Filters.Add(new CommonFileDialogFilter("PNG images", "*.png")); saveDialog.DefaultFileName = DateTime.Now.ToString("yyyyMMddhhmmss") + ".png"; if (saveDialog.ShowDialog(this) == CommonFileDialogResult.Ok) { using (FileStream newFileStream = new FileStream(saveDialog.FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite), oldFileStream = new FileStream(soureFilePath, FileMode.Open, FileAccess.Read)) { string semanticInfo = @" sky: blue sky. heart: cloud heart. Meaning: It means love|爱|❤. "; ////// Reference: http://code.google.com/p/pngcs/wiki/Overview // get decoder pngReader = new PngReader(oldFileStream); // create encoder pngWriter = new PngWriter(newFileStream, pngReader.ImgInfo); // copy int chunkBehav = Hjg.Pngcs.Chunks.ChunkCopyBehaviour.COPY_ALL; // tell to copy all 'safe' chunks pngWriter.CopyChunksFirst(pngReader, chunkBehav); // copy some metadata from reader int channels = pngReader.ImgInfo.Channels; if (channels < 3) { throw new Exception("This example works only with RGB/RGBA images"); } for (int row = 0; row < pngReader.ImgInfo.Rows; row++) { ImageLine l1 = pngReader.ReadRow(row); // format: RGBRGB... or RGBARGBA... pngWriter.WriteRow(l1, row); } pngWriter.CopyChunksLast(pngReader, chunkBehav); // metadata after the image pixels? can happen // app info pngWriter.GetMetadata().SetText(Hjg.Pngcs.Chunks.PngChunkTextVar.KEY_Software, "Semantic Image"); // semantic info Hjg.Pngcs.Chunks.PngChunk chunk = pngWriter.GetMetadata().SetText(Key_SemanticInfo, semanticInfo, false, false); chunk.Priority = true; pngWriter.End(); // dont forget this pngReader.End(); oldFileStream.Close(); newFileStream.Close(); } } }
/// <summary> /// Decodes a raw file buffer of PNG data into raw image buffer, with width and height saved. /// </summary> /// <param name="stream">Png bytes.</param> public ImageLines Deserialize(Stream stream) { if (stream is null) { throw new System.ArgumentNullException(nameof(stream)); } using var png = new PngReader(stream); png.SetUnpackedMode(true); var image = png.ReadRowsByte(); png.End(); return(image); }
public static void testCrcEquals(string image1, long crc) { PngReader png1 = FileHelper.CreatePngReader(image1); PngHelperInternal.InitCrcForTests(png1); png1.ReadRow(png1.ImgInfo.Rows - 1); png1.End(); long crc1 = PngHelperInternal.GetCrctestVal(png1); if (crc1 != crc) { fatalError("different crcs", png1); } }
public static Unity3DTileIndex LoadFromPNG(Stream stream) { #if IMAGE_SHARP_PNG //requires extra dependency DLLs which bloat the webgl build using (var png = SixLabors.ImageSharp.Image.Load <Rgba64>(stream)) var index = new Unity3DTileIndex(png.Width, png.Height); { for (int r = 0; r < png.Height; r++) { for (int c = 0; c < png.Width; c++) { var pixel = png[c, r]; index[0, r, c] = pixel.R; index[1, r, c] = pixel.G; index[2, r, c] = pixel.B; } } } return(index); #elif PNGCS_PNG var png = new PngReader(stream); png.SetUnpackedMode(true); var info = png.ImgInfo; if (info.Channels != 3) { throw new Exception("expected 3 channel PNG, got " + info.Channels); } var index = new Unity3DTileIndex(info.Cols, info.Rows); var buf = new int[3 * info.Cols]; for (int r = 0; r < info.Rows; r++) { png.ReadRow(buf, r); for (int c = 0; c < info.Cols; c++) { index[0, r, c] = (uint)buf[3 * c + 0]; index[1, r, c] = (uint)buf[3 * c + 1]; index[2, r, c] = (uint)buf[3 * c + 2]; } } png.End(); return(index); #else return(null); #endif }
private static TRet ReadChunk <TRet, TChunk>(string filePath, string chunkId, Func <TChunk, TRet> valueFunc) where TChunk : PngChunk { PngReader pngr = null; try { pngr = FileHelper.CreatePngReader(filePath); TChunk chunk = (TChunk)pngr.GetChunksList().GetById1(chunkId); return(valueFunc(chunk)); } finally { pngr?.End(); } }
/// <summary>If <paramref name="outFilePath" /> is NULL then file is written in-place.</summary> //public static void WriteZTxtChunk(string inFilePath, string outFilePath, string text) //{ // PngChunk CreateChunk(ImageInfo imgInfo) // { // PngChunkZTXT chunk = new PngChunkZTXT(imgInfo); // chunk.SetKeyVal(data); // chunk.Priority = true; // return chunk; // } // using (var inStream = OpenInputStream(inFilePath, outFilePath == null)) // WriteChunk(inStream, outFilePath ?? inFilePath, CreateChunk); //} private static void WriteChunk(Stream inStream, string outFilePath, Func <ImageInfo, PngChunk> chunkFunc) { PngReader pngr = new PngReader(inStream); PngWriter pngw = FileHelper.CreatePngWriter(outFilePath, pngr.ImgInfo, true); pngw.CopyChunksFirst(pngr, ChunkCopyBehaviour.COPY_ALL); pngw.GetChunksList().Queue(chunkFunc(pngw.ImgInfo)); for (int row = 0; row < pngr.ImgInfo.Rows; row++) { ImageLine l1 = pngr.ReadRow(row); pngw.WriteRow(l1, row); } pngw.CopyChunksLast(pngr, ChunkCopyBehaviour.COPY_ALL); pngr.End(); pngw.End(); }
public static Texture2D FromPng(Stream stream, Texture2D texture = null) { var pngr = new PngReader(stream); var ms = new MemoryStream(); int channels = pngr.ImgInfo.Channels; int w = pngr.ImgInfo.Cols; int h = pngr.ImgInfo.Rows; var bytes = new byte[w * h * channels]; int count = 0; for (int row = 0; row < pngr.ImgInfo.Rows; row++) { ImageLine l1 = pngr.ReadRowInt(row); // Format: RGBRGB... or RGBARGBA... for (int j = 0; j < pngr.ImgInfo.Cols; j++) { byte R = (byte)l1.Scanline[j * channels]; byte G = (byte)l1.Scanline[j * channels + 1]; byte B = (byte)l1.Scanline[j * channels + 2]; byte A = (byte)l1.Scanline[j * channels + 3]; bytes[count++] = B; bytes[count++] = G; bytes[count++] = R; bytes[count++] = A; } } ms.Close(); pngr.End(); if (texture == null) { texture = new Texture2D(GameClass.Graphics, w, h); } texture.SetData(bytes); return(texture); }
public static void SaveToPng(string FileName, string ToFileName, string XamlFileName) { PngReader pngr = FileHelper.CreatePngReader(FileName); PngWriter pngw = FileHelper.CreatePngWriter(ToFileName, pngr.ImgInfo, true); pngw.CopyChunksFirst(pngr, ChunkCopyBehaviour.COPY_ALL_SAFE); PngChunkSKIN mychunk = new PngChunkSKIN(pngw.ImgInfo); mychunk.Content = File.ReadAllText(XamlFileName); mychunk.Priority = true; // if we want it to be written as soon as possible pngw.GetChunksList().Queue(mychunk); for (int row = 0; row < pngr.ImgInfo.Rows; row++) { ImageLine l1 = pngr.ReadRow(row); pngw.WriteRow(l1, row); } pngw.CopyChunksLast(pngr, ChunkCopyBehaviour.COPY_ALL); pngr.End(); pngw.End(); }
public static void testRead(String file) { // register with factory chunk PngChunk.FactoryRegister(PngChunkSERI.ID, typeof(PngChunkSERI)); // read all file PngReader pngr = FileHelper.CreatePngReader(file); pngr.ReadSkippingAllRows(); pngr.End(); // we assume there can be at most one chunk of this type... PngChunk chunk = pngr.GetChunksList().GetById1(PngChunkSERI.ID); // This would work even if not registered, but then PngChunk would be of type PngChunkUNKNOWN Console.Out.WriteLine(chunk); // the following would fail if we had not register the chunk PngChunkSERI chunkprop = (PngChunkSERI)chunk; string name = chunkprop.GetObj().name; int age = chunkprop.GetObj().age; Console.Out.WriteLine("Done. Name: " + name + " age=" + age); }
public static PngInfo GetInfo(Stream stream) { if (stream == null) { throw new ArgumentNullException("stream"); } PngReader pngReader = new PngReader(stream); pngReader.ShouldCloseStream = false; pngReader.End(); PngInfo result = default(PngInfo); result.Width = pngReader.ImgInfo.Cols; result.Height = pngReader.ImgInfo.Rows; if (pngReader.ImgInfo.BitDepth == 8 && pngReader.ImgInfo.Channels == 4) { result.Format = Format.RGBA8; } else if (pngReader.ImgInfo.BitDepth == 8 && pngReader.ImgInfo.Channels == 3) { result.Format = Format.RGB8; } else if (pngReader.ImgInfo.BitDepth == 8 && pngReader.ImgInfo.Channels == 2 && pngReader.ImgInfo.Greyscale) { result.Format = Format.LA8; } else if (pngReader.ImgInfo.BitDepth == 8 && pngReader.ImgInfo.Channels == 1 && pngReader.ImgInfo.Greyscale) { result.Format = Format.L8; } else { if (pngReader.ImgInfo.BitDepth != 8 || pngReader.ImgInfo.Channels != 1 || !pngReader.ImgInfo.Indexed) { throw new InvalidOperationException("Unsupported PNG pixel format."); } result.Format = Format.Indexed; } return(result); }
public static ResourceDictionary LoadFromPng(string FileName) { // read all file PngReader pngr = FileHelper.CreatePngReader(FileName); pngr.ReadSkippingAllRows(); pngr.End(); // we assume there can be at most one chunk of this type... PngChunk chunk = pngr.GetChunksList().GetById1(PngChunkSKIN.ID); // This would work even if not registered, but then PngChunk would be of type PngChunkUNKNOWN if (chunk != null) { // the following would fail if we had not register the chunk PngChunkSKIN chunkprop = (PngChunkSKIN)chunk; ParserContext pc = new ParserContext(); pc.XamlTypeMapper = XamlTypeMapper.DefaultMapper; // pc.XmlSpace //MimeObjectFactory s; var rd1 = (ResourceDictionary)XamlReader.Parse(chunkprop.Content); // Application.Current.Resources.MergedDictionaries.Add(rd1); // var rd2 = (ResourceDictionary)XamlReader.Parse(chunkprop.Content); //// Application.Current.Resources.MergedDictionaries.Add(rd2); // if (rd1 == rd2) { // } return(rd1); } else { return(null); } }
/// <summary> /// Load from file. /// </summary> /// <param name="pngFilePath">Full file path.</param> public PngData(string pngFilePath) { if (!File.Exists(pngFilePath)) { throw new Exception($"Png file '{pngFilePath}' not exists."); } LoadedImageName = Path.GetFileNameWithoutExtension(pngFilePath); PngReader source = FileHelper.CreatePngReader(pngFilePath); pixelWidth = source.ImgInfo.Cols; pixelHeight = source.ImgInfo.Rows; dataWidth = pixelWidth * 4; // auto convert ot argb dataHeight = pixelHeight; Info = new ImageInfo(source.ImgInfo.Cols, source.ImgInfo.Rows, 8, true); imgData = new byte[dataHeight, dataWidth]; //ConsoleEx.WriteDebug($"Load image '{LoadedImageName}'"); if (source.ImgInfo.Channels == 1) { LoadGrayscaleImage(source); } else if (source.ImgInfo.Channels == 3) { LoadNoAlphaImage(source); } else if (source.ImgInfo.Channels == 4) { LoadRGBAImage(source); } else { throw new Exception($"Not support image format (Channels: {source.ImgInfo.Channels.ToString()})."); } source.End(); }
private void WriteSvgToChunk(string tmpOcclusionFilePath, string svg) { using (Stream inStream = ToMemoryStream(tmpOcclusionFilePath)) { PngReader pngr = new PngReader(inStream); PngWriter pngw = FileHelper.CreatePngWriter(tmpOcclusionFilePath, pngr.ImgInfo, true); pngw.CopyChunksFirst(pngr, ChunkCopyBehaviour.COPY_ALL_SAFE); CreateChunk(pngw, svg); for (int row = 0; row < pngr.ImgInfo.Rows; row++) { ImageLine l1 = pngr.ReadRow(row); pngw.WriteRow(l1, row); } pngw.CopyChunksLast(pngr, ChunkCopyBehaviour.COPY_ALL); pngr.End(); pngw.End(); } }
public string GetHeader(string icon) { string ztxt = string.Empty; PngReader pngr = FileHelper.CreatePngReader(FileName); width = pngr.ImgInfo.Cols; height = pngr.ImgInfo.Rows; ChunksList clist = pngr.GetChunksList(); /*The File should only have one zTxt, this chunk stores our DMI information such as * sprite width, height, iconstates, directionals and frames among other things. */ foreach (PngChunkZTXT desc in clist.GetById("zTXt")) { ztxt = desc.GetVal(); break; } pngr.ShouldCloseStream = true; pngr.End(); return(ztxt); }
private static void additionalTestPalette(string orig, string truecolor) { // covnert to true color 8 bits and check equality PngReader pngr = FileHelper.CreatePngReader(orig); PngChunkPLTE plte = pngr.GetMetadata().GetPLTE(); PngChunkTRNS trns = pngr.GetMetadata().GetTRNS(); string copy = TestsHelper.addSuffixToName(orig, "_tccopy"); bool alpha = trns != null; ImageInfo im2 = new ImageInfo(pngr.ImgInfo.Cols, pngr.ImgInfo.Rows, 8, alpha); PngWriter pngw = FileHelper.CreatePngWriter(copy, im2, true); pngw.CopyChunksFirst(pngr, ChunkCopyBehaviour.COPY_ALL_SAFE); int[] buf = null; for (int row = 0; row < pngr.ImgInfo.Rows; row++) { ImageLine line = pngr.ReadRowInt(row); buf = ImageLineHelper.Palette2rgb(line, plte, trns, buf); pngw.WriteRowInt(buf, row); } pngr.End(); pngw.End(); TestsHelper.testEqual(copy, truecolor); System.IO.File.Delete(copy); }
private static void PngWriter(MemoryStream memoryStream, FileStream fileStream, bool modelpng = false) { PngReader pngReader = new PngReader(fileStream); EngineBinaryWriter binaryWriter = new EngineBinaryWriter(memoryStream, false); binaryWriter.Write(false); pngReader.ShouldCloseStream = false; pngReader.ChunkLoadBehaviour = ChunkLoadBehaviour.LOAD_CHUNK_NEVER; pngReader.MaxTotalBytesRead = 9223372036854775807L; ImageLines imageLines = pngReader.ReadRowsByte(); pngReader.End(); Image image = new Image(pngReader.ImgInfo.Cols, pngReader.ImgInfo.Rows); int n = 0; for (int i = 0; i < image.Height; i++) { byte[] array = imageLines.ScanlinesB[i]; int num = 0; for (int j = 0; j < image.Width; j++) { byte r = array[num++]; byte g = array[num++]; byte b = array[num++]; byte a = array[num++]; image.Pixels[n++] = new Color(r, g, b, a); } } List <Image> list = new List <Image>(); if (IsPowerOf2(image.Width) && IsPowerOf2(image.Height)) { list.AddRange(Image.GenerateMipmaps(image, 2147483647)); } else { list.Add(image); modelpng = true; } if (modelpng) { goto IL_00; } binaryWriter.Write(image.Width); binaryWriter.Write(image.Height); binaryWriter.Write(1); for (int i = 0; i < image.Height; i++) { byte[] array = imageLines.ScanlinesB[i]; int num = 0; for (int j = 0; j < image.Width; j++) { byte r = array[num++]; byte g = array[num++]; byte b = array[num++]; byte a = array[num++]; binaryWriter.Write(new Color(r, g, b, a).PackedValue); } } return; IL_00: binaryWriter.Write(list[0].Width); binaryWriter.Write(list[0].Height); binaryWriter.Write(list.Count); foreach (Image current in list) { for (int j = 0; j < current.Pixels.Length; j++) { binaryWriter.Write(current.Pixels[j].PackedValue); } } }
/// <summary> Create Color[] from PNG file </summary> public static ReadColorsResult ReadColors ( string filePath ) { ReadColorsResult results = new ReadColorsResult { pixels = null, width = -1, height = -1, textureFormatInfered = 0 }; PngReader reader = null; try { reader = FileHelper.CreatePngReader(filePath); var info = reader.ImgInfo; results.height = info.Rows; results.width = info.Cols; results.pixels = new Color[results.width * results.height]; int channels = info.Channels; int bitDepth = info.BitDepth; if (info.Indexed) { throw new System.NotImplementedException("indexed png not implemented"); } //select appropriate texture format: results.textureFormatInfered = GetTextureFormat(bitDepth, channels); //create pixel array: for (int row = 0; row < results.height; row++) { ImageLine imageLine = reader.ReadRowInt(row); var scanline = imageLine.Scanline; if (imageLine.SampleType == ImageLine.ESampleType.INT) { for (int col = 0; col < results.width; col++) { var color = new Color(); for (int ch = 0; ch < channels; ch++) { int raw = scanline[col * channels + ch]; float rawMax = GetBitDepthMaxValue(bitDepth); float value = (float)raw / rawMax; // if (ch == 0) { color.r = value; } else if (ch == 1) { color.g = value; } else if (ch == 2) { color.b = value; } else if (ch == 3) { color.a = value; } else { throw new System.Exception($"channel { ch } not implemented"); } } results.pixels[IndexPngToTexture(row, col, results.height, results.width)] = color; } } else { throw new System.Exception($"imageLine.SampleType { imageLine.SampleType } not implemented"); } } } catch (System.Exception ex) { Debug.LogException(ex); if (results.pixels == null) { results.width = 2; results.height = 2; results.pixels = new Color[results.width * results.height]; } if (results.textureFormatInfered == 0) { results.textureFormatInfered = TextureFormat.RGBA32; } } finally { if (reader != null) { reader.End(); } } return(results); }
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(); }