先在panel容器（长宽为300）中绘制一个宫格，比如下面这样：
 
 

private void Form1_Load(object sender, EventArgs e)
        {
            this.InitRandomPictureBox();
        }
        
        private void InitRandomPictureBox()
        {
            this.pnl_Random.Controls.Clear();
            for (int i = 0; i < this.ImgNumbers; i++)
            {
                for (int j = 0; j < this.ImgNumbers; j++)
                {
                    PictureBox pic = new PictureBox();
                    pic.Location = new Point(j * this.SideLength, i * this.SideLength);
                    pic.Size = new Size(this.SideLength, this.SideLength);
                    pic.Visible = true;
                    pic.BorderStyle = BorderStyle.FixedSingle;

                    this.pnl_Random.Controls.Add(pic);
                }
            }
        }
/// <summary>
        /// 每个方向上要切割成的块数
        /// </summary>
        private int ImgNumbers
        {
            get
            {
                return 3;
            }
        }
        /// <summary>
        /// 要切割成的正方形图片边长
        /// </summary>
        private int SideLength
        {
            get
            {
                return 300 / this.ImgNumbers; //300：panel容器大小
            }
        }
//图片切割：

 
/// <summary>
        /// 将图片切割成小图片,图片顺序为先水平后垂直
        /// </summary>
        /// <param name="cx">水平方向多少个图片</param>
        ///<param name="cy">垂直方向多少个图片</param>
        public static Image[] SplitToSmallImages(this Image fromImage, int cx, int cy)
        {
            Image[] imgs = new Image[cx * cy];

            int nWidth = fromImage.Width / cx;
            int nHeight = fromImage.Height / cy;

            Bitmap image = new Bitmap(nWidth, nHeight);
            Graphics graphics = Graphics.FromImage(image);

            for (int i = 0; i < cy; i++)
            {
                for (int j = 0; j < cx; j++)
                {
                    graphics.DrawImage(fromImage, 0, 0, new Rectangle(j * nWidth, i * nHeight, nWidth, nHeight), GraphicsUnit.Pixel);
                    Image img = Image.FromHbitmap(image.GetHbitmap());
                    int idx = j + i * cx;
                    img.Tag = idx;
                    imgs[idx] = img;
                }
            }

            return imgs;
        }
将切好的图片随机排序然后放入到容器中：

 
var tmp = this._splitImages.OrderBy(p => Guid.NewGuid()).ToList();
            for (int i = 0; i < tmp.Count; i++)
            {
                this._splitPictureBoxes[i].Image = tmp[i];
            }
 

 

文章主要内容主要参考几篇文章并合并在一起的，文章链接依次如下，第二和第三的文章链接是从第一篇文章找到的：
 
（1）、https://blog.csdn.net/qq_25115281/article/details/90766814
 
（2）、https://blog.csdn.net/qq_43145035/article/details/83270501
 
（3）、https://blog.csdn.net/levy_96/article/details/83379373#commentsedit
 
这里只给出相关简单的代码，实际项目应用还需大家自己结合
 
1、首先，第一步，安装pymupdf模块，使用下面的命令安装：
 
pip install pymupdf
 
2、第二步，安装成功后，开始写我们的代码，这里改了一下第一篇参考文章的代码，主要实现将一个pdf转换为图片的代码，其中改了一点代码，增加了异常处理，返回值为布尔类型，True和False：
 
import fitz
import os

def convert_img(file_path):
    try:
        #  打开PDF文件，生成一个对象
        doc = fitz.open(file_path)
        img_path = r'F:\pro\study\imgs'  # 这里的文件路径看你自己的项目路径，
        # 我的项目是F:\pro\study 这个是我的项目路径，后边是要创建的文件夹路径
        # 判断路径文件夹是否存在，如果不存在我们就创建一个 好吧
        if not os.path.exists(img_path):
            os.mkdir(img_path)
        # 这里就是参考的上边连接的方法了，你们看人家的代码很容易明白
        for pg in range(doc.pageCount):
            page = doc[pg]
            rotate = int(0)
            # 每个尺寸的缩放系数为1.5，这将为我们生成分辨率提高三倍多的图像。如果转换出来图片是横排的话（即方向改变的话），请把下面的数值改小点
            zoom_x = 1.5
            zoom_y = 1.5
            trans = fitz.Matrix(zoom_x, zoom_y).preRotate(rotate)
            pm = page.getPixmap(matrix=trans, alpha=False)
            # pm.writePNG('%s.png' % pg)
            # 这里因为我要写入我上边创建的文件加下，所以我要进行路径的拼接，
            # 注意不要直接在这里去改img_path,否则他会在原有path基础上向后追加新的字段，产生新的路径，一定要重新写的新的变量存储路径
            temppic_path = os.path.join(img_path, ('img'+str(pg) + '.png'))
            print(temppic_path)
            pm.writePNG(temppic_path)
            print('done@@@')
        # 这里是因为我后边需要在最后一页加盖章，所以我要返回个关于页数的图片索引，去进行图片的寻找
        # 这里减1是因为 pageCount 得到的是从1 开始的pdf页数，而我后边要索引的时候是从0 进行查查找的，所以先在这里 -1
        # print(str(doc.pageCount - 1))
        # return str(doc.pageCount - 1)
        return True
    except Exception as e:
        return False
 
3、第三步，接下来安装PIL相关的库，使用命令，如果安装失败，可能缺少什么依赖，网上资料很多，请自行查阅：
 
pip install Pillow
 
4、第四步，通过PIL合并生成一张图片，主要参考用了第二篇文章的一部分代码，我直接搬过来了，改了下合成后图片的保存路径，保存为项目底下imgs目录下的img.png，跟pdf拆分出来的图片放在同一个目录，代码如下：
 
def _merge_img(img_list):
    """拼接图片"""
    if img_list:
        img_name = img_list[0]
        color_mod = 'RGBA' if img_name.endswith('.png') else 'RGB'  # jpeg格式不支持RGBA
        first_img = PIL_Image.open(img_list[0])
        height_size = first_img.size[1]
        total_width = first_img.size[0]
        total_height = height_size * len(img_list)
        left = 0
        right = height_size
        target = PIL_Image.new(color_mod, (total_width, total_height))  # 最终拼接的图像的大小
        for img in img_list:
            target.paste(PIL_Image.open(img), (0, left, total_width, right))
            left += height_size
            right += height_size
        target.save('F:\\pro\\study\\imgs\\img.png', quality=100)
        return img_name
    else:
        return ''
 
5、第五步，测试代码，上面的代码都是写在同一个py文件底下，因此我们可以用下面的代码调试，即用的main方法：
 
if __name__ == '__main__':
    # 拆分pdf，生成多张图片
    convert_flag = convert_img('F:\pro\study\test.pdf')
    # 拆分成功，将多张图片追加进列表，并合并为一张图片
    if convert_flag:
        img_list = []
        img_list.append(r'F:\pro\study\imgs\img0.png')
        img_list.append(r'F:\pro\study\imgs\img1.png')
        img_list.append(r'F:\pro\study\imgs\img2.png')
        _merge_img(img_list)
 
6、此时可以看下F:\pro\study\imgs目录底下是否将test.pdf文件拆分为img0.png、img1.png、img2.png三张图片，并合成一张新的图片img.png:
 
 
7、以上内容仅供学习参考，谢谢！

import cv2
 import numpy as np
 #截取图片中的指定区域或在指定区域添加某一图片
 
img = cv2.imread(“1.png”)
 
spilt_img1 = img[0:480, 0:960]
 spilt_img2 = img[480:960, 0:960]
 
cv2.imshow(“spilt_img1”, spilt_img1)
 cv2.imshow(“spilt_img2”, spilt_img2)
 
cv2.imwrite(“spilt_img1.png”, spilt_img1)
 cv2.imwrite(“spilt_img2.png”, spilt_img2)
 
image = np.concatenate((spilt_img1, spilt_img2)) #合并
 cv2.imshow(“image”,image)
 cv2.imwrite(“image.png”,image)

将视频的每帧拆分出来形成图片后保存在本地 
 下面是代码： 
 import org.bytedeco.javacv.FFmpegFrameGrabber; 
 import org.bytedeco.javacv.Frame; 
 import org.bytedeco.javacv.FrameGrabber.Exception; 
 import org.bytedeco.javacv.Java2DFrameConverter; 
 import javax.imageio.ImageIO; 
 import java.awt.image.BufferedImage; 
 import java.io.File; 
 import java.io.IOException;
 
/** 
 * 处理视频.（将视频提取成帧图片） 
 * 
 * 
 */ 
 public class VideoProcessing {
 
//视频帧图片存储路径
public static String videoFramesPath = "D:/img";

/**
 * 将视频文件帧处理并以“jpg”格式进行存储。
 * 依赖FrameToBufferedImage方法：将frame转换为bufferedImage对象
 *
 * @param videoFileName（视频文件的路径）
 */
public static void grabberVideoFramer(String videoFileName) {
    //Frame对象
    Frame frame = null;
    //标识
    int flag = 0;
    /*
        获取视频文件
     */
    FFmpegFrameGrabber fFmpegFrameGrabber = new FFmpegFrameGrabber(videoFileName);
    try {
        //开始转换
        try {
            fFmpegFrameGrabber.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        int ftp = fFmpegFrameGrabber.getLengthInFrames();
        while (flag <= ftp) {
            //文件绝对路径+名字
            String fileName = videoFramesPath + "/img_" + String.valueOf(flag) + ".jpg";
            //文件储存对象
            File outPut = new File(fileName);
            //获取帧
            try {
                frame = fFmpegFrameGrabber.grabImage();
            } catch (Exception e) { 
                e.printStackTrace();
            }
            //根据条件生产图片flag值可以任意修改，根据1s=24帧或者30帧
            if (frame != null&&flag==30) {
                ImageIO.write(FrameToBufferedImage(frame), "jpg", outPut);
            }
            flag++;
        }           
        try {
        //  转换结束    
            fFmpegFrameGrabber.stop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    } catch (IOException E) {
    }
}
/**
 * 创建BufferedImage对象
 *
 * 
 */
public static BufferedImage FrameToBufferedImage(Frame frame) {
    Java2DFrameConverter converter = new Java2DFrameConverter();
    BufferedImage bufferedImage = converter.getBufferedImage(frame);
    bufferedImage=rotateClockwise90(bufferedImage);
    return bufferedImage;
}
/**
 * 处理图片，将图片旋转90度。
 *
 * 
 */
public static BufferedImage rotateClockwise90(BufferedImage bi) {
    int width = bi.getWidth();
    int height = bi.getHeight();
    BufferedImage bufferedImage = new BufferedImage(height, width, bi.getType());
    for (int i = 0; i < width; i++)
          for (int j = 0; j < height; j++)
              bufferedImage.setRGB(j, i, bi.getRGB(i, j));
    return bufferedImage;
}
 
}