//ExEnd:SourceJpegFilePath
#region working with XMP data
/// <summary>
///Gets XMP properties from Jpeg file
/// </summary>
public static void GetXMPProperties()
{
try
{
//ExStart:GetXmpPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get XMP data
XmpProperties xmpProperties = jpegFormat.GetXmpProperties();
// show XMP data
foreach (string key in xmpProperties.Keys)
{
try
{
XmpNodeView xmpNodeView = xmpProperties[key];
Console.WriteLine("[{0}] = {1}", xmpNodeView.Name, xmpNodeView.Value);
}
catch { }
}
//ExEnd:GetXmpPropertiesJpegImage
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// 压缩处理
/// </summary>
/// <param name="photoBytes">bytes</param>
/// <returns></returns>
private MemoryStream ComPress(byte[] photoBytes)
{
// 检测格式
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
Size size = new Size(150, 0);
using (MemoryStream inStream = new MemoryStream(photoBytes))
{
using (MemoryStream outStream = new MemoryStream())
{
// 使用重载初始化ImageFactory以保留EXIF元数据。
using (ImageFactory imageFactory = new ImageFactory(true))
{
// 加载，调整大小，设置格式和质量并保存图像。
imageFactory.Load(inStream)
.Resize(size)
.Format(format)
.Save(outStream);
return(outStream);
}
}
}
}
/// <summary>
/// Gets Exif info from Jpeg file
/// </summary>
public static void GetExifInfo()
{
try
{
//ExStart:GetExifPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get EXIF data
JpegExifInfo exif = (JpegExifInfo)jpegFormat.GetExifInfo();
if (exif != null)
{
// get artist
Console.WriteLine("Artist: {0}", exif.Artist);
// get description
Console.WriteLine("Description: {0}", exif.ImageDescription);
// get user's comment
Console.WriteLine("User Comment: {0}", exif.UserComment);
// get user's Model
Console.WriteLine("Model: {0}", exif.Model);
// get user's Make
Console.WriteLine("Make: {0}", exif.Make);
// get user's CameraOwnerName
Console.WriteLine("CameraOwnerName: {0}", exif.CameraOwnerName);
}
//ExEnd:GetExifPropertiesJpegImage
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
private void DeepfryImage(string imageFilename, int numPasses = 1)
{
for (int i = 0; i < numPasses; i++)
{
var imageBytes = File.ReadAllBytes(imageFilename);
var format = new JpegFormat {
Quality = 10
};
using (var inStream = new MemoryStream(imageBytes))
using (var outStream = new MemoryStream())
using (var saveFileStream = new FileStream(imageFilename, FileMode.Open, FileAccess.Write))
using (var imageFactory = new ImageFactory(preserveExifData: true))
{
imageFactory.Load(inStream)
.Saturation(100)
.Contrast(100)
.Gamma(1.0f)
//.GaussianSharpen(30)
.Format(format)
.Save(outStream);
outStream.CopyTo(saveFileStream);
}
}
}
private void Recompress(string sourceName, string destName, int width, int height, int quality)
{
ISupportedImageFormat format = new JpegFormat {
Quality = quality
};
var size = new Size(width, height);
var rl = new ResizeLayer(size, ResizeMode.Crop);
using (FileStream src = File.OpenRead(Path.Combine(_baseDir, sourceName)))
{
string destPath = Path.Combine(_baseDir, destName);
if (File.Exists(destPath))
{
File.Delete(destPath);
}
using (FileStream dest = File.Create(destPath))
{
using (var factory = new ImageFactory())
{
factory
.Load(src)
.Resize(rl)
.Format(format)
.Save(dest);
}
}
}
}
public Image crop(Image img, Rectangle rect)
{
byte[] photoBytes = imageToByteArray(img);
// Format is automatically detected though can be changed.
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
Image resultingImage = default(Image);
using (MemoryStream inStream = new MemoryStream(photoBytes))
{
using (MemoryStream outStream = new MemoryStream())
{
// Initialize the ImageFactory using the overload to preserve EXIF metadata.
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
// Load, resize, set the format and quality and save an image.
imageFactory.Load(inStream)
.Crop(rect);
resultingImage = imageFactory.Image;
}
}
}
return(resultingImage);
}
public void ImageProcessorTest1()
{
string imagePath = @"D:\test\img\123.jpg";
//string saveImagePath = @"D:\test\img\123N555.jpg";
//string imagePath = @"D:\test\1\xx.png";
string saveImagePath = @"D:\test\1\xx_new3.png";
byte[] photoBytes = File.ReadAllBytes(imagePath);
// Format is automatically detected though can be changed.
ISupportedImageFormat format = new JpegFormat {
};
//Size size = new Size(150, 0);
using (MemoryStream inStream = new MemoryStream(photoBytes))
{
using (MemoryStream outStream = new MemoryStream())
{
// Initialize the ImageFactory using the overload to preserve EXIF metadata.
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
// Load, resize, set the format and quality and save an image.
imageFactory.Load(inStream)
.Filter(MatrixFilters.GreyScale)
.Format(format)
.Save(saveImagePath);
}
// Do something with the stream.
}
}
}
public void SaveUserImage(Stream image, string imagePath)
{
byte[] photoBytes = ReadFully(image);
// Format is automatically detected though can be changed.
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
Size size = new Size(150, 0);
using (MemoryStream inStream = new MemoryStream(photoBytes))
{
using (MemoryStream outStream = new MemoryStream())
{
// Initialize the ImageFactory using the overload to preserve EXIF metadata.
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
// Load, resize, set the format and quality and save an image.
imageFactory.Load(inStream)
.Resize(size)
.Format(format)
.Save(outStream);
}
using (FileStream file = new FileStream(Root + "test.jpg", FileMode.Open, FileAccess.Read))
{
byte[] bytes = new byte[file.Length];
file.Read(bytes, 0, (int)file.Length);
outStream.Write(bytes, 0, (int)file.Length);
}
}
}
}
public static byte[] GetPreview(byte[] original, int quality)
{
using (var inputStream = new MemoryStream(original))
{
using (var outputStream = new MemoryStream())
{
using (var factory = new ImageFactory())
{
// create a format object
// the preview will use Jpeg so that we can reduce the quality
// for faster rendering, the final product will use the original
// format and the original quality
var format = new JpegFormat
{
Quality = quality
};
// load the image and format it
factory.Load(inputStream)
.Format(format)
.Save(outputStream);
}
var length = (int)outputStream.Length;
var bytes = new byte[length];
outputStream.Read(bytes, 0, length);
return(bytes);
}
}
}
private ISupportedImageFormat GetFormat(string extension, ImageInstruction ins)
{
ISupportedImageFormat format = null;
if (extension.Equals(".jpg", StringComparison.OrdinalIgnoreCase) || extension.Equals(".jpeg", StringComparison.OrdinalIgnoreCase))
{
format = new JpegFormat {
Quality = ins.JpegQuality
}
}
;
else
if (extension.Equals(".gif", StringComparison.OrdinalIgnoreCase))
{
format = new GifFormat {
}
}
;
else if (extension.Equals(".png", StringComparison.OrdinalIgnoreCase))
{
format = new PngFormat {
}
}
;
return(format);
}
private void ProcessImage(string inputImage, string outputImage)
{
byte[] photoBytes = File.ReadAllBytes(inputImage);
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
Size size = new Size(EDEN_EDITOR_PREVIEW_WIDTH, EDEN_EDITOR_PREVIEW_HEIGHT);
using (MemoryStream inStream = new MemoryStream(photoBytes))
{
using (MemoryStream outStream = new MemoryStream())
{
using (ImageFactory imageFactory = new ImageFactory())
{
imageFactory.Load(inStream)
.Resize(size)
.Format(format)
.Save(outStream);
}
using (FileStream file = new FileStream(outputImage, FileMode.Create, FileAccess.Write))
{
outStream.WriteTo(file);
}
}
}
}
public static byte[] Shadowing(byte[] image, int percents)
{
byte[] photoBytes = image;
byte[] newImg;
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
using (MemoryStream inStream = new MemoryStream(photoBytes))
{
using (MemoryStream outStream = new MemoryStream())
{
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
imageFactory.Load(inStream)
.Brightness(-percents)
.Format(format)
.Save(outStream);
}
newImg = outStream.ToArray();
}
}
return(newImg);
}
public HttpResponseMessage GetThumbnail(string imagePath, int width)
{
if (false == string.IsNullOrWhiteSpace(imagePath) && imagePath.IndexOf("{{") < 0)
{
var image = Image.FromFile(System.Web.Hosting.HostingEnvironment.MapPath(imagePath));
MemoryStream outStream = new MemoryStream();
byte[] photoBytes = File.ReadAllBytes(System.Web.Hosting.HostingEnvironment.MapPath(imagePath)); // change imagePath with a valid image path
ISupportedImageFormat format = new JpegFormat {
Quality = 70
}; // convert to jpg
var inStream = new MemoryStream(photoBytes);
var imageFactory = new ImageFactory(preserveExifData: true);
Size size = ResizeKeepAspect(image.Size, width, width);
ResizeLayer resizeLayer = new ResizeLayer(size, ResizeMode.Max);
imageFactory.Load(inStream)
.Resize(resizeLayer)
.Format(format)
.Save(outStream);
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StreamContent(outStream);
response.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("image/png");
return(response);
}
else
{
return(null);
}
}
/// <summary>
/// Takes manufacturer as input and returns photos made on particular camera
/// </summary>
/// <param name="manufacturer">Camera manufacturer name</param>
public void FilterByCameraManufacturer(string manufacturer)
{
// Map directory in source folder
string sourceDirectoryPath = Common.MapSourceFilePath(this.PhotosDirectory);
// get jpeg files
string[] files = Directory.GetFiles(sourceDirectoryPath, "*.jpg");
List <string> result = new List <string>();
foreach (string path in files)
{
// recognize file
FormatBase format = FormatFactory.RecognizeFormat(path);
// casting to JpegFormat
if (format is JpegFormat)
{
JpegFormat jpeg = (JpegFormat)format;
// get exif data
JpegExifInfo exif = (JpegExifInfo)jpeg.GetExifInfo();
if (exif != null)
{
if (string.Compare(exif.Make, manufacturer, StringComparison.OrdinalIgnoreCase) == 0)
{
// add file path to list
result.Add(Path.GetFileName(path));
}
}
}
}
Console.WriteLine(string.Join("\n", result));
}
public Image Optimize(string inputfile, int finalsize = 1024, bool retobj = false, float hdpi = 0, float vdpi = 0)
{
var outputpath = inputfile.GetOutputPath(ActionType.OPTIMIZE);
ISupportedImageFormat format = new JpegFormat();
Size size = new Size(finalsize, 0);
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
if (retobj)
{
using (Image sourceImg = imageFactory.Load(inputfile).Resize(size).Format(format).Image)
{
var clonedImg = new Bitmap(sourceImg.Width, sourceImg.Height, PixelFormat.Format32bppArgb);
clonedImg.SetResolution(hdpi == 0 ? Image.FromFile(inputfile).HorizontalResolution : hdpi, vdpi == 0 ? Image.FromFile(inputfile).VerticalResolution : vdpi);
using (var copy = Graphics.FromImage(clonedImg))
{
copy.DrawImage(sourceImg, 0, 0);
}
return(clonedImg);
}
}
else
{
imageFactory.Load(inputfile).Resize(size).Format(format).Save(outputpath);
}
return(imageFactory.Load(inputfile).Image);
}
}
/// <summary>
/// Уменьшение размера файла.
/// На вход принимает файл по типу FileInfo
/// </summary>
public static void ResizeImage(FileInfo fileInfo)
{
var isCorrect = false;
if (SizeCorrection(fileInfo))
{
isCorrect = true;
}
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
using (MemoryStream inStream = new MemoryStream(fileInfo.PhotoBytes))
{
using (FileStream outStream = File.Create($"{DirectoryFind(fileInfo)}{fileInfo.FileName}.{format.DefaultExtension}"))
{
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
if (isCorrect)
{
imageFactory.Load(inStream).Format(format).Save(outStream);
}
else
{
Size size = imageFactory.Load(inStream).Image.Size / 2;
imageFactory.Load(inStream).Resize(size).Format(format).Save(outStream);
}
}
}
}
}
public void saveSmallFileToBoardFolder(string shortName,
HttpPostedFileBase postFile,
double time,
string uploadName)
{
long iTime = Convert.ToInt64(time * 1000);
string uploadsFolder = HttpContext.Current.Server
.MapPath("~/Content/Images");
System.IO.Directory.CreateDirectory(uploadsFolder);
string folder = Path.Combine(uploadsFolder, shortName);
System.IO.Directory.CreateDirectory(folder);
string justFile = iTime + "s.jpg";
string fileName = Path.Combine(folder, justFile);
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
Size size = new Size(250, 0);
using (FileStream outStream = new FileStream(fileName, FileMode.Create))
{
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
imageFactory.Load(postFile.InputStream)
.Resize(size)
.Format(format)
.Save(outStream);
}
}
}
private static Stream GetResizeImageStream(byte[] imageData, int height, int width)
{
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
Size size = new Size(width, height);
using (MemoryStream inStream = new MemoryStream(imageData))
{
using (MemoryStream outStream = new MemoryStream())
{
// Initialize the ImageFactory using the overload to preserve EXIF metadata.
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
// Load, resize, set the format and quality and save an image.
imageFactory.Load(inStream)
.Resize(size)
.Format(format)
.Save(outStream);
return(outStream);
}
// Do something with the stream.
}
}
}
public async Task ResizeCache()
{
var fileName = Guid.NewGuid().ToString();
var width = (ushort)122;
var format = new JpegFormat();
var id = Guid.NewGuid();
var versionName = Guid.NewGuid().ToString();
var cachedFileName = Guid.NewGuid().ToString();
var imaging = Substitute.For <IImaging>();
imaging.Get(Naming.DefaultExtension, 85).Returns(format);
imaging.Resize(Arg.Any <byte[]>(), Arg.Any <ImageVersion>());
var container = Substitute.For <IContainer>();
var table = Substitute.For <ITableStorage>();
var queue = Substitute.For <IStorageQueue>();
var naming = Substitute.For <INaming>();
naming.FromFileName(fileName).Returns(id);
naming.DynamicVersion(format.DefaultExtension, 85, width, 0).Returns(versionName);
naming.FileName(id, versionName, format.DefaultExtension).Returns(cachedFileName);
var store = new DataStore(imaging, container, table, queue, naming);
var result = await store.Resize(fileName, width, 0, Naming.DefaultExtension, 85, true);
Assert.IsNotNull(result);
Assert.IsNotNull(result.Raw);
Assert.AreEqual(format.MimeType, result.MimeType);
naming.Received().FromFileName(fileName);
naming.Received().DynamicVersion(format.DefaultExtension, 85, width, 0);
naming.Received().FileName(id, versionName, format.DefaultExtension);
imaging.Received().Get(Naming.DefaultExtension, 85);
imaging.Received().Resize(Arg.Any <byte[]>(), Arg.Any <ImageVersion>());
}
public ActionResult Download(string id, string fileName)
{
if (!string.IsNullOrEmpty(Request.Headers["If-Modified-Since"]))
{
Response.StatusCode = 304;
Response.StatusDescription = "Not Modified";
Response.AddHeader("Content-Length", "0");
return(Content(String.Empty));
}
var file = AsefianFileContextHelper.GetFile(id, fileName);
try
{
MemoryStream outStream = new MemoryStream();
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: false))
{
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
imageFactory.Load(file.Data)
.Format(format)
.Save(outStream);
return(File(outStream, MimeMapping.GetMimeMapping(fileName)));
}
}
catch (Exception)
{
return(File(file.Data, file.MimeType));
}
}
public void ImageProcessorSandbox()
{
var file = @"E:\CONTENT\CURSOR1.BMP";
var size = new Size(150, 0);
var photoBytes = File.ReadAllBytes(file);
// Format is automatically detected though can be changed.
ISupportedImageFormat format = new JpegFormat {
Quality = 100
};
using (var inStream = new MemoryStream(photoBytes))
{
using (var outStream = new MemoryStream())
{
// Initialize the ImageFactory using the overload to preserve EXIF metadata.
using (var imageFactory = new ImageFactory(preserveExifData: true))
{
// Load, resize, set the format and quality and save an image.
imageFactory.Load(inStream)
.Resize(size)
.Format(format)
.Save(outStream);
}
// Do something with the stream.
var fileStream = File.Create(@".\CURSOR1.BMP");
}
}
}
public void SavePicture(HttpPostedFileBase file, string name, Size size, string formatFile = "jpg")
{
if ((file != null) && (file.ContentLength > 0) && !string.IsNullOrEmpty(file.FileName))
{
// Format is automatically detected though can be changed.
ISupportedImageFormat format = new JpegFormat {
Quality = 90
};
if (formatFile == "png")
{
format = new PngFormat()
{
Quality = 90
}
}
;
//https://naimhamadi.wordpress.com/2014/06/25/processing-images-in-c-easily-using-imageprocessor/
// Initialize the ImageFactory using the overload to preserve EXIF metadata.
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
var path = Path.Combine(Server.MapPath("~/images/community"), string.Format("{0}.{1}", name, formatFile));
// Load, resize, set the format and quality and save an image.
imageFactory.Load(file.InputStream)
.Resize(size)
.Format(format)
.Save(path);
}
}
}
public void TestCompress()
{
for (int i = 10; i <= 100;)
{
var k = (i < 90 ? i += 10 : i += 1);
var distPath = @"C:\Users\Public\Pictures\Sample Pictures\a\Jellyfish-compress-" + i + ".jpg";
var srcPath = @"C:\Users\Public\Pictures\Sample Pictures\Jellyfish.bmp";
byte[] photoBytes = File.ReadAllBytes(srcPath);
// Format is automatically detected though can be changed.
ISupportedImageFormat format = new JpegFormat {
Quality = i
};
using (MemoryStream inStream = new MemoryStream(photoBytes))
{
using (MemoryStream outStream = new MemoryStream())
{
// Initialize the ImageFactory using the overload to preserve EXIF metadata.
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
// Load, resize, set the format and quality and save an image.
imageFactory.Load(inStream)
//.Resize(new Size(1000, 800))
.Format(format)
.Save(distPath);
}
// Do something with the stream.
}
}
}
}
//ExEnd:SourceJpegFilePath
#region working with XMP data
/// <summary>
///Gets XMP properties from Jpeg file
/// </summary>
public static void GetXMPProperties()
{
try
{
//ExStart:GetXmpPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get XMP data
XmpProperties xmpProperties = jpegFormat.GetXmpProperties();
// show XMP data
foreach (string key in xmpProperties.Keys)
{
try
{
XmpNodeView xmpNodeView = xmpProperties[key];
Console.WriteLine("[{0}] = {1}", xmpNodeView.Name, xmpNodeView.Value);
}
catch { }
}
//ExEnd:GetXmpPropertiesJpegImage
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Method used to crop image.
/// </summary>
/// <param name="inputImagePathString">input image path</param>
/// <param name="outputImagePathName">ouput image path</param>
/// <param name="x1">x</param>
/// <param name="y1">y</param>
/// <param name="width">widht of cropped image</param>
/// <param name="height">height of cropped image</param>
public static void CropImage(string inputImagePathString, String outputImagePathName, int x1, int y1, int width, int height)
{
byte[] photoBytes = File.ReadAllBytes(inputImagePathString);
// Format is automatically detected though can be changed.
ISupportedImageFormat format = new JpegFormat {
Quality = 70
};
Rectangle rectangle = new Rectangle(x1, y1, width, height);
using (MemoryStream inStream = new MemoryStream(photoBytes))
{
using (MemoryStream outStream = new MemoryStream())
{
// Initialize the ImageFactory using the overload to preserve EXIF metadata.
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
// Load, resize, set the format and quality and save an image.
imageFactory.Load(inStream)
.Crop(rectangle)
.Format(format)
.Save(outStream);
FileStream fileStream = new FileStream(outputImagePathName, FileMode.Create);
outStream.WriteTo(fileStream);
fileStream.Close();
}
// Do something with the stream.
outStream.Close();
}
}
}
private static ISupportedImageFormat GetFormatFromSelectedOutput(ImageFormat convertTo)
{
ISupportedImageFormat format = null;
switch (convertTo.ToString())
{
case "Jpeg":
format = new JpegFormat {
};
break;
case "Png":
format = new PngFormat {
};
break;
case "Tiff":
format = new TiffFormat {
};
break;
default:
break;
}
return(format);
}
public ActionResult AgregarFotoPorfolio(EditarUsuarioModel modelo)
{
if (ModelState.IsValid)
{
HttpPostedFileBase file = modelo.File;
Usuario usuarioActual = ObtenerUsuarioActual(User);
if (file != null && file.ContentLength > 0)
{
Guid guid = Guid.NewGuid();
string str = guid.ToString();
string path = Path.Combine(Server.MapPath("~/PorfoliosPictures"), str + ".jpg");
using (MemoryStream outStream = new MemoryStream())
{
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: false))
{
Size size = new Size(1000, 1000);
ISupportedImageFormat format = new JpegFormat {
Quality = 80
};
imageFactory.Load(file.InputStream)
.Constrain(size)
.BackgroundColor(Color.White)
.Format(format)
.Save(path);
}
}
//crear nueva foto porfolio
FotoPorfolio foto = new FotoPorfolio();
foto.Usuario = usuarioActual;
foto.UsuarioId = usuarioActual.Id;
foto.Url = str;
//agregarla a la lista
//if (usuarioActual.Fotos == null)
//{
// usuarioActual.Fotos = new List<FotoPorfolio>();
//}
usuarioActual.Fotos.Add(foto);
//db.Usuarios.Add(usuarioActual);
//db.SaveChanges();
db.FotosPorfolio.Add(foto);
db.SaveChangesAsync();
return(RedirectToAction("Index"));
//return View("Usuario", usuarioActual);
}
}
return(RedirectToAction("Index"));
}
public ActionResult ModificarUsuario(EditarUsuarioModel modelo)
{
if (ModelState.IsValid)
{
HttpPostedFileBase file = modelo.File;
Usuario userInfo = modelo.MyUserInfo;
if (userInfo.Fotos == null)
{
userInfo.Fotos = new List <FotoPorfolio>();
}
if (file != null && file.ContentLength > 0)
{
Guid guid = Guid.NewGuid();
string str = guid.ToString();
string path = Path.Combine(Server.MapPath("~/ProfilePictures"), str + ".jpg");
using (MemoryStream outStream = new MemoryStream())
{
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: false))
{
Size size = new Size(200, 200);
ISupportedImageFormat format = new JpegFormat {
Quality = 80
};
imageFactory.Load(file.InputStream)
.Constrain(size)
.BackgroundColor(Color.White)
.Format(format)
.Save(path);
}
}
userInfo.URLFotoPerfil = str;
}
Usuario usuarioActual = ObtenerUsuarioActual(User);
//copiar una por una las propiedades al usuario actual
usuarioActual.Apellido = userInfo.Apellido;
usuarioActual.Descripcion = userInfo.Descripcion;
usuarioActual.Email = userInfo.Descripcion;
usuarioActual.Facebook = userInfo.Facebook;
usuarioActual.Instagram = userInfo.Instagram;
usuarioActual.Nombre = userInfo.Nombre;
usuarioActual.Rol = userInfo.Rol;
usuarioActual.Telefono = userInfo.Telefono;
usuarioActual.URLFotoPerfil = userInfo.URLFotoPerfil;
usuarioActual.Website = userInfo.Website;
db.Entry(usuarioActual).State = EntityState.Modified;
db.SaveChanges();
return(View("Usuario", ObtenerUsuarioActual(User)));
}
return(View(modelo));
}
public static void ConvertToJPGHQ(string path)
{
ISupportedImageFormat jpgFormat = new JpegFormat {
Quality = 100
};
ConvertWebPToImage(path, jpgFormat, ".jpg");
}
private void ConvertToJPGNQ(string path)
{
ISupportedImageFormat jpgFormat = new JpegFormat {
Quality = 80
};
ConvertWebPToImage(path, jpgFormat, ".jpg");
}
public void ResizeImg(string file)
{
var replace = true;
if (file == "")
{
file = @"D:\img.jpeg";
}
var outfile = file;
if (!replace)
{
outfile = file.Replace(".jpeg", "_out" + DateTime.Now.ToString("MMddHHmmss") + ".jpeg");
}
var minDimMax = 256;
byte[] photoBytes = File.ReadAllBytes(file);
using (MemoryStream inStream = new MemoryStream(photoBytes))
{
using (var img = System.Drawing.Image.FromStream(inStream))
{
var w = img.Width;
var h = img.Height;
//if (w > minDimMax && h > minDimMax)
//{
// Format is automatically detected though can be changed.
ISupportedImageFormat format = new JpegFormat {
Quality = 90
};
Size size1 = new Size(minDimMax, minDimMax * 10);
Size size2 = new Size(minDimMax * 10, minDimMax);
var resize1 = new ResizeLayer(size1, ResizeMode.Max);
var resize2 = new ResizeLayer(size2, ResizeMode.Max);
ResizeLayer layer = w < h ? resize1 : resize2;
using (MemoryStream outStream = new MemoryStream())
{
// Initialize the ImageFactory using the overload to preserve EXIF metadata.
using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true))
{
// Load, resize, set the format and quality and save an image.
imageFactory.Load(inStream)
.Resize(layer)
.Format(format)
.Save(outfile);
}
}
//}
//else if (!replace)
//{
// File.Copy(file, outfile);
//}
}
}
}
/// <summary>
/// Updates XMP data of Jpeg file and creates output file
/// </summary>
public static void UpdateXMPProperties()
{
try
{
//ExStart:UpdateXmpPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get xmp wrapper
XmpPacketWrapper xmpPacket = jpegFormat.GetXmpData();
// create xmp wrapper if not exists
if (xmpPacket == null)
{
xmpPacket = new XmpPacketWrapper();
}
// check if DublinCore schema exists
if (!xmpPacket.ContainsPackage(Namespaces.DublinCore))
{
// if not - add DublinCore schema
xmpPacket.AddPackage(new DublinCorePackage());
}
// get DublinCore package
DublinCorePackage dublinCorePackage = (DublinCorePackage)xmpPacket.GetPackage(Namespaces.DublinCore);
string authorName = "New author";
string description = "New description";
string subject = "New subject" ;
string publisher = "New publisher";
string title = "New title";
// set author
dublinCorePackage.SetAuthor(authorName);
// set description
dublinCorePackage.SetDescription(description);
// set subject
dublinCorePackage.SetSubject(subject);
// set publisher
dublinCorePackage.SetPublisher(publisher);
// set title
dublinCorePackage.SetTitle(title);
// update XMP package
jpegFormat.SetXmpData(xmpPacket);
// commit changes
jpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:UpdateXmpPropertiesJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
public void RemoveXMPData()
{
try
{
//ExStart:RemoveXMPData
// create new instance of JpegFormat
JpegFormat jpeg = new JpegFormat(@"C:\image.jpg");
// use RemoveXmpData method to remove xmp metadata
jpeg.RemoveXmpData();
//ExEnd:RemoveXMPData
}
catch (Exception exp)
{
}
}
/// <summary>
/// Detects barcodes in the Jpeg
/// </summary>
public static void DetectBarcodeinJpeg()
{
//ExStart:DetectBarcodeinJpeg
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(barcodeFilePath));
// get barcodes: UPCA, UPCE, EAN13
string[] barCodes = jpegFormat.GetBarCodeTypes();
Console.WriteLine("Barcode Detected:\n");
for (int i = 0; i < barCodes.Length; i++)
{
Console.WriteLine("Code Type: {0}", barCodes[i].ToString());
}
//ExEnd:DetectBarcodeinJpeg
}
/// <summary>
///Update ApplicationRecord/EnvelopeRecord datasets of IPTC metadata
/// </summary>
public static void UpdateIPTCMetadataOfApplicationRecord()
{
try
{
//ExStart:UpdateIPTCMetadataOfApplicationRecord
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// initialize dataset
IptcApplicationRecord applicationRecord = new IptcApplicationRecord();
// update category
applicationRecord.Category = "category";
// update copyright notice
applicationRecord.CopyrightNotice = "Aspose";
// update release date
applicationRecord.ReleaseDate = DateTime.Now;
// update iptc metadata
jpegFormat.UpdateIptc(applicationRecord);
// and commit changes
jpegFormat.Save();
//EXEnd:UpdateIPTCMetadataOfApplicationRecord
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Remove IPTC metadata of Jpeg file
/// </summary>
public static void RemoveIPTCMetadataOfJPEG()
{
try
{
//ExStart:RemoveIPTCMetadataOfJPEG
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// remove iptc
jpegFormat.RemoveIptc();
// and commit changes
jpegFormat.Save();
//ExEnd:RemoveIPTCMetadataOfJPEG
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Updates IPTC metadata of Jpeg file
/// </summary>
public static void UpdateIPTCMetadataOfJPEG()
{
try
{
//ExStart:UpdateIPTCMetadataOfJPEG
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// initialize IptcCollection
IptcCollection collection = new IptcCollection();
// add string property
collection.Add(new IptcProperty(2, "category", 15, "formats"));
// add integer property
collection.Add(new IptcProperty(2, "urgency", 10, 5));
// update iptc metadata
jpegFormat.UpdateIptc(collection);
// and commit changes
jpegFormat.Save();
//ExEnd:UpdateIPTCPhotoMetadataFromXMP
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Updates Basic Job XMP data of Jpeg file and creates output file
/// </summary>
public static void UpdateBasicJobXMPProperties()
{
try
{
//ExStart:UpdateBasicJobTicketXmpPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get xmp data
var xmp = jpegFormat.GetXmpData();
BasicJobTicketPackage package = null;
// looking for the BasicJob schema if xmp data is presented
if (xmp != null)
{
package = xmp.GetPackage(Namespaces.BasicJob) as BasicJobTicketPackage;
}
else
{
xmp = new XmpPacketWrapper();
}
if (package == null)
{
// create package if not exist
package = new BasicJobTicketPackage();
// and add it to xmp data
xmp.AddPackage(package);
}
// create array of jobs
Job[] jobs = new Job[1];
jobs[0] = new Job()
{
Id = "1",
Name = "test job"
};
// update schema
package.SetJobs(jobs);
// update xmp data
jpegFormat.SetXmpData(xmp);
// commit changes
jpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:UpdateBasicJobTicketXmpPropertiesJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Reads Image Resource Blocks (native PSD metadata) in Jpeg format
/// </summary>
public static void ReadImageResourceBlocks()
{
try
{
//ExStart:ReadImageResourceBlocksInJpeg
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// check if JPEG contain photoshop metadata
if (jpegFormat.HasImageResourceBlocks)
{
// get native photoshop metadata
ImageResourceMetadata imageResource = jpegFormat.GetImageResourceBlocks();
// display all blocks
foreach (ImageResourceBlock imageResourceBlock in imageResource.Blocks)
{
Console.WriteLine("Id: {0}, size: {1}", imageResourceBlock.DefinedId, imageResourceBlock.DataSize);
// create your own logic to parse image resource block
byte[] data = imageResourceBlock.Data;
}
}
//ExEnd:ReadImageResourceBlocksInJpeg
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Removes Exif info of Jpeg file and creates output file
/// </summary>
public static void RemoveExifInfo()
{
try
{
//ExStart:RemoveExifPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// remove Exif info
jpegFormat.RemoveExifInfo();
// commit changes
jpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:RemoveExifPropertiesJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Removes GPS Data of Jpeg file and creates output file
/// </summary>
public static void RemoveGPSData()
{
try
{
//ExStart:RemoveGPSDataJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get location
GpsLocation location = jpegFormat.GetGpsLocation();
if (location != null)
{
// remove GPS location
jpegFormat.RemoveGpsLocation();
}
// commit changes
jpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:RemoveGPSDataJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Updates Exif info using properties and creates output file
/// </summary>
public static void UpdateExifInfoUsingProperties()
{
try
{
//ExStart:UpdateExifValuesUsingPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get EXIF data
JpegExifInfo exif = (JpegExifInfo)jpegFormat.ExifValues;
// set artist
exif.Artist = "new test artist";
// set the name of the camera's owner
exif.CameraOwnerName = "new camera owner's name";
// set description
exif.ImageDescription = "update test description";
// commit changes
jpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:UpdateExifValuesUsingPropertiesJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Updates Exif info of Jpeg file and creates output file
/// </summary>
public static void UpdateExifInfo()
{
try
{
//ExStart:UpdateExifPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get EXIF data
JpegExifInfo exif = (JpegExifInfo)jpegFormat.GetExifInfo();
if (exif == null)
{
// initialize EXIF data if null
exif = new JpegExifInfo();
}
// set artist
exif.Artist = "Usman";
// set make
exif.Make = "ABC";
// set model
exif.Model = "S120";
// set the name of the camera's owner
exif.CameraOwnerName = "Owner";
// set description
exif.ImageDescription = "sample description";
// update EXIF data
jpegFormat.SetExifInfo(exif);
// commit changes
jpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:UpdateExifPropertiesJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Gets Exif info from Jpeg file
/// </summary>
public static void GetExifInfo()
{
try
{
//ExStart:GetExifPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get EXIF data
JpegExifInfo exif = (JpegExifInfo)jpegFormat.GetExifInfo();
if (exif != null)
{
// get artist
Console.WriteLine("Artist: {0}", exif.Artist);
// get description
Console.WriteLine("Description: {0}", exif.ImageDescription);
// get user's comment
Console.WriteLine("User Comment: {0}", exif.UserComment);
// get user's Model
Console.WriteLine("Model: {0}", exif.Model);
// get user's Make
Console.WriteLine("Make: {0}", exif.Make);
// get user's CameraOwnerName
Console.WriteLine("CameraOwnerName: {0}", exif.CameraOwnerName);
// get longitude
Console.WriteLine("Longitude: {0}", exif.GPSData.Longitude[0].ToString());
// get latitude
Console.WriteLine("Latitude: {0}", exif.GPSData.Latitude[0].ToString());
}
//ExEnd:GetExifPropertiesJpegImage
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Updates thumbnails in XMP data of Jpeg file and creates output file
/// </summary>
public static void UpdateThumbnailInXMPData()
{
try
{
//ExStart:UpdateThumbnailXmpPropertiesJpegImage
string path = Common.MapSourceFilePath(filePath);
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get image base64 string
string base64String;
using (Image image = Image.FromFile(path))
{
using (MemoryStream m = new MemoryStream())
{
image.Save(m, image.RawFormat);
byte[] imageBytes = m.ToArray();
// Convert byte[] to Base64 String
base64String = Convert.ToBase64String(imageBytes);
}
}
// create image thumbnail
Thumbnail thumbnail = new Thumbnail { ImageBase64 = base64String };
// initialize array and add thumbnail
Thumbnail[] thumbnails = new Thumbnail[1];
thumbnails[0] = thumbnail;
// update thumbnails property in XMP Basic schema
jpegFormat.XmpValues.Schemes.XmpBasic.Thumbnails = thumbnails;
// commit changes
jpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:UpdateThumbnailXmpPropertiesJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Removes Photoshop Metadata in Jpeg format
/// </summary>
public static void RemovePhotoshopMetadata()
{
try
{
//ExStart:RemovePhotoshopMetadataJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// remove photoshop metadata
jpegFormat.RemovePhotoshopData();
// and commit changes
jpegFormat.Save();
//ExEnd:RemovePhotoshopMetadataJpegImage
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Updates XMP values of Jpeg file and creates output file
/// </summary>
public static void UpdateXMPValues()
{
try
{
//ExStart:UpdateXmpValuesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
const string dcFormat = "test format";
string[] dcContributors = { "test contributor" };
const string dcCoverage = "test coverage";
const string phCity = "NY";
const string phCountry = "USA";
const string xmpCreator = "GroupDocs.Metadata";
jpegFormat.XmpValues.Schemes.DublinCore.Format = dcFormat;
jpegFormat.XmpValues.Schemes.DublinCore.Contributors = dcContributors;
jpegFormat.XmpValues.Schemes.DublinCore.Coverage = dcCoverage;
jpegFormat.XmpValues.Schemes.Photoshop.City = phCity;
jpegFormat.XmpValues.Schemes.Photoshop.Country = phCountry;
jpegFormat.XmpValues.Schemes.XmpBasic.CreatorTool = xmpCreator;
// commit changes
jpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:UpdateXmpValuesJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Read Specific Exif tag
/// </summary>
///
public static void ReadExifTag()
{
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get EXIF data
ExifInfo exifInfo = jpegFormat.GetExifInfo();
if (exifInfo != null)
{
// get specific tag using indexer
TiffAsciiTag artist = (TiffAsciiTag)exifInfo[TiffTagIdEnum.Artist];
if (artist != null)
{
Console.WriteLine("Artist: {0}", artist.Value);
}
}
}
/// <summary>
/// Read All Exif tags
/// </summary>
///
public static void ReadAllExifTags()
{
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get EXIF data
ExifInfo exifInfo = jpegFormat.GetExifInfo();
if (exifInfo != null)
{
TiffTag[] allTags = exifInfo.Tags;
foreach (TiffTag tag in allTags)
{
switch (tag.TagType)
{
case TiffTagType.Ascii:
TiffAsciiTag asciiTag = tag as TiffAsciiTag;
Console.WriteLine("Tag: {0}, value: {1}", asciiTag.DefinedTag, asciiTag.Value);
break;
case TiffTagType.Rational:
TiffRationalTag rationalTag = tag as TiffRationalTag;
Console.WriteLine("Tag: {0}, value: {1}", rationalTag.DefinedTag, rationalTag.Value);
break;
}//end of switch
}//end of foreach
}//end of if (exifInfo != null)
}
/// <summary>
/// Gets IPTC metadata from Jpeg file
/// </summary>
public static void GetIPTCMetadata()
{
try
{
//ExStart:GetIPTCMetadata
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// if file contains iptc metadata
if (jpegFormat.HasIptc)
{
// get iptc collection
IptcCollection iptcCollection = jpegFormat.GetIptc();
// go through array and write property name and formatted value
foreach (IptcProperty iptcProperty in iptcCollection)
{
Console.WriteLine(string.Format("{0}: {1}", iptcProperty.Name, iptcProperty.GetFormattedValue()));
}
// initialize IptcDataSetCollection to read well-known properties
IptcDataSetCollection dsCollection = new IptcDataSetCollection(iptcCollection);
// try to read Application Record dataset
if (dsCollection.ApplicationRecord != null)
{
// get category
string category = dsCollection.ApplicationRecord.Category;
// get headline
string headline = dsCollection.ApplicationRecord.Headline;
}
if (dsCollection.EnvelopeRecord != null)
{
// get model version
int? modelVersion = dsCollection.EnvelopeRecord.ModelVersion;
// get dataSent property
DateTime? dataSent = dsCollection.EnvelopeRecord.DataSent;
}
}
//ExEnd:GetIPTCMetadata
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Updates CameraRaw XMP data of Jpeg file and creates output file
/// </summary>
public static void UpdateCameraRawXMPProperties()
{
try
{
//ExStart:UpdateCameraRawXmpPropertiesJpegImage
// initialize JpegFormat
JpegFormat JpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get access to CameraRaw schema
var package = JpegFormat.XmpValues.Schemes.CameraRaw;
// update properties
package.AutoBrightness = true;
package.AutoContrast = true;
package.CropUnits = CropUnits.Pixels;
// update white balance
package.SetWhiteBalance(WhiteBalance.Auto);
// commit changes
JpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:UpdateCameraRawXmpPropertiesJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
/// <summary>
/// Updates PagedText XMP data of Jpeg file and creates output file
/// </summary>
public static void UpdatePagedTextXMPProperties()
{
try
{
//ExStart:UpdatePagedTextXmpPropertiesJpegImage
// initialize JpegFormat
JpegFormat jpegFormat = new JpegFormat(Common.MapSourceFilePath(filePath));
// get access to PagedText schema
var package = jpegFormat.XmpValues.Schemes.PagedText;
// update MaxPageSize
package.MaxPageSize = new Dimensions(600, 800);
// update number of pages
package.NumberOfPages = 10;
// update plate names
package.PlateNames = new string[] { "1", "2", "3" };
// commit changes
jpegFormat.Save(Common.MapDestinationFilePath(filePath));
//ExEnd:UpdatePagedTextXmpPropertiesJpegImage
Console.WriteLine("File saved in destination folder.");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
}
