public void CropAndResizeImage(HttpPostedFileBase imageFile, string outPutFilePath, string outPuthFileName, int width, int height, bool pngFormat = false)
{
try
{
var image = Image.FromStream(imageFile.InputStream);
var kalikoImage = new KalikoImage(image);
var imgCrop = kalikoImage.Scale(new FitScaling(width, height));
if (!Directory.Exists(HttpContext.Current.Server.MapPath(string.Concat("~/", outPutFilePath))))
{
Directory.CreateDirectory(HttpContext.Current.Server.MapPath(string.Concat("~/", outPutFilePath)));
}
var path = HttpContext.Current.Server.MapPath(string.Concat("~/", Path.Combine(outPutFilePath, outPuthFileName)));
if (!pngFormat)
{
imgCrop.SaveJpg(path, 99, true);
}
else
{
imgCrop.SavePng(path);
}
kalikoImage.Dispose();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
// generate a thumbnail while removing transparency and preserving aspect ratio
public static async Task <string> GenerateThumbFromUrl(string sourceUrl)
{
var randomFileName = GenerateRandomFilename();
var request = WebRequest.Create(sourceUrl);
request.Timeout = 300;
var response = request.GetResponse();
var originalImage = new KalikoImage(response.GetResponseStream())
{
BackgroundColor = Color.Black
};
originalImage.Scale(new PadScaling(MaxWidth, MaxHeight)).SaveJpg(DestinationPathThumbs + '\\' + randomFileName + ".jpg", 90);
// call upload to storage method if CDN config is enabled
if (Settings.UseContentDeliveryNetwork)
{
string tempThumbLocation = DestinationPathThumbs + '\\' + randomFileName + ".jpg";
if (FileExists(tempThumbLocation, DestinationPathThumbs))
{
await UploadBlobToStorageAsync(tempThumbLocation, "thumbs");
// delete local file after uploading to CDN
File.Delete(tempThumbLocation);
}
}
return(randomFileName + ".jpg");
}
private void Normalize(KalikoImage image)
{
byte[] byteArray = image.ByteArray;
// subtract lowest values from all pixels
byte[] lowest = FindLowestValues(image);
for (int i = 0, l = byteArray.Length; i < l; i += 4)
{
byteArray[i] -= lowest[0]; // b
byteArray[i + 1] -= lowest[1]; // g
byteArray[i + 2] -= lowest[2]; // r
}
// multiply all pixels by (255 / highest value for that channel)
byte[] highest = FindHighestValues(image);
float[] multipliers = GetMultipliers(highest);
for (int i = 0, l = byteArray.Length; i < l; i += 4)
{
byteArray[i] = (byte)Math.Round(byteArray[i] * multipliers[0]); // b
byteArray[i + 1] = (byte)Math.Round(byteArray[i + 1] * multipliers[1]); // g
byteArray[i + 2] = (byte)Math.Round(byteArray[i + 2] * multipliers[2]); // r
}
image.ByteArray = byteArray;
}
public void ApplyChromaKey(KalikoImage image)
{
unsafe {
var bitmapData = image.LockBits();
var bytesPerPixel = Image.GetPixelFormatSize(bitmapData.PixelFormat) / 8;
var height = bitmapData.Height;
var widthInBytes = bitmapData.Width * bytesPerPixel;
var startOffset = (byte *)bitmapData.Scan0;
var keyHsb = ColorSpaceHelper.RGBtoHSB(KeyColor);
Parallel.For(0, height, y => {
var currentLine = startOffset + (y * bitmapData.Stride);
for (var x = 0; x < widthInBytes; x = x + bytesPerPixel)
{
var red = currentLine[x];
var green = currentLine[x + 1];
var blue = currentLine[x + 2];
var hsb = ColorSpaceHelper.RGBtoHSB(red, green, blue);
if (Abs(hsb.Hue, keyHsb.Hue) < ToleranceHue && Abs(hsb.Saturation, keyHsb.Saturation) < ToleranceSaturnation && Abs(hsb.Brightness, keyHsb.Brightness) < ToleranceBrightness)
{
currentLine[x + 3] = 0;
}
}
});
image.UnlockBits(bitmapData);
}
}
public void CropAndResizeImage(Image image, string outPutFilePath, string outPuthFileName, int?width = null, int?height = null, bool pngFormat = false)
{
try
{
if (!width.HasValue)
{
width = new int?(image.Width);
}
if (!height.HasValue)
{
height = new int?(image.Height);
}
KalikoImage kalikoImage = new KalikoImage(image);
KalikoImage kalikoImage1 = kalikoImage.Scale(new FitScaling(width.Value, height.Value));
if (!Directory.Exists(HttpContext.Current.Server.MapPath(string.Concat("~/", outPutFilePath))))
{
Directory.CreateDirectory(HttpContext.Current.Server.MapPath(string.Concat("~/", outPutFilePath)));
}
string str = HttpContext.Current.Server.MapPath(string.Concat("~/", Path.Combine(outPutFilePath, outPuthFileName)));
if (!pngFormat)
{
kalikoImage1.SaveJpg(str, (long)99);
}
else
{
kalikoImage1.SavePng(str);
}
kalikoImage1.Dispose();
kalikoImage.Dispose();
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public void ApplyChromaKey(KalikoImage image)
{
var pixels = image.IntArray;
var keyHsb = ColorSpaceHelper.RGBtoHSB(KeyColor);
for (int i = 0; i < pixels.Length; i++)
{
int rgb = pixels[i];
int red = (rgb >> 16) & 0xff;
int green = (rgb >> 8) & 0xff;
int blue = rgb & 0xff;
HSB hsb = ColorSpaceHelper.RGBtoHSB(red, green, blue);
if (Math.Abs(hsb.Hue - keyHsb.Hue) < ToleranceHue && Math.Abs(hsb.Saturation - keyHsb.Saturation) < ToleranceSaturnation && Math.Abs(hsb.Brightness - keyHsb.Brightness) < ToleranceBrightness)
{
pixels[i] = rgb & 0xffffff;
}
else
{
pixels[i] = rgb;
}
}
image.IntArray = pixels;
}
// store uploaded avatar
public static async Task <bool> GenerateAvatar(Image inputImage, string userName, string mimetype)
{
try
{
// store avatar locally
var originalImage = new KalikoImage(inputImage);
originalImage.Scale(new PadScaling(MaxWidth, MaxHeight)).SaveJpg(DestinationPathAvatars + '\\' + userName + ".jpg", 90);
if (!Settings.UseContentDeliveryNetwork)
{
return(true);
}
// call upload to storage since CDN is enabled in config
string tempAvatarLocation = DestinationPathAvatars + '\\' + userName + ".jpg";
// the avatar file was not found at expected path, abort
if (!FileSystemUtility.FileExists(tempAvatarLocation, DestinationPathAvatars))
{
return(false);
}
// upload to CDN
await CloudStorageUtility.UploadBlobToStorageAsync(tempAvatarLocation, "avatars");
// delete local file after uploading to CDN
File.Delete(tempAvatarLocation);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
private void ChangeContrast(KalikoImage image)
{
var precalc = new byte[256];
// Precalculate all changes
for (int i = 0; i < 256; i++)
{
double val = i / 255.0;
val -= 0.5;
val *= _contrast;
val += 0.5;
val = (int)Math.Round(val * 255);
if (val < 0)
{
val = 0;
}
else if (val > 255)
{
val = 255;
}
precalc[i] = (byte)val;
}
byte[] b = image.ByteArray;
for (int i = 0, l = b.Length; i < l; i += 4)
{
b[i] = precalc[b[i]]; // b
b[i + 1] = precalc[b[i + 1]]; // g
b[i + 2] = precalc[b[i + 2]]; // r
}
image.ByteArray = b;
}
private void ChangeContrast(KalikoImage image) {
var precalc = new byte[256];
// Precalculate all changes
for(int i = 0;i < 256;i++) {
double val = i / 255.0;
val -= 0.5;
val *= _contrast;
val += 0.5;
val = (int)Math.Round(val * 255);
if(val < 0) {
val = 0;
}
else if(val > 255) {
val = 255;
}
precalc[i] = (byte)val;
}
byte[] b = image.ByteArray;
for(int i = 0, l = b.Length;i < l;i += 4) {
b[i] = precalc[b[i]]; // b
b[i + 1] = precalc[b[i + 1]]; // g
b[i + 2] = precalc[b[i + 2]]; // r
}
image.ByteArray = b;
}
/// <summary>
/// Controls if target size is larger than original size
/// </summary>
/// <param name="sourceImage"></param>
/// <returns></returns>
public bool IsTargetLargerThan(KalikoImage sourceImage)
{
var originalSize = new Size(sourceImage.Width, sourceImage.Height);
var calculatedSize = CalculateNewImageSize(originalSize);
return(originalSize.Width <= calculatedSize.Width && originalSize.Height <= calculatedSize.Height);
}
/// <summary>
/// Processes the images.
/// </summary>
/// <param name="groupName">Name of the group.</param>
public static void ProcessImages(string groupName)
{
try
{
var settings = SettingsHelper.Get();
string fileFolder = settings.BaseReportPath + "\\" + groupName;
if (Directory.Exists(fileFolder))
{
var imgLocations = Directory.GetFiles(fileFolder, "*.png", SearchOption.AllDirectories);
foreach (var imgLoc in imgLocations)
{
using (KalikoImage image = new KalikoImage(imgLoc))
{
using (KalikoImage thumb = image.Scale(new FitScaling(200, 200)))
{
thumb.SaveJpg(imgLoc.ToJpgThumbFileName(), 90);
}
image.SaveJpg(imgLoc.ToJpgImageFileName(), 90);
}
FileFolderRemover.DeleteFile(imgLoc);
}
}
}
catch (Exception ex)
{
LoggerService.LogException(ex);
}
}
private void HandleImageScanFinished(Bitmap bitmap, bool preview, bool rotate)
{
if (bitmap != null)
{
if (rotate)
{
KalikoImage img = new KalikoImage(bitmap);
img.RotateFlip(RotateFlipType.Rotate180FlipNone);
bitmap = img.GetAsBitmap();
}
m_ScannedImage = bitmap;
m_ProcessedImage = m_ImageProcessor.GetProcessedImage(m_ScannedImage, m_ProcessedMarkers);
if (preview)
{
DisplayBitmap(m_ScannedImage);
}
previewImageScanButton.Enabled = true;
previewImageProcessedButton.Enabled = true;
analyzeGenerateButton.Enabled = true;
analyzeGenerateButton.BackColor = m_ButtonColorBase;
analyzePreviewButton.Enabled = false;
verifyAddButton.Enabled = false;
verifyPreviewOwnerButton.Enabled = false;
verifyButton.Enabled = false;
verifyButton.BackColor = m_ButtonColorBase;
}
}
// generate a thumbnail while removing transparency and preserving aspect ratio
public static async Task <string> GenerateThumbFromImageUrl(string imageUrl, int timeoutInMilliseconds = 3000)
{
var randomFileName = GenerateRandomFilename();
var tempPath = Path.Combine(DestinationPathThumbs, $"{randomFileName}.jpg");
var request = WebRequest.Create(imageUrl);
request.Timeout = timeoutInMilliseconds; //Putts: extended this from 300 mills
using (var response = request.GetResponse())
{
var originalImage = new KalikoImage(response.GetResponseStream())
{
BackgroundColor = Color.Black
};
originalImage.Scale(new PadScaling(MaxWidth, MaxHeight)).SaveJpg(tempPath, 90);
}
// call upload to storage method if CDN config is enabled
if (Settings.UseContentDeliveryNetwork)
{
if (FileSystemUtility.FileExists(tempPath, DestinationPathThumbs))
{
await CloudStorageUtility.UploadBlobToStorageAsync(tempPath, "thumbs");
// delete local file after uploading to CDN
File.Delete(tempPath);
}
}
return(Path.GetFileName(tempPath));
}
public void Run()
{
// TODO:
// Grab an image from a public URL and write a function thats rescale the image to a desired format
// The use of 3rd party plugins is permitted
// For example: 100x80 (thumbnail) and 1200x1600 (preview)
// Install-Package ImageLibrary
// http://kaliko.com/image-library/
Directory.CreateDirectory(@"C:\MyImages");
var image = new KalikoImage(@"https://web.usask.ca/images/homer.jpg");
image.SaveJpg(@"C:\MyImages\org.jpg", 99);
// Create thumbnail by cropping
KalikoImage thumb = image.Scale(new CropScaling(128, 128));
thumb.SaveJpg(@"C:\MyImages\thumbnail-fit.jpg", 99);
// Create preview 1200x1600
image.Resize(1600, 1200);
image.SaveJpg(@"C:\MyImages\preview.jpg", 99);
Console.WriteLine("Images saved to C:\\MyImages\\");
}
public string Execute(FileItem item, string infile, string dest, ValuePairEnumerator configData)
{
try
{
var conf = new ChromakeyViewModel(configData);
dest = Path.Combine(Path.GetDirectoryName(dest), Path.GetFileNameWithoutExtension(dest) + ".jpg");
KalikoImage image = new KalikoImage(infile);
var x = (System.Windows.Media.Color)System.Windows.Media.ColorConverter.ConvertFromString(conf.BackgroundColor);
var filter = new ChromaKeyFilter();
filter.KeyColor = Color.FromArgb(x.R, x.G, x.B);
filter.ToleranceHue = conf.Hue;
filter.ToleranceSaturnation = conf.Saturnation / 100f;
filter.ToleranceBrightness = conf.Brigthness / 100f;
image.ApplyFilter(filter);
var res = image.Clone();
if (conf.UnsharpMask)
{
res.ApplyFilter(new UnsharpMaskFilter(1.4f, 1.32f, 5));
}
var backdrop = new KalikoImage(conf.BackgroundFile);
backdrop = backdrop.Scale(new FitScaling(image.Width, image.Height));
backdrop.BlitImage(res);
backdrop.SaveJpg(dest, 90);
return(dest);
}
catch (Exception e)
{
Log.Debug("Chromakey error", e);
}
return(null);
}
private void ChangeContrast(KalikoImage image)
{
var lookupTable = BuildLookupTable();
unsafe {
var bitmapData = image.LockBits();
var bytesPerPixel = Image.GetPixelFormatSize(bitmapData.PixelFormat) / 8;
var height = bitmapData.Height;
var widthInBytes = bitmapData.Width * bytesPerPixel;
var startOffset = (byte *)bitmapData.Scan0;
Parallel.For(0, height, y => {
var currentLine = startOffset + (y * bitmapData.Stride);
for (var x = 0; x < widthInBytes; x = x + bytesPerPixel)
{
var red = currentLine[x];
var green = currentLine[x + 1];
var blue = currentLine[x + 2];
currentLine[x] = lookupTable[red];
currentLine[x + 1] = lookupTable[green];
currentLine[x + 2] = lookupTable[blue];
}
});
image.UnlockBits(bitmapData);
}
}
internal override KalikoImage DrawResizedImage(KalikoImage sourceImage, Size calculatedSize, Size originalSize) {
var resizedImage = new KalikoImage(_targetSize, sourceImage.BackgroundColor);
KalikoImage.DrawScaledImage(resizedImage, sourceImage, (_targetSize.Width - calculatedSize.Width) / 2, (_targetSize.Height - calculatedSize.Height) / 2, calculatedSize.Width, calculatedSize.Height);
return resizedImage;
}
public void Image_Blur(ImageItem imageItem)
{
KalikoImage bluredImage = new KalikoImage(imageItem.UriSource.OriginalString);
bluredImage.ApplyFilter(new GaussianBlurFilter());
imageItem.Image = ImageToBitmapImage(bluredImage);
}
internal override KalikoImage DrawResizedImage(KalikoImage sourceImage, Size calculatedSize, Size originalSize) {
var resizedImage = new KalikoImage(calculatedSize);
KalikoImage.DrawScaledImage(resizedImage, sourceImage, 0, 0, calculatedSize.Width, calculatedSize.Height);
return resizedImage;
}
public Task ExecuteAsync(dynamic p)
{
if (!CanExecute(p))
{
return(Task.FromResult(false));
}
var image = new KalikoImage(_stream);
if (Math.Max(image.Height, image.Width) < _size)
{
_stream.Position = 0;
return(Task.FromResult(false));
}
var thumb = image.Scale(_scaling);
var ms = new MemoryStream();
thumb.SaveJpg(ms, 99);
ms.Position = 0;
p.Stream = ms;
return(Task.FromResult(true));
}
// store uploaded avatar
public static async Task <bool> GenerateAvatar(Image inputImage, string userName, string mimetype)
{
try
{
// call upload to storage if CDN config is enabled
if (Settings.UseContentDeliveryNetwork)
{
string tempAvatarLocation = DestinationPathAvatars + '\\' + userName + ".jpg";
if (FileExists(tempAvatarLocation, DestinationPathAvatars))
{
await UploadBlobToStorageAsync(tempAvatarLocation, "avatars");
// delete local file after uploading to CDN
File.Delete(tempAvatarLocation);
}
return(true);
}
// store avatar locally
var originalImage = new KalikoImage(inputImage);
originalImage.Scale(new PadScaling(MaxWidth, MaxHeight)).SaveJpg(DestinationPathAvatars + '\\' + userName + ".jpg", 90);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
private const int YSIZE = 594; // A4
public KalikoImage GetProcessedMarkers(Bitmap bitmap)
{
KalikoImage image = new KalikoImage(bitmap);
ProcessImage(image);
return(image);
}
/// <summary>Core function that applies the scaling to the image.</summary>
/// <param name="sourceImage">Image to be scaled</param>
/// <returns>Scaled image</returns>
public KalikoImage Scale(KalikoImage sourceImage)
{
var originalSize = new Size(sourceImage.Width, sourceImage.Height);
var calculatedSize = CalculateNewImageSize(originalSize);
return(DrawResizedImage(sourceImage, calculatedSize, originalSize));
}
internal override KalikoImage DrawResizedImage(KalikoImage sourceImage, Size calculatedSize, Size originalSize)
{
var resizedImage = new KalikoImage(calculatedSize);
KalikoImage.DrawScaledImage(resizedImage, sourceImage, 0, 0, calculatedSize.Width, calculatedSize.Height);
return(resizedImage);
}
internal override KalikoImage DrawResizedImage(KalikoImage sourceImage, Size calculatedSize, Size originalSize)
{
var resizedImage = new KalikoImage(_targetSize, sourceImage.BackgroundColor);
KalikoImage.DrawScaledImage(resizedImage, sourceImage, (_targetSize.Width - calculatedSize.Width) / 2, (_targetSize.Height - calculatedSize.Height) / 2, calculatedSize.Width, calculatedSize.Height);
return(resizedImage);
}
private bool IsCropValueFullImage(KalikoImage image)
{
if (_cropX == 0 && _cropY == 0 && _cropW == image.Width && _cropH == image.Height) {
return true;
}
return false;
}
private void SaveThumbnail(CreateBackgroundModel model, string thumbnailPath)
{
var sourceImage = new KalikoImage(model.File.OpenReadStream());
var fitScaling = new FitScaling(192, 108);
var image = fitScaling.Scale(sourceImage);
image.SavePng($"{_appEnvironment.WebRootPath}{thumbnailPath}");
}
private void verifyAddButton_Click(object sender, EventArgs e)
{
m_Verifier.SetIdentity(m_VerificationScanFeatures);
m_VerificationOwnerImage = m_FeaturesImage;
verifyPreviewOwnerButton.Enabled = true;
verifyButton.Enabled = true;
verifyButton.BackColor = m_ButtonColorBase;
}
private static void DesaturateImage(KalikoImage image) {
byte[] b = image.ByteArray;
for(int i = 0, l = b.Length;i < l;i += 4) {
b[i] = b[i + 1] = b[i + 2] = (byte)(.299 * b[i + 2] + .587 * b[i + 1] + .114 * b[i]);
}
image.ByteArray = b;
}
private void CreateThumb(string path, string localThumbPath)
{
EnsureThumbnailPath();
var image = new KalikoImage(path);
var thumbnail = image.Scale(new CropScaling(128, 128));
thumbnail.SaveJpg(localThumbPath, 85);
}
/// <summary>Core function that applies the scaling to the image with the option to prevent upscaling</summary>
/// <param name="sourceImage"></param>
/// <param name="preventUpscaling"></param>
/// <returns>Scaled image</returns>
public KalikoImage Scale(KalikoImage sourceImage, bool preventUpscaling)
{
if (preventUpscaling && IsTargetLargerThan(sourceImage))
{
return(sourceImage);
}
return(Scale(sourceImage));
}
private void loadMarkersButton_Click(object sender, EventArgs e)
{
KalikoImage markers = new KalikoImage(MARKERS_EMPTY_PATH);
if (markers != null)
{
HandleMarkerScanFinished(markers.GetAsBitmap(), false, true);
}
}
// GET: Formation/Details/5
public ActionResult Details(int id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Formation p;
p = MyFormationService.GetById((int)id);
if (p == null)
{
return(HttpNotFound());
}
FormationVM pvm = new FormationVM()
{
FormationID = p.FormationID,
Title = p.Title,
Affiche = p.Affiche,
Start = p.Start,
End = p.End,
Description = p.Description,
Location = p.Location,
Price = p.Price,
Theme = p.Theme,
NbrMax = p.NbrMax
};
var t = MyActiviteService.GetMany();
foreach (Activite A in t)
{
if (string.IsNullOrEmpty(A.Affiche))
{
var path = Path.Combine(Server.MapPath("~/Content/Front/images/event/event_02.jpg"));
KalikoImage image = new KalikoImage(path);
KalikoImage thumb = image.Scale(new CropScaling(90, 80));
var path2 = Path.Combine(Server.MapPath("~/Content/Uploads"), A.Title + "latest.jpg");
thumb.SaveJpg(path2, 99);
A.Affiche = A.Title + "latest.jpg";
}
else
{
var path = Path.Combine(Server.MapPath("~/Content/Uploads"), A.Affiche);
KalikoImage image = new KalikoImage(path);
KalikoImage thumb = image.Scale(new CropScaling(90, 80));
var path2 = Path.Combine(Server.MapPath("~/Content/Uploads"), A.Title + "latest.jpg");
thumb.SaveJpg(path2, 99);
A.Affiche = A.Title + "latest.jpg";
}
}
List <Activite> Courses = t.ToList();
ViewData["Courses"] = Courses;
return(View(pvm));
}
/// <summary>
///
/// </summary>
/// <param name="image"></param>
public override void Run(KalikoImage image) {
var inPixels = image.IntArray;
var outPixels = new int[inPixels.Length];
if ( _radius > 0 ) {
ConvolveAndTranspose(Kernel, inPixels, outPixels, image.Width, image.Height, UseAlpha, UseAlpha && PremultiplyAlpha, false, EdgeMode.Clamp);
ConvolveAndTranspose(Kernel, outPixels, inPixels, image.Height, image.Width, UseAlpha, false, UseAlpha && PremultiplyAlpha, EdgeMode.Clamp);
}
image.IntArray = inPixels;
}
private static void InvertImage(KalikoImage image) {
byte[] b = image.ByteArray;
for(int i = 0, l = b.Length;i < l;i += 4) {
b[i] = (byte)(255 - b[i]); // b
b[i + 1] = (byte)(255 - b[i + 1]); // g
b[i + 2] = (byte)(255 - b[i + 2]); // r
}
image.ByteArray = b;
}
private static void GetScaledImage(ImagePreset preset, KalikoImage image, string filePath)
{
using (var scaledImage = image.Scale(preset.ScaleMethod, preset.PreventUpscaling)) {
foreach (var filter in preset.Filters)
{
scaledImage.ApplyFilter(filter);
}
scaledImage.SaveJpg(filePath, preset.Quality);
}
}
private void ChangeBrightness(KalikoImage image) {
byte[] b = image.ByteArray;
for(int i = 0, l = b.Length;i < l;i += 4) {
b[i] = _precalcTable[b[i]]; // b
b[i + 1] = _precalcTable[b[i + 1]]; // g
b[i + 2] = _precalcTable[b[i + 2]]; // r
}
image.ByteArray = b;
}
public void ApplyChromaKey(KalikoImage image) {
var pixels = image.IntArray;
var keyHsb = ColorSpaceHelper.RGBtoHSB(KeyColor);
for (int i = 0; i < pixels.Length; i++) {
int rgb = pixels[i];
int red = (rgb >> 16) & 0xff;
int green = (rgb >> 8) & 0xff;
int blue = rgb & 0xff;
HSB hsb = ColorSpaceHelper.RGBtoHSB(red, green, blue);
if (Math.Abs(hsb.Hue - keyHsb.Hue) < ToleranceHue && Math.Abs(hsb.Saturation - keyHsb.Saturation) < ToleranceSaturnation && Math.Abs(hsb.Brightness - keyHsb.Brightness) < ToleranceBrightness) {
pixels[i] = rgb & 0xffffff;
}
else {
pixels[i] = rgb;
}
}
image.IntArray = pixels;
}
private static void Sharpen(KalikoImage image, float amount, float radius, int threshold) {
var inPixels = image.IntArray;
var workPixels = new int[inPixels.Length];
var outPixels = new int[inPixels.Length];
if (radius > 0) {
var kernel = GaussianBlurFilter.CreateKernel(radius);
GaussianBlurFilter.ConvolveAndTranspose(kernel, inPixels, workPixels, image.Width, image.Height, true, true, false, ConvolveFilter.EdgeMode.Clamp);
GaussianBlurFilter.ConvolveAndTranspose(kernel, workPixels, outPixels, image.Height, image.Width, true, false, true, ConvolveFilter.EdgeMode.Clamp);
}
for (int index = 0; index < inPixels.Length; index++) {
int rgb1 = inPixels[index];
int r1 = (rgb1 >> 16) & 0xff;
int g1 = (rgb1 >> 8) & 0xff;
int b1 = rgb1 & 0xff;
int rgb2 = outPixels[index];
int r2 = (rgb2 >> 16) & 0xff;
int g2 = (rgb2 >> 8) & 0xff;
int b2 = rgb2 & 0xff;
if (Math.Abs(r1 - r2) >= threshold) {
r1 = PixelUtils.Clamp((int)((amount + 1)*(r1 - r2) + r2));
}
if (Math.Abs(g1 - g2) >= threshold) {
g1 = PixelUtils.Clamp((int)((amount + 1)*(g1 - g2) + g2));
}
if (Math.Abs(b1 - b2) >= threshold) {
b1 = PixelUtils.Clamp((int)((amount + 1)*(b1 - b2) + b2));
}
inPixels[index] = (int)(rgb1 & 0xff000000) | (r1 << 16) | (g1 << 8) | b1;
}
image.IntArray = inPixels;
}
public void Run(KalikoImage image) {
InvertImage(image);
}
public void Run(KalikoImage image) {
ValidateParameters();
ApplyChromaKey(image);
}
/// <summary>Execute the filter.</summary>
public void Run(KalikoImage image) {
PrecalculateTable();
ChangeBrightness(image);
}
public void Run(KalikoImage image) {
DesaturateImage(image);
}
internal abstract KalikoImage DrawResizedImage(KalikoImage sourceImage, Size calculatedSize, Size originalSize);
/// <summary>
///
/// </summary>
/// <param name="image"></param>
public void Run(KalikoImage image) {
Sharpen(image, _amount, _radius, _threshold);
}
/// <summary>
///
/// </summary>
/// <param name="image"></param>
/// <exception cref="NotImplementedException"></exception>
public virtual void Run(KalikoImage image) {
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <param name="image"></param>
public void Run(KalikoImage image) {
ChangeContrast(image);
}
/// <summary>Core function that applies the scaling to the image.</summary>
/// <param name="sourceImage">Image to be scaled</param>
/// <returns>Scaled image</returns>
public KalikoImage Scale(KalikoImage sourceImage) {
var originalSize = new Size(sourceImage.Width, sourceImage.Height);
var calculatedSize = CalculateNewImageSize(originalSize);
return DrawResizedImage(sourceImage, calculatedSize, originalSize);
}
