Why are Processors internal?

[alan0428a]

Hi community,

I want to use a customized kernel to blur the image. I have checked the source code and found that the ConvolutionProcessor seems to do the work. But the processor is internal so I could not use it in my code.

I was thinking to use the following code to blur the image but failed because of the internal class setting. Have I missed something? Why are the processors set as internal?

using (var img = Image.Load<L8>(path))
{
    var kernel = myKernel;
    var processor = new ConvolutionProcessor(kernel....  // Could not initialize the class since it is internal
    img.Mutate(x => x.ApplyProcessor(processor ))
}

[antonfirsov]

The generic processor classes such as ConvolutionProcessor<TPixel> are hidden to avoid exposing implementation details. Instead, we expose thin API-s for specific operations.

I was thinking to use the following code to blur the image but failed because of the internal class setting.

Have you tried the GaussianBlur extension methods?

[alan0428a]

Thanks for the prompt reply.

Actually, I am migrating a legacy application that uses the AForge library to blur an image. Its blur processing performs convolution using the kernel below.

[1  2  3  2  1
2  4  5  4  2
3  5  6  5  3
2  4  5  4  2
1  2  3  2  1]

I have tried GaussianBlur and tried to tune the sigma value to match the result. I can achieve a similar result by trial and error tunning the sigma value, but I want to achieve the same result if possible.

So I was trying to find a convolution processor which allows me to use a customized kernel. Or do you have any suggestions for this scenario?

Thanks.

[antonfirsov]

I may be missing something, but it looks to me that currently there are no APIs for this.

Personally, I would be happy to see a community contribution that implements an extension method and a non generic IImageProcessor for convolution with an arbitrary kernel. Don't think we will prioritize it as must-have work for the core team.

[brianpopow]

I agree, we should introduce convolution with arbitrary kernel.

We actually have something quite this already, but its in DetectEdges: You can provide there an DenseMatrix as a kernel.

@alan0428a: until we have something like this you could (miss-)use the EdgeDetection processor for your purpose:

DenseMatrix<float> kernel = new float[,]
{
    { 1,  2,  3,  2,  1 },
    { 2,  4,  5,  4,  2 },
    { 3,  5,  6,  5,  3 },
    { 2,  4,  5,  4,  2 },
    { 1, 2,  3,  2,  1 }
};
image.Mutate(img => img.DetectEdges(new EdgeDetectorKernel(kernel)));

I believe the kernel values need to be divided by the sum of the kernel values to actually make this a blur kernel.
Also you can provide to 1D kernels instead for better performance.

[JimBobSquarePants]

I have plans for this based on some work done last year. Stay tuned!

[alan0428a]

@brianpopow
Thanks for the suggestion. The EdgeDetection processor works great, only few raw bytes are different. The result looks great to me.
Please let me know if there is anything I can contribute. I would be happy to help.