Added set of helpers for easier image handling

StableDiffusion.NET/Extensions/ImageExtensions.cs

@@ -0,0 +1,9 @@
+using StableDiffusion.NET.Helper.Images;
+using StableDiffusion.NET.Helper.Images.Colors;
+
+namespace StableDiffusion.NET;
+
+public static class ImageExtension
+{
+    public static Image<ColorRGB> ToImage(this StableDiffusionImage image) => new(image.Data.ToArray(), 0, 0, image.Width, image.Height, image.Width);
+}

StableDiffusion.NET/Helper/Images/Colors/ColorABGR.cs

@@ -0,0 +1,66 @@
+// ReSharper disable ConvertToAutoProperty
+
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace StableDiffusion.NET.Helper.Images.Colors;
+
+/// <summary>
+/// Represents a color in 32 bit ABGR-format.
+/// </summary>
+[DebuggerDisplay("[A: {A}, R: {R}, G: {G}, B: {B}]")]
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct ColorABGR : IColor
+{
+    #region Properties & Fields
+
+    /// <inheritdoc />
+    public static ColorFormat ColorFormat => ColorFormat.ABGR;
+    
+    private readonly byte _a;
+    private readonly byte _b;
+    private readonly byte _g;
+    private readonly byte _r;
+
+    // ReSharper disable ConvertToAutoPropertyWhenPossible
+    /// <inheritdoc />
+    public byte A => _a;
+
+    /// <inheritdoc />
+    public byte B => _b;
+
+    /// <inheritdoc />
+    public byte G => _g;
+
+    /// <inheritdoc />
+    public byte R => _r;
+    // ReSharper restore ConvertToAutoPropertyWhenPossible
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ColorABGR"/> class.
+    /// </summary>
+    /// <param name="a">The alpha-component of the color.</param>
+    /// <param name="b">The blue-component of the color.</param>
+    /// <param name="g">The green-component of the color.</param>
+    /// <param name="r">The red-component of the color.</param>
+    public ColorABGR(byte a, byte b, byte g, byte r)
+    {
+        this._a = a;
+        this._b = b;
+        this._g = g;
+        this._r = r;
+    }
+
+    #endregion
+
+    #region Methods
+
+    /// <inheritdoc />
+    public override string ToString() => $"[A: {_a}, R: {_r}, G: {_g}, B: {_b}]";
+
+    #endregion
+}

StableDiffusion.NET/Helper/Images/Colors/ColorARGB.cs

@@ -0,0 +1,66 @@
+// ReSharper disable ConvertToAutoProperty
+
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace StableDiffusion.NET.Helper.Images.Colors;
+
+/// <summary>
+/// Represents a color in 32 bit ARGB-format.
+/// </summary>
+[DebuggerDisplay("[A: {A}, R: {R}, G: {G}, B: {B}]")]
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct ColorARGB : IColor
+{
+    #region Properties & Fields
+    
+    /// <inheritdoc />
+    public static ColorFormat ColorFormat => ColorFormat.ARGB;
+    
+    private readonly byte _a;
+    private readonly byte _r;
+    private readonly byte _g;
+    private readonly byte _b;
+
+    // ReSharper disable ConvertToAutoPropertyWhenPossible
+    /// <inheritdoc />
+    public byte A => _a;
+
+    /// <inheritdoc />
+    public byte R => _r;
+
+    /// <inheritdoc />
+    public byte G => _g;
+
+    /// <inheritdoc />
+    public byte B => _b;
+    // ReSharper restore ConvertToAutoPropertyWhenPossible
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ColorARGB"/> class.
+    /// </summary>
+    /// <param name="a">The alpha-component of the color.</param>
+    /// <param name="r">The red-component of the color.</param>
+    /// <param name="g">The green-component of the color.</param>
+    /// <param name="b">The blue-component of the color.</param>
+    public ColorARGB(byte a, byte r, byte g, byte b)
+    {
+        this._a = a;
+        this._r = r;
+        this._g = g;
+        this._b = b;
+    }
+
+    #endregion
+
+    #region Methods
+
+    /// <inheritdoc />
+    public override string ToString() => $"[A: {_a}, R: {_r}, G: {_g}, B: {_b}]";
+
+    #endregion
+}

StableDiffusion.NET/Helper/Images/Colors/ColorBGR.cs

@@ -0,0 +1,63 @@
+// ReSharper disable ConvertToAutoProperty
+
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace StableDiffusion.NET.Helper.Images.Colors;
+
+/// <summary>
+/// Represents a color in 24 bit BGR-format.
+/// </summary>
+[DebuggerDisplay("[A: {A}, R: {R}, G: {G}, B: {B}]")]
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct ColorBGR : IColor
+{
+    #region Properties & Fields
+    
+    /// <inheritdoc />
+    public static ColorFormat ColorFormat => ColorFormat.BGR;
+    
+    private readonly byte _b;
+    private readonly byte _g;
+    private readonly byte _r;
+
+    // ReSharper disable ConvertToAutoPropertyWhenPossible
+    /// <inheritdoc />
+    public byte A => byte.MaxValue;
+
+    /// <inheritdoc />
+    public byte B => _b;
+
+    /// <inheritdoc />
+    public byte G => _g;
+
+    /// <inheritdoc />
+    public byte R => _r;
+    // ReSharper restore ConvertToAutoPropertyWhenPossible
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ColorBGR"/> class.
+    /// </summary>
+    /// <param name="b">The blue-component of the color.</param>
+    /// <param name="g">The green-component of the color.</param>
+    /// <param name="r">The red-component of the color.</param>
+    public ColorBGR(byte b, byte g, byte r)
+    {
+        this._b = b;
+        this._g = g;
+        this._r = r;
+    }
+
+    #endregion
+
+    #region Methods
+
+    /// <inheritdoc />
+    public override string ToString() => $"[A: {A}, R: {_r}, G: {_g}, B: {_b}]";
+
+    #endregion
+}

StableDiffusion.NET/Helper/Images/Colors/ColorBGRA.cs

@@ -0,0 +1,66 @@
+// ReSharper disable ConvertToAutoProperty
+
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace StableDiffusion.NET.Helper.Images.Colors;
+
+/// <summary>
+/// Represents a color in 32 bit BGRA-format.
+/// </summary>
+[DebuggerDisplay("[A: {A}, R: {R}, G: {G}, B: {B}]")]
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct ColorBGRA : IColor
+{
+    #region Properties & Fields
+    
+    /// <inheritdoc />
+    public static ColorFormat ColorFormat => ColorFormat.BGRA;
+    
+    private readonly byte _b;
+    private readonly byte _g;
+    private readonly byte _r;
+    private readonly byte _a;
+
+    // ReSharper disable ConvertToAutoPropertyWhenPossible
+    /// <inheritdoc />
+    public byte B => _b;
+
+    /// <inheritdoc />
+    public byte G => _g;
+
+    /// <inheritdoc />
+    public byte R => _r;
+
+    /// <inheritdoc />
+    public byte A => _a;
+    // ReSharper restore ConvertToAutoPropertyWhenPossible
+
+#endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ColorBGRA"/> class.
+    /// </summary>
+    /// <param name="b">The blue-component of the color.</param>
+    /// <param name="g">The green-component of the color.</param>
+    /// <param name="r">The red-component of the color.</param>
+    /// <param name="a">The alpha-component of the color.</param>
+    public ColorBGRA(byte b, byte g, byte r, byte a)
+    {
+        this._b = b;
+        this._g = g;
+        this._r = r;
+        this._a = a;
+    }
+
+    #endregion
+
+    #region Methods
+
+    /// <inheritdoc />
+    public override string ToString() => $"[A: {_a}, R: {_r}, G: {_g}, B: {_b}]";
+
+    #endregion
+}

StableDiffusion.NET/Helper/Images/Colors/ColorFormat.cs

@@ -0,0 +1,58 @@
+namespace StableDiffusion.NET.Helper.Images.Colors;
+
+/// <summary>
+/// Represents a color format.
+/// </summary>
+public readonly struct ColorFormat
+{
+    #region Instances
+
+    public static readonly ColorFormat BGRA = new(1, 4);
+    public static readonly ColorFormat ABGR = new(2, 4);
+    public static readonly ColorFormat RGBA = new(3, 4);
+    public static readonly ColorFormat ARGB = new(4, 4);
+    public static readonly ColorFormat BGR = new(5, 3);
+    public static readonly ColorFormat RGB = new(6, 3);
+
+    #endregion
+
+    #region Properties & Fields
+
+    /// <summary>
+    /// Gets the Id of the color-format.
+    /// </summary>
+    public readonly int Id;
+
+    /// <summary>
+    /// Gets the Bytes per pixel for this color-format.
+    /// </summary>
+    public readonly int BytesPerPixel;
+
+    #endregion
+
+    #region Constructors
+
+    private ColorFormat(int id, int bytesPerPixel)
+    {
+        this.Id = id;
+        this.BytesPerPixel = bytesPerPixel;
+    }
+
+    #endregion
+
+    #region Methods
+
+    public bool Equals(ColorFormat other) => Id == other.Id;
+    public override bool Equals(object? obj) => obj is ColorFormat other && Equals(other);
+
+    public override int GetHashCode() => Id;
+
+    #endregion
+
+    #region Operators
+
+    public static bool operator ==(ColorFormat left, ColorFormat right) => left.Equals(right);
+    public static bool operator !=(ColorFormat left, ColorFormat right) => !(left == right);
+
+    #endregion
+}

StableDiffusion.NET/Helper/Images/Colors/ColorRGB.cs

@@ -0,0 +1,63 @@
+// ReSharper disable ConvertToAutoProperty
+
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace StableDiffusion.NET.Helper.Images.Colors;
+
+/// <summary>
+/// Represents a color in 24 bit RGB-format.
+/// </summary>
+[DebuggerDisplay("[A: {A}, R: {R}, G: {G}, B: {B}]")]
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct ColorRGB : IColor
+{
+    #region Properties & Fields
+    
+    /// <inheritdoc />
+    public static ColorFormat ColorFormat => ColorFormat.RGB;
+    
+    private readonly byte _r;
+    private readonly byte _g;
+    private readonly byte _b;
+
+    // ReSharper disable ConvertToAutoPropertyWhenPossible
+    /// <inheritdoc />
+    public byte A => byte.MaxValue;
+
+    /// <inheritdoc />
+    public byte R => _r;
+
+    /// <inheritdoc />
+    public byte G => _g;
+
+    /// <inheritdoc />
+    public byte B => _b;
+    // ReSharper restore ConvertToAutoPropertyWhenPossible
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ColorRGB"/> class.
+    /// </summary>
+    /// <param name="r">The red-component of the color.</param>
+    /// <param name="g">The green-component of the color.</param>
+    /// <param name="b">The blue-component of the color.</param>
+    public ColorRGB(byte r, byte g, byte b)
+    {
+        this._r = r;
+        this._g = g;
+        this._b = b;
+    }
+
+    #endregion
+
+    #region Methods
+
+    /// <inheritdoc />
+    public override string ToString() => $"[A: {A}, R: {_r}, G: {_g}, B: {_b}]";
+
+    #endregion
+}

StableDiffusion.NET/Helper/Images/Colors/ColorRGBA.cs

@@ -0,0 +1,66 @@
+// ReSharper disable ConvertToAutoProperty
+
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace StableDiffusion.NET.Helper.Images.Colors;
+
+/// <summary>
+/// Represents a color in 32 bit RGBA-format.
+/// </summary>
+[DebuggerDisplay("[A: {A}, R: {R}, G: {G}, B: {B}]")]
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct ColorRGBA : IColor
+{
+    #region Properties & Fields
+
+    /// <inheritdoc />
+    public static ColorFormat ColorFormat => ColorFormat.RGBA;
+    
+    private readonly byte _r;
+    private readonly byte _g;
+    private readonly byte _b;
+    private readonly byte _a;
+
+    // ReSharper disable ConvertToAutoPropertyWhenPossible
+    /// <inheritdoc />
+    public byte R => _r;
+
+    /// <inheritdoc />
+    public byte G => _g;
+
+    /// <inheritdoc />
+    public byte B => _b;
+
+    /// <inheritdoc />
+    public byte A => _a;
+    // ReSharper restore ConvertToAutoPropertyWhenPossible
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ColorRGBA"/> class.
+    /// </summary>
+    /// <param name="r">The red-component of the color.</param>
+    /// <param name="g">The green-component of the color.</param>
+    /// <param name="b">The blue-component of the color.</param>
+    /// <param name="a">The alpha-component of the color.</param>
+    public ColorRGBA(byte r, byte g, byte b, byte a)
+    {
+        this._r = r;
+        this._g = g;
+        this._b = b;
+        this._a = a;
+    }
+
+    #endregion
+
+    #region Methods
+
+    /// <inheritdoc />
+    public override string ToString() => $"[A: {_a}, R: {_r}, G: {_g}, B: {_b}]";
+
+    #endregion
+}

StableDiffusion.NET/Helper/Images/Colors/IColor.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace StableDiffusion.NET.Helper.Images.Colors;
+
+/// <summary>
+/// Represents a generic color made of 4 bytes (alpha, red, green and blue)
+/// </summary>
+public interface IColor
+{
+    /// <summary>
+    /// Gets the red-component of this color.
+    /// </summary>
+    byte R { get; }
+
+    /// <summary>
+    /// Gets the green-component of this color.
+    /// </summary>
+    byte G { get; }
+
+    /// <summary>
+    /// Gets the blue-component of this color.
+    /// </summary>
+    byte B { get; }
+
+    /// <summary>
+    /// Gets the alpha-component of this color.
+    /// </summary>
+    byte A { get; }
+
+    /// <summary>
+    /// Gets the color-format of this color.
+    /// </summary>
+    public static virtual ColorFormat ColorFormat => throw new NotSupportedException();
+}

StableDiffusion.NET/Helper/Images/IImage.cs

@@ -0,0 +1,193 @@
+using System;
+using System.Collections.Generic;
+using StableDiffusion.NET.Helper.Images.Colors;
+
+namespace StableDiffusion.NET.Helper.Images;
+
+/// <summary>
+/// Represents a image.
+/// </summary>
+public interface IImage : IEnumerable<IColor>
+{
+    /// <summary>
+    /// Gets the color format used in this image.
+    /// </summary>
+    ColorFormat ColorFormat { get; }
+
+    /// <summary>
+    /// Gets the width of this image.
+    /// </summary>
+    int Width { get; }
+
+    /// <summary>
+    /// Gets the height of this image.
+    /// </summary>
+    int Height { get; }
+
+    /// <summary>
+    /// Gets the size in bytes of this image.
+    /// </summary>
+    int SizeInBytes { get; }
+
+    /// <summary>
+    /// Gets the color at the specified location.
+    /// </summary>
+    /// <param name="x">The X-location to read.</param>
+    /// <param name="y">The Y-location to read.</param>
+    /// <returns>The color at the specified location.</returns>
+    IColor this[int x, int y] { get; }
+
+    /// <summary>
+    /// Gets an image representing the specified location.
+    /// </summary>
+    /// <param name="x">The X-location of the image.</param>
+    /// <param name="y">The Y-location of the image.</param>
+    /// <param name="width">The width of the sub-image.</param>
+    /// <param name="height"></param>
+    /// <returns></returns>
+    IImage this[int x, int y, int width, int height] { get; }
+
+    /// <summary>
+    /// Gets a list of all rows of this image.
+    /// </summary>
+    IImageRows Rows { get; }
+
+    /// <summary>
+    /// Gets a list of all columns of this image.
+    /// </summary>
+    IImageColumns Columns { get; }
+
+    /// <summary>
+    /// Gets an <see cref="RefImage{TColor}"/> representing this <see cref="IImage"/>.
+    /// </summary>
+    /// <typeparam name="TColor">The color-type of the iamge.</typeparam>
+    /// <returns>The <inheritdoc cref="RefImage{TColor}"/>.</returns>
+    RefImage<TColor> AsRefImage<TColor>() where TColor : struct, IColor;
+
+    /// <summary>
+    /// Copies the contents of this <see cref="IImage"/> into a destination <see cref="Span{T}"/> instance.
+    /// </summary>
+    /// <param name="destination">The destination <see cref="Span{T}"/> instance.</param>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <paramref name="destination"/> is shorter than the source <see cref="IImage"/> instance.
+    /// </exception>
+    void CopyTo(in Span<byte> destination);
+
+    /// <summary>
+    /// Allocates a new array and copies this <see cref="IImage"/> into it.
+    /// </summary>
+    /// <returns>The new array containing the data of this <see cref="IImage"/>.</returns>
+    byte[] ToArray();
+
+    /// <summary>
+    /// Represents a list of rows of an image.
+    /// </summary>
+    public interface IImageRows : IEnumerable<IImageRow>
+    {
+        /// <summary>
+        /// Gets the amount of rows in this list.
+        /// </summary>
+        int Count { get; }
+
+        /// <summary>
+        /// Gets a specific <see cref="IImageRow"/>.
+        /// </summary>
+        /// <param name="column">The ´row to get.</param>
+        /// <returns>The requested <see cref="IImageRow"/>.</returns>
+        IImageRow this[int column] { get; }
+    }
+
+    /// <summary>
+    /// Represents a list of columns of an image.
+    /// </summary>
+    public interface IImageColumns : IEnumerable<IImageColumn>
+    {
+        /// <summary>
+        /// Gets the amount of columns in this list.
+        /// </summary>
+        int Count { get; }
+
+        /// <summary>
+        /// Gets a specific <see cref="IImageColumn"/>.
+        /// </summary>
+        /// <param name="column">The column to get.</param>
+        /// <returns>The requested <see cref="IImageColumn"/>.</returns>
+        IImageColumn this[int column] { get; }
+    }
+
+    /// <summary>
+    /// Represents a single row of an image.
+    /// </summary>
+    public interface IImageRow : IEnumerable<IColor>
+    {
+        /// <summary>
+        /// Gets the length of the row.
+        /// </summary>
+        int Length { get; }
+
+        /// <summary>
+        /// Gets the size in bytes of this row.
+        /// </summary>
+        int SizeInBytes { get; }
+
+        /// <summary>
+        /// Gets the <see cref="IColor"/> at the specified location.
+        /// </summary>
+        /// <param name="x">The location to get the color from.</param>
+        /// <returns>The <see cref="IColor"/> at the specified location.</returns>
+        IColor this[int x] { get; }
+
+        /// <summary>
+        /// Copies the contents of this <see cref="IImageRow"/> into a destination <see cref="Span{T}"/> instance.
+        /// </summary>
+        /// <param name="destination">The destination <see cref="Span{T}"/> instance.</param>
+        /// <exception cref="ArgumentException">
+        /// Thrown when <paramref name="destination"/> is shorter than the source <see cref="IImageRow"/> instance.
+        /// </exception>
+        void CopyTo(in Span<byte> destination);
+
+        /// <summary>
+        /// Allocates a new array and copies this <see cref="IImageRow"/> into it.
+        /// </summary>
+        /// <returns>The new array containing the data of this <see cref="IImageRow"/>.</returns>
+        byte[] ToArray();
+    }
+
+    /// <summary>
+    /// Represents a single column of an image.
+    /// </summary>
+    public interface IImageColumn : IEnumerable<IColor>
+    {
+        /// <summary>
+        /// Gets the length of the column.
+        /// </summary>
+        int Length { get; }
+
+        /// <summary>
+        /// Gets the size in bytes of this column.
+        /// </summary>
+        int SizeInBytes { get; }
+
+        /// <summary>
+        /// Gets the <see cref="IColor"/> at the specified location.
+        /// </summary>
+        /// <param name="y">The location to get the color from.</param>
+        /// <returns>The <see cref="IColor"/> at the specified location.</returns>
+        IColor this[int y] { get; }
+
+        /// <summary>
+        /// Copies the contents of this <see cref="IImageColumn"/> into a destination <see cref="Span{T}"/> instance.
+        /// </summary>
+        /// <param name="destination">The destination <see cref="Span{T}"/> instance.</param>
+        /// <exception cref="ArgumentException">
+        /// Thrown when <paramref name="destination"/> is shorter than the source <see cref="IImageColumn"/> instance.
+        /// </exception>
+        void CopyTo(in Span<byte> destination);
+
+        /// <summary>
+        /// Allocates a new array and copies this <see cref="IImageColumn"/> into it.
+        /// </summary>
+        /// <returns>The new array containing the data of this <see cref="IImageColumn"/>.</returns>
+        byte[] ToArray();
+    }
+}

StableDiffusion.NET/Helper/Images/Image.cs

@@ -0,0 +1,441 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using StableDiffusion.NET.Helper.Images.Colors;
+
+namespace StableDiffusion.NET.Helper.Images;
+
+/// <inheritdoc />
+public sealed class Image<TColor> : IImage
+    where TColor : struct, IColor
+{
+    #region Properties & Fields
+
+    private readonly byte[] _buffer;
+    
+    private readonly int _x;
+    private readonly int _y;
+    private readonly int _stride;
+
+    /// <inheritdoc />
+    public ColorFormat ColorFormat
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => TColor.ColorFormat;
+    }
+
+    /// <inheritdoc />
+    public int Width { get; }
+
+    /// <inheritdoc />
+    public int Height { get; }
+
+    /// <inheritdoc />
+    public int SizeInBytes => Width * Height * ColorFormat.BytesPerPixel;
+
+    #endregion
+
+    #region Indexer
+
+    /// <inheritdoc />
+    public IColor this[int x, int y]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get
+        {
+            if ((x < 0) || (y < 0) || (x >= Width) || (y >= Height)) throw new IndexOutOfRangeException();
+
+            return MemoryMarshal.Cast<byte, TColor>(_buffer)[((_y + y) * _stride) + (_x + x)];
+        }
+    }
+
+    /// <inheritdoc />
+    public IImage this[int x, int y, int width, int height]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get
+        {
+            if ((x < 0) || (y < 0) || (width <= 0) || (height <= 0) || ((x + width) > Width) || ((y + height) > Height)) throw new IndexOutOfRangeException();
+
+            return new Image<TColor>(_buffer, _x + x, _y + y, width, height, _stride);
+        }
+    }
+
+    /// <inheritdoc />
+    public IImage.IImageRows Rows
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => new ImageRows(_buffer, _x, _y, Width, Height, _stride);
+    }
+
+    /// <inheritdoc />
+    public IImage.IImageColumns Columns
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => new ImageColumns(_buffer, _x, _y, Width, Height, _stride);
+    }
+
+    #endregion
+
+    #region Constructors
+
+    public Image(byte[] buffer, int x, int y, int width, int height, int stride)
+    {
+        this._buffer = buffer;
+        this._x = x;
+        this._y = y;
+        this.Width = width;
+        this.Height = height;
+        this._stride = stride;
+    }
+
+    #endregion
+
+    #region Methods
+
+    /// <inheritdoc />
+    public void CopyTo(in Span<byte> destination)
+    {
+        if (destination == null) throw new ArgumentNullException(nameof(destination));
+        if (destination.Length < SizeInBytes) throw new ArgumentException("The destination is too small to fit this image.", nameof(destination));
+
+        int targetStride = Width * ColorFormat.BytesPerPixel;
+        IImage.IImageRows rows = Rows;
+        Span<byte> target = destination;
+        foreach (IImage.IImageRow row in rows)
+        {
+            row.CopyTo(target);
+            target = target[targetStride..];
+        }
+    }
+
+    /// <inheritdoc />
+    public byte[] ToArray()
+    {
+        byte[] array = new byte[SizeInBytes];
+        CopyTo(array);
+        return array;
+    }
+
+    /// <inheritdoc />
+    public RefImage<T> AsRefImage<T>()
+        where T : struct, IColor
+    {
+        if (typeof(T) != typeof(TColor)) throw new ArgumentException("The requested color format does not fit this image.", nameof(T));
+
+        return new RefImage<T>(MemoryMarshal.Cast<byte, T>(_buffer), _x, _y, Width, Height, _stride);
+    }
+
+    /// <inheritdoc />
+    public IEnumerator<IColor> GetEnumerator()
+    {
+        for (int y = 0; y < Height; y++)
+            for (int x = 0; x < Width; x++)
+                yield return this[x, y];
+    }
+
+    /// <inheritdoc />
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    #endregion
+
+    #region Indexer-Classes
+
+    /// <inheritdoc />
+    private sealed class ImageRows : IImage.IImageRows
+    {
+        #region Properties & Fields
+
+        private readonly byte[] _buffer;
+        private readonly int _x;
+        private readonly int _y;
+        private readonly int _width;
+        private readonly int _height;
+        private readonly int _stride;
+
+        /// <inheritdoc />
+        public int Count => _height;
+
+        #endregion
+
+        #region Indexer
+
+        /// <inheritdoc />
+        public IImage.IImageRow this[int row]
+        {
+            get
+            {
+                if ((row < 0) || (row >= _height)) throw new IndexOutOfRangeException();
+
+                return new ImageRow(_buffer, (((row + _y) * _stride) + _x), _width);
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        internal ImageRows(byte[] buffer, int x, int y, int width, int height, int stride)
+        {
+            this._buffer = buffer;
+            this._x = x;
+            this._y = y;
+            this._width = width;
+            this._height = height;
+            this._stride = stride;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <inheritdoc />
+        public IEnumerator<IImage.IImageRow> GetEnumerator()
+        {
+            for (int y = 0; y < _height; y++)
+                yield return this[y];
+        }
+
+        /// <inheritdoc />
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        #endregion
+    }
+
+    /// <inheritdoc />
+    private sealed class ImageRow : IImage.IImageRow
+    {
+        #region Properties & Fields
+
+        private readonly byte[] _buffer;
+        private readonly int _start;
+        private readonly int _length;
+
+        /// <inheritdoc />
+        public int Length => _length;
+
+#if NET7_0_OR_GREATER
+        /// <inheritdoc />
+        public int SizeInBytes => Length * TColor.ColorFormat.BytesPerPixel;
+#else
+        /// <inheritdoc />
+        public int SizeInBytes => Length * default(TColor).Net6ColorFormat.BytesPerPixel;
+#endif
+
+        #endregion
+
+        #region Indexer
+
+        /// <inheritdoc />
+        public IColor this[int x]
+        {
+            get
+            {
+                if ((x < 0) || (x >= _length)) throw new IndexOutOfRangeException();
+
+                ReadOnlySpan<TColor> row = MemoryMarshal.Cast<byte, TColor>(_buffer)[_start..];
+                return row[x];
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        internal ImageRow(byte[] buffer, int start, int length)
+        {
+            this._buffer = buffer;
+            this._start = start;
+            this._length = length;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <inheritdoc />
+        public void CopyTo(in Span<byte> destination)
+        {
+            if (destination == null) throw new ArgumentNullException(nameof(destination));
+            if (destination.Length < SizeInBytes) throw new ArgumentException("The destination is too small to fit this image.", nameof(destination));
+
+            MemoryMarshal.Cast<byte, TColor>(_buffer).Slice(_start, _length).CopyTo(MemoryMarshal.Cast<byte, TColor>(destination));
+        }
+
+        /// <inheritdoc />
+        public byte[] ToArray()
+        {
+            byte[] array = new byte[SizeInBytes];
+            CopyTo(array);
+            return array;
+        }
+
+        /// <inheritdoc />
+        public IEnumerator<IColor> GetEnumerator()
+        {
+            for (int x = 0; x < _length; x++)
+                yield return this[x];
+        }
+
+        /// <inheritdoc />
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        #endregion
+    }
+
+    /// <inheritdoc />
+    private sealed class ImageColumns : IImage.IImageColumns
+    {
+        #region Properties & Fields
+
+        private readonly byte[] _buffer;
+        private readonly int _x;
+        private readonly int _y;
+        private readonly int _width;
+        private readonly int _height;
+        private readonly int _stride;
+
+        /// <inheritdoc />
+        public int Count => _width;
+
+        #endregion
+
+        #region Indexer
+
+        /// <inheritdoc />
+        public IImage.IImageColumn this[int column]
+        {
+            get
+            {
+                if ((column < 0) || (column >= _width)) throw new IndexOutOfRangeException();
+
+                return new ImageColumn(_buffer, (_y * _stride) + _x + column, _height, _stride);
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        internal ImageColumns(byte[] buffer, int x, int y, int width, int height, int stride)
+        {
+            this._buffer = buffer;
+            this._x = x;
+            this._y = y;
+            this._width = width;
+            this._height = height;
+            this._stride = stride;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <inheritdoc />
+        public IEnumerator<IImage.IImageColumn> GetEnumerator()
+        {
+            for (int y = 0; y < _height; y++)
+                yield return this[y];
+        }
+
+        /// <inheritdoc />
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        #endregion
+    }
+
+    /// <inheritdoc />
+    private sealed class ImageColumn : IImage.IImageColumn
+    {
+        #region Properties & Fields
+
+        private readonly byte[] _buffer;
+        private readonly int _start;
+        private readonly int _length;
+        private readonly int _step;
+
+        /// <inheritdoc />
+        public int Length => _length;
+
+#if NET7_0_OR_GREATER
+        /// <inheritdoc />
+        public int SizeInBytes => Length * TColor.ColorFormat.BytesPerPixel;
+#else
+        /// <inheritdoc />
+        public int SizeInBytes => Length * default(TColor).Net6ColorFormat.BytesPerPixel;
+#endif
+
+        #endregion
+
+        #region Indexer
+
+        /// <inheritdoc />
+        public IColor this[int y]
+        {
+            get
+            {
+                if ((y < 0) || (y >= _length)) throw new IndexOutOfRangeException();
+
+                ReadOnlySpan<TColor> data = MemoryMarshal.Cast<byte, TColor>(_buffer)[_start..];
+                return data[y * _step];
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        internal ImageColumn(byte[] buffer, int start, int length, int step)
+        {
+            this._buffer = buffer;
+            this._start = start;
+            this._length = length;
+            this._step = step;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <inheritdoc />
+        public void CopyTo(in Span<byte> destination)
+        {
+            if (destination == null) throw new ArgumentNullException(nameof(destination));
+            if (destination.Length < SizeInBytes) throw new ArgumentException("The destination is too small to fit this image.", nameof(destination));
+
+            if (_step == 1)
+                _buffer.AsSpan(_start, SizeInBytes).CopyTo(destination);
+            else
+            {
+                ReadOnlySpan<TColor> data = MemoryMarshal.Cast<byte, TColor>(_buffer)[_start..];
+                Span<TColor> target = MemoryMarshal.Cast<byte, TColor>(destination);
+                for (int i = 0; i < Length; i++)
+                    target[i] = data[i * _step];
+            }
+        }
+
+        /// <inheritdoc />
+        public byte[] ToArray()
+        {
+            byte[] array = new byte[SizeInBytes];
+            CopyTo(array);
+            return array;
+        }
+
+        /// <inheritdoc />
+        public IEnumerator<IColor> GetEnumerator()
+        {
+            for (int y = 0; y < _length; y++)
+                yield return this[y];
+        }
+
+        /// <inheritdoc />
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        #endregion
+    }
+
+    #endregion
+}

StableDiffusion.NET/Helper/Images/ReadOnlyRefEnumerable.cs

@@ -0,0 +1,266 @@
+// DarthAffe 05.09.2023: Based on https://github.com/CommunityToolkit/dotnet/blob/b0d6c4f9c0cfb5d860400abb00b0ca1b3e94dfa4/src/CommunityToolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable%7BT%7D.cs
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StableDiffusion.NET.Helper.Images;
+
+/// <summary>
+/// A <see langword="ref"/> <see langword="struct"/> that iterates readonly items from arbitrary memory locations.
+/// </summary>
+/// <typeparam name="T">The type of items to enumerate.</typeparam>
+public readonly ref struct ReadOnlyRefEnumerable<T>
+{
+    #region Properties & Fields
+
+    /// <summary>
+    /// The <see cref="ReadOnlySpan{T}"/> instance pointing to the first item in the target memory area.
+    /// </summary>
+    /// <remarks>The <see cref="ReadOnlySpan{T}.Length"/> field maps to the total available length.</remarks>
+    private readonly ReadOnlySpan<T> _span;
+
+    /// <summary>
+    /// The distance between items in the sequence to enumerate.
+    /// </summary>
+    /// <remarks>The distance refers to <typeparamref name="T"/> items, not byte offset.</remarks>
+    private readonly int _step;
+
+    /// <summary>
+    /// Gets the total available length for the sequence.
+    /// </summary>
+    public int Length
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _span.Length;
+    }
+
+    /// <summary>
+    /// Gets the element at the specified zero-based index.
+    /// </summary>
+    /// <param name="index">The zero-based index of the element.</param>
+    /// <returns>A reference to the element at the specified index.</returns>
+    /// <exception cref="IndexOutOfRangeException">
+    /// Thrown when <paramref name="index"/> is invalid.
+    /// </exception>
+    public ref readonly T this[int index]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get
+        {
+            if ((uint)index >= (uint)Length) throw new IndexOutOfRangeException();
+
+            ref T r0 = ref MemoryMarshal.GetReference(_span);
+            nint offset = (nint)(uint)index * (nint)(uint)_step;
+            ref T ri = ref Unsafe.Add(ref r0, offset);
+
+            return ref ri;
+        }
+    }
+
+    /// <summary>
+    /// Gets the element at the specified zero-based index.
+    /// </summary>
+    /// <param name="index">The zero-based index of the element.</param>
+    /// <returns>A reference to the element at the specified index.</returns>
+    /// <exception cref="IndexOutOfRangeException">
+    /// Thrown when <paramref name="index"/> is invalid.
+    /// </exception>
+    public ref readonly T this[Index index]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => ref this[index.GetOffset(Length)];
+    }
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ReadOnlyRefEnumerable{T}"/> struct.
+    /// </summary>
+    /// <param name="reference">A reference to the first item of the sequence.</param>
+    /// <param name="length">The number of items in the sequence.</param>
+    /// <param name="step">The distance between items in the sequence to enumerate.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal ReadOnlyRefEnumerable(in T reference, int length, int step)
+    {
+        this._step = step;
+
+        _span = MemoryMarshal.CreateReadOnlySpan(ref Unsafe.AsRef(reference), length);
+    }
+
+    #endregion
+
+    #region Methods
+
+    /// <inheritdoc cref="System.Collections.IEnumerable.GetEnumerator"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Enumerator GetEnumerator() => new(_span, _step);
+
+    public T[] ToArray()
+    {
+        int length = _span.Length;
+
+        // Empty array if no data is mapped
+        if (length == 0)
+            return Array.Empty<T>();
+
+        T[] array = new T[length];
+        CopyTo(array);
+
+        return array;
+    }
+
+    /// <summary>
+    /// Copies the contents of this <see cref="ReadOnlyRefEnumerable{T}"/> into a destination <see cref="Span{T}"/> instance.
+    /// </summary>
+    /// <param name="destination">The destination <see cref="Span{T}"/> instance.</param>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <paramref name="destination"/> is shorter than the source <see cref="ReadOnlyRefEnumerable{T}"/> instance.
+    /// </exception>
+    public void CopyTo(Span<T> destination)
+    {
+        if (_step == 1)
+        {
+            _span.CopyTo(destination);
+            return;
+        }
+
+        ref T sourceRef = ref MemoryMarshal.GetReference(_span);
+        int length = _span.Length;
+        if ((uint)destination.Length < (uint)length)
+            throw new ArgumentException("The target span is too short to copy all the current items to.");
+
+        ref T destinationRef = ref MemoryMarshal.GetReference(destination);
+
+        CopyTo(ref sourceRef, ref destinationRef, (nint)(uint)length, (nint)(uint)_step);
+    }
+
+    /// <summary>
+    /// Attempts to copy the current <see cref="ReadOnlyRefEnumerable{T}"/> instance to a destination <see cref="Span{T}"/>.
+    /// </summary>
+    /// <param name="destination">The target <see cref="Span{T}"/> of the copy operation.</param>
+    /// <returns>Whether or not the operation was successful.</returns>
+    public bool TryCopyTo(Span<T> destination)
+    {
+        if (destination.Length >= _span.Length)
+        {
+            CopyTo(destination);
+            return true;
+        }
+
+        return false;
+    }
+
+    private static void CopyTo(ref T sourceRef, ref T destinationRef, nint length, nint sourceStep)
+    {
+        nint sourceOffset = 0;
+        nint destinationOffset = 0;
+
+        while (length >= 8)
+        {
+            Unsafe.Add(ref destinationRef, destinationOffset + 0) = Unsafe.Add(ref sourceRef, sourceOffset);
+            Unsafe.Add(ref destinationRef, destinationOffset + 1) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+            Unsafe.Add(ref destinationRef, destinationOffset + 2) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+            Unsafe.Add(ref destinationRef, destinationOffset + 3) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+            Unsafe.Add(ref destinationRef, destinationOffset + 4) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+            Unsafe.Add(ref destinationRef, destinationOffset + 5) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+            Unsafe.Add(ref destinationRef, destinationOffset + 6) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+            Unsafe.Add(ref destinationRef, destinationOffset + 7) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+
+            length -= 8;
+            sourceOffset += sourceStep;
+            destinationOffset += 8;
+        }
+
+        if (length >= 4)
+        {
+            Unsafe.Add(ref destinationRef, destinationOffset + 0) = Unsafe.Add(ref sourceRef, sourceOffset);
+            Unsafe.Add(ref destinationRef, destinationOffset + 1) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+            Unsafe.Add(ref destinationRef, destinationOffset + 2) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+            Unsafe.Add(ref destinationRef, destinationOffset + 3) = Unsafe.Add(ref sourceRef, sourceOffset += sourceStep);
+
+            length -= 4;
+            sourceOffset += sourceStep;
+            destinationOffset += 4;
+        }
+
+        while (length > 0)
+        {
+            Unsafe.Add(ref destinationRef, destinationOffset) = Unsafe.Add(ref sourceRef, sourceOffset);
+
+            length -= 1;
+            sourceOffset += sourceStep;
+            destinationOffset += 1;
+        }
+    }
+
+    #endregion
+
+    /// <summary>
+    /// A custom enumerator type to traverse items within a <see cref="ReadOnlyRefEnumerable{T}"/> instance.
+    /// </summary>
+    public ref struct Enumerator
+    {
+        #region Properties & Fields
+
+        /// <inheritdoc cref="ReadOnlyRefEnumerable{T}._span"/>
+        private readonly ReadOnlySpan<T> _span;
+
+        /// <inheritdoc cref="ReadOnlyRefEnumerable{T}._step"/>
+        private readonly int _step;
+
+        /// <summary>
+        /// The current position in the sequence.
+        /// </summary>
+        private int _position;
+
+        /// <inheritdoc cref="System.Collections.Generic.IEnumerator{T}.Current"/>
+        public readonly ref readonly T Current
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                ref T r0 = ref MemoryMarshal.GetReference(_span);
+
+                nint offset = (nint)(uint)_position * (nint)(uint)_step;
+                ref T ri = ref Unsafe.Add(ref r0, offset);
+
+                return ref ri;
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Enumerator"/> struct.
+        /// </summary>
+        /// <param name="span">The <see cref="ReadOnlySpan{T}"/> instance with the info on the items to traverse.</param>
+        /// <param name="step">The distance between items in the sequence to enumerate.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal Enumerator(ReadOnlySpan<T> span, int step)
+        {
+            this._span = span;
+            this._step = step;
+
+            _position = -1;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool MoveNext() => ++_position < _span.Length;
+
+        #endregion
+    }
+}

StableDiffusion.NET/Helper/Images/RefImage.cs

@@ -0,0 +1,368 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using StableDiffusion.NET.Helper.Images.Colors;
+
+namespace StableDiffusion.NET.Helper.Images;
+
+public readonly ref struct RefImage<TColor>
+    where TColor : struct, IColor
+{
+    #region Properties & Fields
+
+    private readonly ReadOnlySpan<TColor> _pixels;
+
+    private readonly int _x;
+    private readonly int _y;
+
+    /// <summary>
+    /// Gets the width of the image.
+    /// </summary>
+    public int Width { get; }
+
+    /// <summary>
+    /// Gets the height of the image.
+    /// </summary>
+    public int Height { get; }
+
+    /// <summary>
+    /// Gets the stride (entries per row) of the underlying buffer.
+    /// Only useful if you want to work with a pinned buffer.
+    /// </summary>
+    public int RawStride { get; }
+
+    #endregion
+
+    #region Indexer
+
+    public ref readonly TColor this[int x, int y]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get
+        {
+            if ((x < 0) || (y < 0) || (x >= Width) || (y >= Height)) throw new IndexOutOfRangeException();
+
+            ref TColor r0 = ref MemoryMarshal.GetReference(_pixels);
+            nint offset = (nint)(uint)((_y + y) * RawStride) + (_x + x);
+            return ref Unsafe.Add(ref r0, offset);
+        }
+    }
+
+    public RefImage<TColor> this[int x, int y, int width, int height]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get
+        {
+            if ((x < 0) || (y < 0) || (width <= 0) || (height <= 0) || ((x + width) > Width) || ((y + height) > Height)) throw new IndexOutOfRangeException();
+
+            return new RefImage<TColor>(_pixels, _x + x, _y + y, width, height, RawStride);
+        }
+    }
+
+    public ImageRows Rows
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => new(_pixels, _x, _y, Width, Height, RawStride);
+    }
+    public ImageColumns Columns
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => new(_pixels, _x, _y, Width, Height, RawStride);
+    }
+
+    #endregion
+
+    #region Constructors
+
+    public RefImage(ReadOnlySpan<TColor> pixels, int x, int y, int width, int height, int stride)
+    {
+        this._pixels = pixels;
+        this._x = x;
+        this._y = y;
+        this.Width = width;
+        this.Height = height;
+        this.RawStride = stride;
+    }
+
+    #endregion
+
+    #region Methods
+
+    /// <summary>
+    /// Copies the contents of this <see cref="RefImage{TColor}"/> into a destination <see cref="Span{T}"/> instance.
+    /// </summary>
+    /// <param name="destination">The destination <see cref="Span{T}"/> instance.</param>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <paramref name="destination"/> is shorter than the source <see cref="RefImage{TColor}"/> instance.
+    /// </exception>
+    public void CopyTo(in Span<TColor> destination)
+    {
+        if (destination == null) throw new ArgumentNullException(nameof(destination));
+        if (destination.Length < (Width * Height)) throw new ArgumentException("The destination is too small to fit this image.", nameof(destination));
+
+        ImageRows rows = Rows;
+        Span<TColor> target = destination;
+        foreach (ReadOnlyRefEnumerable<TColor> row in rows)
+        {
+            row.CopyTo(target);
+            target = target[Width..];
+        }
+    }
+
+    /// <summary>
+    /// Allocates a new array and copies this <see cref="RefImage{TColor}"/> into it.
+    /// </summary>
+    /// <returns>The new array containing the data of this <see cref="RefImage{TColor}"/>.</returns>
+    public TColor[] ToArray()
+    {
+        TColor[] array = new TColor[Width * Height];
+        CopyTo(array);
+        return array;
+    }
+
+    /// <summary>
+    /// Returns a reference to the first element of this image inside the full image buffer.
+    /// </summary>
+    public ref readonly TColor GetPinnableReference()
+    {
+        if (_pixels.Length == 0)
+            return ref Unsafe.NullRef<TColor>();
+
+        int offset = (_y * RawStride) + _x;
+        return  ref MemoryMarshal.GetReference(_pixels[offset..]);
+    }
+
+    /// <inheritdoc cref="System.Collections.IEnumerable.GetEnumerator"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ImageEnumerator GetEnumerator() => new(_pixels);
+
+    #endregion
+
+    public ref struct ImageEnumerator
+    {
+        #region Properties & Fields
+
+        private readonly ReadOnlySpan<TColor> _pixels;
+        private int _position;
+
+        /// <inheritdoc cref="System.Collections.Generic.IEnumerator{T}.Current"/>
+        public TColor Current
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _pixels[_position];
+        }
+
+        #endregion
+
+        #region Constructors
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal ImageEnumerator(ReadOnlySpan<TColor> pixels)
+        {
+            this._pixels = pixels;
+
+            _position = -1;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool MoveNext() => ++_position < _pixels.Length;
+
+        #endregion
+    }
+
+    #region Indexer-Structs
+
+    public readonly ref struct ImageRows
+    {
+        #region Properties & Fields
+
+        private readonly ReadOnlySpan<TColor> _pixels;
+        private readonly int _x;
+        private readonly int _y;
+        private readonly int _width;
+        private readonly int _height;
+        private readonly int _stride;
+
+        public int Count => _height;
+
+        #endregion
+
+        #region Indexer
+
+        public readonly ReadOnlyRefEnumerable<TColor> this[int row]
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                if ((row < 0) || (row > _height)) throw new IndexOutOfRangeException();
+
+                ref TColor r0 = ref MemoryMarshal.GetReference(_pixels);
+                ref TColor rr = ref Unsafe.Add(ref r0, (nint)(uint)(((row + _y) * _stride) + _x));
+
+                return new ReadOnlyRefEnumerable<TColor>(rr, _width, 1);
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        public ImageRows(ReadOnlySpan<TColor> pixels, int x, int y, int width, int height, int stride)
+        {
+            this._pixels = pixels;
+            this._x = x;
+            this._y = y;
+            this._width = width;
+            this._height = height;
+            this._stride = stride;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <inheritdoc cref="System.Collections.IEnumerable.GetEnumerator"/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ImageRowsEnumerator GetEnumerator() => new(this);
+
+        #endregion
+
+        public ref struct ImageRowsEnumerator
+        {
+            #region Properties & Fields
+
+            private readonly ImageRows _rows;
+            private int _position;
+
+            /// <inheritdoc cref="System.Collections.Generic.IEnumerator{T}.Current"/>
+            public ReadOnlyRefEnumerable<TColor> Current
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => _rows[_position];
+            }
+
+            #endregion
+
+            #region Constructors
+
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal ImageRowsEnumerator(ImageRows rows)
+            {
+                this._rows = rows;
+
+                _position = -1;
+            }
+
+            #endregion
+
+            #region Methods
+
+            /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public bool MoveNext() => ++_position < _rows._height;
+
+            #endregion
+        }
+    }
+
+    public readonly ref struct ImageColumns
+    {
+        #region Properties & Fields
+
+        private readonly ReadOnlySpan<TColor> _pixels;
+        private readonly int _x;
+        private readonly int _y;
+        private readonly int _width;
+        private readonly int _height;
+        private readonly int _stride;
+
+        public int Count => _width;
+
+        #endregion
+
+        #region Indexer
+
+        public ReadOnlyRefEnumerable<TColor> this[int column]
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                if ((column < 0) || (column > _width)) throw new IndexOutOfRangeException();
+
+                ref TColor r0 = ref MemoryMarshal.GetReference(_pixels);
+                ref TColor rc = ref Unsafe.Add(ref r0, (nint)(uint)((_y * _stride) + (column + _x)));
+
+                return new ReadOnlyRefEnumerable<TColor>(rc, _height, _stride);
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        public ImageColumns(ReadOnlySpan<TColor> pixels, int x, int y, int width, int height, int stride)
+        {
+            this._pixels = pixels;
+            this._x = x;
+            this._y = y;
+            this._width = width;
+            this._height = height;
+            this._stride = stride;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <inheritdoc cref="System.Collections.IEnumerable.GetEnumerator"/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ImageColumnsEnumerator GetEnumerator() => new(this);
+
+        #endregion
+
+        public ref struct ImageColumnsEnumerator
+        {
+            #region Properties & Fields
+
+            private readonly ImageColumns _columns;
+            private int _position;
+
+            /// <inheritdoc cref="System.Collections.Generic.IEnumerator{T}.Current"/>
+            public ReadOnlyRefEnumerable<TColor> Current
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => _columns[_position];
+            }
+
+            #endregion
+
+            #region Constructors
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal ImageColumnsEnumerator(ImageColumns columns)
+            {
+                this._columns = columns;
+                this._position = -1;
+            }
+
+            #endregion
+
+            #region Methods
+
+            /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public bool MoveNext() => ++_position < _columns._width;
+
+            #endregion
+        }
+    }
+
+    #endregion
+}