Load gray scale 8-bit images directly

[nietras]

It does not appear ImageSharp supports loading gray scale images directly?

[JimBobSquarePants]

The pixel format you’re looking for is L8.

A little less snark next time please.

[nietras]

I don't understand the L8 documentation then, it shows a 4 component definition, how is that to be interpreted?

[antonfirsov]

It has only one PackedValue byte property that represents the luminance.

Source:
https://github.com/SixLabors/ImageSharp/blob/master/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs

If you are looking into direct pixel manipulation this should help:
https://docs.sixlabors.com/articles/imagesharp/pixelbuffers.html#efficient-pixel-manipulation

The Span<T> API-s will change in 2.0: #1739

[nietras]

@antonfirsov thank you. Yes I was completely thrown off by the L8 documentation string, which says it's "Packed" and has a "[x,x,x,1] vector form", both of which were entirely unsuspected to me given I was looking for a pixel that is not "packed" as such but just unsigned 8-bit. But think I get it now, that all pixels are considered "packed" it seems.

Packed pixel type containing a single 8-bit normalized luminance value.
Ranges from [0, 0, 0, 1] to [1, 1, 1, 1] in vector form.

I can load an image as expected now.

using Image<L8> image = Image.Load<L8>(ImageBytes);

However, if I wanted to load different kinds of images like Bgr24 and L8 while preserving their formats e.g. like:

using Image image = Image.Load(ImageBytes); // Could be Bgr24 or L8 or ?

is that supported? (WPF has something like BitmapCreateOptions.PreservePixelFormat for example).

The Span API-s will change in 2.0

Yes, that is understandable I guess, but perhaps also a bit unfortunate as I definitely wanted to try to get to the underlying "native memory" of the image in question. As far as I can understand image data is stored in native memory. At least based on benchmarking. Or it is pooled, that could be the case. One could do that via public Span<T> DangerousGetRowSpan(int rowIndex); so still possible, although unsafe. Right? This is for a case where we "interop" with other libraries and want to avoid copying data or similar, but need the data as a raw pointer for this case.

One question, my baseline is GDI+ or System.Drawing and I am seeing ~2.3x slower decode times. Is that expected? For png, 8-bit gray scale image.

PS: Removed offending comment, no doubt I did not phrase it constructively.