/// <summary> /// Crops an image to the given width and height with the given source rectangle. /// <remarks> /// If the source rectangle is smaller than the target dimensions then the /// area within the source is resized performing a zoomed crop. /// </remarks> /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam> /// <param name="source">The image to crop.</param> /// <param name="width">The target image width.</param> /// <param name="height">The target image height.</param> /// <param name="sourceRectangle"> /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to draw. /// </param> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image"/></returns> public static Image <T, TP> Crop <T, TP>(this Image <T, TP> source, int width, int height, Rectangle sourceRectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { Guard.MustBeGreaterThan(width, 0, nameof(width)); Guard.MustBeGreaterThan(height, 0, nameof(height)); if (sourceRectangle.Width < width || sourceRectangle.Height < height) { // If the source rectangle is smaller than the target perform a // cropped zoom. source = source.Resize(sourceRectangle.Width, sourceRectangle.Height); } CropProcessor <T, TP> processor = new CropProcessor <T, TP>(); processor.OnProgress += progressHandler; try { return(source.Process(width, height, sourceRectangle, new Rectangle(0, 0, width, height), processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Applies the given colorblindness simulator to the image. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></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> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> ColorBlindness <T, TP>(this Image <T, TP> source, ColorBlindness colorBlindness, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { IImageProcessor <T, TP> processor; switch (colorBlindness) { case ImageProcessorCore.ColorBlindness.Achromatomaly: processor = new AchromatomalyProcessor <T, TP>(); break; case ImageProcessorCore.ColorBlindness.Achromatopsia: processor = new AchromatopsiaProcessor <T, TP>(); break; case ImageProcessorCore.ColorBlindness.Deuteranomaly: processor = new DeuteranomalyProcessor <T, TP>(); break; case ImageProcessorCore.ColorBlindness.Deuteranopia: processor = new DeuteranopiaProcessor <T, TP>(); break; case ImageProcessorCore.ColorBlindness.Protanomaly: processor = new ProtanomalyProcessor <T, TP>(); break; case ImageProcessorCore.ColorBlindness.Protanopia: processor = new ProtanopiaProcessor <T, TP>(); break; case ImageProcessorCore.ColorBlindness.Tritanomaly: processor = new TritanomalyProcessor <T, TP>(); break; default: processor = new TritanopiaProcessor <T, TP>(); break; } processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Detects any edges within the image. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></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="filter">The filter for detecting edges.</param> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> DetectEdges <T, TP>(this Image <T, TP> source, Rectangle rectangle, IEdgeDetectorFilter <T, TP> filter, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { filter.OnProgress += progressHandler; try { return(source.Process(rectangle, filter)); } finally { filter.OnProgress -= progressHandler; } }
/// <summary> /// Replaces the background color of image with the given one. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam> /// <param name="source">The image this method extends.</param> /// <param name="color">The color to set as the background.</param> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> BackgroundColor <T, TP>(this Image <T, TP> source, T color, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { BackgroundColorProcessor <T, TP> processor = new BackgroundColorProcessor <T, TP>(color); processor.OnProgress += progressHandler; try { return(source.Process(source.Bounds, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Combines 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="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam> /// <param name="percent">The opacity of the image image to blend. Must be between 0 and 100.</param> /// <param name="rectangle"> /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter. /// </param> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> Blend <T, TP>(this Image <T, TP> source, ImageBase <T, TP> image, int percent, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { BlendProcessor <T, TP> processor = new BlendProcessor <T, TP>(image, percent); processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Crops an image to the area of greatest entropy. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam> /// <param name="source">The image to crop.</param> /// <param name="threshold">The threshold for entropic density.</param> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image"/></returns> public static Image <T, TP> EntropyCrop <T, TP>(this Image <T, TP> source, float threshold = .5f, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { EntropyCropProcessor <T, TP> processor = new EntropyCropProcessor <T, TP>(threshold); processor.OnProgress += progressHandler; try { return(source.Process(source.Width, source.Height, source.Bounds, Rectangle.Empty, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Applies a box blur to the image. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam> /// <param name="source">The image this method extends.</param> /// <param name="radius">The 'radius' value representing the size of the area to sample.</param> /// <param name="rectangle"> /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter. /// </param> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> BoxBlur <T, TP>(this Image <T, TP> source, int radius, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { BoxBlurProcessor <T, TP> processor = new BoxBlurProcessor <T, TP>(radius); processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Alters the contrast component of the image. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam> /// <param name="source">The image this method extends.</param> /// <param name="amount">The new contrast 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> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> Contrast <T, TP>(this Image <T, TP> source, int amount, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { ContrastProcessor <T, TP> processor = new ContrastProcessor <T, TP>(amount); processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Alters the hue component of the image. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam> /// <param name="source">The image this method extends.</param> /// <param name="degrees">The angle in degrees to adjust the image.</param> /// <param name="rectangle"> /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter. /// </param> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> Hue <T, TP>(this Image <T, TP> source, float degrees, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { HueProcessor <T, TP> processor = new HueProcessor <T, TP>(degrees); processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Applies a Guassian blur to the image. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></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> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> GuassianBlur <T, TP>(this Image <T, TP> source, float sigma, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { GuassianBlurProcessor <T, TP> processor = new GuassianBlurProcessor <T, TP>(sigma); processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Alters the colors of the image recreating an old Lomograph camera effect. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></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="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> Lomograph <T, TP>(this Image <T, TP> source, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { LomographProcessor <T, TP> processor = new LomographProcessor <T, TP>(); processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Flips an image by the given instructions. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam> /// <param name="source">The image to rotate, flip, or both.</param> /// <param name="flipType">The <see cref="FlipType"/> to perform the flip.</param> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image"/></returns> public static Image <T, TP> Flip <T, TP>(this Image <T, TP> source, FlipType flipType, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { FlipProcessor <T, TP> processor = new FlipProcessor <T, TP>(flipType); processor.OnProgress += progressHandler; try { return(source.Process(source.Width, source.Height, source.Bounds, source.Bounds, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Applies binerization to the image splitting the pixels at the given threshold. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam> /// <param name="source">The image this method extends.</param> /// <param name="threshold">The threshold to apply binerization 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> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> BinaryThreshold <T, TP>(this Image <T, TP> source, float threshold, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { BinaryThresholdProcessor <T, TP> processor = new BinaryThresholdProcessor <T, TP>(threshold); processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Skews an image by the given angles in degrees. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></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> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image"/></returns> public static Image <T, TP> Skew <T, TP>(this Image <T, TP> source, float degreesX, float degreesY, bool expand, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { SkewProcessor <T, TP> processor = new SkewProcessor <T, TP> { AngleX = degreesX, AngleY = degreesY, Expand = expand }; processor.OnProgress += progressHandler; try { return(source.Process(source.Width, source.Height, source.Bounds, source.Bounds, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Applies Grayscale toning to the image. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></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> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> Grayscale <T, TP>(this Image <T, TP> source, Rectangle rectangle, GrayscaleMode mode = GrayscaleMode.Bt709, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { IImageProcessor <T, TP> processor = mode == GrayscaleMode.Bt709 ? (IImageProcessor <T, TP>) new GrayscaleBt709Processor <T, TP>() : new GrayscaleBt601Processor <T, TP>(); processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Resizes an image to the given width and height with the given sampler and /// source rectangle. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></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> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/></returns> /// <remarks>Passing zero for one of height or width will automatically preserve the aspect ratio of the original image</remarks> public static Image <T, TP> Resize <T, TP>(this Image <T, TP> source, int width, int height, IResampler sampler, Rectangle sourceRectangle, Rectangle targetRectangle, bool compand = false, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { 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)); ResamplingWeightedProcessor <T, TP> processor; if (compand) { processor = new CompandingResizeProcessor <T, TP>(sampler); } else { processor = new ResizeProcessor <T, TP>(sampler); } processor.OnProgress += progressHandler; try { return(source.Process(width, height, sourceRectangle, targetRectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Pixelates and image with the given pixel size. /// </summary> /// <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> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> Pixelate <T, TP>(this Image <T, TP> source, int size, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { if (size <= 0 || size > source.Height || size > source.Width) { throw new ArgumentOutOfRangeException(nameof(size)); } PixelateProcessor <T, TP> processor = new PixelateProcessor <T, TP>(size); processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }
/// <summary> /// Applies a radial glow effect to an image. /// </summary> /// <typeparam name="T">The pixel format.</typeparam> /// <typeparam name="TP">The packed format. <example>long, float.</example></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> /// <param name="progressHandler">A delegate which is called as progress is made processing the image.</param> /// <returns>The <see cref="Image{T,TP}"/>.</returns> public static Image <T, TP> Glow <T, TP>(this Image <T, TP> source, T color, float radius, Rectangle rectangle, ProgressEventHandler progressHandler = null) where T : IPackedVector <TP> where TP : struct { GlowProcessor <T, TP> processor = new GlowProcessor <T, TP> { Radius = radius, }; if (!color.Equals(default(T))) { processor.GlowColor = color; } processor.OnProgress += progressHandler; try { return(source.Process(rectangle, processor)); } finally { processor.OnProgress -= progressHandler; } }