/// <summary>
/// Resizes an image to the given width and height with the given sampler and
/// source rectangle.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image to resize.</param>
/// <param name="width">The target image width.</param>
/// <param name="height">The target image height.</param>
/// <param name="sampler">The <see cref="IResampler"/> to perform the resampling.</param>
/// <param name="sourceRectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to draw.
/// </param>
/// <param name="targetRectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the target image object to draw to.
/// </param>
/// <param name="compand">Whether to compress and expand the image color-space to gamma correct the image during processing.</param>
/// <returns>The <see cref="Image{TColor}"/></returns>
/// <remarks>Passing zero for one of height or width will automatically preserve the aspect ratio of the original image</remarks>
public static Image <TColor> Resize <TColor>(this Image <TColor> source, int width, int height, IResampler sampler, Rectangle sourceRectangle, Rectangle targetRectangle, bool compand = false)
where TColor : struct, IPixel <TColor>
{
if (width == 0 && height > 0)
{
width = source.Width * height / source.Height;
targetRectangle.Width = width;
}
if (height == 0 && width > 0)
{
height = source.Height * width / source.Width;
targetRectangle.Height = height;
}
Guard.MustBeGreaterThan(width, 0, nameof(width));
Guard.MustBeGreaterThan(height, 0, nameof(height));
ResizeProcessor <TColor> processor =
new ResizeProcessor <TColor>(sampler, width, height, targetRectangle)
{
Compand = compand
};
source.ApplyProcessor(processor, sourceRectangle);
return(source);
}
/// <summary>
/// Resizes an image to the given width and height with the given sampler and
/// source rectangle.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image to resize.</param>
/// <param name="width">The target image width.</param>
/// <param name="height">The target image height.</param>
/// <param name="sampler">The <see cref="IResampler"/> to perform the resampling.</param>
/// <param name="sourceRectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to draw.
/// </param>
/// <param name="targetRectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the target image object to draw to.
/// </param>
/// <param name="compand">Whether to compress and expand the image color-space to gamma correct the image during processing.</param>
/// <returns>The <see cref="Image{TPixel}"/></returns>
/// <remarks>Passing zero for one of height or width will automatically preserve the aspect ratio of the original image</remarks>
public static Image <TPixel> Resize <TPixel>(this Image <TPixel> source, int width, int height, IResampler sampler, Rectangle sourceRectangle, Rectangle targetRectangle, bool compand)
where TPixel : struct, IPixel <TPixel>
{
if (width == 0 && height > 0)
{
width = (int)MathF.Round(source.Width * height / (float)source.Height);
targetRectangle.Width = width;
}
if (height == 0 && width > 0)
{
height = (int)MathF.Round(source.Height * width / (float)source.Width);
targetRectangle.Height = height;
}
Guard.MustBeGreaterThan(width, 0, nameof(width));
Guard.MustBeGreaterThan(height, 0, nameof(height));
var processor = new ResizeProcessor <TPixel>(sampler, width, height, targetRectangle)
{
Compand = compand
};
source.ApplyProcessor(processor, sourceRectangle);
return(source);
}
/// <summary>
/// Flips an image by the given instructions.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image to rotate, flip, or both.</param>
/// <param name="flipType">The <see cref="FlipType"/> to perform the flip.</param>
/// <returns>The <see cref="Image{TPixel}"/></returns>
public static Image <TPixel> Flip <TPixel>(this Image <TPixel> source, FlipType flipType)
where TPixel : struct, IPixel <TPixel>
{
FlipProcessor <TPixel> processor = new FlipProcessor <TPixel>(flipType);
source.ApplyProcessor(processor, source.Bounds);
return(source);
}
/// <summary>
/// Crops an image to the given rectangle.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image to crop.</param>
/// <param name="cropRectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to retain.
/// </param>
/// <returns>The <see cref="Image"/></returns>
public static Image <TColor> Crop <TColor>(this Image <TColor> source, Rectangle cropRectangle)
where TColor : struct, IPixel <TColor>
{
CropProcessor <TColor> processor = new CropProcessor <TColor>(cropRectangle);
source.ApplyProcessor(processor, source.Bounds);
return(source);
}
/// <summary>
/// Crops an image to the area of greatest entropy.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image to crop.</param>
/// <param name="threshold">The threshold for entropic density.</param>
/// <returns>The <see cref="Image"/></returns>
public static Image <TPixel> EntropyCrop <TPixel>(this Image <TPixel> source, float threshold = .5f)
where TPixel : struct, IPixel <TPixel>
{
EntropyCropProcessor <TPixel> processor = new EntropyCropProcessor <TPixel>(threshold);
source.ApplyProcessor(processor, source.Bounds);
return(source);
}
/// <summary>
/// Flips an image by the given instructions.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image to rotate, flip, or both.</param>
/// <param name="flipType">The <see cref="FlipType"/> to perform the flip.</param>
/// <returns>The <see cref="Image"/></returns>
public static Image <TColor> Flip <TColor>(this Image <TColor> source, FlipType flipType)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
FlipProcessor <TColor> processor = new FlipProcessor <TColor>(flipType);
source.ApplyProcessor(processor, source.Bounds);
return(source);
}
/// <summary>
/// Crops an image to the area of greatest entropy.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image to crop.</param>
/// <param name="threshold">The threshold for entropic density.</param>
/// <returns>The <see cref="Image"/></returns>
public static Image <TColor> EntropyCrop <TColor>(this Image <TColor> source, float threshold = .5f)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
EntropyCropProcessor <TColor> processor = new EntropyCropProcessor <TColor>(threshold);
source.ApplyProcessor(processor, source.Bounds);
return(source);
}
/// <summary>
/// Applies <see cref="GrayscaleMode.Bt709"/> Grayscale toning to the image.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> Grayscale <TPixel>(this Image <TPixel> source, Rectangle rectangle)
where TPixel : struct, IPixel <TPixel>
{
IImageProcessor <TPixel> processor = new GrayscaleBt709Processor <TPixel>();
source.ApplyProcessor(processor, rectangle);
return(source);
}
/// <summary>
/// Skews an image by the given angles in degrees.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image to skew.</param>
/// <param name="degreesX">The angle in degrees to perform the rotation along the x-axis.</param>
/// <param name="degreesY">The angle in degrees to perform the rotation along the y-axis.</param>
/// <param name="expand">Whether to expand the image to fit the skewed result.</param>
/// <returns>The <see cref="Image{TPixel}"/></returns>
public static Image <TPixel> Skew <TPixel>(this Image <TPixel> source, float degreesX, float degreesY, bool expand)
where TPixel : struct, IPixel <TPixel>
{
SkewProcessor <TPixel> processor = new SkewProcessor <TPixel> {
AngleX = degreesX, AngleY = degreesY, Expand = expand
};
source.ApplyProcessor(processor, source.Bounds);
return(source);
}
/// <summary>
/// Applies Grayscale toning to the image.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <param name="mode">The formula to apply to perform the operation.</param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> Grayscale <TColor>(this Image <TColor> source, Rectangle rectangle, GrayscaleMode mode = GrayscaleMode.Bt709)
where TColor : struct, IPixel <TColor>
{
IImageProcessor <TColor> processor = mode == GrayscaleMode.Bt709
? (IImageProcessor <TColor>) new GrayscaleBt709Processor <TColor>()
: new GrayscaleBt601Processor <TColor>();
source.ApplyProcessor(processor, rectangle);
return(source);
}
/// <summary>
/// Rotates an image by the given angle in degrees.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image to rotate.</param>
/// <param name="degrees">The angle in degrees to perform the rotation.</param>
/// <param name="expand">Whether to expand the image to fit the rotated result.</param>
/// <returns>The <see cref="Image"/></returns>
public static Image <TColor> Rotate <TColor>(this Image <TColor> source, float degrees, bool expand)
where TColor : struct, IPixel <TColor>
{
RotateProcessor <TColor> processor = new RotateProcessor <TColor> {
Angle = degrees, Expand = expand
};
source.ApplyProcessor(processor, source.Bounds);
return(source);
}
/// <summary>
/// Skews an image by the given angles in degrees.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image to skew.</param>
/// <param name="degreesX">The angle in degrees to perform the rotation along the x-axis.</param>
/// <param name="degreesY">The angle in degrees to perform the rotation along the y-axis.</param>
/// <param name="expand">Whether to expand the image to fit the skewed result.</param>
/// <returns>The <see cref="Image"/></returns>
public static Image <TColor> Skew <TColor>(this Image <TColor> source, float degreesX, float degreesY, bool expand)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
SkewProcessor <TColor> processor = new SkewProcessor <TColor> {
AngleX = degreesX, AngleY = degreesY, Expand = expand
};
source.ApplyProcessor(processor, source.Bounds);
return(source);
}
/// <summary>
/// Pixelates an image with the given pixel size.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="size">The size of the pixels.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> Pixelate <TPixel>(this Image <TPixel> source, int size, Rectangle rectangle)
where TPixel : struct, IPixel <TPixel>
{
if (size <= 0 || size > source.Height || size > source.Width)
{
throw new ArgumentOutOfRangeException(nameof(size));
}
source.ApplyProcessor(new PixelateProcessor <TPixel>(size), rectangle);
return(source);
}
/// <summary>
/// Applies a radial vignette effect to an image.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="color">The color to set as the vignette.</param>
/// <param name="radiusX">The the x-radius.</param>
/// <param name="radiusY">The the y-radius.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> Vignette <TColor>(this Image <TColor> source, TColor color, float radiusX, float radiusY, Rectangle rectangle)
where TColor : struct, IPixel <TColor>
{
VignetteProcessor <TColor> processor = new VignetteProcessor <TColor>(color)
{
RadiusX = radiusX, RadiusY = radiusY
};
source.ApplyProcessor(processor, rectangle);
return(source);
}
/// <summary>
/// Applies a radial vignette effect to an image.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="color">The color to set as the vignette.</param>
/// <param name="radiusX">The the x-radius.</param>
/// <param name="radiusY">The the y-radius.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <param name="options">The options effecting pixel blending.</param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> Vignette <TPixel>(this Image <TPixel> source, TPixel color, float radiusX, float radiusY, Rectangle rectangle, GraphicsOptions options)
where TPixel : struct, IPixel <TPixel>
{
var processor = new VignetteProcessor <TPixel>(color, options)
{
RadiusX = radiusX, RadiusY = radiusY
};
source.ApplyProcessor(processor, rectangle);
return(source);
}
/// <summary>
/// Applies a radial glow effect to an image.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="color">The color to set as the glow.</param>
/// <param name="radius">The the radius.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> Glow <TPixel>(this Image <TPixel> source, TPixel color, float radius, Rectangle rectangle)
where TPixel : struct, IPixel <TPixel>
{
GlowProcessor <TPixel> processor = new GlowProcessor <TPixel>(color)
{
Radius = radius,
};
source.ApplyProcessor(processor, rectangle);
return(source);
}
/// <summary>
/// Alters the colors of the image recreating an oil painting effect.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="levels">The number of intensity levels. Higher values result in a broader range of color intensities forming part of the result image.</param>
/// <param name="brushSize">The number of neighboring pixels used in calculating each individual pixel value.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> OilPaint <TPixel>(this Image <TPixel> source, int levels, int brushSize, Rectangle rectangle)
where TPixel : struct, IPixel <TPixel>
{
Guard.MustBeGreaterThan(levels, 0, nameof(levels));
if (brushSize <= 0 || brushSize > source.Height || brushSize > source.Width)
{
throw new ArgumentOutOfRangeException(nameof(brushSize));
}
source.ApplyProcessor(new OilPaintingProcessor <TPixel>(levels, brushSize), rectangle);
return(source);
}
/// <summary>
/// Applies a radial glow effect to an image.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="color">The color to set as the glow.</param>
/// <param name="radius">The the radius.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> Glow <TColor>(this Image <TColor> source, TColor color, float radius, Rectangle rectangle)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
GlowProcessor <TColor> processor = new GlowProcessor <TColor> {
Radius = radius,
};
if (!color.Equals(default(TColor)))
{
processor.GlowColor = color;
}
source.ApplyProcessor(processor, rectangle);
return(source);
}
/// <summary>
/// Applies a radial vignette effect to an image.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="color">The color to set as the vignette.</param>
/// <param name="radiusX">The the x-radius.</param>
/// <param name="radiusY">The the y-radius.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> Vignette <TColor>(this Image <TColor> source, TColor color, float radiusX, float radiusY, Rectangle rectangle)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
VignetteProcessor <TColor> processor = new VignetteProcessor <TColor> {
RadiusX = radiusX, RadiusY = radiusY
};
if (!color.Equals(default(TColor)))
{
processor.VignetteColor = color;
}
source.ApplyProcessor(processor, rectangle);
return(source);
}
/// <summary>
/// Draws the given image together with the current one by blending their pixels.
/// </summary>
/// <param name="source">The image this method extends.</param>
/// <param name="image">The image to blend with the currently processing image.</param>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="percent">The opacity of the image image to blend. Must be between 0 and 100.</param>
/// <param name="size">The size to draw the blended image.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> DrawImage <TPixel>(this Image <TPixel> source, Image <TPixel> image, int percent, Size size, Point location)
where TPixel : struct, IPixel <TPixel>
{
if (size == default(Size))
{
size = new Size(image.Width, image.Height);
}
if (location == default(Point))
{
location = Point.Empty;
}
source.ApplyProcessor(new DrawImageProcessor <TPixel>(image, size, location, percent), source.Bounds);
return(source);
}
/// <summary>
/// Applies the given colorblindness simulator to the image.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="colorBlindness">The type of color blindness simulator to apply.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> ColorBlindness <TPixel>(this Image <TPixel> source, ColorBlindness colorBlindness, Rectangle rectangle)
where TPixel : struct, IPixel <TPixel>
{
IImageProcessor <TPixel> processor;
switch (colorBlindness)
{
case ImageSharp.Processing.ColorBlindness.Achromatomaly:
processor = new AchromatomalyProcessor <TPixel>();
break;
case ImageSharp.Processing.ColorBlindness.Achromatopsia:
processor = new AchromatopsiaProcessor <TPixel>();
break;
case ImageSharp.Processing.ColorBlindness.Deuteranomaly:
processor = new DeuteranomalyProcessor <TPixel>();
break;
case ImageSharp.Processing.ColorBlindness.Deuteranopia:
processor = new DeuteranopiaProcessor <TPixel>();
break;
case ImageSharp.Processing.ColorBlindness.Protanomaly:
processor = new ProtanomalyProcessor <TPixel>();
break;
case ImageSharp.Processing.ColorBlindness.Protanopia:
processor = new ProtanopiaProcessor <TPixel>();
break;
case ImageSharp.Processing.ColorBlindness.Tritanomaly:
processor = new TritanomalyProcessor <TPixel>();
break;
default:
processor = new TritanopiaProcessor <TPixel>();
break;
}
source.ApplyProcessor(processor, rectangle);
return(source);
}
/// <summary>
/// Dithers the image reducing it to two colors using error diffusion.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="diffuser">The diffusion algorithm to apply.</param>
/// <param name="threshold">The threshold to apply binarization of the image. Must be between 0 and 1.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> Dither <TPixel>(this Image <TPixel> source, IErrorDiffuser diffuser, float threshold, Rectangle rectangle)
where TPixel : struct, IPixel <TPixel>
{
source.ApplyProcessor(new ErrorDiffusionDitherProcessor <TPixel>(diffuser, threshold), rectangle);
return(source);
}
/// <summary>
/// Dithers the image reducing it to two colors using ordered dithering.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="dither">The ordered ditherer.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <param name="index">The component index to test the threshold against. Must range from 0 to 3.</param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> Dither <TPixel>(this Image <TPixel> source, IOrderedDither dither, Rectangle rectangle, int index = 0)
where TPixel : struct, IPixel <TPixel>
{
source.ApplyProcessor(new OrderedDitherProcessor <TPixel>(dither, index), rectangle);
return(source);
}
/// <summary>
/// Alters the colors of the image recreating an old Polaroid camera effect.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <param name="options">The options effecting pixel blending.</param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> Polaroid <TPixel>(this Image <TPixel> source, Rectangle rectangle, GraphicsOptions options)
where TPixel : struct, IPixel <TPixel>
{
source.ApplyProcessor(new PolaroidProcessor <TPixel>(options), rectangle);
return(source);
}
/// <summary>
/// Alters the colors of the image recreating an old Lomograph camera effect.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> Lomograph <TColor>(this Image <TColor> source, Rectangle rectangle)
where TColor : struct, IPixel <TColor>
{
source.ApplyProcessor(new LomographProcessor <TColor>(), rectangle);
return(source);
}
/// <summary>
/// Applies a Gaussian blur to the image.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="sigma">The 'sigma' value representing the weight of the blur.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> GaussianBlur <TColor>(this Image <TColor> source, float sigma, Rectangle rectangle)
where TColor : struct, IPixel <TColor>
{
source.ApplyProcessor(new GaussianBlurProcessor <TColor>(sigma), rectangle);
return(source);
}
/// <summary>
/// Alters the brightness component of the image.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="amount">The new brightness of the image. Must be between -100 and 100.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> Brightness <TPixel>(this Image <TPixel> source, int amount, Rectangle rectangle)
where TPixel : struct, IPixel <TPixel>
{
source.ApplyProcessor(new BrightnessProcessor <TPixel>(amount), rectangle);
return(source);
}
/// <summary>
/// Alters the colors of the image recreating an old Kodachrome camera effect.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static Image <TPixel> Kodachrome <TPixel>(this Image <TPixel> source, Rectangle rectangle)
where TPixel : struct, IPixel <TPixel>
{
source.ApplyProcessor(new KodachromeProcessor <TPixel>(), rectangle);
return(source);
}
/// <summary>
/// Applies binarization to the image splitting the pixels at the given threshold.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="threshold">The threshold to apply binarization of the image. Must be between 0 and 1.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> BinaryThreshold <TColor>(this Image <TColor> source, float threshold, Rectangle rectangle)
where TColor : struct, IPixel <TColor>
{
source.ApplyProcessor(new BinaryThresholdProcessor <TColor>(threshold), rectangle);
return(source);
}
/// <summary>
/// Alters the colors of the image recreating an old Polaroid camera effect.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> Polaroid <TColor>(this Image <TColor> source, Rectangle rectangle)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
source.ApplyProcessor(new PolaroidProcessor <TColor>(), rectangle);
return(source);
}
