Actually changing pixel transparency during Mutate

[jhwheuer]

Right, I am getting my Image instance like so:
SixLabors.ImageSharp.Image<Rgba32>.Load(inStream);
Then I am stepping through the pixels using a Mutate()

                    image.Mutate(c => c.ProcessPixelRowsAsVector4(row =>
                    {

                        // Vector4 XYZW => RGBA
                        Windows.UI.Color sourceColor = new Windows.UI.Color();
                        int distance = 0;

                        for (int x = 0; x < row.Length; x++)
                        {
                            // Get
                            sourceColor.R = (byte)(255f * row[x].X);
                            sourceColor.G = (byte)(255f * row[x].Y);
                            sourceColor.B = (byte)(255f * row[x].Z);
                            sourceColor.A = (byte)(255f * row[x].W);

                            // What is the distance?

                            distance = ColorHelper.Distance(sourceColor, matchColor);

                            if (distance <= this.Value)
                            {
                                row[x].X = targetR;
                                row[x].Y = targetG;
                                row[x].Z = targetB;
                                row[x].W = targetA;
                            }
                        }
                    }));

I then save this as a PNG to load it into a XAML Image element...

Works great, until I want to replace with #00000000, which does not happen... all other colors are fine, just the transparency bit is ignored.

Any ideas where I mess this up?

[JimBobSquarePants]

Sounds like you're not saving the png in 32bit format.

[jhwheuer]

Even when grabbing
c.ProcessPixelRowsAsVector4(row =>{...], , PixelConversionModifiers.Scale)

I still end up with what appear to be 2 bit colors... Rather than pulling info bit by bit, where in the docu is the end-to-end protocol explained? Or might I ask you to actually write the correct way to load a 32bi RGBa bitmap, changing the RGBa of a pixel and saving that to PNG with alpha intact? That would be very helpful.

[JimBobSquarePants]

Or might I ask you to actually write the correct way to load a 32bi RGBa bitmap, changing the RGBa of a pixel and saving that to PNG with alpha intact?

Yeah use Image<Rgba32> which you seem to be doing. Explicitly setting the metadata might help but tbh I'd like an input image to experiment with. Something seems really fishy.

[jhwheuer]

Well, the UC is to add transparency to a BMP and then save it as a PNG.
I am using a simple BMP image, read that into the Image, mess with the pixels and then export the bitmap to a PNG file.
Maybe my basic premise that Image is format agnostic is wonky?

[jhwheuer]

Jim, on the distance method... the replacement seems to ignore the transparency byte and only take the two top bits of the RGB... feels like I am doing the conversion from target color to the Vector4 wrong... This is what I am doing right now, maybe that is the culprit...

                    float targetR = targetColor.R / 255;
                    float targetG = targetColor.G / 255;
                    float targetB = targetColor.B / 255;
                    float targetA = targetColor.A / 255;

[jhwheuer]

Yep, doing this for 40 years, still not thinking through how a compiler would parse those statements... replaced 255 with 255.0f, now at least the nuances are right.

Alpha still not being honored. I have taken the bitmap and removed the background in Paint.net, saved it as a PNG and then taken through the same transform. This time it works... It looks like if I load a PNG and save it as a PNG, that "understands" alpha... if I start with a BMP and change Alpha info of pixels, that somehow does not make it to the PNG save..

.

[jhwheuer]

Had to convert to JPG, BMP attachments are not supported

[JimBobSquarePants]

I can't seem to replicate your issue. Here's some code demonstrating working with bitmaps of varying bit depth.

Note it would be more efficient to use Vector4 for rather than converting to/from Rgba32, in addition to the lack of converting overhead (which these methods are designed to avoid) you could then pow2 your distance threshold and used Vector4.DistanceSquared(...) to get the difference across all components faster.

using Dicussion2185;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats.Png;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;

Console.WriteLine("Hello, World!");

var appPath = Path.Combine(Directory.GetCurrentDirectory(), @"..\..\..\");

var depths = new int[] { 4, 8, 24 };

foreach (var depth in depths)
{
    using var image = Image.Load(Path.Combine(appPath, $"input{depth}.bmp"));
    image.Mutate(c => c.ProcessPixelRowsAsVector4(row =>
    {
        Rgba32 sourceColor = default;
        Rgba32 matchColor = Color.White;
        Rgba32 target = default;

        for (int x = 0; x < row.Length; x++)
        {
            // Get
            sourceColor.R = (byte)(255F * row[x].X);
            sourceColor.G = (byte)(255F * row[x].Y);
            sourceColor.B = (byte)(255F * row[x].Z);
            sourceColor.A = (byte)(255F * row[x].W);

            // What is the distance?
            double distance = ColorHelper.Distance(sourceColor, matchColor);

            // Match up to a diff of 1 per pixel component.
            if (distance <= 1.74)
            {
                // SET
                row[x].X = target.R / 255F;
                row[x].Y = target.G / 255F;
                row[x].Z = target.B / 255F;
                row[x].W = target.A / 255F;
            }
        }
    }, PixelConversionModifiers.Scale));

    string outPath = Path.GetFullPath(Path.Combine(appPath, $"output{depth}.png"));
    image.Save(Path.Combine(appPath, $"output{depth}.png"), new PngEncoder());
    Console.WriteLine(outPath);
}

Here the actual working example.
Dicussion2185.zip

[JimBobSquarePants]

Your not setting the explicit options in the encoder

[antonfirsov]

Instantiating from SixLabors.ImageSharp.Image<Rgba32>.Load(inStream);

If that's literally your code, it's still a call the non-generic Image.Load(), since Image<Rgba32> is a subclass of Image that doesn't overload the static Load method. You need to use the generic method Image.Load<Rgba32>(inStream), which returns Image<Rgba32>.

[jhwheuer]

Bingo, Anton, did not dive into the source to understand the nature of the static call.

Solved the problem.

Much appreciated!!!

[JimBobSquarePants]

IDE should be flagging that. Does on my machine.

[jhwheuer]

Hmm, that is true... It does not on mine... this is a UWP project, weirdness abounds.

[tocsoft]

is using var image = Image.Load(Path.Combine(appPath, $"input{depth}.bmp")); picking a pixel format internally with out transparency
try making use you specify a pixel format using var image = Image.Load<Rgba32>(Path.Combine(appPath, $"input{depth}.bmp"));
and also try clearing down/nulling the images metadata as I believe that can influence the re-encoding choice in some scenarios.

[tocsoft]

Oh wait it does mention using the pixel format overload, if that's the case then the metadata clearing might still be a factor

[jhwheuer]

Thank you. I am submitting some artefacts as evidence... I cannot delete MetaData as USER is manipulating that.