Feature Request: PixelBrush<TPixel>

[calrsom]

I'm trying to use ImageSharp to render polygon data to raster data, where the underlying pixel values represent data values rather than colors. At first the ability to define a custom TPixel implementation seemed like the perfect match. Digging deeper, I see that values are converted to single floating point values under the hood; this still works for me. However, unfortunately the drawing library uses a 16-bit int for the Color class. I can understand this choice for actual colors, but it is limiting for representing other data.

I'm looking for an implementation of the SolidBrush that takes a TPixel value rather than a Color. That sidesteps the Color issue entirely. You could call this a "PixelBrush" or "ValueBrush". Looking at the source, it seems trivial to add this, since the SolidBrush converts to a TPixel internally. I'd implement this in my own code base, except BrushApplicator has a protected constructor, which means that IBrush is not really meant to be implemented (I suppose except for wrapping an existing brush). I can respect that decision being related to the library being in "beta" status and the API not being locked down.

I could probably put together a PR pretty quick by tweaking the SolidBrush class as described.

[tocsoft]

This idea sounds fine to me, from an API/implementation POV I would suggest creating a new class SolidBush<TPixel> whoes CreateApplicator<T> throws if the pixels do not match....alternatively we could fast path with the same pixel type, otherwise we could then call new Color(TBrushPixel.ToRgba32()).ToPixel<TImagePixel>() (or equivalent) to translate between pixel types.

Both versions of SolidBrush (generic and not) would then both use the same internal SolidBrushApplicator<T> (it would just need to be made internal rather than private.)

However saying all that I would like to add you can actually create a custom BrushApplicator<T> in your own codebase, the protected constructor just mean you will need to call it from your derived types constructor...ie you can just copy the SolidBrushApplicator implementation into your own code and it should compile fine..

[antonfirsov]

Vector4 also brings floating point flakiness, it's better to keep the backing storage integer-based.

From OP:

[...] where the underlying pixel values represent data values rather than colors.

@calrsom I wonder what is your use case, and what is the data you store in a pixel?

[JimBobSquarePants]

PR created. SixLabors/ImageSharp#1797

[JimBobSquarePants]

I'd rather go "good enough" than bloat out the PixelOperations API but we'll see. Using RgbaVector is an improvement anyway and everything we do is single precision so not even reliable machine to machine.

Plus...

Digging deeper, I see that values are converted to single floating point values under the hood; this still works for me.

[calrsom]

Sorry I've been out of the loop here, but I did want to update the discussion with my use case.

I am rendering agricultural crop and product coverage maps. I have a custom pixel type that stores the data as floating point values; this is convenient, since the data values vary considerably in magnitude based on the underlying data measurement units. I initially used the add blend mode to calculate overlapping coverage. I have since written a custom brush, because I discovered I needed more control over the pixel blending math.

As a point of interest, here is the custom brush I came up with:

    /// <summary>
    /// Custom brush for compositing coverage data
    /// </summary>
    public class DataBrush : IBrush
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="DataBrush"/> class.
        /// </summary>
        /// <param name="value">Data values to composite</param>
        public DataBrush(TaPixel value) => Data = value;

        /// <summary>
        /// Gets the color.
        /// </summary>
        public TaPixel Data { get; }

        /// <inheritdoc />
        public BrushApplicator<TPixel> CreateApplicator<TPixel>(
            Configuration configuration,
            GraphicsOptions options,
            ImageFrame<TPixel> source,
            RectangleF region)
            where TPixel : unmanaged, IPixel<TPixel>
        {
            if (source is ImageFrame<TaPixel> dataSource)
            {
                return new DataBrushApplicator(configuration, options, dataSource, Data) as BrushApplicator<TPixel>;
            }
            throw new NotSupportedException("DataBrush only works on TaPixel images");
        }

        /// <summary>
        /// The data brush applicator.
        /// </summary>
        private sealed class DataBrushApplicator : BrushApplicator<TaPixel>
        {
            private TaPixel Data;

            /// <summary>
            /// Initializes a new instance of the <see cref="DataBrushApplicator"/> class.
            /// </summary>
            /// <param name="configuration">Ignored.</param>
            /// <param name="options">Ignored.</param>
            /// <param name="source">The source image.</param>
            /// <param name="data">Data values to composite</param>
            public DataBrushApplicator(
                Configuration configuration,
                GraphicsOptions options,
                ImageFrame<TaPixel> source,
                TaPixel data)
                : base(configuration, options, source)
            {
                Data = data;
            }

            /// <inheritdoc />
            public override void Apply(Span<float> scanline, int x, int y)
            {
                Span<TaPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x);

                // Constrain the spans to each other
                if (destinationRow.Length > scanline.Length)
                    destinationRow = destinationRow.Slice(0, scanline.Length);

                for (int i = 0; i < destinationRow.Length; i++)
                {
                    // Target add blend capped, Actual add blend; see https://en.wikipedia.org/wiki/Blend_modes
                    destinationRow[i] = new TaPixel(
                        Math.Min(destinationRow[i].Target + Data.Target * scanline[i], Math.Max(destinationRow[i].Target, Data.Target)), 
                        destinationRow[i].Actual + Data.Actual * scanline[i]);
                }
            }
        }
    }

[antonfirsov]

@calrsom thanks! What is the content of TaPixel? Two doubles?

Note that we added support for backing Color by an arbitrary IPixel<T> implementation in SixLabors/ImageSharp#1801. You should be able to create it with Color.FromPixel(new TaPixel(...)).

Edit: I see you already found the PR 👍