Matrix.cs

using SkiaSharp;
using System;
 
namespace IdApp.Cv
{
    public class Matrix<T> : IMatrix
        where T : struct
    {
        private T[] data;
        private int width;
        private int height;
        private int left;
        private int top;
        private int rowSize;
        private int dataSize;
        private int start;
        private int skip;
 
        private Matrix()
        {
            this.data = [];
        }
 
        public Matrix(int Width, int Height)
            : this(Width, Height, new T[Width * Height])
        {
        }
 
        public Matrix(int Width, int Height, T[] Data)
        {
            this.dataSize = Width * Height;
            if (this.dataSize != Data.Length)
                throw new ArgumentOutOfRangeException(nameof(Data));
 
            this.data = Data;
            this.width = Width;
            this.height = Height;
            this.left = 0;
            this.top = 0;
            this.start = 0;
            this.rowSize = Width;
            this.skip = 0;
        }
 
        protected Matrix(int Width, int Height, T[] Data, int Left, int Top, int RowSize, 
            int Start, int Skip)
        {
            this.dataSize = Data.Length;
            this.data = Data;
            this.width = Width;
            this.height = Height;
            this.left = Left;
            this.top = Top;
            this.start = Start;
            this.rowSize = RowSize;
            this.skip = Skip;
        }
 
        public virtual Matrix<T> ShallowCopy()
        {
            return new Matrix<T>()
            {
                data = this.data,
                width = this.width,
                height = this.height,
                left = this.left,
                top = this.top,
                start = this.start,
                rowSize = this.rowSize,
                dataSize = this.dataSize,
                skip = this.skip
            };
        }
 
        public Type ElementType => typeof(T);
 
        public T[] Data => this.data;
 
        public int Width
        {
            get => this.width;
            set
            {
                if (value <= 0 || value >= this.rowSize - this.left)
                    throw new ArgumentOutOfRangeException(nameof(this.Width));
 
                this.width = value;
                this.skip = this.rowSize - this.width;
            }
        }
 
        public int Height
        {
            get => this.height;
            set
            {
                if (value <= 0 || (this.top + value) * this.width >= this.dataSize)
                    throw new ArgumentOutOfRangeException(nameof(this.Height));
 
                this.height = value;
            }
        }
 
        public int Left
        {
            get => this.left;
            set
            {
                if (value < 0 || value >= this.rowSize - this.width)
                    throw new ArgumentOutOfRangeException(nameof(this.Left));
 
                this.left = value;
                this.start = this.left + this.top * this.rowSize;
            }
        }
 
        public int Top
        {
            get => this.top;
            set
            {
                if (value < 0 || (value + this.height) * this.width >= this.dataSize)
                    throw new ArgumentOutOfRangeException(nameof(this.Top));
 
                this.top = value;
                this.start = this.left + this.top * this.rowSize;
            }
        }
 
        public void SetXSpan(int Left, int Width)
        {
            if (Left < 0 || Left + Width > this.rowSize)
                throw new ArgumentOutOfRangeException(nameof(Left));
 
            if (Width <= 0)
                throw new ArgumentOutOfRangeException(nameof(Width));
 
            this.left = Left;
            this.start = this.left + this.top * this.rowSize;
            this.width = Width;
            this.skip = this.rowSize - this.width;
        }
 
        public void SetYSpan(int Top, int Height)
        {
            if (Top < 0 || (Top + Height) * this.width > this.dataSize)
                throw new ArgumentOutOfRangeException(nameof(Top));
 
            if (Height <= 0)
                throw new ArgumentOutOfRangeException(nameof(Height));
 
            this.top = Top;
            this.height = Height;
            this.start = this.left + this.top * this.rowSize;
        }
        public int RowSize => this.rowSize;
 
        public int DataSize => this.dataSize;
 
        public int Start => this.start;
 
        public int Skip => this.skip;
 
        public T this[int X, int Y]
        {
            get => this.data[(X + this.left) + (Y + this.top) * this.rowSize];
            set => this.data[(X + this.left) + (Y + this.top) * this.rowSize] = value;
        }
 
        public int StartIndex(int X, int Y)
        {
            return (X + this.left) + (Y + this.top) * this.rowSize;
        }
 
        public Matrix<T> Row(int RowIndex)
        {
            if (RowIndex < 0 || RowIndex >= this.height)
                throw new ArgumentOutOfRangeException(nameof(RowIndex));
 
            return new Matrix<T>()
            {
                data = this.data,
                width = this.width,
                height = 1,
                left = this.left,
                top = this.top + RowIndex,
                rowSize = this.rowSize,
                dataSize = this.dataSize,
                start = this.start + (RowIndex * this.rowSize),
                skip = this.skip
            };
        }
 
        public Matrix<T> Column(int ColumnIndex)
        {
            if (ColumnIndex < 0 || ColumnIndex >= this.width)
                throw new ArgumentOutOfRangeException(nameof(ColumnIndex));
 
            return new Matrix<T>()
            {
                data = this.data,
                width = 1,
                height = this.height,
                left = this.left + ColumnIndex,
                top = this.top,
                rowSize = this.rowSize,
                dataSize = this.dataSize,
                start = this.start + ColumnIndex,
                skip = this.rowSize - 1
            };
        }
 
        public Matrix<T> Region(int Left, int Top, int Width, int Height)
        {
            if (Left < 0 || Left >= this.width)
                throw new ArgumentOutOfRangeException(nameof(Left));
 
            if (Top < 0 || Top >= this.height)
                throw new ArgumentOutOfRangeException(nameof(Top));
 
            if (Width <= 0 || Width > this.width - this.left - Left)
                throw new ArgumentOutOfRangeException(nameof(Width));
 
            if (Height <= 0 || Height > this.height - this.top - Top)
                throw new ArgumentOutOfRangeException(nameof(Height));
 
            return new Matrix<T>()
            {
                data = this.data,
                width = Width,
                height = Height,
                left = this.left + Left,
                top = this.top + Top,
                rowSize = this.rowSize,
                dataSize = this.dataSize,
                start = this.start + Left + (Top * this.rowSize),
                skip = this.rowSize - Width
            };
        }
 
        public static IMatrix LoadFromFile(string FileName)
        {
            using SKBitmap Bmp = SKBitmap.Decode(FileName);
            byte[] Data = Bmp.Bytes;
 
            switch (Bmp.BytesPerPixel)
            {
                case 1:
                    return new Matrix<byte>(Bmp.Width, Bmp.Height, Data);
 
                case 2:
                    int i, j, c = Data.Length;
                    ushort[] Bin16 = new ushort[c / 2];
                    ushort u;
 
                    i = j = 0;
                    while (i < c)
                    {
                        u = Data[i++];
                        u <<= 8;
                        u |= Data[i++];
                        Bin16[j++] = u;
                    }
 
                    return new Matrix<ushort>(Bmp.Width, Bmp.Height, Bin16);
 
                case 3:
                    c = Data.Length;
                    uint[] Bin32 = new uint[c / 3];
                    uint v;
 
                    i = j = 0;
                    while (i < c)
                    {
                        v = Data[i++];
                        v <<= 8;
                        v |= Data[i++];
                        v <<= 8;
                        v |= Data[i++];
                        Bin32[j++] = v;
                    }
 
                    return new Matrix<uint>(Bmp.Width, Bmp.Height, Bin32);
 
                case 4:
                    c = Data.Length;
                    Bin32 = new uint[c / 4];
 
                    i = j = 0;
                    while (i < c)
                    {
                        v = Data[i++];
                        v <<= 8;
                        v |= Data[i++];
                        v <<= 8;
                        v |= Data[i++];
                        v <<= 8;
                        v |= Data[i++];
                        Bin32[j++] = v;
                    }
 
                    return new Matrix<uint>(Bmp.Width, Bmp.Height, Bin32);
 
                default:
                    throw new ArgumentException("Color type not supported.", nameof(FileName));
            }
        }
 
    }
}