python pillow 把图片切成拼图块

最新推荐文章于 2022-10-22 18:31:35 发布
最新推荐文章于 2022-10-22 18:31:35 发布
阅读量1.4k 收藏 6
点赞数 3
分类专栏： python学习 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zbbzb/article/details/120127932
版权

契机:

【Unity】实现拖拽功能并制作一个拼图游戏
在这里插入图片描述

当我看到这个视频里的素材, 很馋, 但是原作者也没有发素材文件, 只能自己弄素材了, 3D就直接pass了, 不熟和学习成本过高, 那就2D的来, 目的是脚本文件可以批量把照片分隔成拼图块

分解需求

最简易的矩形ROI分割（剪裁），其本质是多维数组（矩阵）的切片

1. 分隔成n*m个方块
2. 拿出一个方块, 获取左右方块 之间的中心圆心坐标, 还有上下方块 之间的中心圆心坐标, 然后补满这个圆就可以获得拼图的凸出, 消减这个圆可以获得拼图的凹入
请添加图片描述

3. 增加圆心偏移
也就是让凸出和凹进更加好看点
请添加图片描述

4. 随机凹凸

先了解下怎么切圆

python3切割圆形图片
看完这篇文章可知如何生成圆形图片
新建一个图像b, 然后把a中符合这个圆的点复制b中, 输出图像b, 就生成了圆形图像
如何符合圆, 要用到初中的知识点, 点到圆心的距离 <= 半径

分隔成n*m个方块

import os
from PIL import Image

# 分割几行几列, 二维数组保存
def SplitImages(img_path, row, col):
    path_name = os.path.dirname(img_path)
    img = Image.open(img_path).convert("RGBA")
    imgSize = img.size

    splitW = int(imgSize[0]/col)
    splitL = int(imgSize[1]/row)

    pimg = img.load()

    imbList = []
    for i in range(row):
        rowList = []
        l = (i + 1) * splitL
        for j in range(col):
            w = (j + 1) * splitW
            imb = Image.new('RGBA', (splitW, splitL),(255,255,255,0))
            pimb = imb.load()

            for k in range(j * splitW, w):
                for z in range(i * splitL, l):
                    pimb[k - splitW * j, z - i * splitL] = pimg[k,z]
            dirPath = path_name + "/" + str(i*10 + j) + ".png"
            # imb.save(dirPath)
            rowList.append(imb)
        imbList.append(rowList)

    return imbList

简单版

不考虑随机凹凸, 不考虑圆心偏移, 凹凸都是固定的, 从第一个开始向右凸出, 向下凸出

def SplitCircle(imbList, imgPath):
    path_name = os.path.dirname(imgPath)
    img = Image.open(imgPath).convert("RGBA")
    imgSize = img.size

    col = len(imbList[0])
    row = len(imbList)

    if col == 1 and row == 1:
        return 

    splitW = int(imgSize[0]/col)
    splitL = int(imgSize[1]/row)

    minV = min(splitW, splitL)
    r_d = int(minV / 4) # 要计算 两个不能比 l 长 并且加上 offset 也不能超过 l
    #r_offset = int(minV / 8)

    #pSplitW = splitW + (r_d + r_offset) * 2
    #pSplitL = splitL + (r_d + r_offset) * 2

    pimg = img.load()

    pointList = []
    for i in range(row):
        colPointList = []
        for j in range(col):
            colPoint = []
            rowPoint = []
            if j != col - 1:
                colPoint = [splitW * (j + 1), int(splitL/2) + i * splitL]
            if i != row - 1:
                rowPoint = [int(splitW / 2) + j * splitW, splitL * (i + 1)]
            colPointList.append({'colPoint': colPoint, 'rowPoint': rowPoint})
        pointList.append(colPointList)

    for i in range(row):
        for j in range(col):
            imbImg = imbList[i][j]
            new_img = imbImg

            if j != col - 1 and i != row - 1:
                l = imbImg.size[1]
                w = imbImg.size[0]
   
                l = l + r_d
                w = w + r_d

                new_img = Resize(imbImg, w, l)
            elif j == col - 1 and i != row - 1:
                new_img = Resize(imbImg, splitW, splitL + r_d)
            elif j != col - 1 and i == row - 1:
                new_img = Resize(imbImg, splitW + r_d, splitL)

            new_img_imb = new_img.load()

            if j != col - 1:
                    new_next_img = imbList[i][j + 1]
                    new_next_img_imb = new_next_img.load()
                    # 左右
                    for k in range((j + 1) * splitW, (j + 1) * splitW + r_d):
                        for z in range(i * splitL, (i + 1) * splitL):
                            r_w = pointList[i][j]['colPoint'][0]
                            r_l = pointList[i][j]['colPoint'][1]
                            r = ((pow(abs(k - r_w),2) + pow(abs(z - r_l),2))) ** 0.5
                            if r < r_d:
                                new_img_imb[k - j * splitW , z - i * splitL] = pimg[k, z]
                                new_next_img_imb[k - (j + 1) * splitW, z - i * splitL] = (255,255,255,0)

                    imbList[i][j + 1] = new_next_img      

            if i!= row - 1:
                    new_down_img = imbList[i + 1][j]
                    new_down_img_imb = new_down_img.load()
                    # 上下
                    for k in range(j * splitW, (j + 1) * splitW):
                        for z in range((i + 1) * splitL, (i + 1) * splitL + r_d):
                            r_w = pointList[i][j]['rowPoint'][0]
                            r_l = pointList[i][j]['rowPoint'][1]
                            r = ((pow(abs(k - r_w),2) + pow(abs(z - r_l),2))) ** 0.5
                            if r < r_d:
                                new_img_imb[k - j * splitW, z - i * splitL] = pimg[k, z]
                                new_down_img_imb[k - j * splitW, z - (i + 1) * splitL] = (255,255,255,0)
            
                    imbList[i + 1][j] = new_down_img     
            imbList[i][j] = new_img
            
        
    for i in range(row):
        for j in range(col):
            dirPath = path_name + "/" + str(i*10 + j) + ".png"
            imbList[i][j].save(dirPath)

在这里插入图片描述

最终版

随机凹凸, 考虑圆心偏移

import os
from PIL import Image
import random

# 分割几行几列, 二维数组保存
def SplitImages(img_path, row, col):
    path_name = os.path.dirname(img_path)
    img = Image.open(img_path).convert("RGBA")
    imgSize = img.size

    splitW = int(imgSize[0]/col)
    splitL = int(imgSize[1]/row)

    pimg = img.load()

    imbList = []
    for i in range(row):
        rowList = []
        l = (i + 1) * splitL
        for j in range(col):
            w = (j + 1) * splitW
            imb = Image.new('RGBA', (splitW, splitL),(255,255,255,0))
            pimb = imb.load()

            for k in range(j * splitW, w):
                for z in range(i * splitL, l):
                    pimb[k - splitW * j, z - i * splitL] = pimg[k,z]
            dirPath = path_name + "/" + str(i*10 + j) + ".png"
            # imb.save(dirPath)
            rowList.append(imb)
        imbList.append(rowList)

    return imbList

def Resize(img, rizeW, rizel, pastePoint=None): 
    if pastePoint is None:
        pastePoint = [0, 0]

    new_im = Image.new('RGBA', [rizeW, rizel],(255,255,255,0))
    new_im.paste(img, pastePoint)

    return new_im

def SplitCircle(imbList, imgPath):
    path_name = os.path.dirname(imgPath)
    img = Image.open(imgPath).convert("RGBA")
    imgSize = img.size

    col = len(imbList[0])
    row = len(imbList)

    if col == 1 and row == 1:
        return 

    splitW = int(imgSize[0]/col)
    splitL = int(imgSize[1]/row)

    minV = min(splitW, splitL)
    r_d = int(minV / 4) # 要计算 两个不能比 l 长 并且加上 offset 也不能超过 l
    r_offset = int(minV / 8)

    pSplitW = splitW + (r_d + r_offset) * 2
    pSplitL = splitL + (r_d + r_offset) * 2

    pimg = img.load()
    
	# 存(row - 1) * (col - 1) 个中心点
    pointList = []
    for i in range(row):
        colPointList = []
        for j in range(col):
            colPoint = []
            rowPoint = []
            if j != col - 1:
                colPoint = [splitW * (j + 1), int(splitL/2) + i * splitL]
            if i != row - 1:
                rowPoint = [int(splitW / 2) + j * splitW, splitL * (i + 1)]
            colPointList.append({'colPoint': colPoint, 'rowPoint': rowPoint})

            imbList[i][j] = Resize(imbList[i][j], pSplitW, pSplitL, [r_d + r_offset, r_d + r_offset])
            dirPath = path_name + "/" + str(i*10 + j) + ".png"
            # imbList[i][j].save(dirPath)
        pointList.append(colPointList)

    for i in range(row):
        for j in range(col):
            imbImg = imbList[i][j]
            new_img = imbImg

            # 圆心靠左 靠右, 默认靠右
            lrandNum = random.randint(0, 999999)
            drandNum = random.randint(0, 999999)
            lrRight = True
            drRight = True
        
            if lrandNum < 500000:
                lrRight = False
            if drandNum < 500000:
                drRight = False

            new_img_imb = new_img.load()

            if j != col - 1:

                if lrRight :
                    new_next_img = imbList[i][j + 1]
                    new_next_img_imb = new_next_img.load()
                    # 左右
                    for k in range((j + 1) * splitW, (j + 1) * splitW + r_d + r_offset):
                        for z in range(i * splitL, (i + 1) * splitL):
                            r_w = pointList[i][j]['colPoint'][0] + r_offset
                            r_l = pointList[i][j]['colPoint'][1] 
                            r = ((pow(abs(k - r_w),2) + pow(abs(z - r_l),2))) ** 0.5
                            if r < r_d:
                                new_img_imb[k - j * splitW + r_d + r_offset, z - i * splitL + r_d + r_offset] = pimg[k, z]
                                new_next_img_imb[k - (j + 1) * splitW + r_d + r_offset, z - i * splitL + r_d + r_offset] = (255,255,255,0)

                    imbList[i][j + 1] = new_next_img
                else:
                    new_next_img = imbList[i][j + 1]
                    new_next_img_imb = new_next_img.load()
                    # 左右
                    for k in range((j + 1) * splitW - r_d - r_offset, (j + 1) * splitW):
                        for z in range(i * splitL, (i + 1) * splitL):
                            r_w = pointList[i][j]['colPoint'][0] - r_offset
                            r_l = pointList[i][j]['colPoint'][1]
                            r = ((pow(abs(k - r_w),2) + pow(abs(z - r_l),2))) ** 0.5
                            if r < r_d:
                                new_next_img_imb[k - (j + 1) * splitW + r_d + r_offset, z - i * splitL + r_d + r_offset] = pimg[k, z]
                                new_img_imb[k - j * splitW  + r_d + r_offset, z - i * splitL + r_d + r_offset] = (255,255,255,0)

                    imbList[i][j + 1] = new_next_img   

            if i!= row - 1:

                if drRight:
                    new_down_img = imbList[i + 1][j]
                    new_down_img_imb = new_down_img.load()
                    # 上下
                    for k in range(j * splitW, (j + 1) * splitW):
                        for z in range((i + 1) * splitL, (i + 1) * splitL + r_d + r_offset):
                            r_w = pointList[i][j]['rowPoint'][0]
                            r_l = pointList[i][j]['rowPoint'][1] + r_offset
                            r = ((pow(abs(k - r_w),2) + pow(abs(z - r_l),2))) ** 0.5
                            if r < r_d:
                                new_img_imb[k - j * splitW + r_d + r_offset, z - i * splitL + r_d + r_offset] = pimg[k, z]
                                new_down_img_imb[k - j * splitW + r_d + r_offset, z - (i + 1) * splitL + r_d + r_offset] = (255,255,255,0)
            
                    imbList[i + 1][j] = new_down_img
                else:
                    new_down_img = imbList[i + 1][j]

                    new_down_img_imb = new_down_img.load()
                    # 上下
                    for k in range(j * splitW, (j + 1) * splitW):
                        for z in range((i + 1) * splitL - r_d - r_offset, (i + 1) * splitL):
                            r_w = pointList[i][j]['rowPoint'][0]
                            r_l = pointList[i][j]['rowPoint'][1] - r_offset
                            r = ((pow(abs(k - r_w),2) + pow(abs(z - r_l),2))) ** 0.5
                            if r < r_d:
                                new_down_img_imb[k - j * splitW + r_d + r_offset, z - (i + 1) * splitL + r_d + r_offset] = pimg[k, z]
                                new_img_imb[k - j * splitW + r_d + r_offset, z - i * splitL + r_d + r_offset] = (255,255,255,0)

                    imbList[i + 1][j] = new_down_img
        
            imbList[i][j] = new_img
        
    for i in range(row):
        for j in range(col):
            dirPath = path_name + "/" + str(i*10 + j) + ".png"
            imbList[i][j].save(dirPath)


if __name__ == '__main__':
    dirPath = "E:/PythonWorkSpace/slice_pic/"
    SplitCircle(SplitImages(dirPath + "a.png", 6, 4) , dirPath + "a.png")

在这里插入图片描述
完整项目地址

zbbzb
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python利用 PIL (Pillow) 库来将两张图片合成一张图片(横向+纵向)
weixin_42636075的博客
05-17 849
Python利用 PIL (Pillow) 库来将两张图片合成一张图片(横向+纵向)
python如何将图像随机分布,如何在python的空白背景图像（200x200）中随机添加20张图像（10x10）？...
weixin_39673601的博客
12-15 268
I'm working on a small project to randomly place or put several images of size (10 w x 10 h) in another image that will be used as background of size (200 w x 200 h) in python. The small images should...
Python——基于PIL和CV2实现自动拼图解决方案
无限迭代中......
10-23 2036
解决方案 # python3 import cv2 from PIL import Image import numpy as np import os import shutil import threading # 读取目标图片 source = cv2.imread(r"C:/Users/Lenovo/Desktop/pt/source.jpg") # 拼接结果 target = Image.fromarray(np.zeros(source.shape, np.uint8)) # 图库目.
使用python切割图片
weixin_40335142的博客
03-24 3334
import sys import os from PIL import Image file_root = "E:\\work\\yin\\yinn" #要切的图片放的文件 fileList = [] n = 0 #读取文件列表 def read_bmp_file_list(path): for root, dirs, files in os.walk(path, topdown=False): for file in files: fi
用Python和OpenCV实现照片马赛克拼图（蒙太奇照片）
york1996的博客
11-25 8604
https://www.bilibili.com/video/av39158788 马赛克拼图介绍： 相片马赛克（Photomosaic），或称蒙太奇照片、蒙太奇拼贴，是一种影像处理的艺术技巧，利用这个方式做出来的图片，近看时是由许多张小照片合在一起的，但远看时，每张照片透过光影和色彩的微调，组成了一张大图的基本像素，就叫做相片马赛克技巧。最先是由一个美国大学生发明的，但当时限于计算机性能，无...
【python实现抠图】
Hexiang_2020的博客
10-22 2717
python实现抠图。
Python Tkinter——数字拼图游戏配套图片
05-25
3. **Image模块**：为了加载和显示图片，我们需要使用Python的PIL（Pillow）库，它是Python Imaging Library的分支，能够处理各种图像格式。 4. **图片切分**：在数字拼图游戏中，原始图像会被切割成多个小方块。这...
python tkinter 实现拼图游戏
01-30
在Python中，我们可以使用PIL（Python Imaging Library）或其分支Pillow来处理图片。首先，我们需要加载图像，然后将其分割成若干个小块，这将是我们拼图的单元。这一步可以通过切片操作实现，或者使用PIL提供的裁剪...
使用python实现的拼图游戏
03-17
7. **图像处理库**：为了处理拼图图像，开发者可能使用了PIL（Python Imaging Library）或其分支Pillow，这两个库提供了丰富的图像处理功能，如加载、裁剪、旋转图片等。 8. **测试与调试**：开发过程中，单元测试...
Python小游戏源码-拼图游戏源码
02-27
【Python小游戏源码-拼图游戏源码】是一款基于Python编程语言开发的简单拼图游戏。这款游戏源码的实现展示了Python在游戏开发领域的应用，尤其是对于初学者来说，这是一个很好的学习资源，能够帮助他们理解如何用...
Python 拼图游戏，使用python编写实现拼图游戏
最新发布
05-28
在拼图游戏中，我们首先要加载原图，然后根据设定的行和列数将其分割成多个图块。这可以通过遍历图像的像素并将其切割成指定大小的矩形来实现。 接下来，为了实现随机打乱图块的功能，我们可以使用Python的random...
PIL（pillow）简单使用：新建画布、添加文字、画矩形、裁剪、粘贴
01-07
安装依赖 pip install pillow 1、新建一张300*300的白色画布 # -*- coding: utf-8 -*- from PIL import Image # 参数：模式、大小、颜色 image = Image.new(mode=RGB, size=(300, 300), color=white) image.save(1.png) 图片： 2、画布上加一些文字 # -*- coding: utf-8 -*- from PIL import Image, ImageDraw, ImageFont # 参数：模式、大小、颜色 image = Image.n
Python 图片裁剪为圆形.py
05-28
python pillow 批量处理图片，将头像处理为圆形，非圆形区域设置为透明；裁剪方式为从矩形的正中心截取最大的圆形。
用Python语言对任意图像进行m*n的均匀分块并拼接还原（思路非常清晰，步骤简单）
热门推荐
隔壁老王的博客
11-21 2万+
用Python语言对图像进行m*n的均匀分块   基本思路：根据图像尺寸创建一个(m+1)×(n+1)(m+1) \times (n+1)(m+1)×(n+1)个均匀的网格顶点坐标，对于图像块来说每个图像块的左上角和右下角可以唯一确定一个图像块，这样就可以利用网格顶点坐标对原始图像进行裁剪。   注意：本文是用jupyter编写的，由于jupyter显示的图片效果较差，实际的图像是在命令行下运行....
基于Pillow对图像进行切割
qq_45780647的博客
03-18 4002
Pillow库是一个Python的第三方库。 在Python2中，PIL(Python Imaging Library)是一个非常好用的图像处理库，但PIL不支持Python3，所以有人(Alex Clark和Contributors)提供了Pillow，可以在Python3中使用。
python脚本编程——将批量的长方形图片切割成多个正方形图片
Eve_if的博客
05-22 5035
简介 在处理.mat文件得到图片(bmp)时，转成的图片尺寸大小与.mat文件有关。两个特征的.mat文件分别是1294*86和1294*128大小。这也是两个文件中的图片大小，由于模型输入需要的是批量的正方形图片，因此用python写脚本来将批量的长方形图片切割成多个正方形图片，并保存在相应文件夹中。 写代码 以1294*128尺寸的图像为例，需要的是128*128的正方形图像，也就是...
Python拼接图像 Pillow
若风
05-20 624
拼接指定的图像 from PIL import Image import os def GetFileFromThisRootDir(dir, ext=None): allfiles = [] needExtFilter = (ext != None) for root, dirs, files in os.walk(dir): for filespath in files: filepath = os.path.join(root,.
CTF 图片按顺序分割脚本 Python
zxsctf的博客
03-30 1133
CTF中可能出现很多拼图的题目，那么拼图是怎么生成的呢？ 下面给大家一个CTF中图片按照顺序分割的脚本： # -*- coding: utf-8 -*- # 青少年网络安全 2022 03 30 from PIL import Image filename = r'what.png' img = Image.open(filename) size = img.size print(size) # 大小为根号100 # 准备将图片切割成100张小图片 weight = int(size[0] // 1
python 将一张图片切成n份
02-07
使用 Python 将一张图片切割成 n 份的方法如下： 1. 首先，使用 Python 的图像处理库 PIL（Python Imaging Library）或者 Pillow 读取图片。 2. 然后，获取图片的宽度和高度，并计算出每一份图片的宽度和高度。 3...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值