1. bmp图像含有头数据，一般长度为54个字节，像素按照从左到右，从下到上的顺序排列；raw图像不含头数据，且像素为1个字节，因此直接分割即可，像素按照从左到右，从上到下的顺序排列。
2. bmp图像按照从左到右，从下到上的顺序依次输出编号为[1,rowCount*colCount]的bmp图像；raw图像按照从左到右，从上到下的顺序依次输出编号为[1,rowCount*colCount]的raw图像。
3. 注意，rowCount和colCount必须为原图高度和宽度的整数因子。

using System;
using System.IO;

namespace _05
{
    
    class Program
    {
    
        static void Main(string[] args)
        {
    
            Test.DivideBmpImage("D:\\Desktop\\Files\\Directory\\BmpImage.bmp", 2, 4, "D:\\Desktop\\Files\\Directory");
            Test.DivideRawImage("D:\\Desktop\\Files\\Directory\\RawImage.raw", 10800, 21600, 2, 4, "D:\\Desktop\\Files\\Directory");
        }
    }

    class Test
    {
    
        /// <summary>
        /// 根据给定的行数和列数，分割bmp图像
        /// bmp图像含有头数据，一般长度为54个字节，像素按照从左到右，从下到上的顺序排列
        /// 注意，头数据以2个或4个字节为单位，按照十六进制倒序排列，因此，只能调用BitConverter类的方法进行修改
        /// 按照从左到右，从下到上的顺序依次输出编号为[1,rowCount*colCount]的bmp图像
        /// 注意，rowCount和colCount必须为原图高度和宽度的整数因子
        /// </summary>
        /// <param name="sourceImagePath">原图路径</param>
        /// <param name="rowCount">行数</param>
        /// <param name="colCount">列数</param>
        /// <param name="outputDirectory">输出目录</param>
        public static void DivideBmpImage(string sourceImagePath, int rowCount, int colCount, string outputDirectory)
        {
    
            //获取原数据
            byte[] sourceData = File.ReadAllBytes(sourceImagePath);

            //提取头数据
            int headSize = BitConverter.ToInt32(sourceData, 10);//头数据大小，单位为字节
            byte[] headData = new byte[headSize];
            for (int i = 0; i < headSize; i++)
            {
    
                headData[i] = sourceData[i];
            }

            //提取像素数据
            int width = BitConverter.ToInt32(headData, 18);//图像宽度，单位为像素
            int height = BitConverter.ToInt32(headData, 22);//图像高度，单位为像素
            int pixelSize = BitConverter.ToInt32(headData, 28) / 8;//单个像素大小，单位为字节
            int widthSize = width * pixelSize;//图像宽度，单位为字节
            int heightSize = height;//图像高度，单位为字节
            byte[][] pixelData = new byte[heightSize][];
            for (int i = 0; i < heightSize; i++)
            {
    
                pixelData[i] = new byte[widthSize];
                for (int j = 0; j < widthSize; j++)
                {
    
                    pixelData[i][j] = sourceData[headSize + i * widthSize + j];
                }
            }

            //重建头数据
            byte[] newHeadData = new byte[headSize];
            for (int i = 0; i < headSize; i++)
            {
    
                newHeadData[i] = headData[i];
            }
            int newFileSize = headSize + (widthSize / colCount) * (heightSize / rowCount);
            byte[] newFileSize_ = BitConverter.GetBytes(newFileSize);
            for (int i = 0; i < newFileSize_.Length; i++)
            {
    
                newHeadData[2 + i] = newFileSize_[i];
            }
            int newWidth = width / colCount;
            byte[] newWidth_ = BitConverter.GetBytes(newWidth);
            for (int i = 0; i < newWidth_.Length; i++)
            {
    
                newHeadData[18 + i] = newWidth_[i];
            }
            int newHeight = height / rowCount;
            byte[] newHeight_ = BitConverter.GetBytes(newHeight);
            for (int i = 0; i < newHeight_.Length; i++)
            {
    
                newHeadData[22 + i] = newHeight_[i];
            }
            int newPixelSize = BitConverter.ToInt32(headData, 34) / (rowCount * colCount);
            byte[] newPixelSize_ = BitConverter.GetBytes(newPixelSize);
            for (int i = 0; i < newPixelSize_.Length; i++)
            {
    
                newHeadData[34 + i] = newPixelSize_[i];
            }

            //重建像素数据
            int newWidthSize = newWidth * pixelSize;
            int newHeightSize = newHeight;
            //原图按行分割
            byte[][][][] newPixelData = new byte[rowCount][][][];
            for (int i = 0; i < rowCount; i++)
            {
    
                //原图按列分割
                newPixelData[i] = new byte[colCount][][];
                for (int j = 0; j < colCount; j++)
                {
    
                    //新图按行分割
                    newPixelData[i][j] = new byte[newHeightSize][];
                    for (int m = 0; m < newHeightSize; m++)
                    {
    
                        //新图按列分割
                        newPixelData[i][j][m] = new byte[newWidthSize];
                        for (int n = 0; n < newWidthSize; n++)
                        {
    
                            newPixelData[i][j][m][n] = pixelData[i * newHeightSize + m][j * newWidthSize + n];
                        }
                    }
                }
            }

            //重建图片并输出
            byte[] newData;
            for (int i = 0; i < rowCount; i++)
            {
    
                for (int j = 0; j < colCount; j++)
                {
    
                    newData = new byte[newFileSize];
                    //加入头数据
                    for (int k = 0; k < headSize; k++)
                    {
    
                        newData[k] = newHeadData[k];
                    }
                    //加入像素数据
                    for (int m = 0; m < newHeightSize; m++)
                    {
    
                        for (int n = 0; n < newWidthSize; n++)
                        {
    
                            newData[headSize + m * newWidthSize + n] = newPixelData[i][j][m][n];
                        }
                    }
                    //输出
                    File.WriteAllBytes($"{
      outputDirectory}\\{
      i * colCount + j + 1}.bmp", newData);
                }
            }
        }

        /// <summary>
        /// 根据给定的行数和列数，分割raw图像
        /// raw图像不含头数据，且像素为1个字节，因此直接分割即可，像素按照从左到右，从上到下的顺序排列
        /// 按照从左到右，从上到下的顺序依次输出编号为[1,rowCount*colCount]的raw图像
        /// 注意，rowCount和colCount必须为原图高度和宽度的整数因子
        /// </summary>
        /// <param name="sourceImagePath">原图路径</param>
        /// <param name="rowCount">行数</param>
        /// <param name="colCount">列数</param>
        /// <param name="outputDirectory">输出目录</param>
        public static void DivideRawImage(string sourceImagePath, int heightSize, int widthSize, int rowCount, int colCount, string outputDirectory)
        {
    
            //获取原数据
            byte[] sourceData = File.ReadAllBytes(sourceImagePath);

            //提取像素数据
            byte[][] pixelData = new byte[heightSize][];
            for (int i = 0; i < heightSize; i++)
            {
    
                pixelData[i] = new byte[widthSize];
                for (int j = 0; j < widthSize; j++)
                {
    
                    pixelData[i][j] = sourceData[i * widthSize + j];
                }
            }

            //重建像素数据
            int newWidthSize = widthSize / colCount;
            int newHeightSize = heightSize / rowCount;
            //原图按行分割
            byte[][][][] newPixelData = new byte[rowCount][][][];
            for (int i = 0; i < rowCount; i++)
            {
    
                //原图按列分割
                newPixelData[i] = new byte[colCount][][];
                for (int j = 0; j < colCount; j++)
                {
    
                    //新图按行分割
                    newPixelData[i][j] = new byte[newHeightSize][];
                    for (int m = 0; m < newHeightSize; m++)
                    {
    
                        //新图按列分割
                        newPixelData[i][j][m] = new byte[newWidthSize];
                        for (int n = 0; n < newWidthSize; n++)
                        {
    
                            newPixelData[i][j][m][n] = pixelData[i * newHeightSize + m][j * newWidthSize + n];
                        }
                    }
                }
            }

            //重建图片并输出
            byte[] newData;
            for (int i = 0; i < rowCount; i++)
            {
    
                for (int j = 0; j < colCount; j++)
                {
    
                    newData = new byte[newHeightSize * newWidthSize];
                    //加入像素数据
                    for (int m = 0; m < newHeightSize; m++)
                    {
    
                        for (int n = 0; n < newWidthSize; n++)
                        {
    
                            newData[m * newWidthSize + n] = newPixelData[i][j][m][n];
                        }
                    }
                    //输出
                    File.WriteAllBytes($"{
      outputDirectory}\\{
      i * colCount + j + 1}.raw", newData);
                }
            }
        }
    }
}