public override ImageData Read(Stream stream, ImageMetaData info)
{
var meta = info as YkgMetaData;
if (null == meta)
{
throw new ArgumentException("YkgFormat.Read should be supplied with YkgMetaData", "info");
}
switch (meta.Format)
{
case YkgImage.Bmp:
using (var bmp = new StreamRegion(stream, meta.DataOffset, meta.DataSize, true))
return(Bmp.Read(bmp, info));
case YkgImage.Png:
using (var png = new StreamRegion(stream, meta.DataOffset, meta.DataSize, true))
return(Png.Read(png, info));
case YkgImage.Gnp:
using (var body = new StreamRegion(stream, meta.DataOffset + 4, meta.DataSize - 4, true))
using (var png = new PrefixStream(PngPrefix, body))
return(Png.Read(png, info));
default:
throw new InvalidFormatException();
}
}
void IUtilityCommand.Run(Utility utility, string[] args)
{
Png png;
using (var pngStream = File.OpenRead(args[1]))
png = new Png(pngStream);
var yaml = MiniYaml.FromFile(Path.ChangeExtension(args[1], "yaml"));
var frameSizeField = yaml.Where(y => y.Key == "FrameSize").Select(y => y.Value.Value).FirstOrDefault();
if (frameSizeField != null)
{
var frameSize = FieldLoader.GetValue<Size>("FrameSize", frameSizeField);
var frameAmountField = yaml.Where(y => y.Key == "FrameAmount").Select(y => y.Value.Value).FirstOrDefault();
if (frameAmountField != null)
{
var frameAmount = FieldLoader.GetValue<int>("FrameAmount", frameAmountField);
if (frameAmount > (png.Width / frameSize.Width) * (png.Height / frameSize.Height))
throw new InvalidDataException(".png file is too small for given FrameSize and FrameAmount.");
}
}
foreach (var node in yaml)
png.EmbeddedData[node.Key] = node.Value.Value;
png.Save(args[1]);
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (YkgMetaData)info;
switch (meta.Format)
{
case YkgImage.Bmp:
using (var reg = new StreamRegion(stream.AsStream, meta.DataOffset, meta.DataSize, true))
using (var bmp = new BinaryStream(reg, stream.Name))
return(Bmp.Read(bmp, info));
case YkgImage.Png:
using (var reg = new StreamRegion(stream.AsStream, meta.DataOffset, meta.DataSize, true))
using (var png = new BinaryStream(reg, stream.Name))
return(Png.Read(png, info));
case YkgImage.Gnp:
using (var body = new StreamRegion(stream.AsStream, meta.DataOffset + 4, meta.DataSize - 4, true))
using (var pre = new PrefixStream(PngPrefix, body))
using (var png = new BinaryStream(pre, stream.Name))
return(Png.Read(png, info));
default:
throw new InvalidFormatException();
}
}
Sprite LoadSprite(string url, int density)
{
var spriteSize = IconSize * density;
var sprite = sheetBuilder.Allocate(new Size(spriteSize, spriteSize), 1f / density);
Action <DownloadDataCompletedEventArgs> onComplete = i =>
{
if (i.Error != null)
{
return;
}
try
{
var icon = new Png(new MemoryStream(i.Result));
if (icon.Width == spriteSize && icon.Height == spriteSize)
{
Game.RunAfterTick(() =>
{
Util.FastCopyIntoSprite(sprite, icon);
sprite.Sheet.CommitBufferedData();
});
}
}
catch { }
};
new Download(url, _ => { }, onComplete);
return(sprite);
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var key = new byte[0x10];
stream.Position = 4;
if (key.Length != stream.Read(key, 0, key.Length))
{
return(null);
}
using (var enc = new InputProxyStream(stream.AsStream, true))
using (var crypto = new InputCryptoStream(enc, new GaxTransform(key)))
using (var input = new BinaryStream(crypto, stream.Name))
{
var info = Png.ReadMetaData(input);
if (null == info)
{
return(null);
}
return(new GaxMetaData
{
OffsetX = info.OffsetX,
OffsetY = info.OffsetY,
Width = info.Width,
Height = info.Height,
BPP = info.BPP,
Key = key,
});
}
}
public void SimpleCheckerboard()
{
var builder = PngBuilder.Create(2, 2, false);
var red = new Pixel(255, 0, 12);
var black = new Pixel(0, 0, 0, 255, false);
builder.SetPixel(new Pixel(255, 0, 12), 0, 0);
builder.SetPixel(255, 0, 12, 1, 1);
using (var memory = new MemoryStream())
{
builder.Save(memory);
memory.Seek(0, SeekOrigin.Begin);
var read = Png.Open(memory);
var left = read.GetPixel(0, 0);
Assert.Equal(red, left);
var right = read.GetPixel(1, 0);
Assert.Equal(black, right);
var bottomLeft = read.GetPixel(0, 1);
Assert.Equal(black, bottomLeft);
var bottomRight = read.GetPixel(1, 1);
Assert.Equal(red, bottomRight);
}
}
} // 'MICO'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x10);
if (!header.AsciiEqual(4, "CG01"))
{
return(null);
}
int length = header.ToInt32(8);
using (var input = new Mg2EncryptedStream(file.AsStream, 0x10, length))
using (var png = new BinaryStream(input, file.Name))
{
var info = Png.ReadMetaData(png);
if (null == info)
{
return(null);
}
return(new Mg2MetaData
{
Width = info.Width,
Height = info.Height,
OffsetX = info.OffsetX,
OffsetY = info.OffsetY,
BPP = info.BPP,
ImageLength = length,
AlphaLength = header.ToInt32(12)
});
}
}
public List <string> GetSameSprite(string fullName)
{
List <string> sameFileList = new List <string>();
if (!allPngs.ContainsKey(fullName))
{
return(sameFileList);
}
Png p = allPngs[fullName];
string[] keys = allPngs.Keys.ToArray();
for (int i = 0; i < keys.Length; i++)
{
string file = keys[i];
if (file.Equals(fullName))
{
continue;
}
Png p2 = allPngs[file];
if (PngUtil.IsSamePng(p, p2))
{
sameFileList.Add(file);
}
}
return(sameFileList);
}
/// <summary>
/// Removes the chosen chunks from an PNG image
/// </summary>
private void ProcessImage(string filename, string suffixForFilename)
{
/* as .NET does some further unnecessary changes to the file when opening it,
* do not use following code for opening images from disk:
* Image image = Image.FromFile(filename);
* pngimage = new Png(image);
*/
try
{
Png pngimage = new Png(filename);
if (checkboxRemoveGamma.Checked)
{
pngimage.RemoveChunk(Png.ChunkType.Gamma);
}
if (checkboxRemoveText.Checked)
{
pngimage.RemoveChunk(Png.ChunkType.IsoText);
pngimage.RemoveChunk(Png.ChunkType.UnicodeText);
pngimage.RemoveChunk(Png.ChunkType.CompressedText);
}
pngimage.Save(filename + suffixForFilename);
}
catch (Exception)
{
MessageBox.Show("The image " + filename + " could not be opened.", "PNG Fix", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public void WhenCreatingAPngFromAMalformedPathThenThrowException()
{
string temporaryPath = Path.GetTempPath();
string invalidFilepath = temporaryPath + "\\Hi.png";
Assert.Throws <FileNotFoundException>(() => Png.Load(invalidFilepath));
}
public void WhenCropingAnPngImageFromFileGiveACorrectCroppedImage()
{
//checking with cat image
string filepath = SaveEmbeddedResourceToFile(PngCatLogicalName);
Image avatarImage = Png.Load(filepath);
Image newImage = avatarImage.CircleCrop(0, 0);
}
public override Image[] Load(string assetName)
{
var stream = FileLoader.GetStream(assetName);
byte[] bytes = null;
var width = 0;
var height = 0;
if (Png.IsPng(stream))
{
stream.Position = 0;
var png = new Png();
var imageOutput = new PngImageOutput();
png.read(stream, imageOutput);
width = png.ihdr.width;
height = png.ihdr.height;
bytes = imageOutput.Bytes;
}
var frame = ContentManager.CreateAssetPart <Image>();
frame.Width = width;
frame.Height = height;
if (null != bytes)
{
frame.ImageContext.SetFrame(bytes);
}
return(new[] { frame });
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
var meta = (RpgmvpMetaData)info;
using (var png = RpgmvDecryptor.DecryptStream(file, meta.Key, true))
return(Png.Read(png, info));
}
} // 'GRPH'
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x1C);
byte key = (byte)(header[4] ^ header[5]);
int data_offset = 0x14;
int x = 0, y = 0;
if (0 != header[0xC])
{
data_offset += header.ToInt32(0x10) / 0x10 * 0x18;
x = header.ToInt32(0x14);
y = header.ToInt32(0x18);
}
using (var input = new StreamRegion(stream.AsStream, data_offset, true))
using (var crypto = new XoredStream(input, key))
using (var png = new BinaryStream(crypto, stream.Name))
{
var info = Png.ReadMetaData(png);
if (null == info)
{
return(null);
}
return(new KgpMetaData
{
Width = info.Width,
Height = info.Height,
OffsetX = x,
OffsetY = y,
BPP = info.BPP,
Key = key,
DataOffset = data_offset,
DataLength = header.ToInt32(8),
});
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x10);
if (!header.AsciiEqual(4, "CG01"))
{
return(null);
}
int length = header.ToInt32(8);
foreach (var scheme in KnownSchemes)
{
using (var input = scheme.CreateStream(file.AsStream, 0x10, length))
using (var png = new BinaryStream(input, file.Name))
{
var info = Png.ReadMetaData(png);
if (null == info)
{
continue;
}
return(new Mg2MetaData
{
Width = info.Width,
Height = info.Height,
OffsetX = info.OffsetX,
OffsetY = info.OffsetY,
BPP = info.BPP,
ImageLength = length,
AlphaLength = header.ToInt32(12),
Scheme = scheme,
});
}
}
return(null);
}
/// <summary>
/// 组合
/// </summary>
static void Composite()
{
Console.WriteLine($"组合{Environment.NewLine}-------------------------------------------");
IFile folder = new Folder("我的文档");
IFile txtFileA = new Txt("新建文本文档A");
IFile pngFileA = new Png("QQ截图A");
IFile folderA = new Folder("新建文件夹A");
if (folder.IsFolder)
{
folder.Add(txtFileA);
folder.Add(pngFileA);
folder.Add(folderA);
}
IFile txtFileB = new Txt("新建文本文档B");
IFile pngFileB = new Png("QQ截图B");
if (folderA.IsFolder)
{
folderA.Add(txtFileB);
folderA.Add(pngFileB);
}
Console.WriteLine(folder.ShowMyself());
Console.ReadKey();
}
public void SimpleCheckerboardWithArbitraryTextData()
{
var builder = PngBuilder.Create(2, 2, false);
builder.SetPixel(new Pixel(255, 0, 12), 0, 0);
builder.SetPixel(255, 0, 12, 1, 1);
builder.StoreText("Title", "Checkerboard");
builder.StoreText("another-data", "bərd that's good and other\r\nstuff");
using (var memory = new MemoryStream())
{
builder.Save(memory);
memory.Seek(0, SeekOrigin.Begin);
var visitor = new MyChunkVisitor();
var read = Png.Open(memory, visitor);
Assert.NotNull(read);
var textChunks = visitor.Visited.Where(x => x.header.Name == "iTXt").ToList();
Assert.Equal(2, textChunks.Count);
}
}
public void FourByFourGrayscale()
{
var values = new List <byte[]>
{
new byte[] { 176, 255, 255, 176 },
new byte[] { 255, 0, 0, 255 },
new byte[] { 133, 255, 255, 133 },
new byte[] { 255, 176, 176, 255 }
};
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "images", "4by4grayscale.png");
using (var stream = File.OpenRead(path))
{
var img = Png.Open(stream);
for (var row = 0; row < values.Count; row++)
{
var expectedRow = values[row];
for (var col = 0; col < expectedRow.Length; col++)
{
var pixel = img.GetPixel(col, row);
Assert.Equal(values[row][col], pixel.R);
Assert.True(pixel.IsGrayscale);
}
}
Assert.Equal(4, img.Width);
Assert.Equal(4, img.Height);
Assert.False(img.HasAlphaChannel);
}
}
void getAllFiles(string path)
{
if (Directory.Exists(path))
{
string[] files = Directory.GetFiles(path, "*.png");
for (int j = 0; j < files.Length; j++)
{
string fullName = files[j].Replace("\\", "/");
allPngFiles.Add(fullName);
if (!allPngs.ContainsKey(fullName))
{
try
{
Png p = new Png(fullName);
allPngs.Add(fullName, p);
}
catch (Exception e)
{
Debug.Log("error on file:" + fullName + "; " + e.Message);
}
}
EditorUtility.DisplayProgressBar("collecting pic info...", "正在收集pic信息..", (float)j / files.Length);
}
string[] directories = Directory.GetDirectories(path);
for (int i = 0; i < directories.Length; i++)
{
getAllFiles(directories[i]);
}
}
}
public bool TryParseSprite(Stream s, out ISpriteFrame[] frames, out TypeDictionary metadata)
{
metadata = null;
frames = null;
if (!Png.Verify(s))
{
return(false);
}
var png = new Png(s);
List <Rectangle> frameRegions;
List <float2> frameOffsets;
// Prefer manual defined regions over auto sliced regions.
if (png.EmbeddedData.Any(meta => meta.Key.StartsWith("Frame[")))
{
RegionsFromFrames(png, out frameRegions, out frameOffsets);
}
else
{
RegionsFromSlices(png, out frameRegions, out frameOffsets);
}
frames = new ISpriteFrame[frameRegions.Count];
for (var i = 0; i < frames.Length; i++)
{
var frameStart = frameRegions[i].X + frameRegions[i].Y * png.Width;
var frameSize = new Size(frameRegions[i].Width, frameRegions[i].Height);
var pixelLength = png.Palette == null ? 4 : 1;
frames[i] = new PngSheetFrame()
{
Size = frameSize,
FrameSize = frameSize,
Offset = frameOffsets[i],
Data = new byte[frameRegions[i].Width * frameRegions[i].Height * pixelLength],
Type = png.Palette == null ? SpriteFrameType.BGRA : SpriteFrameType.Indexed
};
for (var y = 0; y < frames[i].Size.Height; y++)
{
Array.Copy(png.Data, (frameStart + y * png.Width) * pixelLength, frames[i].Data, y * frames[i].Size.Width * pixelLength, frames[i].Size.Width * pixelLength);
}
}
metadata = new TypeDictionary
{
new PngSheetMetadata(png.EmbeddedData),
};
if (png.Palette != null)
{
metadata.Add(new EmbeddedSpritePalette(png.Palette.Select(x => (uint)x.ToArgb()).ToArray()));
}
return(true);
}
public Sprite Add(Png src, float scale = 1f)
{
var rect = Allocate(new Size(src.Width, src.Height), scale);
Util.FastCopyIntoSprite(rect, src);
current.CommitBufferedData();
return(rect);
}
public Sprite Add(Png src)
{
var rect = Allocate(new Size(src.Width, src.Height), TextureChannel.RGBA);
Util.FastCopyIntoSprite(rect, src);
currentSheet2D.CommitBufferedData();
return(rect);
}
/*----------------------Functionality Unit Tests------------------------------------*/
private static void ValidateImagePng(Image img, string embeddedLogicalName)
{
Stream toCompare = typeof(GraphicsUnitTests).GetTypeInfo().Assembly.GetManifestResourceStream(embeddedLogicalName);
Image comparison = Png.Load(toCompare);
Assert.Equal(comparison.HeightInPixels, img.HeightInPixels);
Assert.Equal(comparison.WidthInPixels, img.WidthInPixels);
Assert.Equal(comparison.TrueColor, img.TrueColor);
}
public void WhenCropingAnPngImageFromFileGiveACorrectCroppedImage()
{
//checking with cat image
string filepath = @"C:\Users\t-roblo\Pictures\PerfTestImages\pngcat.png";
Image avatarImage = Png.Load(filepath);
Image newImage = avatarImage.CircleCrop();
Png.WriteToFile(newImage, @"C:\Users\t-roblo\Pictures\pngcatf.png");
}
public FireMaterial()
{
if (Texture == null)
{
var img = Png.Decode("flame.png", File.OpenRead("flame.png"));
img.FlipY();
Texture = new Texture(img, true);
}
}
public static void WhenAddingANegativeFilterToAPngGiveAValidGreyScaledImage()
{
string filepath = SaveEmbeddedResourceToFile(BlackCatLogicalName);
Image img1 = Png.Load(filepath);
img1.ApplyMatrixMultiplier(ImageExtensions.NegativeMatrix);
ValidateImagePng(img1, BlackCatLogicalName);
Png.WriteToFile(img1, Path.GetTempPath() + "NegativeCat.png");
}
public void CallBack(Png png)
{
if (CallBackHandler != null)
{
png.Path = (LsDir.Items[_LastIdx] as Dir).Path;
CallBackHandler(png);
}
Close();
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (KgpMetaData)info;
using (var input = new StreamRegion(stream.AsStream, meta.DataOffset, true))
using (var crypto = new XoredStream(input, meta.Key))
using (var png = new BinaryStream(crypto, stream.Name))
return(Png.Read(png, info));
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (GaxMetaData)info;
using (var enc = new StreamRegion(stream.AsStream, 0x14, true))
using (var crypto = new InputCryptoStream(enc, new GaxTransform(meta.Key)))
using (var input = new BinaryStream(crypto, stream.Name))
return(Png.Read(input, info));
}
public PlayerBadge LoadBadge(MiniYaml yaml)
{
if (sheetBuilder == null)
{
sheetBuilder = new SheetBuilder(SheetType.BGRA, 128);
// We must manually force the buffer creation to avoid a crash
// that is indirectly triggered by rendering from a Sheet that
// has not yet been written to.
sheetBuilder.Current.CreateBuffer();
}
var labelNode = yaml.Nodes.FirstOrDefault(n => n.Key == "Label");
var icon24Node = yaml.Nodes.FirstOrDefault(n => n.Key == "Icon24");
if (labelNode == null || icon24Node == null)
{
return(null);
}
Sprite sprite;
lock (syncObject)
{
if (!spriteCache.TryGetValue(icon24Node.Value.Value, out sprite))
{
sprite = spriteCache[icon24Node.Value.Value] = sheetBuilder.Allocate(new Size(24, 24));
Action <DownloadDataCompletedEventArgs> onComplete = i =>
{
if (i.Error != null)
{
return;
}
try
{
var icon = new Png(new MemoryStream(i.Result));
if (icon.Width == 24 && icon.Height == 24)
{
Game.RunAfterTick(() =>
{
Util.FastCopyIntoSprite(sprite, icon);
sprite.Sheet.CommitBufferedData();
});
}
}
catch { }
};
new Download(icon24Node.Value.Value, _ => { }, onComplete);
}
}
return(new PlayerBadge(labelNode.Value.Value, sprite));
}
public void CanCompressImageUsingPalette()
{
var rawBytes = File.ReadAllBytes(GetImageFile("10by9pixelsrgb8bpp.png"));
var png = Png.Open(rawBytes);
var builder = PngBuilder.FromPng(png);
var compressed = builder.Save(SaveCompressed);
Assert.True(compressed.Length < rawBytes.Length, $"Compressed size {compressed.Length} bytes was not smaller than raw size {rawBytes.Length}.");
}
private void ChangeImgByKey(Png png)
{
LogoAtt logo = _SafeModel.Logo;
if (png != null && logo.Text != png.File)
{
logo.Text = png.File;
logo.SetSpec(LogoAtt.SPEC_LOGO_DIR, png.Path);
logo.LargeIcon = png.LargeImage ?? BeanUtil.NaN24;
logo.SmallIcon = logo.LoadImage(_DataModel.KeyDir, png.Path, png.File, CApp.IMG_KEY_EDIT_EXT, BeanUtil.NaN16);
logo.Modified = true;
}
_SafeModel.Modified |= logo.Modified;
PbLogo.Image = logo.SmallIcon;
}
private void ChangeImgByKey(Png png)
{
if (png != null && _Att.Text != png.File)
{
_Att.Text = png.File;
_Att.SetSpec(LogoAtt.SPEC_LOGO_DIR, png.Path);
_Att.LargeIcon = png.LargeImage ?? BeanUtil.NaN24;
_Att.SmallIcon = _Att.LoadImage(_DataModel.KeyDir, png.Path, png.File, CApp.IMG_KEY_EDIT_EXT, BeanUtil.NaN16);
_Att.Modified = true;
}
PbLogo.Image = _Att.SmallIcon;
}
public void ChangeIcon(Png png)
{
if (!CharUtil.IsValidateHash(png.File))
{
png.File = CPwd.DEF_CAT_IMG;
}
if (!ImageList.Images.ContainsKey(png.File))
{
ImageList.Images.Add(png.File, png.LargeImage);
}
_LastNode.ImageKey = png.File;
_LastNode.SelectedImageKey = png.File;
Cat cat = _LastNode.Tag as Cat;
if (cat == null)
{
return;
}
cat.Icon = png.File;
_DataModel.SaveVcs(cat);
}
public void start(Png png)
{
Bytes = new byte[png.ihdr.width*png.ihdr.height*4];
_stream = new MemoryStream();
}
