public void DetectEdges_Rect_EdgeDetectorCompassProcessorSet(EdgeDetectorCompassKernel kernel, bool grayscale)
{
this.operations.DetectEdges(kernel, grayscale, this.rect);
EdgeDetectorCompassProcessor processor = this.Verify <EdgeDetectorCompassProcessor>(this.rect);
Assert.Equal(grayscale, processor.Grayscale);
Assert.Equal(kernel, processor.Kernel);
}
public void DetectEdges_EdgeDetectorCompassProcessor_DefaultGrayScale_Set(EdgeDetectorCompassKernel kernel, bool _)
{
this.operations.DetectEdges(kernel);
EdgeDetectorCompassProcessor processor = this.Verify <EdgeDetectorCompassProcessor>();
Assert.True(processor.Grayscale);
Assert.Equal(kernel, processor.Kernel);
}
/// <summary>
/// Detects any edges within the image using a <see cref="EdgeDetectorCompassKernel"/>.
/// </summary>
/// <param name="source">The image this method extends.</param>
/// <param name="kernel">Thecompass 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,
EdgeDetectorCompassKernel kernel,
bool grayscale)
{
var processor = new EdgeDetectorCompassProcessor(kernel, grayscale);
source.ApplyProcessor(processor);
return(source);
}
public void WorksWithDiscoBuffersCompass <TPixel>(
TestImageProvider <TPixel> provider,
EdgeDetectorCompassKernel detector,
string _)
where TPixel : unmanaged, IPixel <TPixel>
{
provider.RunBufferCapacityLimitProcessorTest(
41,
c => c.DetectEdges(detector),
detector);
}
public void DetectEdgesCompass_WorksWithAllFilters <TPixel>(
TestImageProvider <TPixel> provider,
EdgeDetectorCompassKernel 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 EdgeDetectorCompassKernelEqualityOperatorTest()
{
EdgeDetectorCompassKernel kernel0 = KnownEdgeDetectorKernels.Kirsch;
EdgeDetectorCompassKernel kernel1 = KnownEdgeDetectorKernels.Kirsch;
EdgeDetectorCompassKernel kernel2 = KnownEdgeDetectorKernels.Robinson;
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">Thecompass 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,
EdgeDetectorCompassKernel kernel,
Rectangle rectangle) =>
DetectEdges(source, kernel, true, rectangle);
