/// <summary>
/// The get image format.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <returns>
/// </returns>
private static ImageFormat GetImageFormat(IImageParameters parameters)
{
if (parameters.Parameters.ContainsKey("format"))
{
string imageTypeParameter = parameters.Parameters["format"];
if (!string.IsNullOrEmpty(imageTypeParameter))
{
switch (imageTypeParameter.ToLowerInvariant())
{
case "png":
return(ImageFormat.Png);
case "gif":
return(ImageFormat.Gif);
case "jpg":
return(ImageFormat.Jpeg);
case "tif":
return(ImageFormat.Tiff);
}
}
}
return(ImageFormat.Jpeg);
}
/// <summary>
/// The process.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="context">
/// The context.
/// </param>
/// <param name="bitmap">
/// The bitmap.
/// </param>
/// <returns>
/// The process.
/// </returns>
public bool Process(IImageParameters parameters, HttpContext context, ref Bitmap bitmap)
{
if (parameters.Parameters.ContainsKey("watermark"))
{
string watermarkParameter = parameters["watermark"];
if (string.IsNullOrEmpty(watermarkParameter))
{
return(false);
}
float fontSize = 15;
if (!string.IsNullOrEmpty(parameters["watermark_fontsize"]))
{
fontSize = (float)Convert.ToDouble(parameters["watermark_fontsize"]);
}
int alpha = 20;
if (!string.IsNullOrEmpty(parameters["watermark_opacity"]))
{
alpha = Convert.ToInt32(parameters["watermark_opacity"]);
}
Color color = Color.White;
if (!string.IsNullOrEmpty(parameters["watermark_color"]))
{
color = Color.FromName(parameters["watermark_color"]);
}
IImageTool imageTool = Factory.GetImageTool();
bitmap = imageTool.Watermark(bitmap, watermarkParameter, fontSize, alpha, color);
return(true);
}
return(false);
}
/// <summary>
/// Retrieve or update cache, and write to output stream
/// </summary>
/// <param name="context">
/// </param>
/// <exception cref="ApplicationException">
/// Unable to determine image parameter provider
/// </exception>
public void ProcessRequest(HttpContext context)
{
IImageParameters parameters = Factory.GetImageParameters();
if (parameters == null)
{
throw new ApplicationException("Unable to determine image parameter provider");
}
// add query string to the parameters...
parameters.AddCollection(context);
if (string.IsNullOrEmpty(parameters.ImageSrc))
{
// parameters aren't assigned...
return;
}
// add file updated parameter if available...
Factory.GetImageProvider().AddImageLastUpdatedParameter(parameters);
string key = parameters.Key;
string eTag = string.Format(@"""{0}""", key);
if (CheckETag(context, eTag))
{
return;
}
ImageFormat imageFormat = GetImageFormat(parameters);
byte[] imageData = s_ImageStore.GetImageData(key);
if (imageData.IsNull())
{
imageData = this.GetImageData(parameters, context, imageFormat);
if (imageData.IsNull())
{
return;
}
s_ImageStore.PutImageData(key, imageData);
}
context.Response.Cache.SetCacheability(HttpCacheability.Public);
context.Response.Cache.SetETag(eTag);
context.Response.Cache.SetExpires(DateTime.Now.AddYears(1));
context.Response.ContentType = "image/" + imageFormat.ToString().ToLower();
context.Response.OutputStream.Write(imageData, 0, imageData.Length);
}
private string GetMappedFileFromParams(IImageParameters parameters)
{
if (string.IsNullOrEmpty(parameters.GetImageSrc()))
{
return null;
}
if (FileSystemHelpers.FileExists(parameters.GetImageSrc()))
{
return parameters.GetImageSrc();
}
string filePath = HostingEnvironment.MapPath(parameters.GetImageSrc());
return FileSystemHelpers.FileExists(filePath) ? filePath : null;
}
public void AddImageLastUpdatedParameter(IImageParameters parameters)
{
string fileName = this.GetMappedFileFromParams(parameters);
if (!string.IsNullOrEmpty(fileName))
{
DateTime fileUpdated = File.GetLastWriteTimeUtc(fileName);
if (parameters.Parameters.ContainsKey(ImageLastUpdatedKey))
{
parameters.Parameters.Remove(ImageLastUpdatedKey);
}
parameters.Parameters.Add(ImageLastUpdatedKey, fileUpdated.ToString());
}
}
/// <summary>
/// The get image last updated.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
public void AddImageLastUpdatedParameter(IImageParameters parameters)
{
string fileName = this.GetMappedFileFromParams(parameters);
if (!string.IsNullOrEmpty(fileName))
{
DateTime fileUpdated = File.GetLastWriteTimeUtc(fileName);
if (parameters.Parameters.ContainsKey(ImageLastUpdatedKey))
{
parameters.Parameters.Remove(ImageLastUpdatedKey);
}
parameters.Parameters.Add(ImageLastUpdatedKey, fileUpdated.ToString());
}
}
/// <summary>
/// The get mapped file from params.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <returns>
/// The get mapped file from params.
/// </returns>
private string GetMappedFileFromParams(IImageParameters parameters)
{
if (string.IsNullOrEmpty(parameters.ImageSrc))
{
return(null);
}
if (FileSystemHelpers.FileExists(parameters.ImageSrc))
{
return(parameters.ImageSrc);
}
string filePath = HostingEnvironment.MapPath(parameters.ImageSrc);
return(FileSystemHelpers.FileExists(filePath) ? filePath : null);
}
/// <summary>
/// The process.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="context">
/// The context.
/// </param>
/// <param name="bitmap">
/// The bitmap.
/// </param>
/// <returns>
/// The process.
/// </returns>
public bool Process(IImageParameters parameters, HttpContext context, ref Bitmap bitmap)
{
if (parameters.Parameters.ContainsKey("rotate"))
{
string rotateParameter = parameters.Parameters["rotate"];
float angle;
if (float.TryParse(rotateParameter, NumberStyles.Float, CultureInfo.InvariantCulture, out angle))
{
IImageTool imageTool = Factory.GetImageTool();
bitmap = imageTool.Rotate(bitmap, angle);
return(true);
}
}
return(false);
}
/// <summary>
/// The process.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="context">
/// The context.
/// </param>
/// <param name="bitmap">
/// The bitmap.
/// </param>
/// <returns>
/// The process.
/// </returns>
public bool Process(IImageParameters parameters, HttpContext context, ref Bitmap bitmap)
{
if (parameters.Parameters.ContainsKey("greyscale"))
{
string greyScaleParameter = parameters.Parameters["greyscale"];
if (string.IsNullOrEmpty(greyScaleParameter))
{
return(false);
}
IImageTool imageTool = Factory.GetImageTool();
bitmap = imageTool.ToGreyScale(bitmap);
return(true);
}
return(false);
}
/// <summary>
/// The process.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="context">
/// The context.
/// </param>
/// <param name="bitmap">
/// The bitmap.
/// </param>
/// <returns>
/// The process.
/// </returns>
public bool Process(IImageParameters parameters, HttpContext context, ref Bitmap bitmap)
{
if (parameters.Parameters.ContainsKey("zoom"))
{
string zoomParameter = parameters.Parameters["zoom"];
float zoomFactor;
if (float.TryParse(zoomParameter, NumberStyles.Float, CultureInfo.InvariantCulture, out zoomFactor))
{
IImageTool imageTool = Factory.GetImageTool();
bitmap = imageTool.Zoom(bitmap, zoomFactor);
return(true);
}
}
return(false);
}
/// <summary>
/// Takes care of resizeing image from url parameters
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="context">
/// </param>
/// <param name="imageFormat">
/// </param>
/// <returns>
/// </returns>
private byte[] GetImageData(IImageParameters parameters, HttpContext context, ImageFormat imageFormat)
{
IImageProvider provider = Factory.GetImageProvider();
if (provider.IsNull())
{
throw new ApplicationException("Unable to determine image provider");
}
byte[] data = provider.GetImageData(parameters);
if (data.IsNull())
{
return(null);
}
using (var sourceImageData = new MemoryStream(data))
{
var outputImg = (Bitmap)Image.FromStream(sourceImageData);
foreach (IImageFilter imageFilter in this.m_ImageFilters)
{
Bitmap oldOutputImage = outputImg;
bool modified = imageFilter.Process(parameters, context, ref outputImg);
if (modified)
{
// Dispose old bitmap
oldOutputImage.Dispose();
}
}
using (outputImg)
{
// Encode image
return(s_ImageTool.Encode(outputImg, imageFormat));
}
}
}
/// <summary>
/// The process.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="context">
/// The context.
/// </param>
/// <param name="bitmap">
/// The bitmap.
/// </param>
/// <returns>
/// The process.
/// </returns>
public bool Process(IImageParameters parameters, HttpContext context, ref Bitmap bitmap)
{
if (parameters.Parameters.ContainsKey("width") || parameters.Parameters.ContainsKey("height"))
{
string widthParameter = parameters.Parameters.ContainsKey("width") ? parameters.Parameters["width"] : string.Empty;
string heightParameter = parameters.Parameters.ContainsKey("height")
? parameters.Parameters["height"]
: string.Empty;
int imageResizeWidth = 0;
int imageResizeHeight = 0;
// Preserve aspect only if either width or height is specified, not both.
if (!string.IsNullOrEmpty(widthParameter))
{
int width;
if (int.TryParse(widthParameter, out width))
{
imageResizeWidth = width;
}
}
if (!string.IsNullOrEmpty(heightParameter))
{
int height;
if (int.TryParse(heightParameter, out height))
{
imageResizeHeight = height;
}
}
if (imageResizeWidth == 0 && imageResizeHeight == 0)
{
imageResizeWidth = bitmap.Width;
imageResizeHeight = bitmap.Height;
}
bool constrainImageSize = true;
if (!string.IsNullOrEmpty(parameters["resize_constrain"]))
{
bool.TryParse(parameters["resize_constrain"], out constrainImageSize);
}
bool keepSquare = false;
if (!string.IsNullOrEmpty(parameters["resize_square"]))
{
bool.TryParse(parameters["resize_square"], out keepSquare);
}
Color bgColor = Color.White;
if (!string.IsNullOrEmpty(parameters["resize_bgcolor"]))
{
bgColor = Color.FromName(parameters["resize_bgcolor"]);
}
IImageTool imageTool = Factory.GetImageTool();
bitmap = imageTool.Resize(bitmap, imageResizeWidth, imageResizeHeight, constrainImageSize, keepSquare, bgColor);
return(true);
}
return(false);
}
/// <summary>
/// Takes care of resizing image from url parameters
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="context">
/// </param>
/// <param name="imageFormat">
/// </param>
/// <returns>
/// </returns>
private byte[] GetImageData(IImageParameters parameters, HttpContext context, ImageFormat imageFormat)
{
IImageProvider provider = Factory.GetImageProvider();
if (provider == null)
{
throw new ApplicationException("Unable to determine image provider");
}
var data = provider.GetImageData(parameters);
if (data == null)
{
return null;
}
Bitmap outputImg = null;
try
{
using (var sourceImageData = new MemoryStream(data)) outputImg = (Bitmap)Image.FromStream(sourceImageData);
foreach (var imageFilter in this.ImageFilters.OrderBy(s => s.Order))
{
Bitmap oldOutputImage = outputImg;
bool modified = imageFilter.Process(parameters, context, ref outputImg);
if (modified)
{
// Dispose old bitmap
try
{
oldOutputImage.Dispose();
}
catch (ObjectDisposedException)
{
}
}
}
// Encode image
return _imageTool.Encode(outputImg, imageFormat);
}
finally
{
if (outputImg != null)
{
try
{
outputImg.Dispose();
}
catch (ObjectDisposedException)
{
}
}
}
}
public byte[] GetImageData(IImageParameters parameters)
{
string fileName = this.GetMappedFileFromParams(parameters);
return string.IsNullOrEmpty(fileName) ? null : File.ReadAllBytes(fileName);
}
/// <summary>
/// The get image data.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <returns>
/// </returns>
public byte[] GetImageData(IImageParameters parameters)
{
string fileName = this.GetMappedFileFromParams(parameters);
return(string.IsNullOrEmpty(fileName) ? null : File.ReadAllBytes(fileName));
}
