public static Image ApplyFilter(Image image, IImageFilter filter)
{
if (image == null)
{
return(null);
}
var bitmap = new Bitmap(image);
Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
BitmapData bitmapData = bitmap.LockBits(rect, ImageLockMode.ReadWrite, bitmap.PixelFormat);
{
int sizeBitmap = bitmapData.Stride * bitmap.Height;
int sizePixel = bitmapData.Stride / bitmap.Width;
byte[] pixels = new byte[sizeBitmap];
Marshal.Copy(bitmapData.Scan0, pixels, 0, sizeBitmap);
{
filter.Filter(pixels, sizePixel);
}
Marshal.Copy(pixels, 0, bitmapData.Scan0, sizeBitmap);
}
bitmap.UnlockBits(bitmapData);
return(bitmap);
}
public Bitmap Transform(Bitmap image, IImageFilter filter)
{
var newImage = image.Copy();
Change(newImage, filter);
return(newImage);
}
private async Task Capture(IEnumerable <MediaCapture> devices, IImageFilter filter)
{
IEnumerable <MediaCapture> cameraDevices = devices as MediaCapture[] ?? devices.ToArray();
while (true)
{
foreach (MediaCapture cameraDevice in cameraDevices)
{
string cameraId = cameraDevice.MediaCaptureSettings.VideoDeviceId;
Debug.WriteLine($"Processing camera: {cameraId}");
BitmapDecoder bitmapDecoder;
IRandomAccessStream imageStream;
try
{
Tuple <BitmapDecoder, IRandomAccessStream> photoData = await GetPhotoStreamAsync(cameraDevice);
bitmapDecoder = photoData.Item1;
imageStream = photoData.Item2;
Debug.WriteLine($"Got stream from camera: {cameraId}");
}
catch (Exception ex)
{
Debug.WriteLine($"Camera {cameraId} failed with message: {ex.Message}");
continue;
}
#pragma warning disable 4014
filter?.ProcessImageAsync(bitmapDecoder, imageStream, cameraId);
#pragma warning restore 4014
}
}
// ReSharper disable once FunctionNeverReturns
}
private IActionResult ProcessAndSend(IImageFilter filter, int x, int y, int w, int h,
params object[] filterParams)
{
IActionResult result;
try
{
using (var imgFromRequest = new Bitmap(Request.BodyReader.AsStream(true)))
{
var cropArea = _service.ToCropArea(imgFromRequest.Size, x, y, w, h);
if (cropArea == Rectangle.Empty)
{
return(NoContent());
}
var responseImgStream = new MemoryStream();
using (var processedImg = _service.Process(imgFromRequest, cropArea, filter, filterParams))
processedImg.Save(responseImgStream, ImageFormat.Png);
responseImgStream.Position = 0;
result = File(responseImgStream, "image/png");
}
}
catch (OperationCanceledException)
{
result = StatusCode(429);
}
catch (Exception e)
{
_log.Error(e);
result = StatusCode(500);
}
return(result);
}
public List <ImageViewModel> GetImages(string tags = null, DateTime?dateFrom = null, DateTime?dateTo = null)
{
IImageFilter filter = null;
if (!string.IsNullOrEmpty(tags))
{
filter = new TagFilterDecorator(filter, tags);
}
if (dateFrom != null || dateTo != null)
{
filter = new TimestampFilterDecorator(filter, dateFrom, dateTo);
}
var query =
"SELECT Id, FileName, '/userImages/'+UserId+'/'+FileName AS RelativePath, Timestamp FROM dbo.Image ";
var parameters = new Dictionary <string, object>();
if (filter != null)
{
query = filter.FilterQuery(query);
filter.AddParameters(parameters);
}
query += " ORDER BY FileName";
using (var connection = new SqlConnection(_dbSettings.ConnectionString))
{
connection.Open();
return(connection.Query <ImageViewModel>(query, parameters).ToList());
}
}
private void ApplySelectedEffectAndShowImageAsync(WriteableBitmap bitmap)
{
// Find selected effect
IImageFilter effect = null;
if (ListBoxEffects != null)
{
var item = ListBoxEffects.SelectedItem as EffectItem;
if (item != null)
{
effect = item.Effect;
}
}
// Apply selected effect
if (effect == null)
{
// Present original
ShowImage(bitmap);
}
else
{
var dispatcher = Dispatcher;
// Apply Effect on int[] since WriteableBitmap can't be used in background thread
var width = bitmap.PixelWidth;
var height = bitmap.PixelHeight;
var resultPixels = effect.process(new HaoRan.ImageFilter.Image(bitmap));
// Present result
// WriteableBitmap ctor has to be invoked on the UI thread
resultPixels.copyPixelsFromBuffer();
dispatcher.BeginInvoke(() => ShowImage(resultPixels.destImage));
}
}
private void LoadImage(ExtendedImage image)
{
Contract.Requires(image != null);
if (!_isLoadingImage)
{
_isLoadingImage = true;
if (Filter != null)
{
IImageFilter filter = Filter;
ThreadPool.QueueUserWorkItem(x =>
{
ExtendedImage filteredImage = ExtendedImage.ApplyFilters(image, filter);
Dispatcher.BeginInvoke(() => AssignImage(filteredImage));
});
}
else
{
AssignImage(image);
}
}
}
public ProcessFilter(SourceData sourceData, IImageFilter filter, int fromPixel, int toPixel, ManualResetEvent doneEvent)
{
_sourceData = sourceData;
_filter = filter;
_fromPixel = fromPixel;
_toPixel = toPixel;
_doneEvent = doneEvent;
}
public void Change(Bitmap image, IImageFilter filter)
{
foreach (var pixel in image.GetPixels())
{
var newColor = filter.Apply(pixel.Color);
image.SetPixel(pixel.X, pixel.Y, newColor);
}
}
public MainForm()
{
InitializeComponent();
_imageProcessService = ImageProcessService.Instance;
_imageProcessService.OnProgressUpdate += imageProcessService_OnProgressUpdate;
_imageProcessService.OnProcessComplete += imageProcessService_OnProcessComplete;
_selectedFilterValues = new SelectedFilterValues();
_selectedImageFilter = new GammaFilter(_selectedFilterValues.Gamma);
}
//change the current filter to the given new one
private void ChangeCurrentFilter(IImageFilter newFilter)
{
ComboBox filterComboBox = ((System.Windows.Controls.ComboBox) this.FindName("FilterSelectComboBox"));
var filter = filterManager.GetFilterByName((string)filterComboBox.SelectedItem);
this.currentFilter = filter;
DisplayCurrentFilterSettings();
}
/// <summary>
/// Applies Grayscale toning to the image.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <typeparam name="TPacked">The packed format. <example>uint, 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>
/// <returns>The <see cref="Image{TColor, TPacked}"/>.</returns>
public static Image <TColor, TPacked> Grayscale <TColor, TPacked>(this Image <TColor, TPacked> source, Rectangle rectangle, GrayscaleMode mode = GrayscaleMode.Bt709)
where TColor : struct, IPackedPixel <TPacked>
where TPacked : struct
{
IImageFilter <TColor, TPacked> processor = mode == GrayscaleMode.Bt709
? (IImageFilter <TColor, TPacked>) new GrayscaleBt709Processor <TColor, TPacked>()
: new GrayscaleBt601Processor <TColor, TPacked>();
return(source.Process(rectangle, processor));
}
public void RegisterFilter(string name, IImageFilter filter)
{
if (IsRegistered(name))
{
throw new Exception($"Filter with name \"{name}\" already registered");
}
_filtersCache.AddOrUpdate(name, filter, (s, imageFilter) => imageFilter);
_filtersCache.TryAdd(name, filter);
}
/// <summary>
/// Handles the Click event of the ChangeColorsButton control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
private void ChangeColorsButton_Click(object sender, RoutedEventArgs e)
{
if (Container.Source != null && Container.Source.IsFilled)
{
IImageFilter[] filters =
new IImageFilter[] { new Brightness((int)BrightnessSlider.Value), new Contrast((int)ContrastSlider.Value) };
Container.Source = ExtendedImage.ApplyFilters(Container.Source, filters);
}
}
public TimestampFilterDecorator(IImageFilter baseFilter, DateTime?start, DateTime?end)
: base(baseFilter)
{
if (start == null && end == null)
{
throw new ArgumentException("At least one value must be set.");
}
_start = start;
_end = end;
}
public static IImageFilter bindTo_IImageFilter(IComponentIntrospect component)
{
global::System.IntPtr cPtr = solarPINVOKE.bindTo_IImageFilter(IComponentIntrospect.getCPtr(component));
IImageFilter ret = (cPtr == global::System.IntPtr.Zero) ? null : new IImageFilter(cPtr, true);
if (solarPINVOKE.SWIGPendingException.Pending)
{
throw solarPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public async Task ApplyFilter(IImageFilter imageFilter, EdgeHandling edgeHandling)
{
if (IsRunning || _sourceBitmap == null)
{
return;
}
IsRunning = true;
await Task.Run(() => { ApplyFilterMultithreaded(imageFilter, edgeHandling); });
IsRunning = false;
}
public Form1(IThemeService themeService, IPaperWallRssParser paperWallRssParser, IImageFilter imageFilter, IAsyncDownloadManager asyncDownloadManager)
{
this._themeService = themeService;
this._paperWallRssParser = paperWallRssParser;
this._imageFilter = imageFilter;
this._downloadManager = asyncDownloadManager;
Init();
DownloadTimer_Tick(this, null);
}
public void filter_image_partial(string name, IImageFilter filter)
{
var image = Image.Load("TestImages/Backdrop.jpg");
var watch = Stopwatch.StartNew();
image = image.Filter(new Rectangle(40, 60, 400, 250), filter);
Trace.WriteLine($"{ name }: { watch.ElapsedMilliseconds}ms");
image.VerifyAndSave("TestResult/Filtered/" + name + ".partial.png");
}
public void filter_image_partial(string name, IImageFilter filter)
{
var image = Image.Load("TestImages/Backdrop.jpg");
var watch = Stopwatch.StartNew();
image = image.Filter(new Rectangle(40, 60, 400, 250), filter);
Trace.WriteLine($"{ name }: { watch.ElapsedMilliseconds}ms");
image.VerifyAndSave("TestResult/Filtered/" + name + ".partial.png");
}
public void filter_image(string name, IImageFilter filter)
{
var stream = File.OpenRead("TestImages/Backdrop.jpg");
var image = new Image(stream);
var watch = Stopwatch.StartNew();
image = image.Filter(filter);
Trace.WriteLine($"{ name }: { watch.ElapsedMilliseconds}ms");
image.VerifyAndSave("TestResult/Filtered/" + name + ".png");
}
public Image <Rgba32> AddFilter(IImageFilter filter)
{
using (var context = new Context())
{
var acceleratorId = Accelerator.Accelerators.Where(a =>
a.AcceleratorType == AcceleratorType.CPU)
.FirstOrDefault();
using (var accelerator = Accelerator.Create(context, acceleratorId))
{
return(filter.PerformFilter(accelerator));
}
}
}
/// <summary>
/// Converts the image to a silverlight bitmap, which can be assigned
/// to a image control.
/// </summary>
/// <param name="image">The image, which should be converted. Cannot be null
/// (Nothing in Visual Basic).</param>
/// <param name="filter">The filter, which should be applied before converting the
/// image or null, if no filter should be applied to. Cannot be null.</param>
/// <returns>The resulting bitmap.</returns>
/// <exception cref="ArgumentNullException"><paramref name="filter"/> is null
/// (Nothing in Visual Basic).</exception>
public static WriteableBitmap ToBitmap(this ImageBase image, IImageFilter filter)
{
Contract.Requires <ArgumentNullException>(image != null, "Image cannot be null.");
Contract.Requires <ArgumentException>(image.IsFilled, "Image has not been loaded.");
WriteableBitmap bitmap = new WriteableBitmap(image.PixelWidth, image.PixelHeight);
ImageBase temp = image;
if (filter != null)
{
temp = new ImageBase(image);
filter.Apply(temp, image, temp.Bounds);
}
byte[] pixels = temp.Pixels;
if (pixels != null)
{
int[] raster = bitmap.Pixels;
if (raster != null)
{
Buffer.BlockCopy(pixels, 0, raster, 0, pixels.Length);
for (int i = 0; i < raster.Length; i++)
{
int abgr = raster[i];
int a = (abgr >> 24) & 0xff;
float m = a / 255f;
int argb = a << 24 |
(int)(((abgr >> 0) & 0xff) * m) << 16 |
(int)(((abgr >> 8) & 0xff) * m) << 8 |
(int)(((abgr >> 16) & 0xff) * m);
raster[i] = argb;
}
}
}
bitmap.Invalidate();
return(bitmap);
}
private void SetFilterParameters()
{
foreach (var control in flowLayoutPanel1.Controls)
{
var radioButton = control as RadioButton;
if (radioButton != null && radioButton.Checked)
{
int tagId = int.Parse(radioButton.Tag.ToString());
switch (tagId)
{
case 1:
_selectedImageFilter = new GammaFilter(_selectedFilterValues.Gamma);
break;
case 2:
_selectedImageFilter = new BlurFilter(_selectedFilterValues.Smooth);
break;
case 3:
_selectedImageFilter = new SharpenFilter(_selectedFilterValues.Sharpen);
break;
case 4:
_selectedImageFilter = new EdgeDetectionFilter();
break;
case 5:
_selectedImageFilter = new GaussianBlurFilter(_selectedFilterValues.Gaussian);
break;
case 6:
_selectedImageFilter = new EmbossingFilter();
break;
case 7:
_selectedImageFilter = new MosaicFilter();
break;
default:
break;
}
return;
}
}
}
private void filterRadioButton_CheckedChanged(object sender, EventArgs e)
{
var radioButton = sender as RadioButton;
if (radioButton != null)
{
int tagId = int.Parse(radioButton.Tag.ToString());
switch (tagId)
{
case 1:
_selectedImageFilter = new GammaFilter(_selectedFilterValues.Gamma);
tabControlFilterSettings.SelectedIndex = 0;
break;
case 2:
_selectedImageFilter = new BlurFilter(_selectedFilterValues.Smooth);
tabControlFilterSettings.SelectedIndex = 1;
break;
case 3:
_selectedImageFilter = new SharpenFilter(_selectedFilterValues.Sharpen);
tabControlFilterSettings.SelectedIndex = 2;
break;
case 4:
_selectedImageFilter = new EdgeDetectionFilter();
break;
case 5:
_selectedImageFilter = new GaussianBlurFilter(_selectedFilterValues.Gaussian);
tabControlFilterSettings.SelectedIndex = 3;
break;
case 6:
_selectedImageFilter = new EmbossingFilter();
break;
case 7:
_selectedImageFilter = new MosaicFilter();
break;
default:
break;
}
}
}
public FilterManager()
{
//get all classes that implements IImageFilter
var filterImplementations = from type in Assembly.GetExecutingAssembly().GetTypes()
where typeof(IImageFilter).IsAssignableFrom(type)
select type;
//create instances and put them into the dict
foreach (var filterType in filterImplementations)
{
if (filterType != typeof(IImageFilter))
{
IImageFilter newFilter = (IImageFilter)Activator.CreateInstance(filterType);
filters.Add(newFilter.Name, newFilter);
}
}
}
public void AddFilter(IImageFilter filter)
{
if (_baseImage == null)
{
return;
}
if (filter == null)
{
return;
}
if (_resultImage == null)
{
_resultImage = (Bitmap)_baseImage.Clone();
}
_resultImage = filter.Proccess(_resultImage, true);
_filters.Add(filter);
pictureBox.Image = _resultImage;
UpdateViewSize();
}
public Bitmap Process(Bitmap image, Rectangle scope, IImageFilter filter, params object[] filterParams)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
var cropImage = image.Clone(scope, image.PixelFormat);
var success = filter.Filtrate(cropImage, filterParams);
if (!success)
{
throw new OperationCanceledException();
}
return(cropImage);
}
public Image<Rgba32> AddFilter(IImageFilter filter)
{
using (var context = new Context())
{
AcceleratorId acceleratorId = new AcceleratorId();
if (Accelerator.Accelerators.Where(a => a.AcceleratorType == AcceleratorType.Cuda).Count() != 0)
{
acceleratorId = Accelerator.Accelerators.Where(a =>
a.AcceleratorType == AcceleratorType.Cuda)
.FirstOrDefault();
}
else
{
acceleratorId = Accelerator.Accelerators.Where(a => a.AcceleratorType == AcceleratorType.CPU).FirstOrDefault();
}
using (var accelerator = Accelerator.Create(context, acceleratorId))
{
return filter.PerformFilter(accelerator);
}
}
}
/// <summary>
/// Use filter
/// </summary>
/// <param name="_filter"></param>
private void UseFilter(IImageFilter _filter)
{
NewPhoto.Source = null;
if (OrigPhoto.Source == null)
{
MessageBox.Show("No Image set");
return;
}
var im = WpfApplicationPicture.ImageClass.
ImageConverter.ConvertToBitMap((BitmapSource)OrigPhoto.Source);
var outImage = _filter.filter(im);
NewPhoto.Source = WpfApplicationPicture.ImageClass.
ImageConverter.GetImageSourceFromBitmap(outImage) as BitmapSource;
//Dispose image
outImage.Dispose();
im.Dispose();
GC.Collect();
GC.WaitForPendingFinalizers();
_filter = null;
}
/// <summary>
/// Converts the image to a png stream, which can be assigned to
/// a silverlight image control as image source and applies the specified
/// filter before converting the image.
/// </summary>
/// <param name="image">The image, which should be converted. Cannot be null
/// (Nothing in Visual Basic).</param>
/// <param name="filter">The filter, which should be applied before converting the
/// image or null, if no filter should be applied to. Cannot be null.</param>
/// <returns>The resulting stream.</returns>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="image"/> is null (Nothing in Visual Basic).</para>
/// <para>- or -</para>
/// <para><paramref name="filter"/> is null (Nothing in Visual Basic).</para>
/// </exception>
public static Stream ToStream(this ExtendedImage image, IImageFilter filter)
{
Contract.Requires <ArgumentNullException>(image != null, "Image cannot be null.");
Contract.Requires <ArgumentException>(image.IsFilled, "Image has not been loaded.");
MemoryStream memoryStream = new MemoryStream();
try
{
ExtendedImage temp = image;
if (filter != null)
{
temp = image.Clone();
filter.Apply(temp, image, temp.Bounds);
}
PngEncoder encoder = new PngEncoder();
encoder.IsWritingUncompressed = true;
encoder.Encode(temp, memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
}
catch
{
if (memoryStream != null)
{
memoryStream.Dispose();
memoryStream = null;
}
throw;
}
return(memoryStream);
}
public static Image Filter(this Image source, Rectangle rectangle, IImageFilter filter)
{
return PerformAction(source, image => filter.Apply(image, rectangle));
}
/// <summary>
/// The add filter.
/// </summary>
/// <param name="imageFilter">
/// The image filter.
/// </param>
public void AddFilter(IImageFilter imageFilter)
{
if (imageFilter == null)
{
throw new ArgumentNullException("imageFilter");
}
this.ImageFilters.Add(imageFilter);
}
/// <summary>
/// Initialises a new instance of ImageEventArgs with the associated image.
/// </summary>
/// <param name="image">The image that this event is based around.</param>
/// <param name="filter">The filter currently being used to process this image.</param>
public ImageEventArgs(Image image, IImageFilter filter)
{
Image = image;
Filter = filter;
}
static Samples()
{
_list = new List<ImageGenerator>();
rippleEffect = new GSImageFilter()
{
Name = "Ripple 2x",
Description = "period: 20, amplitude: 5, vert. + horiz.",
runGSFilter = (GSImage image) =>
{
Gimp.Procedure procedure =
new Gimp.Procedure("plug_in_ripple");
procedure.Run(image.Image, image.Drawable,
20, 5, 0, 1, 1, 1, 0);
procedure.Run(image.Image, image.Drawable,
20, 5, 1, 1, 1, 1, 0);
}
};
_list.Add(new ImageGenerator() {
Name = "Euclid + ripple",
SpotFunction = SpotFunction.Samples.euclidDot,
Effects = { rippleEffect }
});
noiseEffect = new GSImageFilter()
{
Name = "Noise",
Description = "RGB noise, independent, corelated, amount: 0.2",
runGSFilter = (GSImage image) =>
{
Gimp.Procedure procedure =
new Gimp.Procedure("plug_in_rgb_noise");
procedure.Run(image.Image, image.Drawable,
1, 1, 0.2);
}
};
_list.Add(new ImageGenerator()
{
Name = "Euclid + noise",
SpotFunction = SpotFunction.Samples.euclidDot,
Effects = { noiseEffect }
});
pixelizeEffect = new GSImageFilter()
{
Name = "Pixelize",
Description = "block: 4px",
runGSFilter = (GSImage image) =>
{
Gimp.Procedure procedure =
new Gimp.Procedure("plug_in_pixelize");
procedure.Run(image.Image, image.Drawable, 4);
}
};
_list.Add(new ImageGenerator()
{
Name = "Euclid + pixelize",
SpotFunction = SpotFunction.Samples.euclidDot,
Effects = { pixelizeEffect }
});
canvasEffect = new GSImageFilter()
{
Name = "Canvas",
Description = "direction: 0, depth: 4",
runGSFilter = (GSImage image) =>
{
Gimp.Procedure procedure =
new Gimp.Procedure("plug_in_apply_canvas");
procedure.Run(image.Image, image.Drawable, 0, 4);
}
};
_list.Add(new ImageGenerator()
{
Name = "Euclid + canvas",
SpotFunction = SpotFunction.Samples.euclidDot,
Effects = { canvasEffect }
});
_list.Add(new ImageGenerator()
{
Name = "Euclid + pixelize + ripple",
SpotFunction = SpotFunction.Samples.euclidDot,
Effects = { pixelizeEffect, rippleEffect }
});
patternEffect = new GSImageFilter()
{
Name = "Pattern",
Description = "Veryovka-Buchanan: current pattern + histogram equalization",
runGSFilter = (GSImage image) =>
{
image.Drawable.Fill(Gimp.FillType.Pattern);
image.Drawable.Equalize(false);
}
};
_list.Add(new ImageGenerator()
{
Name = "Veryovka-Buchanan",
SpotFunction = SpotFunction.Samples.nullSpot,
Effects = { patternEffect }
});
}
public EffectItem(IImageFilter effect, string thumbnailRelativeResourcePath, string name)
: this(effect, thumbnailRelativeResourcePath)
{
Name = name;
}
public EffectItem(IImageFilter effect, string thumbnailRelativeResourcePath)
: this(effect)
{
// Load the thumbnail from the resource stream using the WriteableBitmapEx lib
Thumbnail = new BitmapImage(new System.Uri(thumbnailRelativeResourcePath, System.UriKind.RelativeOrAbsolute));// new WriteableBitmap(0, 0).FromResource(thumbnailRelativeResourcePath);
}
public EffectItem(IImageFilter effect)
{
Effect = effect;
Name = effect.Name;
}
/// <summary>
/// Initialises a new instance of ImageProcessor with an initial image filter to use.
/// </summary>
/// <param name="filter">The initial image filter to use when processing.</param>
public ImageProcessor(IImageFilter filter)
{
Filters.Add(filter);
}
public static Image Filter(this Image source, IImageFilter filter) => Filter(source, source.Bounds, filter);
/// <summary>
/// Applies the processor to the image.
/// <remarks>This method does not resize the target image.</remarks>
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <typeparam name="TPacked">The packed format. <example>uint, long, float.</example></typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="sourceRectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to draw.
/// </param>
/// <param name="processor">The processors to apply to the image.</param>
/// <returns>The <see cref="Image{TColor, TPacked}"/>.</returns>
internal static Image <TColor, TPacked> Process <TColor, TPacked>(this Image <TColor, TPacked> source, Rectangle sourceRectangle, IImageFilter <TColor, TPacked> processor)
where TColor : struct, IPackedPixel <TPacked>
where TPacked : struct
{
return(PerformAction(source, (sourceImage) => processor.Apply(sourceImage, sourceRectangle)));
}
/// <summary>
/// Adds a new filter to the filter processing queue.
/// </summary>
/// <param name="filter">The filter to be added.</param>
/// <remarks>Images are processed by filters in the order that they are added to the
/// filter queue.</remarks>
public void AddFilter(IImageFilter filter)
{
Filters.Add(filter);
}
