public void Decode_32bitTestImages(string path, int w, int h)
{
var d = new PngDecoder();
var pixels = d.Decode(File.ReadAllBytes(path));
Assert.AreEqual(w, pixels.GetLength(0));
Assert.AreEqual(h, pixels.GetLength(1));
Assert.IsNotNull(pixels);
var e = new PngEncoder(new PngEncoderOptions());
var encodedPixels = e.Encode(pixels);
File.WriteAllBytes(Path.ChangeExtension(path, "out.png"), encodedPixels);
}
public void PngCore()
{
using (var memoryStream = new MemoryStream())
{
QuantizerBase <Rgba32> quantizer = this.UseOctreeQuantizer
? (QuantizerBase <Rgba32>)
new OctreeQuantizer <Rgba32>()
: new PaletteQuantizer <Rgba32>();
var options = new PngEncoder()
{
Quantizer = quantizer
};
this.bmpCore.SaveAsPng(memoryStream, options);
}
}
private static string SavePng <TPixel>(TestImageProvider <TPixel> provider, PngColorType pngColorType)
where TPixel : unmanaged, IPixel <TPixel>
{
using (Image <TPixel> sourceImage = provider.GetImage())
{
if (pngColorType != PngColorType.RgbWithAlpha)
{
sourceImage.Mutate(c => c.MakeOpaque());
}
var encoder = new PngEncoder {
ColorType = pngColorType
};
return(provider.Utility.SaveTestOutputFile(sourceImage, "png", encoder));
}
}
public byte[] GetBytesFromPixels(Rgba32[] pixelArray, int height, int width)
{
using (MemoryStream stream = new MemoryStream())
{
using (var image = Image.LoadPixelData(pixelArray, width, height))
{
PngEncoder pngEncoder = new PngEncoder
{
CompressionLevel = 9,
ColorType = PngColorType.RgbWithAlpha
};
image.SaveAsPng(stream, pngEncoder);
return(stream.ToArray());
}
}
}
public IReadOnlyTexture <byte> Serdes(IReadOnlyTexture <byte> existing, AssetInfo info, AssetMapping mapping, ISerializer s, IJsonUtil jsonUtil)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
if (s == null)
{
throw new ArgumentNullException(nameof(s));
}
var paletteId = info.Get(AssetProperty.PaletteId, 0);
var palette = Resolve <IAssetManager>()
.LoadPalette(new PaletteId(AssetType.Palette, paletteId))
.GetUnambiguousPalette();
if (info.AssetId.Type == AssetType.Font)
{
palette = new uint[256];
palette[1] = 0xffffffff;
palette[2] = 0xffcccccc;
palette[3] = 0xffaaaaaa;
palette[4] = 0xff777777;
palette[5] = 0xff555555;
}
if (s.IsWriting())
{
if (existing == null)
{
throw new ArgumentNullException(nameof(existing));
}
var encoder = new PngEncoder();
var bytes = Write(encoder, palette, existing);
s.Bytes(null, bytes, bytes.Length);
return(existing);
}
else // Read
{
var decoder = new PngDecoder();
var configuration = new Configuration();
var bytes = s.Bytes(null, null, (int)s.BytesRemaining);
using var stream = new MemoryStream(bytes);
using var image = decoder.Decode <Rgba32>(configuration, stream);
return(Read(info.AssetId, palette, image, info.Width, info.Height));
}
}
// TODO Move to specfic ImageProcessorService
private static byte[] CompressImage(IFormFile file)
{
using (var stream = file.OpenReadStream())
using (var image = Image.Load(stream))
using (var output = new MemoryStream())
{
IImageEncoder encoder;
#region Content Checking + Compression
if (file.ContentType == "image/jpeg")
{
encoder = new JpegEncoder {
IgnoreMetadata = true, Quality = 60
};
}
else if (file.ContentType == "image/png")
{
encoder = new PngEncoder()
{
IgnoreMetadata = true, CompressionLevel = 5
};
}
else
{
throw new NotSupportedException($"File with content type {file.ContentType} is not supported!");
}
#endregion
#region Resizing
if (image.Width > image.Height && image.Width > 1920)
{
var width = 1920;
var height = (int)(image.Height / (image.Width / 1920.0));
image.Mutate(i => i.Resize(width, height));
}
else if (image.Height > 1080)
{
var height = 1080;
var width = (int)(image.Width / (image.Height / 1080.0));
image.Mutate(i => i.Resize(width, height));
}
#endregion
image.Save(output, encoder);
return(output.ToArray());
}
}
private static void SaveAsPng(string file, IImage image, byte[] newData)
{
var newFile = Path.ChangeExtension(file, ".png");
var encoder = new PngEncoder();
using (var fs = File.Create(newFile))
{
switch (image.Format)
{
case ImageFormat.Rgba32:
IS.Image.LoadPixelData <Bgra32>(newData, image.Width, image.Height).Save(fs, encoder);
break;
case ImageFormat.Rgb24:
IS.Image.LoadPixelData <Bgr24>(newData, image.Width, image.Height).Save(fs, encoder);
break;
case ImageFormat.Rgba16:
IS.Image.LoadPixelData <Bgra4444>(newData, image.Width, image.Height).Save(fs, encoder);
break;
case ImageFormat.R5g5b5:
// Turn the alpha channel on for image sharp.
for (int i = 1; i < newData.Length; i += 2)
{
newData[i] |= 128;
}
IS.Image.LoadPixelData <Bgra5551>(newData, image.Width, image.Height).Save(fs, encoder);
break;
case ImageFormat.R5g5b5a1:
IS.Image.LoadPixelData <Bgra5551>(newData, image.Width, image.Height).Save(fs, encoder);
break;
case ImageFormat.R5g6b5:
IS.Image.LoadPixelData <Bgr565>(newData, image.Width, image.Height).Save(fs, encoder);
break;
case ImageFormat.Rgb8:
IS.Image.LoadPixelData <Gray8>(newData, image.Width, image.Height).Save(fs, encoder);
break;
default:
throw new Exception($"ImageSharp does not recognize image format: {image.Format}");
}
}
}
public async Task SaveAsync_WithNonSeekableStream_IsCancellable()
{
using var image = new Image <Rgba32>(4000, 4000);
var encoder = new PngEncoder()
{
CompressionLevel = PngCompressionLevel.BestCompression
};
using var stream = new MemoryStream();
var asyncStream = new AsyncStreamWrapper(stream, () => false);
var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromTicks(1));
await Assert.ThrowsAnyAsync <TaskCanceledException>(() =>
image.SaveAsync(asyncStream, encoder, cts.Token));
}
/// <summary>
/// Handles the RunWorkerCompleted event of the renderThread control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.ComponentModel.RunWorkerCompletedEventArgs"/> instance containing the event data.</param>
private void renderThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Cancelled || e.Result == null)
{
return;
}
object[] result = (object[])e.Result;
PngEncoder ei = (PngEncoder)result[0];
int width = (int)result[1];
int height = (int)result[2];
Envelope extent = (Envelope)result[3];
OnImageComplete onComplete = (OnImageComplete)result[4];
BitmapImage image = new BitmapImage();
image.SetSource(ei.GetImageStream());
onComplete(image, width, height, extent);
}
public static async Task Run([BlobTrigger("image-blob/{name}", Connection = "AzureWebJobsStorage")] Stream myBlob, string name, [Blob("output-blob/{name}", FileAccess.ReadWrite, Connection = "AzureWebJobsStorage")] CloudBlockBlob outputBlob, ILogger log)
{
log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");
var width = 100;
var height = 200;
var encoder = new PngEncoder();
using (var output = new MemoryStream())
using (Image <Rgba32> image = Image.Load(myBlob))
{
image.Mutate(x => x.Resize(width, height));
image.Save(output, encoder);
output.Position = 0;
await outputBlob.UploadFromStreamAsync(output);
}
}
public static async Task <string> SaveImageIntoBlobContainer(IFormFile file, string reference, int width, int height) //Saves Images
{
var requestOption = new BlobRequestOptions()
{
ParallelOperationThreadCount = 8,
SingleBlobUploadThresholdInBytes = 10 * 1024 * 1024
};
CloudStorageAccount cloudStorage = CloudStorageAccount.Parse(_blobconnectionString);
CloudBlobClient blobClient = cloudStorage.CreateCloudBlobClient();
blobClient.DefaultRequestOptions = requestOption;
CloudBlobContainer blobContainer = blobClient.GetContainerReference("streamworkblobcontainer");
CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(reference);
blockBlob.DeleteIfExists();
var encoder = new PngEncoder();
using (var stream = file.OpenReadStream())
{
using (var output = new MemoryStream())
using (Image image = Image.Load(stream))
{
//int currWidth = image.Width;
//int currHeight = image.Height;
//if ((float)width / height > (float)currWidth / currHeight) // image is too tall relative to its width
//{
// int resizeHeight = (int)((float)currHeight / currWidth * width);
// image.Mutate(i => i.Resize(width, resizeHeight).Crop(new Rectangle(0, Math.Abs(resizeHeight - height) / 2, width - 1, height - 1)));
//}
//else // image is too wide relative to its height, or perfect
//{
// int resizeWidth = (int)((float)currWidth / currHeight * height);
// image.Mutate(i => i.Resize(resizeWidth, height).Crop(new Rectangle(Math.Abs(resizeWidth - width) / 2, 0, width - 1, height - 1)));
//}
image.Save(output, encoder);
output.Position = 0;
await blockBlob.UploadFromStreamAsync(output);
}
return(blockBlob.Uri.AbsoluteUri + "?" + DateTime.Now);
}
}
public byte[] ResizeImage(byte[] imageBytes, int width, int height)
{
using (var image = Image.Load(imageBytes, out IImageFormat imageFormat))
using (var outStream = new MemoryStream())
{
if (width == 0)
{
width = image.Width;
}
if (height == 0)
{
height = image.Height;
}
image.Mutate(x => x
.Resize(new ResizeOptions()
{
Size = new Size(width, height),
Mode = ResizeMode.Pad
})
.BackgroundColor(Rgba32.White));
IImageEncoder encoder = null;
switch (imageFormat.Name)
{
case "PNG":
encoder = new PngEncoder();
break;
case "GIF":
encoder = new GifEncoder();
break;
case "BMP":
encoder = new BmpEncoder();
break;
default:
encoder = new JpegEncoder();
break;
}
image.Save(outStream, encoder);
return(outStream.ToArray());
}
}
public void CompressImagePng(string path, int quality, JpegSubsample jpegSubsample)
{
using (var image = SixLabors.ImageSharp.Image.Load(path))
{
PngEncoder encoder = new PngEncoder();
encoder.CompressionLevel = 8;
//JpegEncoder encoder = new JpegEncoder() { Quality = quality, Subsample = jpegSubsample };
string outputPath = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path) + "_转换后" + Path.GetExtension(path));
int count = 0;
while (File.Exists(outputPath))
{
count++;
outputPath = Path.Combine(Path.GetDirectoryName(outputPath), Path.GetFileNameWithoutExtension(path) + count.ToString() + Path.GetExtension(outputPath));
}
image.Save(outputPath, encoder);
}
}
internal static async Task WriteImageToFileAsync(string fileName, Image <Gray8> image, PngBitDepth bitDepth = PngBitDepth.Bit1)
{
var outputFolder = await GetOutputFolderAsync();
var imageFile = await outputFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
using (var stream = await imageFile.OpenAsync(FileAccessMode.ReadWrite))
{
using (IOutputStream outputStream = stream.GetOutputStreamAt(0))
{
var encoder = new PngEncoder();
encoder.ColorType = PngColorType.Grayscale;
encoder.BitDepth = bitDepth;
image.Save(outputStream.AsStreamForWrite(), encoder);
await outputStream.FlushAsync();
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
int height = 512;
int width = 512;
using var image = new Image <Rgba32>(width, height);
// Renderer.SetLine5(image, 13, 20, 80, 40, Rgba32.Yellow);
// Renderer.SetLine5(image, 20, 13, 40, 80, Rgba32.White);
// Renderer.SetLine5(image, 80, 40, 13, 20, Rgba32.Red);
// Test(image);
RenderObjFile();
// int2 p0 = new int2(10, 70);
// int2 p1 = new int2(50, 160);
// int2 p2 = new int2(70, 80);
// int2 p3 = new int2(180, 50);
// int2 p4 = new int2(150, 1);
// int2 p5 = new int2(70, 180);
// int2 p6 = new int2(180, 150);
// int2 p7 = new int2(120, 160);
// int2 p8 = new int2(130, 180);
// Renderer.Triangle(p0, p1, p2, image, Rgba32.Red);
// Renderer.Triangle(p3, p4, p5, image, Rgba32.White);
// Renderer.Triangle(p6, p7, p8, image, Rgba32.Gold);
// int2[] points = new int2[] {new int2(10, 10), new int2(100, 30), new int2(190, 160)};
// Renderer.Triangle(points, image, Rgba32.Blue);
// SAVE TO DISK
var encoder = new PngEncoder()
{
CompressionLevel = 1,
};
if (!Directory.Exists("output/"))
{
Directory.CreateDirectory("output/");
}
image.Save("output/image.png", encoder);
}
public MemoryStream getAsEncodedStream(string type = null, int quality = 90)
{
MemoryStream imageStream = new MemoryStream();
if (type == null)
{
type = this.type != "" ? this.type : JPEG.MIME;
}
if (type == JPEG.MIME) // Encode as JPEG
{
byte[][,] raster = _bm.ToRaster();
FluxJpeg.Core.Image jpegImage = new FluxJpeg.Core.Image(new ColorModel {
colorspace = ColorSpace.RGB
}, raster);
JpegEncoder jpegEncoder = new JpegEncoder(jpegImage, quality, imageStream);
jpegEncoder.Encode();
if (_img != null)
{
// strip off any headers that might be left by encoder, etc
imageStream = new MemoryStream(((JPEG)_img).stripHeaders(imageStream));
if (_preserveHeaders)
{
imageStream = new MemoryStream(((JPEG)_img).insertHeaders(imageStream));
}
}
}
else if (type == PNG.MIME) // Encode as PNG
{
PngEncoder pngEncoder = new PngEncoder(_bm.Pixels, _bm.PixelWidth, _bm.PixelHeight, false, PngEncoder.FILTER_NONE, Deflater.BEST_COMPRESSION);
byte[] pngBuffer = pngEncoder.pngEncode();
imageStream.Write(pngBuffer, 0, pngBuffer.Length);
}
else
{
Error(this, null);
return(null);
}
return(imageStream);
}
public override IImageEncoder CreateEncoder()
{
if (BitDepth != null ||
ColorType != null ||
CompressionLevel != null ||
Gamma != null ||
Threshold != null ||
QuantizationMethod != null ||
InterlaceMode != null ||
ChunkFilter != null ||
TransparentColorMode != null ||
IgnoreMetadata)
{
var encoder = new PngEncoder
{
BitDepth = (SharpPngBitDepth?)BitDepth,
ColorType = (SharpPngColorType?)ColorType,
Gamma = Gamma,
InterlaceMethod = (SharpPngInterlaceMode?)InterlaceMode,
ChunkFilter = (SharpPngChunkFilter?)ChunkFilter,
Quantizer = ImageSharpUtility.CreateQuantizer(QuantizationMethod),
IgnoreMetadata = IgnoreMetadata
};
if (TransparentColorMode != null)
{
encoder.TransparentColorMode = (SharpPngTransparentColorMode)TransparentColorMode.Value;
}
if (CompressionLevel != null)
{
encoder.CompressionLevel = (SharpPngCompressionLevel)CompressionLevel;
}
if (Threshold != null)
{
encoder.Threshold = Threshold.Value;
}
return(encoder);
}
return(base.CreateEncoder());
}
// 이미지를 팔레트화시킨다.
// 팔레트에는 반드시 검은색과 흰색은 빠지도록 한다.
static string ExecuteQuantize(string sourceFileName, int maxColor = 30)
{
Logger.WriteLine($"Running {nameof(ExecuteQuantize)}");
var targetFileName = AppendToFileName(sourceFileName, "-Q");
var quOpts = new QuantizerOptions {
MaxColors = maxColor
};
//var quantizer = new OctreeQuantizer(quOpts);
var quantizer = new WuQuantizer(quOpts);
var config = Configuration.Default;
var pixelQuantizer = quantizer.CreatePixelSpecificQuantizer <Rgba32>(config);
using (var image = Image.Load <Rgba32>(sourceFileName))
using (var quantizedResult =
pixelQuantizer.BuildPaletteAndQuantizeFrame(image.Frames[0], image.Frames[0].Bounds()))
{
var quantizedPalette = new List <Color>();
foreach (var p in quantizedResult.Palette.Span)
{
var c = new Color(p);
// 팔레트에 흰색과 검은색은 반드시 빠지도록 한다.
if (c != Color.White && c != Color.Black)
{
quantizedPalette.Add(c);
}
}
using (var stream = new FileStream(targetFileName, FileMode.Create))
{
var encoder = new PngEncoder
{
Quantizer = new PaletteQuantizer(quantizedPalette.ToArray()),
ColorType = PngColorType.Palette
};
image.SaveAsPng(stream, encoder);
stream.Close();
}
return(targetFileName);
}
}
public static (bool succsseded, string result) UploadImage(IFormFile file, string path, int maxLength = _maxImageLength, int width = (int)ImageWidth.Medium, int height = (int)ImageHeight.Medium, int compression = (int)ImageComperssion.Normal)
{
if (!IsImageMimeTypeValid(file) || !IsImageExtentionValid(file))
{
return(false, "فرمت عکس صحیح نیست.");
}
if (!IsImageSizeValid(file, maxLength))
{
return(false, $"سایز عکس باید کمتر از {maxLength} باشد");
}
try
{
var image = Image.Load(file.OpenReadStream());
var resizeOptions = new ResizeOptions()
{
Size = new Size(width, height),
Mode = ResizeMode.Crop
};
image.Mutate(x => x.Resize(resizeOptions));
//var encoder = new JpegEncoder()
//{
// Quality = compression
//};
var encoder = new PngEncoder()
{
CompressionLevel = PngCompressionLevel.BestCompression,
};
var fileName = GetRandomFileName(file);
var savePath = Path.GetFullPath(Path.Combine(path, fileName));
//image.Saveasp(savePath, encoder);
image.SaveAsPng(savePath, encoder);
return(true, fileName);
}
catch (Exception e)
{
return(false, e.Message);
}
}
public bool Save(string path, int quality, int compression)
{
renderCam.Render();
Reader.Start();
Reader.WaitForCompletion();
var data = Reader.GetData();
var bytes = new byte[16 * 1024 * 1024];
int length;
var ext = System.IO.Path.GetExtension(path).ToLower();
if (ext == ".png")
{
length = PngEncoder.Encode(data, videoWidth, videoHeight, Reader.BytesPerPixel, compression, bytes);
}
else if (ext == ".jpeg" || ext == ".jpg")
{
length = JpegEncoder.Encode(data, videoWidth, videoHeight, Reader.BytesPerPixel, quality, bytes);
}
else
{
return(false);
}
if (length > 0)
{
try
{
using (var file = System.IO.File.Create(path))
{
file.Write(bytes, 0, length);
}
return(true);
}
catch
{
}
}
return(false);
}
public static void Save(this Image bitmap, IFileSystem fileSystem, UPath path)
{
var extension = path.GetExtensionWithDot();
IImageEncoder format;
switch (extension)
{
case ".png":
format = new PngEncoder();
break;
default:
throw new NotSupportedException();
}
using var fileStream = fileSystem.CreateFile(path);
bitmap.Save(fileStream, format);
}
public void InfersColorTypeAndBitDepth <TPixel>(TestImageProvider <TPixel> provider, PngColorType pngColorType, PngBitDepth pngBitDepth)
where TPixel : struct, IPixel <TPixel>
{
using (Stream stream = new MemoryStream())
{
var encoder = new PngEncoder();
encoder.Encode(provider.GetImage(), stream);
stream.Seek(0, SeekOrigin.Begin);
var decoder = new PngDecoder();
Image image = decoder.Decode(Configuration.Default, stream);
PngMetadata metadata = image.Metadata.GetPngMetadata();
Assert.Equal(pngColorType, metadata.ColorType);
Assert.Equal(pngBitDepth, metadata.BitDepth);
}
}
public Photo Resize(Photo photo, int maxHeight, int maxWidth)
{
Ensure.Any.IsNotNull(photo, nameof(photo));
using (var image = Image.Load(null, photo.Data))
{
if (RequiresResize(image, maxHeight, maxWidth) == false)
{
return(photo);
}
var options = new ResizeOptions
{
Mode = ResizeMode.Max,
Size = new Size(maxWidth, maxHeight)
};
image.Mutate(ctx => ctx.Resize(options));
var stream = new MemoryStream();
IImageEncoder encoder;
if (photo.ContentType == "image/png")
{
encoder = new PngEncoder();
}
else if (photo.ContentType == "image/jpeg")
{
encoder = new JpegEncoder();
}
else
{
throw new NotSupportedException();
}
image.Save(stream, encoder);
stream.Position = 0;
return(new Photo(photo, stream));
}
}
public static IImageEncoder GetEncoder(EncoderTypes encoderType)
{
IImageEncoder encoder;
switch (encoderType)
{
case EncoderTypes.Png:
encoder = new PngEncoder();
break;
case EncoderTypes.Jpeg:
encoder = new JpegEncoder();
break;
default:
throw new ArgumentException($"Encoder '{ encoderType }' not found!");
}
;
return(encoder);
}
/// <summary>
/// Saves the image to a given file in PNG format
/// </summary>
/// <param name="image">Image to save</param>
/// <param name="filePath">File to save to, please include .png in path</param>
public static void SaveImagePng(Image <Rgba32> image, string filePath)
{
var filePathAsPng = filePath;
var fileStream = new FileStream(filePathAsPng, FileMode.Create);
try
{
var encodingOptions = new PngEncoder();
encodingOptions.ColorType = PngColorType.RgbWithAlpha;
image.SaveAsPng(fileStream, encodingOptions);
}
catch (Exception ex)
{
throw;
}
finally
{
fileStream.Close();
}
}
public static MemoryStream ToStream(Image image, string format)
{
var memoryStream = new MemoryStream();
IImageEncoder encoder;
if (format == "jpg" || format == ".jpg")
{
encoder = new JpegEncoder
{
Quality = 75
};
}
else
{
encoder = new PngEncoder();
}
image.Save(memoryStream, encoder);
memoryStream.Seek(0, SeekOrigin.Begin);
return(memoryStream);
}
/// <summary>
/// Converts the image to a stream, which can be assigned to
/// a silverlight image control as image source and applies the specified
/// filter before converting the image. The encoder to use will be created by
/// the file extension name.
/// </summary>
/// <param name="image">The image, which should be converted. Cannot be null
/// (Nothing in Visual Basic).</param>
/// <param name="extension">The file extension to create the <see cref="IImageEncoder"/> that
/// will be used to create an image stream.</param>
/// <returns>The resulting stream.</returns>
/// <exception cref="ArgumentException"><paramref name="extension"/> is empty or
/// contains only blanks.</exception>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="image"/> is null (Nothing in Visual Basic).</para>
/// <para>- or -</para>
/// <para><paramref name="extension"/> is null (Nothing in Visual Basic).</para>
/// </exception>
public static Stream ToStreamByExtension(this ExtendedImage image, string extension)
{
Contract.Requires <ArgumentNullException>(image != null, "Image cannot be null.");
Contract.Requires <ArgumentException>(image.IsFilled, "Image has not been loaded.");
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(extension), "Extension cannot be null or empty.");
IImageEncoder encoder = null;
foreach (IImageEncoder availableEncoder in Encoders.GetAvailableEncoders())
{
if (availableEncoder != null && availableEncoder.IsSupportedFileExtension(extension))
{
encoder = availableEncoder;
break;
}
}
if (encoder == null)
{
encoder = new PngEncoder();
}
MemoryStream memoryStream = null;
try
{
memoryStream = new MemoryStream();
encoder.Encode(image, memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
}
catch
{
if (memoryStream != null)
{
memoryStream.Dispose();
}
throw;
}
return(memoryStream);
}
public bool SaveAsync(string imgFileName, string timeFileName, int quality, int compression)
{
renderCam.Render();
DateTime renderTime = DateTime.Now;
Reader.Start();
Reader.Update(true);
var data = Reader.GetData();
var bytes = new byte[16 * 1024 * 1024];
int length;
var ext = System.IO.Path.GetExtension(imgFileName).ToLower();
if (ext == ".png")
{
length = PngEncoder.Encode(data, videoWidth, videoHeight, Reader.BytesPerPixel, compression, bytes);
}
else if (ext == ".jpeg" || ext == ".jpg")
{
length = JpegEncoder.Encode(data, videoWidth, videoHeight, Reader.BytesPerPixel, quality, bytes);
}
else
{
return(false);
}
if (length > 0)
{
try
{
SaveAsync(bytes, length, imgFileName, timeFileName, renderTime);
return(true);
}
catch
{
}
}
return(false);
}
static void Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Usage: NFTRFontDump [nftr file] [size]");
}
if (!File.Exists(args[0]))
{
Console.WriteLine($"{args[0]} not found.");
Environment.Exit(1);
}
Rgba32 color = Rgba32.FromHex("ff00ff");
try
{
color = Rgba32.FromHex(args[1]);
}
catch
{
}
Stream nftrData = File.OpenRead(args[0]);
var font = NFTR.Read(nftrData);
var dumper = new NFTRDumper(font, color);
using (var file = File.OpenWrite(Path.GetFileNameWithoutExtension(args[0]) + ".xml"))
{
dumper.GetXmlInfo().Save(file);
}
int counter = 0;
var encoder = new PngEncoder();
using (var file = File.OpenWrite($"{args[1]}_font_{counter}.png"))
{
dumper.GetTextureMapping().Save(file, encoder);
}
}
public static byte[] GetXorImageBytesFullColor(this Image <Rgba32> image, IconEntryDescription description, bool asPng = false)
{
int bytesPerPixel = description.BitCount / 8;
if (asPng)
{
PngEncoder encoder = new PngEncoder {
BitDepth = PngBitDepth.Bit8,
ColorType = (description.BitCount == 32 ? PngColorType.RgbWithAlpha : PngColorType.Rgb)
};
using (MemoryStream stream = new MemoryStream())
{
image.SaveAsPng(stream, encoder);
stream.Seek(0, SeekOrigin.Begin);
return(stream.ToArray());
}
}
Console.WriteLine($"bytesPerPixel = {bytesPerPixel}");
int stride = description.Width * bytesPerPixel;
Console.WriteLine($"stride = {stride}");
byte[] xorImageBytes = new byte[description.Height * stride];
for (int r = 0; r < description.Height; r++)
{
int rowOffset = r * stride;
for (int c = 0; c < description.Width; c++)
{
int offset = rowOffset + c * bytesPerPixel;
Rgba32 pixel = image[c, description.Height - 1 - r];
xorImageBytes[offset] = pixel.B;
xorImageBytes[offset + 1] = pixel.G;
xorImageBytes[offset + 2] = pixel.R;
if (bytesPerPixel == 4)
{
xorImageBytes[offset + 3] = pixel.A;
}
}
}
return(xorImageBytes);
}
public static byte[] UploadImage(string displayMode, int x, int y, int h, int w)
{
string path = HttpContext.Current.Server.MapPath("~/AppContent/RenderImages/uploadPlaceholder.png");
using (AtalaImage image = new AtalaImage(856, 500, PixelFormat.Pixel32bppBgra, Color.Transparent))
{
using (AtalaImage uploadImage = new AtalaImage(path))
{
var g = image.GetGraphics();
g.DrawImage(uploadImage.ToBitmap(), new Rectangle(x, y, w, h));
byte[] data = null;
using (MemoryStream m = new MemoryStream())
{
PngEncoder encoder = new PngEncoder();
encoder.Save(m, image, null);
data = m.ToArray();
}
return(data);
}
}
}
//returns an encoder based on image type
public static ImageEncoder GetEncoderFromType( ImageType type )
{
ImageEncoder encoder = null;
switch ( type )
{
case ImageType.Jpeg:
encoder = new JpegEncoder();
break;
case ImageType.Png:
encoder = new PngEncoder();
break;
case ImageType.J2k:
encoder = new Jp2Encoder();
break;
case ImageType.Bmp:
encoder = new BmpEncoder();
break;
case ImageType.Emf:
encoder = new EmfEncoder();
break;
case ImageType.Gif:
encoder = new GifEncoder();
break;
case ImageType.Pcx:
encoder = new PcxEncoder();
break;
case ImageType.Psd:
encoder = new PsdEncoder();
break;
case ImageType.Tga:
encoder = new TgaEncoder();
break;
case ImageType.Tiff:
encoder = new TiffEncoder();
break;
case ImageType.Wbmp:
encoder = new WbmpEncoder();
break;
case ImageType.Wmf:
encoder = new WmfEncoder();
break;
case ImageType.Tla:
encoder = new TlaEncoder();
break;
default:
MessageBox.Show( "当前的图像格式不支持" );
break;
}
return encoder;
}
public WriteableBitmap GetCanvas()
{
int titleLength = title.Length + title.Where(c => c >= 0xFF && c != 0x201C && c != 0x201D).Count();
if (titleLength > 22 && titleLength < 30 ||
titleLength > 44 && titleLength < 50)
textfactor = 0.85f;
var textblock = new TextBlock()
{
Text = title,
TextWrapping = System.Windows.TextWrapping.Wrap,
Foreground = new SolidColorBrush(Color.FromArgb(255, 255, 255, 255)),
Width = (int)(size - 2 * hoffset - 2 * textmargin) * textfactor,
Height = 40,
MaxHeight = 40,
TextAlignment = System.Windows.TextAlignment.Left,
VerticalAlignment = System.Windows.VerticalAlignment.Bottom,
FontSize = 28
};
var b = new Rectangle()
{
Width = size,
Height = (int)(size - 2 * voffset) * 0.43 + voffset,
Fill = new LinearGradientBrush()
{
EndPoint = new System.Windows.Point(0.5, 1),
StartPoint = new System.Windows.Point(0.5, 0),
GradientStops = new GradientStopCollection()
{
new GradientStop() {Offset = 0},
new GradientStop() {Offset = 1, Color= Color.FromArgb(0xFF, 0x00, 0x00, 0x00)}
}
}
};
var image = new Image()
{
Width = size,
Height = size,
Source = ImgSrc,
Stretch = Stretch.UniformToFill
};
WriteableBitmap bm = new WriteableBitmap(size, size);
bm.Render(image, null);
bm.Render(b, new TranslateTransform()
{
X = 0,
Y = size - voffset - b.ActualHeight
});
bm.Render(textblock, new TranslateTransform()
{
X = textmargin, //size - hoffset - textmargin - textblock.ActualWidth,
Y = size - voffset - textmargin - textblock.ActualHeight
});
bm.Invalidate();
#if false
var encoder = new PngEncoder();
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
using (var stream = new IsolatedStorageFileStream("shared/shellcontent/" + filename + ".jpg", FileMode.Create, store))
{
bm.SaveJpeg(stream, 336, 336, 0, 80);
stream.Close();
}
}
#endif
return bm;
}
/// <summary>
/// Determines if the images at the specified paths are equal.
/// </summary>
/// <param name="expected">Path to the expected image.</param>
/// <param name="actual">Path to the actual image.</param>
/// <param name="message">The message.</param>
/// <param name="output">The output difference file.</param>
public static void AreEqual(string expected, string actual, string message, string output)
{
var expectedImage = LoadImage(expected);
var actualImage = LoadImage(actual);
if (expectedImage == null)
{
EnsureFolder(expected);
File.Copy(actual, expected);
Assert.Fail("File not found: {0}", expected);
}
if (expectedImage.GetLength(0) != actualImage.GetLength(0))
{
Assert.Fail("Expected height: {0}\nActual height:{1}\n{2}", expectedImage.GetLength(0), actualImage.GetLength(0), message);
}
if (expectedImage.GetLength(1) != actualImage.GetLength(1))
{
Assert.Fail("Expected width: {0}\nActual width:{1}\n{2}", expectedImage.GetLength(1), actualImage.GetLength(1), message);
}
var w = expectedImage.GetLength(0);
var h = expectedImage.GetLength(1);
var differences = 0;
var differenceImage = new OxyColor[w, h];
for (int i = 0; i < h; i++)
{
for (int j = 0; j < w; j++)
{
if (!expectedImage[j, i].Equals(actualImage[j, i]))
{
differences++;
differenceImage[j, i] = OxyColors.Red;
}
else
{
differenceImage[j, i] = actualImage[j, i].ChangeIntensity(100);
}
}
}
if (differences > 0)
{
if (output != null)
{
for (int i = 0; i < h; i++)
{
for (int j = 0; j < w; j++)
{
if (!expectedImage[j, i].Equals(actualImage[j, i]))
{
}
}
}
EnsureFolder(output);
var encoder = new PngEncoder(new PngEncoderOptions());
File.WriteAllBytes(output, encoder.Encode(differenceImage));
}
Assert.Fail("Pixel differences: {0}\n{1}", differences, message);
}
}
