public async Task <string> SaveImage(IFormFile image)
{
try
{
var save_path = Path.Combine(_imagePath); //use this to avoid errors using normal string
if (!Directory.Exists(save_path))
{
Directory.CreateDirectory(save_path);
}
//Internet Explorer Error
//var fileName = image.FileName;
var mime = image.FileName.Substring(image.FileName.LastIndexOf('.'));
var fileName = $"image_{DateTime.Now.ToString("dd-MM-yyyy-HH-mm-ss")}{mime}";
//a Stream is like a tunnel to the folder
using (var fileStream = new FileStream(Path.Combine(save_path, fileName), FileMode.Create)) //using limits an IDisposable object to this scope
{
//await image.CopyToAsync(fileStream);
MagicImageProcessor.ProcessImage(image.OpenReadStream(), fileStream, imageOptions());
}
return(fileName);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return("Error");
}
}
public async Task <string> SaveImageAsync(IFormFile image)
{
try
{
var savePath = Path.Combine(_newsImagesPath);
if (!Directory.Exists(savePath))
{
Directory.CreateDirectory(savePath);
}
var fileName = $"img_{DateTime.Now:dd-MM-yyyy-HH-mm-ss}{image.FileName.Substring(image.FileName.LastIndexOf('.'))}";
using var fileStream = new FileStream(Path.Combine(savePath, fileName), FileMode.Create);
//await image.CopyToAsync(fileStream);
await Task.Run(() => MagicImageProcessor.ProcessImage(image.OpenReadStream(), fileStream, ImageOptions()));
return(fileName);
}
catch (Exception ex)
{
return(ex.Message);
}
}
public Size MagicScalerResize()
{
// stride is width * bytes per pixel (3 for BGR), rounded up to the nearest multiple of 4
const uint stride = ResizedWidth * 3u + 3u & ~3u;
const uint bufflen = ResizedHeight * stride;
var settings = new ProcessImageSettings
{
Width = ResizedWidth,
Height = ResizedHeight,
Sharpen = false
};
using (var pixels = new TestPatternPixelSource(Width, Height, PixelFormats.Bgr24bpp))
using (var pipeline = MagicImageProcessor.BuildPipeline(pixels, settings))
{
var rect = new Rectangle(0, 0, ResizedWidth, ResizedHeight);
var buffer = ArrayPool <byte> .Shared.Rent((int)bufflen);
pipeline.PixelSource.CopyPixels(rect, (int)stride, new Span <byte>(buffer, 0, (int)bufflen));
ArrayPool <byte> .Shared.Return(buffer);
return(rect.Size);
}
}
public async Task <string> SaveImage(IFormFile image)
{
try
{
var save_path = Path.Combine(_imagePath);
if (!Directory.Exists(save_path))
{
Directory.CreateDirectory(save_path);
}
//Internet explorer error
//var fileName = image.FileName;
var mime = image.FileName.Substring(image.FileName.LastIndexOf('.'));
var fileName = $"img_{DateTime.Now.ToString("dd-MM-yyyy-HH-mm-ss")}{mime}";
using (var fileStream = new FileStream(Path.Combine(save_path, fileName), FileMode.Create))
{
MagicImageProcessor.ProcessImage(image.OpenReadStream(), fileStream, ImageOptions());
}
return(fileName);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return("Error");
}
}
public async Task <string> SaveImage(IFormFile image)
{
var save_path = Path.Combine(_ImaghePath);
try
{
if (!Directory.Exists(save_path))
{
Directory.CreateDirectory(save_path);
}
var mimeType = image.FileName.Substring(image.FileName.LastIndexOf('.'));
var fileName = $"img_{DateTime.Now.ToString("dd-MM-yyyy-HH-mm-ss")}{mimeType}";
using (var fileStram = new FileStream(Path.Combine(save_path, fileName), FileMode.Create))
{
// await image.CopyToAsync(fileStram);
MagicImageProcessor.ProcessImage(image.OpenReadStream(), fileStram, ImageOptions());
}
return(fileName);
}
catch (Exception ex)
{
//throw ex;
return("Error");
}
}
public string SaveCategoryImage(IFormFile categoryImage)
{
try
{
//Get the path & if path can't be saved because doesn't exist then create it
var categorySavePath = Path.Combine(_categoryImagePath);
if (!Directory.Exists(categorySavePath))
{
Directory.CreateDirectory(categorySavePath);
}
//Get the mime & fileName, done this way to prevent internet explorer errors
var mime = categoryImage.FileName.Substring(categoryImage.FileName.LastIndexOf('.'));
//Generate just the file name so it can be copied over to asset files instead of generic tag
string fileWithExt = categoryImage.FileName;
string[] file = fileWithExt.Split('.');
string fileNoExt = file[0];
var categoryFileName = $"{fileNoExt}_{DateTime.Now:dd-MM-yyyy-HH-mm-ss}{mime}";
//Get the filestream and then save the image
using (var categoryFileStream = new FileStream(Path.Combine(categorySavePath, categoryFileName), FileMode.Create))
{
//Imagine processing to make files smaller, same size etc doesnt have an async method
MagicImageProcessor.ProcessImage(categoryImage.OpenReadStream(), categoryFileStream, CategoryImageOptions());
}
return(categoryFileName);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return("Error");
}
}
private Stream MagicScaleResize(Stream stream)
{
var outStream = new MemoryStream(1024);
const int quality = 75;
var settings = new ProcessImageSettings()
{
Width = this._width,
Height = this._height,
ResizeMode = CropScaleMode.Crop,
SaveFormat = fileFormat,
JpegQuality = quality,
JpegSubsampleMode = ChromaSubsampleMode.Subsample420
};
MagicImageProcessor.ProcessImage(stream, outStream, settings);
return(outStream);
}
public string SaveImage(IFormFile image)
{
var save_path = Path.Combine(_imagePath);
try
{
if (!Directory.Exists(save_path))
{
Directory.CreateDirectory(save_path);
}
var mime = image.FileName.Substring(image.FileName.LastIndexOf("."));
var fileName = $"img_{DateTime.Now.ToString("dd-MM-yyy-HH-mm-ss")}{mime}";
using (var filestream = new FileStream(Path.Combine(save_path, fileName), FileMode.Create))
{
/*await image.CopyToAsync(filestream);*/
MagicImageProcessor.ProcessImage(image.OpenReadStream(), filestream, imageoptions());
}
return(fileName);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return("Error-");
}
}
public FileInfo ResizeTo(FileInfo toResize, int width, int quality, string imageTypeString, bool addSizeString,
IProgress <string> progress)
{
if (!toResize.Exists)
{
return(null);
}
var newFile = Path.Combine(toResize.Directory?.FullName ?? string.Empty, $"{Guid.NewGuid()}.jpg");
var newFileInfo = new FileInfo(newFile);
if (newFileInfo.Exists)
{
newFileInfo.Delete();
}
var settings = new ProcessImageSettings {
Width = width, JpegQuality = quality
};
using var outStream = new FileStream(newFileInfo.FullName, FileMode.Create);
var results = MagicImageProcessor.ProcessImage(toResize.FullNameWithLongFilePrefix(), outStream, settings);
outStream.Dispose();
var finalFileName = Path.Combine(toResize.Directory?.FullName ?? string.Empty,
$"{Path.GetFileNameWithoutExtension(toResize.Name)}--{imageTypeString}{(addSizeString ? $"--{width}w--{results.Settings.Height}h" : string.Empty)}.jpg");
FileManagement.MoveFileAndLog(newFileInfo.FullName, finalFileName);
newFileInfo = new FileInfo(finalFileName);
return(newFileInfo);
}
public async Task <string> SaveImage(IFormFile image)
{
//try
{
var save_path = Path.Combine(_imagePath);
if (!Directory.Exists(_imagePath))
{
Directory.CreateDirectory(save_path);
}
//Internet Explorer Error
//var fileName = image.FileName;
//var mime gets the code of the image (jpg, png, etc), filename is the name we give to the image, and add to it the mime.
var mime = image.FileName.Substring(image.FileName.LastIndexOf('.'));
var fileName = $"img_{DateTime.Now.ToString("dd-MM-yyyy-HH-mm-ss")}{mime}";
using (var fileStream = new FileStream(Path.Combine(save_path, fileName), FileMode.Create))
{
MagicImageProcessor.ProcessImage(image.OpenReadStream(), fileStream, ImageOptions());
}
return(fileName);
}
//catch(Exception e)
//{
// Console.WriteLine(e.Message);
// return "Error";
//}
}
public string SaveImage(IFormFile image)
{
try
{
var save_path = Path.Combine(_imagePath);
if (!Directory.Exists(save_path))
{
Directory.CreateDirectory(save_path);
}
string mime = image.FileName.Substring(image.FileName.LastIndexOf('.'));
var fileName = $"dev-messenger_img_{DateTime.Now.ToString("dd-MM-yyyy-HH-mm-ss").Replace("-", string.Empty)}{mime}";
using (var fileStream = new FileStream(Path.Combine(save_path, fileName), FileMode.Create))
{
MagicImageProcessor.ProcessImage(image.OpenReadStream(), fileStream, ImageOptions());
}
return(fileName);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return("Error");
}
ProcessImageSettings ImageOptions() => new ProcessImageSettings
{
Width = 800,
Height = 500,
SaveFormat = FileFormat.Auto,
ResizeMode = CropScaleMode.Crop,
JpegQuality = 100,
JpegSubsampleMode = ChromaSubsampleMode.Subsample420
};
}
private void resizeImage(string input)
{
using (var output = new FileStream(OutputPath(input, outputDirectory), FileMode.Create))
{
MagicImageProcessor.ProcessImage(input, output, this.settings);
}
}
private void MinifyImage(string source, string destination)
{
var settings = new ProcessImageSettings {
Width = Consts.ImageWidth
};
using var outStream = new FileStream(destination, FileMode.CreateNew);
MagicImageProcessor.ProcessImage(source, outStream, settings);
}
private async Task SaveFile(Stream file, string path)
{
using FileStream imageStream = System.IO.File.Create("Images/" + Guid.NewGuid().ToString() + Path.GetExtension(path));
await file.CopyToAsync(imageStream);
imageStream.Position = 0;
using FileStream previewStream = System.IO.File.Create("Previews/" + Path.GetFileName(imageStream.Name));
MagicImageProcessor.ProcessImage(imageStream, previewStream, settings);
}
private static void OptimizeThumb(string tempThumbPath, string thumbPath)
{
using (var output = new FileStream(thumbPath, FileMode.Create))
{
MagicImageProcessor.ProcessImage(tempThumbPath, output, ThumbImageSettings);
}
File.Delete(tempThumbPath);
}
public Stream GenerateThumbnail(Stream originalStream)
{
var outputStream = new MemoryStream();
MagicImageProcessor.ProcessImage(originalStream, outputStream, new ProcessImageSettings {
Width = 50, Height = 50
});
outputStream.Seek(0, SeekOrigin.Begin);
return(outputStream);
}
//Save portfolio asset
public string SavePortfolioAsset(IFormFile portfolioAsset)
{
try
{
//Get the mime & fileName, done this way to prevent internet explorer errors
var mime = portfolioAsset.FileName.Substring(portfolioAsset.FileName.LastIndexOf('.'));
//Generate just the file name so it can be copied over to asset files instead of generic tag
string fileWithExt = portfolioAsset.FileName;
string[] file = fileWithExt.Split('.');
string fileNoExt = file[0];
if (ImageTypes.Contains(mime))
{
//Get the path & if path can't be saved because doesn't exist then create it
var save_path = Path.Combine(_portfolioAssetPath);
if (!Directory.Exists(save_path))
{
Directory.CreateDirectory(save_path);
}
var fileName = $"{fileNoExt}_{DateTime.Now.ToString("dd-MM-yyyy-HH-mm-ss")}{mime}";
//Get the filestream and then save the image
using (var fileStream = new FileStream(Path.Combine(save_path, fileName), FileMode.Create))
{
//Imagine processing to make files smaller, same size etc doesnt have an async method
MagicImageProcessor.ProcessImage(portfolioAsset.OpenReadStream(), fileStream, AssetImageOptions());
}
return(fileName);
}
else
{
//Get the path & if path can't be saved because doesn't exist then create it
var save_path = Path.Combine(_portfolioAssetFilesPath);
if (!Directory.Exists(save_path))
{
Directory.CreateDirectory(save_path);
}
//Get the mime & fileName, done this way to prevent internet explorer errors
var fileName = $"{fileNoExt}_{DateTime.Now.ToString("dd-MM-yyyy-HH-mm-ss")}{mime}";
using (FileStream fileStream = new FileStream(Path.Combine(save_path, fileName), FileMode.Create, FileAccess.Write))
{
portfolioAsset.CopyTo(fileStream);
}
return(fileName);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return("Error");
}
}
public static void Resize(Stream inputStream, Stream outputStream, int oldWidth, int oldHeight, int size = DefaultThumbnailSize)
{
var scaled = ScaledSize(oldWidth, oldHeight, size);
var settings = new ProcessImageSettings()
{
Width = scaled.width,
Height = scaled.height,
ResizeMode = CropScaleMode.Max,
SaveFormat = FileFormat.Jpeg,
JpegQuality = Quality,
JpegSubsampleMode = ChromaSubsampleMode.Subsample420
};
MagicImageProcessor.ProcessImage(inputStream, outputStream, settings);
}
public void SaveImage(int ID, IFormFile file)
{
if (file == null || file.Length == 0)
{
// Empty file
string defaultFileName = "default.png";
string sourcePath = Path.Combine(_hostingEnv.WebRootPath + @"\img\temp", defaultFileName);
var ext = Path.GetExtension(Path.Combine(sourcePath, defaultFileName));
var fileName = ID + ext;
string targetPath = Path.Combine(_hostingEnv.WebRootPath + @"\img\products", fileName);
File.Copy(sourcePath, targetPath);
}
else
{
var fileName = ID + Path.GetExtension(file.FileName);
fileName = _hostingEnv.WebRootPath + $@"\img\temp\{fileName}";
using (FileStream fs = File.Create(fileName))
{
file.CopyTo(fs);
fs.Flush();
}
const int size = 160;
var path = fileName;
var outputDirectory = string.Empty;
outputDirectory = _hostingEnv.WebRootPath + $@"\img\products";
var settings = new ProcessImageSettings()
{
Width = size,
Height = size,
ResizeMode = CropScaleMode.Max,
SaveFormat = FileFormat.Png
};
using (var output = new FileStream(OutputPath(path, outputDirectory), FileMode.Create))
{
MagicImageProcessor.ProcessImage(path, output, settings);
File.Delete(path);
}
}
}
internal static void MagicScalerResize(string path, int size, string outputDirectory)
{
var settings = new ProcessImageSettings()
{
Width = size,
Height = size,
ResizeMode = CropScaleMode.Max,
SaveFormat = FileFormat.Jpeg,
JpegQuality = Quality,
JpegSubsampleMode = ChromaSubsampleMode.Subsample420
};
using (var output = new FileStream(OutputPath(path, outputDirectory, MagicScaler), FileMode.Create))
{
MagicImageProcessor.ProcessImage(path, output, settings);
}
}
private static async Task process(TaskCompletionSource <ArraySegment <byte> > tcs, string reqPath, string cachePath, ProcessImageSettings s)
{
try
{
if (reqPath == WebRSizeModule.NotFoundPath)
{
using (await enterWorkQueueAsync())
using (var oimg = new MemoryStream(8192))
{
#pragma warning disable 0618 // obsolete
GdiImageProcessor.CreateBrokenImage(oimg, s);
#pragma warning restore 0618
oimg.Position = 0;
saveResult(tcs, oimg, cachePath, DateTime.MinValue);
return;
}
}
var vpp = HostingEnvironment.VirtualPathProvider;
var file = vpp is CachingAsyncVirtualPathProvider vppAsync ? await vppAsync.GetFileAsync(reqPath) : vpp.GetFile(reqPath);
var afile = file as AsyncVirtualFile;
var lastWrite = afile?.LastModified ?? DateTime.MinValue;
if (lastWrite == DateTime.MinValue && mpbvfType.Value.IsAssignableFrom(file.GetType()))
{
lastWrite = File.GetLastWriteTimeUtc(HostingEnvironment.MapPath(reqPath));
}
using (var iimg = afile != null ? await afile.OpenAsync() : file.Open())
using (await enterWorkQueueAsync())
using (var oimg = new MemoryStream(16384))
{
MagicImageProcessor.ProcessImage(iimg, oimg, s);
saveResult(tcs, oimg, cachePath, lastWrite);
}
}
catch (Exception ex)
{
tcs.SetException(ex);
tdic.TryRemove(cachePath, out _);
}
}
private void UploadWholeFile(HttpContext requestContext, List <ViewDataUploadFilesResult> statuses)
{
var request = requestContext.Request;
foreach (IFormFile file in request.Form.Files)
//for (int i = 0; i < request.Files.Count; i++)
{
//var file = request.Files[i];
String pathOnServer = Path.Combine(StorageRoot);
var fullPath = Path.Combine(pathOnServer, Path.GetFileName(file.FileName));
//file.SaveAs(fullPath);
using (FileStream fs = System.IO.File.Create(fullPath))
{
file.CopyTo(fs);
fs.Flush();
}
//Create thumb
string[] imageArray = file.FileName.Split('.');
if (imageArray.Length != 0)
{
String extansion = imageArray[imageArray.Length - 1].ToLower();
if (extansion != "jpg" && extansion != "png" && extansion != "jpeg") //Do not create thumb if file is not an image
{
}
else
{
var thumbfullPath = Path.Combine(pathOnServer, "thumbs");
//String fileThumb = file.FileName + ".80x80.jpg";
String fileThumb = Path.GetFileNameWithoutExtension(file.FileName) + "80x80.jpg";
var thumbfullPath2 = Path.Combine(thumbfullPath, fileThumb);
//using (MemoryStream stream = new MemoryStream(System.IO.File.ReadAllBytes(fullPath)))
//{
// var thumbnail = new WebImage(stream).Resize(80, 80);
// thumbnail.Save(ThumbfullPath2, "jpg");
//}
using (var outStream = new FileStream(thumbfullPath2, FileMode.Create))
{
MagicImageProcessor.ProcessImage(fullPath, outStream, new ProcessImageSettings {
Width = 80
});
}
}
}
statuses.Add(UploadResult(file.FileName, file.Length, file.FileName));
}
}
public void MagicScalerResize(string input)
{
var settings = new ProcessImageSettings()
{
Width = ThumbnailSize,
Height = ThumbnailSize,
ResizeMode = CropScaleMode.Max,
SaveFormat = FileFormat.Jpeg,
JpegQuality = Quality,
JpegSubsampleMode = ChromaSubsampleMode.Subsample420
};
using (var output = new FileStream(OutputPath(input, MagicScaler), FileMode.Create))
{
MagicImageProcessor.ProcessImage(input, output, settings);
}
}
public (bool Saved, string FileName) SaveImage(string id, IFormFile picture)
{
try
{
var settings = new ProcessImageSettings()
{
Height = 75,
Width = 75,
ResizeMode = CropScaleMode.Crop,
SaveFormat = FileFormat.Jpeg,
JpegQuality = 100
};
var savePath = Path.Combine(_env.ContentRootPath, _userImages, id);
if (!Directory.Exists(savePath))
{
Directory.CreateDirectory(savePath);
}
var fileName = $"img_{CreateFileName()}.jpg";
var finalPath = Path.Combine(savePath, fileName);
var currentImage = Directory.GetFiles(savePath).FirstOrDefault();
using (var output = new FileStream(finalPath, FileMode.Create))
{
MagicImageProcessor.ProcessImage(picture.OpenReadStream(), output, settings);
}
if (!IsNullOrEmpty(currentImage))
{
File.Delete(currentImage);
}
return(true, fileName);
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(false, $"Error: {e.Message}");
}
}
public void Test()
{
using (FileStream inputStream = File.OpenRead(@"Content\landscape-4665051.small.jpg"))
using (var originalImage = new Bitmap(inputStream))
using (var outputStream = File.Create(@"Content\landscape-4665051.resized.jpg"))
{
int width = 1140;
var ratio = (float)width / originalImage.Width;
int height = Convert.ToInt32(originalImage.Height * ratio);
var settings = new ProcessImageSettings
{
Width = 1140
};
inputStream.Seek(0, SeekOrigin.Begin);
var result = MagicImageProcessor.ProcessImage(inputStream, outputStream, settings);
}
}
public static string ResizeImageFromByte(byte[] buffer, int size)
{
const int quality = 100;
var settings = new ProcessImageSettings()
{
Width = size,
Height = size,
ResizeMode = CropScaleMode.Max,
SaveFormat = FileFormat.Jpeg,
JpegQuality = quality,
JpegSubsampleMode = ChromaSubsampleMode.Subsample420
};
using var imgStream = new MemoryStream(buffer);
using var output = new MemoryStream();
MagicImageProcessor.ProcessImage(imgStream, output, settings);
var t = ReadToEnd(output);
return(ImageToSrc(t));
}
/// <summary>
/// Cache entity thumbnail.
/// </summary>
/// <remarks>
/// This operation encodes <paramref name="decodedImage"/> as JPEG and saves the encoded data
/// in attribute storage using the <see cref="IAttributeStorage.StoreThumbnail"/> method.
/// </remarks>
/// <param name="entity">Metadata of the image</param>
/// <param name="decodedImage">Decoded image in BMP format</param>
private void SaveThumbnail(IEntity entity, byte[] decodedImage)
{
using (var output = new MemoryStream())
using (var input = new MemoryStream(decodedImage))
{
MagicImageProcessor.ProcessImage(input, output, new ProcessImageSettings
{
Interpolation = InterpolationSettings.Linear,
SaveFormat = FileFormat.Jpeg,
JpegQuality = SavedThumbnailQuality
});
// update entity thumbnail
var value = new ImageValue(output.ToArray());
var newEntity = entity.SetAttribute(new Attribute(
ExifAttributeReaderFactory.Thumbnail,
value, AttributeSource.Metadata));
_storage.StoreThumbnail(newEntity);
}
}
public Task <string> CreateThumbnailAsync(byte[] content, string fileName)
{
var frameInfo = ImageFileInfo.Load(content).Frames.First();
var settings = new ProcessImageSettings
{
Width = frameInfo.Width >= frameInfo.Height ? THUMBNAIL_SIZE : 0,
Height = frameInfo.Height > frameInfo.Width ? THUMBNAIL_SIZE : 0,
HybridMode = HybridScaleMode.Off,
ResizeMode = CropScaleMode.Contain
};
var newFileName = GetUniqueFileName(GetThumbnailFileName(fileName));
using (var stream = GetFileStream(newFileName, FileMode.Create))
{
MagicImageProcessor.ProcessImage(content, stream, settings);
}
return(Task.FromResult(newFileName));
}
public static async Task ResizeImageToFile(string path, IFormFile file)
{
const int size = Constants.ImageSize;
const int quality = 100;
var settings = new ProcessImageSettings()
{
Width = size,
Height = size,
ResizeMode = CropScaleMode.Max,
SaveFormat = FileFormat.Jpeg,
JpegQuality = quality,
JpegSubsampleMode = ChromaSubsampleMode.Subsample420
};
await using var imgStream = new MemoryStream();
await using var output = new FileStream(path, FileMode.Create);
await file.CopyToAsync(imgStream);
imgStream.Position = 0;
MagicImageProcessor.ProcessImage(imgStream, output, settings);
}
public void MagicScalerResize()
{
// stride is width * bytes per pixel (3 for BGR), rounded up to the nearest multiple of 4
const uint stride = ResizedWidth * 3u + 3u & ~3u;
const uint bufflen = ResizedHeight * stride;
var pixels = new TestPatternPixelSource(Width, Height, PixelFormats.Bgr24bpp);
var settings = new ProcessImageSettings
{
Width = ResizedWidth,
Height = ResizedHeight
};
using (var pipeline = MagicImageProcessor.BuildPipeline(pixels, settings))
{
var rect = new System.Drawing.Rectangle(0, 0, ResizedWidth, ResizedHeight);
var buffer = Marshal.AllocHGlobal((int)bufflen);
pipeline.PixelSource.CopyPixels(rect, stride, bufflen, buffer);
Marshal.FreeHGlobal(buffer);
}
}
