SkiaSharp SKbitmap.GetPixel and SKbitmap.SetPixel - improve performance

I am trying to use C# and SkiaSharp to implement image processing.
The code below is trying to implement edge detection.

The result of the code below is quite good, it needs improving, but this is not my point:

Image for testing the code

canvas.Clear(SKColors.White);
//  USerskbitmapNEW has been loaded earlier.
SKBitmap image = new SKBitmap(USerskbitmapNEW.Width, USerskbitmapNEW.Height);
for (int i = 0; i < image.Width; i++)
{
    for (int j = 0; j < image.Height; j++)
    {
        SKColor c1 = USerskbitmapNEW.GetPixel(i, j - 1);
        SKColor c2 = USerskbitmapNEW.GetPixel(i, j + 1);
        int xval = 0;
        int yval = 0;
        xval = (int)(c1.Red * .3 + c2.Blue * 0.11 - (c2.Red * .3));
        yval = (int)(c2.Red * .3 + c2.Green * .29 + c2.Blue * 0.11);
        if (xval > yval )
        {
            SKColor c = SKColors.Black;
            image.SetPixel(i, j, c);
        }
    }
}
canvas.DrawBitmap(image, myframe);

My problem is that the methods : SKbitmap.GetPixel(i, j); and SKbitmap.SetPixel(i, j, color); are extremely slow when use them with images bigger than 200kb size.

In contrast to the above methods( .GetPixel .SetPixel) , when you apply image various filters , for example , var cf = SKColorFilter.CreateTable(null, null, colorTable, colorTable); .... skiasharp is very fast.

My question: is there any other way, using skiasharp, to read and modify pixels of the image, with better performance than the methods I described?

Thanks in advance
Michalis

You need to forget about GetPixel/SetPixel methods if you want to have direct access to pixels.

For starters, you access pixel data directly for SKBitmap using GetPixels method:

IntPtr pixelsPtr = image.GetPixels();

Then, in unsafe context, you can manipulate the data quickly (you need to calculate pixel offset manually, as well as setting colors via uint or byte values).

unsafe
{
    var unsafePtr = (uint*)pixelsPtr.ToPointer();
    for (int y = 1; y < image.Height - 1; y++)
    {
        var rowOffset = y * image.Width;
        
        for (int x = 0; x < image.Width; x++)
        {
            uint c1 = unsafePtr [rowOffset - image.Width + x];
            uint c2 = unsafePtr [rowOffset + image.Width + x];
            // now you should have c1/c2 uints representing RGBA pixel data
            // you can manipulate those and store back via unsafePtr
...
        }
    }
}

I will not rewrite the whole logic for you, I can see there is also a problem that you change the pixel colors on the fly, so setting a black color at (x, y) coordinates will cause false calculation at pixel (x, y + 1)