/// <summary>
///
/// </summary>
/// <param name="ContentType"></param>
public void SetDecoder(string ContentType)
{
IImageDecoder imageDecoder = null;
switch (ContentType)
{
case _Png: // PNG 格式上传会出错，原因未知，所以曲线救国（已经解决）
imageDecoder = new PngDecoder()
{
};
break;
case _Bmp:
imageDecoder = new BmpDecoder();
break;
case _Gif:
imageDecoder = new GifDecoder();
break;
case _Jpg:
imageDecoder = new JpegDecoder();
break;
default: // 前面已经验证过，因此走不到这里，不需要处理
break;
}
ImageDecoder = imageDecoder;
}
public static ImageInfo?FromStream(Stream stream)
{
ImageInfo?info = null;
if (JpgDecoder.Test(stream))
{
info = JpgDecoder.Info(stream);
}
else if (PngDecoder.Test(stream))
{
info = PngDecoder.Info(stream);
}
else if (BmpDecoder.Test(stream))
{
info = BmpDecoder.Info(stream);
}
else if (GifDecoder.Test(stream))
{
info = GifDecoder.Info(stream);
}
else if (PsdDecoder.Test(stream))
{
info = PsdDecoder.Info(stream);
}
else if (TgaDecoder.Test(stream))
{
info = TgaDecoder.Info(stream);
}
return(info);
}
public static void SaveToJpeg(Stream image, string destination)
{
if (image == null)
{
return;
}
image.Position = 0;
var bmpDecoder = new BmpDecoder();
var img = bmpDecoder.Decode(Configuration.Default, image);
if (img == null)
{
return;
}
var width = (int)(img.Width * 0.5D);
var height = (int)(img.Height * 0.5D);
img.Mutate(context => context.Resize(new ResizeOptions
{
Mode = ResizeMode.Max,
Size = new Size(width, height)
}));
using var ms = new MemoryStream();
img.Save(ms, JpegFormat.Instance);
img.Dispose();
File.WriteAllBytes(destination, ms.ToArray());
}
public void Identify_VerifyRatio(string imagePath, int xResolution, int yResolution, PixelResolutionUnit resolutionUnit)
{
var testFile = TestFile.Create(imagePath);
using (var stream = new MemoryStream(testFile.Bytes, false))
{
var decoder = new BmpDecoder();
IImageInfo image = decoder.Identify(Configuration.Default, stream);
ImageMetaData meta = image.MetaData;
Assert.Equal(xResolution, meta.HorizontalResolution);
Assert.Equal(yResolution, meta.VerticalResolution);
Assert.Equal(resolutionUnit, meta.ResolutionUnits);
}
}
public static Image Load(string name, byte[] data)
{
using (var ms = new MemoryStream(data))
using (var simage = new BmpDecoder().Decode <Rgb24>(Configuration.Default, ms)) {
var pixels = new byte[simage.Width * simage.Height * 3];
var span = simage.Frames[0].GetPixelSpan();
var j = 0;
for (var i = 0; i < simage.Width * simage.Height * 3; ++i)
{
var pixel = span[i];
pixels[j++] = pixel.R;
pixels[j++] = pixel.G;
pixels[j++] = pixel.B;
}
return(new Image(ColorMode.Rgb, (simage.Width, simage.Height), pixels, name));
}
}
public static ImageResult FromStream(Stream stream, ColorComponents?requiredComponents = null,
bool use8BitsPerChannel = true)
{
ImageResult result = null;
if (JpgDecoder.Test(stream))
{
result = JpgDecoder.Decode(stream, requiredComponents);
}
else if (PngDecoder.Test(stream))
{
result = PngDecoder.Decode(stream, requiredComponents);
}
else if (BmpDecoder.Test(stream))
{
result = BmpDecoder.Decode(stream, requiredComponents);
}
else if (GifDecoder.Test(stream))
{
result = GifDecoder.Decode(stream, requiredComponents);
}
else if (PsdDecoder.Test(stream))
{
result = PsdDecoder.Decode(stream, requiredComponents);
}
else if (TgaDecoder.Test(stream))
{
result = TgaDecoder.Decode(stream, requiredComponents);
}
if (result == null)
{
Decoder.stbi__err("unknown image type");
}
if (use8BitsPerChannel && result.BitsPerChannel != 8)
{
result.Data = Conversion.stbi__convert_16_to_8(result.Data, result.Width, result.Height,
(int)result.ColorComponents);
}
return(result);
}
public static ImageInfo?FromStream(Stream stream)
{
var info = JpgDecoder.Info(stream);
if (info != null)
{
return(info);
}
info = PngDecoder.Info(stream);
if (info != null)
{
return(info);
}
info = GifDecoder.Info(stream);
if (info != null)
{
return(info);
}
info = BmpDecoder.Info(stream);
if (info != null)
{
return(info);
}
info = PsdDecoder.Info(stream);
if (info != null)
{
return(info);
}
info = TgaDecoder.Info(stream);
if (info != null)
{
return(info);
}
return(null);
}
public async Task <IActionResult> SetAvatarResult <T>(T entity, IFormFile uploadedFile) where T : IIdentifiable <Guid>
{
IImageDecoder decoder;
switch (uploadedFile.ContentType)
{
case "image/png":
decoder = new PngDecoder();
break;
case "image/gif":
decoder = new GifDecoder();
break;
case "image/jpeg":
decoder = new JpegDecoder();
break;
case "image/bmp":
decoder = new BmpDecoder();
break;
default:
return(new BadRequestObjectResult(uploadedFile.ContentType + " is not a supported image type"));
}
// Load settings from config
var section = _configuration.GetSection("Avatars");
bool resize = section.GetValue <bool>("Resize");
int width = section.GetValue <int>("Width");
int height = section.GetValue <int>("Height");
// Memory Buffer to hold resized image
await using var finalImage = new MemoryStream();
try
{
// Load the image from the incoming stream
using Image image = Image.Load(uploadedFile.OpenReadStream(), decoder);
// Resize the image and save as PNG
if (resize)
{
image.Mutate(x => x.Resize(width, height));
}
image.SaveAsPng(finalImage);
}
catch (Exception)
{
return(new BadRequestObjectResult("Unable to read or manipulate image"));
}
// Upload the blob to Azure
var avatar = await GetAvatarBlob(entity);
finalImage.Position = 0;
await avatar.DeleteIfExistsAsync();
await avatar.UploadFromStreamAsync(finalImage);
return(new NoContentResult());
}
public static Image FromFile(string path)
{
var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
var image = new Image();
try {
var format = FileTypeDetector.DetectFileType(stream);
stream.Seek(0, SeekOrigin.Begin);
image.Metadata = new Metadata(path);
stream.Seek(0, SeekOrigin.Begin);
byte[] data;
switch (format)
{
case FileType.Bmp:
data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
image.source = BmpDecoder.FromBytes(data);
break;
case FileType.WebP:
data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
image.source = WebpDecoder.FromBytes(data);
break;
case FileType.QuickTime:
var qtFt = image.Metadata.Directories
.OfType <QuickTimeFileTypeDirectory>()
.FirstOrDefault()
?.GetDescription(1);
if (qtFt != "avif" && qtFt != "avis" && qtFt != "av01")
{
return(null);
}
data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
image.source = AvifDecoder.FromBytes(data);
break;
case FileType.Heif:
data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
image.source = HeifDecoder.FromBytes(data);
break;
case FileType.Jpeg:
case FileType.Tiff:
case FileType.Png:
case FileType.Gif:
case FileType.Ico:
image.source = WpfDecoder.FromStream(stream);
break;
case FileType.Unknown:
if (stream.Length < 4)
{
return(null);
}
var header = new byte[4];
stream.Read(header, 0, 4);
if (FlifDecoder.MagicDetect(header) == DetectResult.Yes)
{
data = new byte[stream.Length];
stream.Seek(0, SeekOrigin.Begin);
stream.Read(data, 0, data.Length);
image.source = FlifDecoder.FromBytes(data);
}
break;
default:
return(null);
}
return(image.source != null ? image : null);
}
catch (Exception e) {
return(null);
}
finally {
stream.Dispose();
}
}
public DibDecoder()
{
decoder = new BmpDecoder();
}
public static Image Load(string name, byte[] data)
{
using (var ms = new MemoryStream(data))
using (var simage = new BmpDecoder().Decode <Rgb24>(Configuration.Default, ms))
return(new Image(ColorMode.Rgb, (simage.Width, simage.Height), simage.Frames[0].SavePixelData(), name));
}
