Gary Sharp
314 lines
12 KiB
C#
314 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.IO;
|
|
using System.Drawing.Imaging;
|
|
|
|
namespace Disco.BI.Extensions
|
|
{
|
|
public static class UtilityExtensions
|
|
{
|
|
|
|
public static string StreamToString(this System.IO.Stream stream)
|
|
{
|
|
if (stream.Position != 0 && stream.CanSeek)
|
|
{
|
|
stream.Position = 0;
|
|
}
|
|
using (System.IO.StreamReader sr = new System.IO.StreamReader(stream))
|
|
{
|
|
return sr.ReadToEnd();
|
|
}
|
|
}
|
|
|
|
#region Date/Time Extensions
|
|
public static string ToFuzzy(this DateTime d)
|
|
{
|
|
var n = DateTime.Now;
|
|
|
|
// Today
|
|
if (d.Date == n.Date)
|
|
{
|
|
if (d < n)
|
|
{
|
|
// Earlier
|
|
if (d > n.AddMinutes(-1))
|
|
return "A moment ago";
|
|
|
|
if (d > n.AddMinutes(-10))
|
|
return "A few minutes ago";
|
|
}
|
|
else
|
|
{
|
|
// Later
|
|
if (d < n.AddMinutes(1))
|
|
return "In a moment";
|
|
|
|
if (d < n.AddMinutes(10))
|
|
return "In a few minutes";
|
|
}
|
|
|
|
return string.Format("Today at {0:h:mm tt}", d);
|
|
}
|
|
|
|
if (d.Date < n.Date)
|
|
{
|
|
// PAST
|
|
var dif = n.Subtract(d);
|
|
|
|
// Yesterday
|
|
if (d.Date == n.Date.AddDays(-1))
|
|
return string.Format("Yesterday at {0:h:mm tt}", d);
|
|
// Last Week
|
|
if (dif.TotalDays <= 7)
|
|
return string.Format("Last {0:dddd} at {0:h:mm tt}", d);
|
|
// Within 8 Weeks
|
|
if (d > n.Date.AddMonths(-2))
|
|
return string.Format("{0} Weeks ago, {1:ddd, d MMM}", (int)(dif.TotalDays / 7), d);
|
|
// Same Year
|
|
if (d.Year == n.Year)
|
|
return string.Format("{0} Months ago, {1:ddd, d MMM}", (int)(dif.TotalDays / 30), d);
|
|
}
|
|
else
|
|
{
|
|
// Future
|
|
var dif = d.Subtract(n);
|
|
|
|
// Tomorrow
|
|
if (d.Date == n.Date.AddDays(1))
|
|
return string.Format("Tomorrow at {0:h:mm tt}", d);
|
|
// Next Week
|
|
if (dif.TotalDays <= 7)
|
|
return string.Format("Next {0:dddd} at {0:h:mm tt}", d);
|
|
// < 2 Month
|
|
if (d < n.Date.AddMonths(2))
|
|
return string.Format("In {0} Weeks, {1:ddd, d MMM}", (int)(dif.TotalDays / 7), d);
|
|
// Same Year
|
|
if (d.Year == n.Year)
|
|
return string.Format("In {0} Months, {1:ddd, d MMM}", (int)(dif.TotalDays / 30), d);
|
|
}
|
|
|
|
return d.ToString("ddd, d MMM yyyy");
|
|
}
|
|
public static string ToFuzzy(this DateTime? d, string NullValue = "N/A")
|
|
{
|
|
if (d.HasValue)
|
|
return ToFuzzy(d.Value);
|
|
else
|
|
return NullValue;
|
|
}
|
|
public static string ToFullDateTime(this DateTime d)
|
|
{
|
|
return d.ToString("ddd, d MMM yyyy @ h:mm:sstt");
|
|
}
|
|
public static string ToFullDateTime(this DateTime? d, string NullValue = "N/A")
|
|
{
|
|
if (d.HasValue)
|
|
return ToFullDateTime(d.Value);
|
|
else
|
|
return NullValue;
|
|
}
|
|
public static long ToSortableDateTime(this DateTime? d)
|
|
{
|
|
if (d.HasValue)
|
|
return d.Value.ToBinary();
|
|
else
|
|
return -1;
|
|
}
|
|
public static long ToSortableDateTime(this DateTime d)
|
|
{
|
|
return d.ToBinary();
|
|
}
|
|
#endregion
|
|
|
|
#region Image Extensions
|
|
public static Bitmap ResizeImage(this Image Source, int Width, int Height, Brush BackgroundColor = null)
|
|
{
|
|
Bitmap destination = new Bitmap(Width, Height);
|
|
destination.SetResolution(72, 72);
|
|
using (Graphics destinationGraphics = Graphics.FromImage(destination))
|
|
{
|
|
destinationGraphics.CompositingQuality = CompositingQuality.HighQuality;
|
|
destinationGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
|
|
destinationGraphics.SmoothingMode = SmoothingMode.HighQuality;
|
|
|
|
if (BackgroundColor != null)
|
|
destinationGraphics.FillRectangle(BackgroundColor, destinationGraphics.VisibleClipBounds);
|
|
|
|
float ratio = Math.Min((float)(destination.Width) / (float)(Source.Width), (float)(destination.Height) / (float)(Source.Height));
|
|
|
|
destinationGraphics.DrawImageResized(Source, ratio);
|
|
}
|
|
|
|
return destination;
|
|
}
|
|
public static void DrawImageResized(this Graphics graphics, Image SourceImage, float? Scale = null, float LocationX = -1, float LocationY = -1)
|
|
{
|
|
RectangleF clipBounds = graphics.VisibleClipBounds;
|
|
if (Scale == null) // Calculate Scale
|
|
Scale = Math.Min(clipBounds.Width / SourceImage.Width, clipBounds.Height / SourceImage.Height);
|
|
float newWidth = SourceImage.Width * Scale.Value;
|
|
float newHeight = SourceImage.Height * Scale.Value;
|
|
float newLeft = LocationX;
|
|
float newTop = LocationY;
|
|
|
|
if (newLeft < 0 || newTop < 0)
|
|
{
|
|
if (newWidth < clipBounds.Width)
|
|
newLeft = (clipBounds.Width - newWidth) / 2;
|
|
else
|
|
newLeft = 0;
|
|
if (newHeight < clipBounds.Height)
|
|
newTop = (clipBounds.Height - newHeight) / 2;
|
|
else
|
|
newTop = 0;
|
|
}
|
|
newLeft += clipBounds.Left;
|
|
newTop += clipBounds.Top;
|
|
|
|
graphics.DrawImage(SourceImage, new RectangleF(newLeft, newTop, newWidth, newHeight), new RectangleF(0, 0, SourceImage.Width, SourceImage.Height), GraphicsUnit.Pixel);
|
|
}
|
|
public static void EmbedIconOverlay(this Image Source, Image Icon)
|
|
{
|
|
int top = Math.Max(0, Source.Height - Icon.Height);
|
|
int left = Math.Max(0, Source.Width - Icon.Width);
|
|
|
|
using (Graphics sourceGraphics = Graphics.FromImage(Source))
|
|
{
|
|
sourceGraphics.DrawImage(Icon, left, top);
|
|
}
|
|
}
|
|
public static void SavePng(this Image Source, string Filename)
|
|
{
|
|
using (FileStream outStream = new FileStream(Filename, FileMode.Create, FileAccess.Write, FileShare.None))
|
|
{
|
|
SavePng(Source, outStream);
|
|
outStream.Flush();
|
|
outStream.Close();
|
|
}
|
|
}
|
|
public static void SavePng(this Image Source, Stream OutStream)
|
|
{
|
|
Source.Save(OutStream, ImageFormat.Png);
|
|
}
|
|
public static Stream SavePng(this Image Source)
|
|
{
|
|
MemoryStream outStream = new MemoryStream();
|
|
Source.SavePng(outStream);
|
|
outStream.Position = 0;
|
|
return outStream;
|
|
}
|
|
public static Stream SaveJpg(this Image Source, int Quality)
|
|
{
|
|
MemoryStream outStream = new MemoryStream();
|
|
Source.SaveJpg(Quality, outStream);
|
|
outStream.Position = 0;
|
|
return outStream;
|
|
}
|
|
public static void SaveJpg(this Image Source, int Quality, string Filename)
|
|
{
|
|
using (FileStream outStream = new FileStream(Filename, FileMode.Create, FileAccess.Write, FileShare.None))
|
|
{
|
|
SaveJpg(Source, Quality, outStream);
|
|
outStream.Flush();
|
|
outStream.Close();
|
|
}
|
|
}
|
|
public static void SaveJpg(this Image Source, int Quality, Stream OutStream)
|
|
{
|
|
ImageCodecInfo jpgCodec = ImageCodecInfo.GetImageEncoders().Where(c => c.MimeType.Equals("image/jpeg", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
|
|
if (jpgCodec != null)
|
|
{
|
|
if (Quality < 0 || Quality > 100)
|
|
throw new ArgumentOutOfRangeException("Quality", "Quality must be a positive integer <= 100");
|
|
using (EncoderParameters ep = new EncoderParameters(1))
|
|
{
|
|
ep.Param[0] = new EncoderParameter(Encoder.Quality, Quality);
|
|
Source.Save(OutStream, jpgCodec, ep);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fallback
|
|
Source.Save(OutStream, ImageFormat.Jpeg);
|
|
}
|
|
}
|
|
public static ImageMontage BuildImageMontage(this IEnumerable<Image> Images, int MaxHeight = -1, int MaxWidth = -1, bool EnforceDimensions = false)
|
|
{
|
|
if (EnforceDimensions && (MaxHeight < 0 || MaxWidth < 0))
|
|
throw new ArgumentOutOfRangeException("EnforceDimensions", "Dimensions can only be enforced when a MaxHeight and MaxWidth is supplied");
|
|
|
|
Dictionary<Image, int> imageLocations = new Dictionary<Image, int>();
|
|
double imageScale = 1.0;
|
|
int totalHeight = Images.Max(i => i.Height);
|
|
int totalWidth = Images.Sum(i => i.Width);
|
|
if (MaxHeight > 0 && totalHeight > MaxHeight)
|
|
{
|
|
imageScale = (double)MaxHeight / (double)totalHeight;
|
|
}
|
|
if (MaxWidth > 0 && totalWidth > MaxWidth)
|
|
{
|
|
imageScale = System.Math.Min(imageScale, (double)MaxWidth / (double)totalWidth);
|
|
}
|
|
int scaledHeight = EnforceDimensions ? MaxHeight : (int)System.Math.Round((double)totalHeight * imageScale);
|
|
int scaledWidth = EnforceDimensions ? MaxWidth : (int)System.Math.Round((double)totalWidth * imageScale);
|
|
System.Drawing.Bitmap imageResult = new System.Drawing.Bitmap(scaledWidth, scaledHeight);
|
|
imageResult.SetResolution(72f, 72f);
|
|
|
|
using (Graphics g = Graphics.FromImage(imageResult))
|
|
{
|
|
g.FillRectangle(Brushes.White, new Rectangle(Point.Empty, imageResult.Size));
|
|
|
|
int imageResultNextOffset = 0;
|
|
foreach (Image i in Images)
|
|
{
|
|
Rectangle imagePosition = new Rectangle(imageResultNextOffset, 0, (int)System.Math.Round((double)i.Width * imageScale), (int)System.Math.Round((double)i.Height * imageScale));
|
|
System.Drawing.Rectangle imageSize = new System.Drawing.Rectangle(0, 0, i.Width, i.Height);
|
|
g.DrawImage(i, imagePosition, imageSize, System.Drawing.GraphicsUnit.Pixel);
|
|
imageLocations[i] = imageResultNextOffset;
|
|
imageResultNextOffset += imagePosition.Width;
|
|
}
|
|
}
|
|
|
|
return new ImageMontage() { Montage = imageResult, MontageScale = imageScale, MontageSourceImageOffsets = imageLocations };
|
|
}
|
|
public class ImageMontage : IDisposable
|
|
{
|
|
|
|
public Image Montage { get; set; }
|
|
public double MontageScale { get; set; }
|
|
public Dictionary<Image, int> MontageSourceImageOffsets { get; set; }
|
|
|
|
public void Dispose()
|
|
{
|
|
if (Montage != null)
|
|
{
|
|
Montage.Dispose();
|
|
Montage = null;
|
|
}
|
|
if (MontageSourceImageOffsets != null)
|
|
{
|
|
MontageSourceImageOffsets.Clear();
|
|
MontageSourceImageOffsets = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Color InterpolateColours(this Color Start, Color End, double Progress)
|
|
{
|
|
if (Progress > 1 || Progress < 0)
|
|
throw new ArgumentOutOfRangeException("Progress", "Progress must be >= 0 && <= 1");
|
|
|
|
return Color.FromArgb(
|
|
(byte)(Start.A * (1 - Progress) + (End.A * Progress)),
|
|
(byte)(Start.R * (1 - Progress) + (End.R * Progress)),
|
|
(byte)(Start.G * (1 - Progress) + (End.G * Progress)),
|
|
(byte)(Start.B * (1 - Progress) + (End.B * Progress))
|
|
);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|