public virtual bool Save(string path, int quality, int compression)
{
CheckTexture();
RenderCamera();
var readback = AsyncGPUReadback.Request(Distorted ? DistortedTexture : renderTarget.ColorTexture, 0, TextureFormat.RGBA32);
readback.WaitForCompletion();
if (readback.hasError)
{
Debug.Log("Failed to read GPU texture");
return(false);
}
Debug.Assert(readback.done);
var data = readback.GetData <byte>();
var bytes = new byte[16 * 1024 * 1024];
int length;
var ext = System.IO.Path.GetExtension(path).ToLower();
if (ext == ".png")
{
length = PngEncoder.Encode(data, Width, Height, 4, compression, bytes);
}
else if (ext == ".jpeg" || ext == ".jpg")
{
length = JpegEncoder.Encode(data, Width, Height, 4, 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 AmazonS3ImageService(IOptions <ImageServiceOptions> options, IRecurringJobManager recurringJobManager, ApplicationDbContext context, ILogger <AmazonS3ImageService> logger)
{
this.recurringJobManager = recurringJobManager;
this.logger = logger;
this.context = context;
client = new AmazonS3Client(options.Value.S3AwsAccessKeyID, options.Value.S3AwsAccessKey, RegionEndpoint.GetBySystemName(options.Value.S3Region));
bucket = options.Value.S3Bucket;
region = options.Value.S3Region;
encoder = new JpegEncoder()
{
Quality = 90
};
}
public void Setup()
{
var dependencyResolver = new DependencyResolver();
jpegEncoder = (JpegEncoder)dependencyResolver.GetObject <IJpegEncoder>();
downSampler = new DownSampler411();
filePathSource = $"{Environment.CurrentDirectory}\\temp.bmp";
filePathEncodedFile = $"{Environment.CurrentDirectory}\\temp.bmp.pre";
filePathDecodedFile = $"{Environment.CurrentDirectory}\\temp.png.pre.jpg";
TestMethods.CopyFileAndReplaceIfAlreadyExists($"{Environment.CurrentDirectory}\\Images\\TestImage1.bmp", filePathSource);
}
/// <summary>
/// Konvertiert die PDF-Datei in Jpeg-Dateien.
/// Gibt eine liste mit den Pfaden der Jpeg-Dateien zurück.
/// </summary>
public List <string> ConvertPDFToImage(string pathFolder, bool tempPrefix, DocumentParam param)
{
List <string> list = new List <string>();
try
{
if (string.CompareOrdinal(pathFolder, string.Empty) == 0)
{
return(list);
}
FileInfo fileInfo = new FileInfo(param.FilePath);
if (fileInfo.Exists == false)
{
return(list);
}
FilesFunctions.DeleteFilesInFolder(pathFolder, Jpeg);
using (PdfDocument pdfDocument = new PdfDocument(param.FilePath, true))
{
//pdfDocument.RenderingSettings.Resolution = new Resolution(150, 150);
JpegEncoder jpeGencoder = new JpegEncoder
{
Settings = { Quality = param.Quality, SaveAsGrayscale = false }
};
for (int pageCount = 0; pageCount < pdfDocument.Pages.Count; pageCount++)
{
string tempName = FilesFunctions.GetRandomName(pathFolder, fileInfo, tempPrefix, Jpeg);
// get image of PDF page as VintasoftImage object
using (VintasoftImage vsImage = pdfDocument.Pages[pageCount].Render())
{
// save VintasoftImage object as JPEG file
vsImage.Save(tempName, jpeGencoder);
list.Add(tempName);
}
}
}
return(list);
}
catch (Exception ex)
{
FileLogger.FileLogger.Instance.WriteExeption(ex);
return(list);
}
}
public string SaveImg(IFormFile imageDat)
{
using (MemoryStream memoryStream = new MemoryStream())
{
imageDat.CopyTo(memoryStream);
//convertion
using (Image <Rgba32> image = Image.Load(memoryStream.ToArray()))
{
image.Metadata.ExifProfile = null;
double ratio = Convert.ToDouble(image.Width) / image.Height;
if (image.Width >= image.Height && image.Width > _settings.MaxWidth)
{
image.Mutate(x => x
.Resize(_settings.MaxWidth, (int)Math.Round(_settings.MaxWidth / ratio))
);
}
else if (image.Width < image.Height && image.Height > _settings.MaxWidth)
{
image.Mutate(x => x
.Resize((int)Math.Round(_settings.MaxWidth * ratio), _settings.MaxWidth)
);
}
string guid = Guid.NewGuid().ToString();
string newFName = guid + ".jpg";
try
{
if (!Directory.Exists(Path.Join(_environment.WebRootPath, "uploads")))
{
Directory.CreateDirectory(Path.Join(_environment.WebRootPath, "uploads"));
}
JpegEncoder encoder = new JpegEncoder()
{
Quality = 100
};
image.Save(Path.Join(_environment.WebRootPath, "uploads", newFName), encoder);
return(newFName);
}
catch (Exception e)
{
throw e;
}
}
}
}
void Update()
{
if (Bridge == null || Bridge.Status != Ros.Status.Connected)
{
return;
}
Reader.Update();
if (Reader.Status == AsyncTextureReaderStatus.Finished)
{
var data = Reader.GetData();
#if USE_COMPRESSED
var copy = new NativeArray <byte>(data, Allocator.Persistent);
Task.Run(() =>
{
lock (jpegArray)
{
int length = JpegEncoder.Encode(copy, videoWidth, videoHeight, Reader.BytesPerPixel, JpegQuality, jpegArray);
if (length > 0)
{
SendImage(jpegArray, length);
}
}
copy.Dispose();
});
#else
SendImage(data.ToArray(), data.Length);
#endif
}
if (Reader.Status != AsyncTextureReaderStatus.Reading && !ImageIsBeingSent)
{
if (manual)
{
if (Input.GetKeyDown(KeyCode.M))
{
Reader.Start();
}
}
else
{
if (Time.time - lastTimePoint > 1.0f / sendingFPS)
{
lastTimePoint = Time.time;
Reader.Start();
}
}
}
}
public Image ConvertByteArrayToImage(byte[] byteArrayIn)
{
using (MemoryStream ms = new MemoryStream(byteArrayIn))
{
var image = Image.Load(ms);
var encoder = new JpegEncoder()
{
Quality = 40
};
image.Save(ms, encoder);
return(image);
}
}
private static void CreateCacheFileImageFactory(string albumArtPath, string cacheFileName, int maxDimension, int quality)
{
JpegEncoder jpegEncoder = new JpegEncoder {
Quality = quality
};
Size size = new Size(maxDimension, 0);
using (var image = Image.Load(albumArtPath))
{
image.Mutate(x => x.Resize(size));
image.Save(cacheFileName, jpegEncoder);
}
}
void Update()
{
if (Bridge.Status != Ros.Status.Connected)
{
return;
}
Reader.Update();
if (Reader.Status == AsyncTextureReader.ReadStatus.Finished)
{
var data = Reader.GetData();
#if USE_COMPRESSED
Task.Run(() =>
{
lock (jpegArray)
{
int length = JpegEncoder.Encode(data, videoWidth, videoHeight, Reader.BytesPerPixel, 75, jpegArray);
data.Dispose();
if (length > 0)
{
SendImage(jpegArray, length);
}
}
});
#else
SendImage(data.ToArray(), data.Length);
data.Dispose();
#endif
}
if (Reader.Status != AsyncTextureReader.ReadStatus.Reading && !ImageIsBeingSent)
{
if (manual)
{
if (Input.GetKeyDown(KeyCode.S))
{
Reader.Start();
}
}
else
{
if (Time.time - lastTimePoint > 1.0f / sendingFPS)
{
lastTimePoint = Time.time;
Reader.Start();
}
}
}
}
public static bool ResizeAndSaveImage(string filePath, bool isWebUrl, bool overWrite)
{
//C:\YourMediaFilePath\ce8cdcd1-d36e-442b-bda0-837300b095ad.jpg
if (isWebUrl)
{
// convert to file path
filePath = filePath.Replace(FileUrl, FilePath);
filePath = filePath.Replace("\\", "/").Replace("//", "/");
}
// Image<Rgba32> --> var
try
{
FileAttributes attributes = File.GetAttributes(filePath);
if ((attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
attributes &= ~FileAttributes.ReadOnly;
File.SetAttributes(filePath, attributes);
}
using (var image = Image.Load(filePath))
{
image.Mutate(x => x
.Resize(image.Width / 3, image.Height / 3));
var filename = Path.GetFileNameWithoutExtension(filePath);
var extension = Path.GetExtension(filePath);
filename = filename + "_thumb" + extension;
var filenameWithPath = Path.Combine(FilePath, filename);
var encoder = new JpegEncoder()
{
Quality = 70 //Use variable based on your requirements
};
if ((overWrite && File.Exists(filenameWithPath)) || !File.Exists(filenameWithPath))
{
image.Save(filenameWithPath, encoder); // Automatic encoder selected based on extension.
return(true);
}
return(false);
}
}
catch (Exception exception)
{
throw new ApiException(new Error {
Message = "An error occured while resizing and uploading image to server", StackTrace = exception.Message
});
}
}
public async Task <Stream> Compress(Stream stream, int quality = 10)
{
using (Image image = Image.Load(stream))
{
var encoder = new JpegEncoder()
{
Quality = quality,
};
var result = new MemoryStream();
image.SaveAsJpeg(result, encoder);
result.Seek(0, SeekOrigin.Begin);
return(await Task.FromResult(result));
}
}
// 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 async Task <string> EncodeAsync(Func <Task <ThumbnailExtractionResult> > extractFunc)
{
var result = await extractFunc();
File.Delete(ThumbnailPath);
using (var encoder = new JpegEncoder())
using (var fs = File.Create(ThumbnailPath))
{
encoder.SetColorSpace(ColorSpace.Bgra8888);
encoder.SetResolution(result.Size);
await encoder.EncodeAsync(result.RawData, fs);
return(ThumbnailPath);
}
}
/// <summary>
/// Creates a new instance of <see cref="MJpegImageSharpVideoEncoder"/>.
/// </summary>
/// <param name="width">Frame width.</param>
/// <param name="height">Frame height.</param>
/// <param name="quality">
/// Compression quality in the range [1..100].
/// Less values mean less size and lower image quality.
/// </param>
public MJpegImageSharpVideoEncoder(int width, int height, int quality)
{
Argument.IsPositive(width, nameof(width));
Argument.IsPositive(height, nameof(height));
Argument.IsInRange(quality, 1, 100, nameof(quality));
this.width = width;
this.height = height;
#if NET5_0_OR_GREATER
buffer = new MemoryStream(MaxEncodedSize);
#endif
jpegEncoder = new JpegEncoder()
{
Quality = quality
};
}
public void LoadResizeSave <TPixel>(TestImageProvider <TPixel> provider, int quality, JpegSubsample subsample)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> image = provider.GetImage(x => x.Resize(new ResizeOptions {
Size = new Size(150, 100), Mode = ResizeMode.Max
})))
{
image.MetaData.ExifProfile = null; // Reduce the size of the file
JpegEncoder options = new JpegEncoder {
Subsample = subsample, Quality = quality
};
provider.Utility.TestName += $"{subsample}_Q{quality}";
provider.Utility.SaveTestOutputFile(image, "png");
provider.Utility.SaveTestOutputFile(image, "jpg", options);
}
}
public async Task <byte[]> ProcessImage(byte[] imageBytes)
{
using var image = Image.Load(imageBytes);
var resizeOptions = new ResizeOptions {
Size = new Size(1280, 720), Mode = ResizeMode.Min
};
image.Mutate(context => context.Resize(resizeOptions));
var encoder = new JpegEncoder {
Quality = 80
};
await using var stream = new MemoryStream();
await image.SaveAsync(stream, encoder);
return(stream.ToArray());
}
private void SetFileContentsProperties(IFormFile formFile, Photograph photograph)
{
Stream fileStream = formFile.OpenReadStream();
using (var image = Image.Load(fileStream))
{
using (MemoryStream memStream = new MemoryStream())
{
formFile.CopyTo(memStream);
photograph.LargeImage = memStream.ToArray();
}
image.Mutate(x => x.AutoOrient());
if (image.Height > image.Width)
{
photograph.Orientation = PhotoOrientationCodes.Portrait;
var options = new ResizeOptions()
{
Mode = ResizeMode.Crop,
Size = new Size(150, 150)
};
image.Mutate(i => i.Resize(options));
}
else
{
photograph.Orientation = PhotoOrientationCodes.Landscape;
var options = new ResizeOptions()
{
Mode = ResizeMode.Crop,
Size = new Size(300, 150)
};
image.Mutate(i => i.Resize(options));
}
using (MemoryStream resizeMemStream = new MemoryStream())
{
IImageEncoder imageEncoder = new JpegEncoder()
{
Quality = 90,
Subsample = JpegSubsample.Ratio444
};
image.Save(resizeMemStream, imageEncoder);
photograph.SmallImage = resizeMemStream.ToArray();
}
}
}
public async Task <byte[]> ConvertToJpeg(byte[] imageBytes)
{
using (var image = Image.Load(imageBytes))
{
var encoder = new JpegEncoder
{
Quality = 100,
Subsample = JpegSubsample.Ratio444
};
using (var imageStream = new MemoryStream())
{
await image.SaveAsync(imageStream, encoder);
return(imageStream.ToArray());
}
}
}
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());
}
}
private string ConvertToString(WriteableBitmap bitmap)
{
int width = bitmap.PixelWidth;
int height = bitmap.PixelHeight;
int bands = 3;
byte[][,] raster = new byte[bands][, ];
for (int i = 0; i < bands; i++)
{
raster[i] = new byte[width, height];
}
for (int row = 0; row < height; row++)
{
for (int column = 0; column < width; column++)
{
int pixel = bitmap.Pixels[width * row + column];
raster[0][column, row] = (byte)(pixel >> 16);
raster[1][column, row] = (byte)(pixel >> 8);
raster[2][column, row] = (byte)pixel;
}
}
ColorModel model = new ColorModel {
colorspace = ColorSpace.RGB
};
FluxJpeg.Core.Image img = new FluxJpeg.Core.Image(model, raster);
MemoryStream stream = new MemoryStream();
JpegEncoder encoder = new JpegEncoder(img, 100, stream);
encoder.Encode();
stream.Seek(0, SeekOrigin.Begin);
byte[] binaryData = new Byte[stream.Length];
long bytesRead = stream.Read(binaryData, 0, (int)stream.Length);
string base64String =
System.Convert.ToBase64String(binaryData,
0,
binaryData.Length);
return(base64String);
}
public void LoadResizeSave <TColor>(TestImageProvider <TColor> provider, int quality, JpegSubsample subsample)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
using (Image <TColor> image = provider.GetImage().Resize(new ResizeOptions {
Size = new Size(150, 100), Mode = ResizeMode.Max
}))
{
image.MetaData.Quality = quality;
image.MetaData.ExifProfile = null; // Reduce the size of the file
JpegEncoder encoder = new JpegEncoder {
Subsample = subsample, Quality = quality
};
provider.Utility.TestName += $"{subsample}_Q{quality}";
provider.Utility.SaveTestOutputFile(image, "png");
provider.Utility.SaveTestOutputFile(image, "jpg", encoder);
}
}
//public bool Colour { get; set; }
//public int Compression { get; set; }
//public bool KeepOriginal { get; set; }
#region Jpeg
/// <summary>
/// Von dem PDF-Dokument wird die erste Seite in Jpeg konvertiert und gespeichert.
/// die funktion liefert den Path zu der neue Datei zurück.
/// </summary>
public string GetFirstPageAsImageFromDocument(DocumentParam param)
{
try
{
string fileName = string.Empty;
FileInfo fileInfo = new FileInfo(param.FilePath);
if (fileInfo.Exists == false)
{
return(fileName);
}
string pathFolder = Path.GetTempPath();
using (PdfDocument pdfDocument = new PdfDocument(param.FilePath, true))
{
pdfDocument.RenderingSettings.Resolution = new Resolution(150, 150);
JpegEncoder jpeGencoder = new JpegEncoder
{
Settings = { Quality = param.Quality, SaveAsGrayscale = false }
};
for (int pageCount = 0; pageCount < 1; pageCount++)
{
string tempName = FilesFunctions.GetRandomName(pathFolder, fileInfo, true, Jpeg);
// get image of PDF page as VintasoftImage object
using (VintasoftImage vsImage = pdfDocument.Pages[pageCount].Render())
{
// save VintasoftImage object as JPEG file
vsImage.Save(tempName, jpeGencoder);
fileName = tempName;
}
}
}
return(fileName);
}
catch (Exception ex)
{
FileLogger.FileLogger.Instance.WriteExeption(ex);
return(string.Empty);
}
}
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 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 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 Stream Encode(WriteableBitmap bitmap, int quality)
{
//Convert the Image to pass into FJCore
var width = bitmap.PixelWidth;
var height = bitmap.PixelHeight;
var bands = 3;
var raster = new byte[bands][, ];
for (var i = 0; i < bands; i++)
{
raster[i] = new byte[width, height];
}
for (var row = 0; row < height; row++)
{
for (var column = 0; column < width; column++)
{
var pixel = bitmap.Pixels[width * row + column];
raster[0][column, row] = (byte)(pixel >> 16);
raster[1][column, row] = (byte)(pixel >> 8);
raster[2][column, row] = (byte)pixel;
}
}
var model = new ColorModel {
colorspace = ColorSpace.RGB
};
var img = new Image(model, raster);
//Encode the Image as a JPEG
var stream = new MemoryStream();
var encoder = new JpegEncoder(img, quality, stream);
encoder.Encode();
//Move back to the start of the stream
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
public static void EncodeJpeg(WriteableBitmap bmp, Stream dstStream)
{
// Init buffer in FluxJpeg format
int w = bmp.PixelWidth;
int h = bmp.PixelHeight;
int[] p = bmp.Pixels;
byte[][,] pixelsForJpeg = new byte[3][, ]; // RGB colors
pixelsForJpeg[0] = new byte[h, w];
pixelsForJpeg[1] = new byte[h, w];
pixelsForJpeg[2] = new byte[h, w];
// Copy WriteableBitmap data into buffer for FluxJpeg
int i = 0;
for (int x = 0; x < w; x++)
{
for (int y = 0; y < h; y++)
{
int color = p[i++];
// Swap x and y coordinates to cheaply rotate the image 90° clockwise
pixelsForJpeg[0][y, x] = (byte)(color >> 16); // R
pixelsForJpeg[1][y, x] = (byte)(color >> 8); // G
pixelsForJpeg[2][y, x] = (byte)(color); // B
}
}
using (MemoryStream memStream = new MemoryStream())
{
//Encode Image as JPEG
var jpegImage = new FluxJpeg.Core.Image(new ColorModel {
colorspace = ColorSpace.RGB
}, pixelsForJpeg);
var encoder = new JpegEncoder(jpegImage, 95, memStream);
encoder.Encode();
// Seek to begin of stream and write the encoded bytes to the FileSteram
memStream.Seek(0, SeekOrigin.Begin);
// Use the new .Net 4 CopyTo method :)
memStream.CopyTo(dstStream);
}
}
public void OpenBmp_SaveJpeg <TColor>(TestImageProvider <TColor> provider, JpegSubsample subSample, int quality)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
Image <TColor> image = provider.GetImage();
ImagingTestCaseUtility utility = provider.Utility;
utility.TestName += "_" + subSample + "_Q" + quality;
using (var outputStream = File.OpenWrite(utility.GetTestOutputFileName("jpg")))
{
var encoder = new JpegEncoder()
{
Subsample = subSample,
Quality = quality
};
image.Save(outputStream, encoder);
}
}
public void OpenBmp_SaveJpeg <TColor, TPacked>(TestImageFactory <TColor, TPacked> factory, JpegSubsample subSample, int quality)
where TColor : struct, IPackedPixel <TPacked> where TPacked : struct, IEquatable <TPacked>
{
var image = factory.Create();
var utility = factory.Utility;
utility.TestName += "_" + subSample + "_Q" + quality;
using (var outputStream = File.OpenWrite(utility.GetTestOutputFileName("jpg")))
{
var encoder = new JpegEncoder()
{
Subsample = subSample,
Quality = quality
};
image.Save(outputStream, encoder);
}
}
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);
}
//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;
}
