public void DetectEdges_Rect_EdgeDetectorProcessorSet(EdgeDetectorKernel kernel, bool grayscale)
{
this.operations.DetectEdges(kernel, grayscale, this.rect);
EdgeDetectorProcessor processor = this.Verify <EdgeDetectorProcessor>(this.rect);
Assert.Equal(grayscale, processor.Grayscale);
Assert.Equal(kernel, processor.Kernel);
}
public void DetectEdges_Rect_EdgeDetectorProcessor_DefaultGrayScale_Set(EdgeDetectorKernel kernel, bool _)
{
this.operations.DetectEdges(kernel, this.rect);
EdgeDetectorProcessor processor = this.Verify <EdgeDetectorProcessor>(this.rect);
Assert.True(processor.Grayscale);
Assert.Equal(kernel, processor.Kernel);
}
/// <summary>
/// Detects any edges within the image using a <see cref="EdgeDetectorKernel"/>.
/// </summary>
/// <param name="source">The image this method extends.</param>
/// <param name="kernel">The edge detector kernel.</param>
/// <param name="grayscale">
/// Whether to convert the image to grayscale before performing edge detection.
/// </param>
/// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
public static IImageProcessingContext DetectEdges(
this IImageProcessingContext source,
EdgeDetectorKernel kernel,
bool grayscale)
{
var processor = new EdgeDetectorProcessor(kernel, grayscale);
source.ApplyProcessor(processor);
return(source);
}
public void WorksWithDiscoBuffers <TPixel>(
TestImageProvider <TPixel> provider,
EdgeDetectorKernel detector,
string _)
where TPixel : unmanaged, IPixel <TPixel>
{
provider.RunBufferCapacityLimitProcessorTest(
41,
c => c.DetectEdges(detector),
detector);
}
public void DetectEdges_WorksWithAllFilters <TPixel>(
TestImageProvider <TPixel> provider,
EdgeDetectorKernel detector,
string name)
where TPixel : unmanaged, IPixel <TPixel>
{
bool hasAlpha = provider.SourceFileOrDescription.Contains("TestPattern");
ImageComparer comparer = hasAlpha ? TransparentComparer : OpaqueComparer;
using (Image <TPixel> image = provider.GetImage())
{
image.Mutate(x => x.DetectEdges(detector));
image.DebugSave(provider, name);
image.CompareToReferenceOutput(comparer, provider, name);
}
}
public void EdgeDetectorKernelEqualityOperatorTest()
{
EdgeDetectorKernel kernel0 = KnownEdgeDetectorKernels.Laplacian3x3;
EdgeDetectorKernel kernel1 = KnownEdgeDetectorKernels.Laplacian3x3;
EdgeDetectorKernel kernel2 = KnownEdgeDetectorKernels.Laplacian5x5;
Assert.True(kernel0 == kernel1);
Assert.False(kernel0 != kernel1);
Assert.True(kernel0 != kernel2);
Assert.False(kernel0 == kernel2);
Assert.True(kernel0.Equals((object)kernel1));
Assert.True(kernel0.Equals(kernel1));
Assert.False(kernel0.Equals((object)kernel2));
Assert.False(kernel0.Equals(kernel2));
Assert.Equal(kernel0.GetHashCode(), kernel1.GetHashCode());
Assert.NotEqual(kernel0.GetHashCode(), kernel2.GetHashCode());
}
/// <summary>
/// Detects any edges within the image operating in grayscale mode.
/// </summary>
/// <param name="source">The image this method extends.</param>
/// <param name="kernel">The edge detector kernel.</param>
/// <param name="rectangle">
/// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
/// </param>
/// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
public static IImageProcessingContext DetectEdges(
this IImageProcessingContext source,
EdgeDetectorKernel kernel,
Rectangle rectangle) =>
DetectEdges(source, kernel, true, rectangle);
