Python实战笔记(四) 正方体展开图自动出题
0、需求说明
最近笔者遇到一个需求，那就是自动生成正方体展开图的问题，要求生成的问题必须保证正确性与随机性
相信大家或多或少都有接触过这样的问题，这类型的问题主要考察的是做题者的空间推理能力
一个问题包含三个基本要素：题目、选项（包括正确答案与干扰项）、答案，最终效果如下：
题目：以下左图是正方体外表面的展开图，请问右边哪一项可以由它折叠而成？
选项：
答案：C
下面首先会讲解如何生成一道正确的问题，然后介绍怎么将问题转换成图片，最后会贴出完整的代码
不想看过程的朋友，可以直接拖动到最后的代码部分，开箱即用，下面让我们开始吧
PS：由于笔者能力和时间有限，若代码或结果中出现错误，欢迎大家指正！
1、逻辑部分
基本思路：
1、首先预定义好所有可能的正方体展开图，在生成问题时随机选择一种作为题目
2、然后对每一种正方体展开图预定义其中一种还原形态（正方体，过渡变量）
3、最后根据还原形态的正方体，通过旋转变换生成选项（三视图）
业务逻辑与用户界面分离，在日常开发中是一个很重要的准则
下面我们先来解决一个问题，即在不考虑如何画图的情况下，怎么生成一道正方体展开图的问题
（1）展开图到正方体的映射
首先我们知道，一个正方体的展开图只有有限种情况，具体来说有 11 种，列举如下：
然后我们给正方体展开图中的每个面编个号，并定义其中一种还原状态，用代码表示如下：
# 展开图（题干） -> 正方体
figure2cube = [{
'figure': [
[1, 0, 0, 0, 0],
[2, 3, 4, 5, 0],
[6, 0, 0, 0, 0],
],
'cube': ['1/000', '2/000', '3/000', '4/000', '5/000', '6/180']
}, {
'figure': [
[1, 0, 0, 0, 0],
[2, 3, 4, 5, 0],
[0, 6, 0, 0, 0],
],
'cube': ['1/000', '2/000', '3/000', '4/000', '5/000', '6/270']
}, {
'figure': [
[1, 0, 0, 0, 0],
[2, 3, 4, 5, 0],
[0, 0, 6, 0, 0],
],
'cube': ['1/000', '2/000', '3/000', '4/000', '5/000', '6/000']
}, {
'figure': [
[1, 0, 0, 0, 0],
[2, 3, 4, 5, 0],
[0, 0, 0, 6, 0],
],
'cube': ['1/000', '2/000', '3/000', '4/000', '5/000', '6/090']
}, {
'figure': [
[0, 1, 0, 0, 0],
[2, 3, 4, 5, 0],
[0, 6, 0, 0, 0],
],
'cube': ['1/000', '3/000', '4/000', '5/000', '2/000', '6/180']
}, {
'figure': [
[0, 1, 0, 0, 0],
[2, 3, 4, 5, 0],
[0, 0, 6, 0, 0],
],
'cube': ['1/000', '3/000', '4/000', '5/000', '2/000', '6/270']
}, {
'figure': [
[1, 0, 0, 0, 0],
[2, 3, 4, 0, 0],
[0, 0, 5, 6, 0],
],
'cube': ['1/000', '2/000', '3/000', '4/000', '6/270', '5/000']
}, {
'figure': [
[0, 1, 0, 0, 0],
[2, 3, 4, 0, 0],
[0, 0, 5, 6, 0],
],
'cube': ['1/000', '3/000', '4/000', '6/270', '2/000', '5/270']
}, {
'figure': [
[0, 0, 1, 0, 0],
[2, 3, 4, 0, 0],
[0, 0, 5, 6, 0],
],
'cube': ['1/000', '4/000', '6/270', '2/000', '3/000', '5/180']
}, {
'figure': [
[1, 2, 3, 0, 0],
[0, 0, 4, 5, 6],
[0, 0, 0, 0, 0],
],
'cube': ['1/000', '4/180', '2/090', '6/180', '5/180', '3/000']
}, {
'figure': [
[1, 2, 0, 0, 0],
[0, 3, 4, 0, 0],
[0, 0, 5, 6, 0],
],
'cube': ['1/000', '3/090', '2/090', '6/180', '5/180', '4/270']
}]
其中，figure 表示正方体展开图，数字 0 不表示内容，数字 1~ 6 分别表示六个展开面
cube 表示折叠后的正方体，cube 中六个元素分别表示正方体的六个面，对应关系如下图所示：
cube 的值是统一的格式 s/aaa，s 表示对应展开图的哪个面，aaa 表示那个面顺时针旋转多少度
可能上面的描述不是很直观，下面举一个例子来说明：
{
'figure': [
[1, 2, 3, 0, 0],
[0, 0, 4, 5, 6],
[0, 0, 0, 0, 0],
],
'cube': ['1/000', '4/180', '2/090', '6/180', '5/180', '3/000']
}
figure 表示的展开图很直观，这里不再赘述，重点来看 cube 是怎么对应的
cube 第 1 个元素是 1/000，表示正方体上面由展开图中 1 号面顺时针旋转 0 度而来
cube 第 2 个元素是 4/180，表示正方体前面由展开图中 4 号面顺时针旋转 180 度而来
cube 第 3 个元素是 2/090，表示正方体右面由展开图中 2 号面顺时针旋转 90 度而来
cube 第 4 个元素是 6/180，表示正方体后面由展开图中 6 号面顺时针旋转 180 度而来
cube 第 5 个元素是 5/180，表示正方体左面由展开图中 5 号面顺时针旋转 180 度而来
cube 第 6 个元素是 3/000，表示正方体下面由展开图中 3 号面顺时针旋转 0 度而来
（2）正方体到三视图的映射
经过上面的映射，我们已经可以将展开图还原成一个正方体
接下来，我们要针对一个普通的正方体定义出其所有的三视图（上面、前面、右面）
所幸，给定一个正方体，它的三视图也只有有限种情况，具体来说有 24 种，用代码表示如下：
# 正方体 -> 三视图（选项）
view2cube = [
# 1 为上顶面，6 为下底面
['1/000', '2/000', '3/000'],
['1/090', '3/000', '4/000'],
['1/180', '4/000', '5/000'],
['1/270', '5/000', '2/000'],
# 6 为上顶面，1 为下底面
['6/000', '2/180', '5/180'],
['6/090', '5/180', '4/180'],
['6/180', '4/180', '3/180'],
['6/270', '3/180', '2/180'],
# 2 为上顶面，4 为下底面
['2/000', '6/180', '3/090'],
['2/090', '3/090', '1/180'],
['2/180', '1/180', '5/270'],
['2/270', '5/270', '6/180'],
# 4 为上顶面，2 为下底面
['4/000', '6/000', '5/090'],
['4/090', '5/090', '1/000'],
['4/180', '1/000', '3/270'],
['4/270', '3/270', '6/000'],
# 3 为上顶面，5 为下底面
['3/000', '6/090', '4/090'],
['3/090', '4/090', '1/270'],
['3/180', '1/270', '2/270'],
['3/270', '2/270', '6/090'],
# 5 为上顶面，3 为下底面
['5/000', '6/270', '2/090'],
['5/090', '2/090', '1/090'],
['5/180', '1/090', '4/270'],
['5/270', '4/270', '6/270'],
]
view2cube 变量中有 24 个子列表，其中每个列表代表一种可能的三视图
每个子列表有三个元素，分别代表三视图中的三个面，对应关系如下图所示：
元素的值也像上面是一样的格式 s/aaa，s 表示对应正方体的哪个面，aaa 表示那个面顺时针旋转多少度
这里也举一个例子来说明：
['6/000', '2/180', '5/180']
第 1 个元素是 6/000，表示三视图上面由正方体中 6 号面顺时针旋转 0 度而来
第 2 个元素是 2/180，表示三视图前面由正方体中 2 号面顺时针旋转 180 度而来
第 3 个元素是 5/180，表示三视图右面由正方体中 5 号面顺时针旋转 180 度而来
（3）生成问题
最后根据上述的两个对应关系，我们就可以生成题目和选项（包括答案和干扰项）
-
题目的生成逻辑：随机选择一个展开图作为题目
-
答案的生成逻辑：随机选择一个三视图作为答案
-
干扰项生成逻辑：随机选择一个三视图，替换一个面或选择一个面旋转若干角度
详情请看代码中的注释：
def generate_question(config):
# 从 figure2cube 随机选择一项作为题目
f2c = random.choice(figure2cube)
figure = f2c['figure'] # 展开图
cube = f2c['cube'] # 正方体
# 生成答案候选
answers = []
for _ in range(4):
# 从 view2cube 随机选择一项作为答案
v2c = random.choice(view2cube)
ans = []
for c1 in v2c:
s1 = c1.split('/')[0]
a1 = c1.split('/')[1]
c2 = cube[int(s1) - 1]
s2 = c2.split('/')[0]
a2 = c2.split('/')[1]
ans.append(
s2 + '/' + str((int(a1) + int(a2)) % 360).zfill(3)
)
answers.append(ans)
# 将候选答案中的第一项作为正确答案
answer = answers[0]
answer_k = ';'.join(answer)
# 将候选答案中的其余项作为干扰项
option = answers[1:]
for opt in option:
idx = random.choice([1, 2, 3])
isa = random.randint(0, 1)
s = opt[idx - 1].split('/')[0]
a = opt[idx - 1].split('/')[1]
# 替换一个面或选择一个面旋转若干角度
if config['canRotate'] and isa:
a = str((int(a) + random.choice([90, 180, 270])) % 360).zfill(3)
else:
filter_list = [int(opt[idx - 1].split('/')[0]) for idx in [1, 2, 3]]
chosen_list = list(filter(lambda x : x not in filter_list, [1, 2, 3, 4, 5, 6]))
s = str(random.choice(chosen_list))
opt[idx - 1] = s + '/' + a
# 合并正确答案和干扰项，得到所有选项
choice = []
choice.append(answer)
choice.extend(option)
random.shuffle(choice)
# 找出正确答案的选项值，得到答案选项
answer_v = ''
for i, c in enumerate(choice):
if answer_k == ';'.join(c):
answer_v = chr(i + 65)
break
# 返回结果
return figure, choice, answer_v
2、界面部分
基本思路：
1、首先画出六个小正方形分别作为正方体的六个面
2、根据六个正方形和题目（正方体展开图）的表示画出题目
3、根据六个正方形和选项（正方体三视图）的表示画出选项
4、将题目和选项拼接起来得到完整的问题
（1）画六个正方形
def draw_squares(config, side_len):
color = [(255, 0, 0), (255, 192, 0), (255, 255, 0), (0, 176, 80), (0, 112, 192), (112, 48, 160)]
random.shuffle(color)
border_width = 1
fills = [] # 作为填充的正方形
for i in range(6):
fill = Image.new('RGB', (side_len - border_width * 2, side_len - border_width * 2), color[i] if config['hasColor'] else (255, 255, 255))
fills.append(fill)
# 给正方形添加内容
draw_fills(config, fills)
squares = [] # 带有边框的正方形
for i in range(6):
background = Image.new('RGB', (side_len, side_len), color[i] if config['hasColor'] else (0, 0, 0))
background.paste(fills[i], (border_width, border_width, side_len - border_width, side_len - border_width))
squares.append(background)
return squares
给正方形添加内容，可选形状包括：数字、点（仿骰子）、线、面（三角形）
def draw_fills(config, fills):
pattern = config['pattern']
fillW, fillH = fills[0].size
if pattern == 'number': # 数字
order = [1, 2, 3, 4, 5, 6]
random.shuffle(order)
for idx, sur in enumerate(fills):
draw = ImageDraw.Draw(sur)
text = str(order[idx])
draw_ttf = ImageFont.truetype('times.ttf', 25)
ttfW, ttfH = draw_ttf.getsize(text)
draw_poX = (fillW - ttfW) // 2
draw_poY = (fillH - ttfH) // 2
draw.text((draw_poX, draw_poY), text, font = draw_ttf, fill = (0, 0, 0))
elif pattern == 'dot': # 点 (仿骰子)
order = [1, 2, 3, 4, 5, 6]
random.shuffle(order)
radius = 4
gapping = 2
direction = [
[
[fillW // 2 - radius, fillH // 2 - radius, fillW // 2 + radius, fillH // 2 + radius]
],
[
[fillW // 2 - radius, fillH // 2 - radius * 2 - gapping // 2, fillW // 2 + radius, fillH // 2 - gapping // 2],
[fillW // 2 - radius, fillH // 2 + gapping // 2, fillW // 2 + radius, fillH // 2 + gapping // 2 + radius * 2],
],
[
[fillW // 2 - radius * 3 - gapping, fillH // 2 - radius * 3 - gapping, fillW // 2 - radius - gapping, fillH // 2 - radius - gapping],
[fillW // 2 - radius, fillH // 2 - radius, fillW // 2 + radius, fillH // 2 + radius],
[fillW // 2 + radius + gapping, fillH // 2 + radius + gapping, fillW // 2 + radius * 3 + gapping, fillH // 2 + radius * 3 + gapping],
],
[
[fillW // 2 - gapping // 2 - radius * 2, fillH // 2 - gapping // 2 - radius * 2, fillW // 2 - gapping // 2, fillH // 2 - gapping // 2],
[fillW // 2 + gapping // 2, fillH // 2 - gapping // 2 - radius * 2, fillW // 2 + gapping // 2 + radius * 2, fillH // 2 - gapping // 2],
[fillW // 2 - gapping // 2 - radius * 2, fillH // 2 + gapping // 2, fillW // 2 - gapping // 2, fillH // 2 + gapping // 2 + radius * 2],
[fillW // 2 + gapping // 2, fillH // 2 + gapping // 2, fillW // 2 + gapping // 2 + radius * 2, fillH // 2 + gapping // 2 + radius * 2],
],
[
[fillW // 2 - radius * 3 - gapping, fillH // 2 - radius * 3 - gapping, fillW // 2 - radius - gapping, fillH // 2 - radius - gapping],
[fillW // 2 + radius + gapping, fillH // 2 - radius * 3 - gapping, fillW // 2 + radius * 3 + gapping, fillH // 2 - radius - gapping],
[fillW // 2 - radius, fillH // 2 - radius, fillW // 2 + radius, fillH // 2 + radius],
[fillW // 2 - radius * 3 - gapping, fillH // 2 + radius + gapping, fillW // 2 - radius - gapping, fillH // 2 + radius * 3 + gapping],
[fillW // 2 + radius + gapping, fillH // 2 + radius + gapping, fillW // 2 + radius * 3 + gapping, fillH // 2 + radius * 3 + gapping],
],
[
[fillW // 2 - gapping // 2 - radius * 2, fillH // 2 - radius * 3 - gapping, fillW // 2 - gapping // 2, fillH // 2 - radius - gapping],
[fillW // 2 + gapping // 2, fillH // 2 - radius * 3 - gapping, fillW // 2 + gapping // 2 + radius * 2, fillH // 2 - radius - gapping],
[fillW // 2 - gapping // 2 - radius * 2, fillH // 2 - radius, fillW // 2 - gapping // 2, fillH // 2 + radius],
[fillW // 2 + gapping // 2, fillH // 2 - radius, fillW // 2 + gapping // 2 + radius * 2, fillH // 2 + radius],
[fillW // 2 - gapping // 2 - radius * 2, fillH // 2 + radius + gapping, fillW // 2 - gapping // 2, fillH // 2 + radius * 3 + gapping],
[fillW // 2 + gapping // 2, fillH // 2 + radius + gapping, fillW // 2 + gapping // 2 + radius * 2, fillH // 2 + radius * 3 + gapping],
],
]
for idx, sur in enumerate(fills):
draw = ImageDraw.Draw(sur)
for point in direction[order[idx] - 1]:
draw.ellipse(point, fill = (0, 0, 0))
elif pattern == 'line': # 线
direction = [
(0, 0, fillW, fillH),
(fillW, 0, 0, fillH),
# (fillW // 2, 0, fillW // 2, fillH),
# (0, fillH // 2, fillW, fillH // 2),
]
for idx, sur in enumerate(fills):
draw = ImageDraw.Draw(sur)
draw.line(random.choice(direction), fill = (0, 0, 0))
elif pattern == 'triangle': # 面 (三角形)
tempW, tempH = fillW // 3, fillH // 3
direction = [
(tempW, 2 * tempH, 1.5 * tempW, tempH, 2 * tempW, 2 * tempH),
(tempW, tempH, 1.5 * tempW, 2 * tempH, 2 * tempW, tempH),
(tempW, tempH, 2 * tempW, 1.5 * tempH, tempW, 2 * tempH),
(2 * tempW, tempH, tempW, 1.5 * tempH, 2 * tempW, 2 * tempH),
]
for idx, sur in enumerate(fills):
draw = ImageDraw.Draw(sur)
draw.polygon(random.choice(direction), fill = (0, 0, 0))
else:
raise ValueError()
（2）画题目【正方体展开图】
def draw_figure(figure_data, squares, side_len):
row, col = 3, 5
padding = side_len
cn = -1
figure = Image.new('RGB', (col * side_len + padding * 2, row * side_len + padding * 2), (255, 255, 255))
for i in range(row):
for j in range(col):
if figure_data[i][j] != 0:
cn += 1
figure.paste(squares[cn], (padding + j * side_len, padding + i * side_len, padding + (j + 1) * side_len, padding + (i + 1) * side_len))
return figure
（3）画选项【正方体三视图】
def draw_view(choice_data, squares, square_len):
viewW, choiceW = 150, 150
viewH, choiceH = 150, 50
# 对每个选项遍历
views = []
for choice_idx, choice in enumerate(choice_data):
# 对每个三视图中的面遍历
view = Image.new('RGB', (viewW, viewH + choiceH), (255, 255, 255))
for idx, val in enumerate(choice):
s = val.split('/')[0]
a = val.split('/')[1]
square = squares[int(s) - 1].rotate(360 - int(a))
if idx == 0: # 三视图的上面
px = (viewW - (square_len + square_len // 2)) // 2
py = (viewH - (square_len + square_len // 2)) // 2 + square_len // 2
square = square.resize((square_len, square_len // 2))
matrixV = np.array(view)
matrixS = np.array(square)
for i in range(square_len // 2):
matrixV[py - i, px + i: px + i + square_len] = matrixS[square_len // 2 - i - 1]
view = Image.fromarray(matrixV)
elif idx == 1: # 三视图的前面
px = (viewW - (square_len + square_len // 2)) // 2
py = (viewH - (square_len + square_len // 2)) // 2 + square_len // 2
view.paste(square, (px, py))
elif idx == 2: # 三视图的右面
px = (viewW - (square_len + square_len // 2)) // 2 + square_len
py = (viewH - (square_len + square_len // 2)) // 2 + (square_len + square_len // 2)
square = square.resize((square_len // 2, square_len))
matrixV = np.array(view)
matrixS = np.array(square)
for i in range(square_len // 2):
matrixV[py - square_len - i: py - i, px + i] = matrixS[:, i]
view = Image.fromarray(matrixV)
# 写选项值 (A / B / C / D)
draw = ImageDraw.Draw(view)
draw_ttf = ImageFont.truetype('times.ttf', 25)
draw_poX = choiceW // 2 - 12
draw_poY = viewH + choiceH // 2 - 12
draw.text((draw_poX, draw_poY), chr(choice_idx + 65), font = draw_ttf, fill = (0, 0, 0))
# 得到一个选项的三视图
views.append(view)
# 拼接所有选项的三视图，合成一张图片
data = Image.new('RGB', (viewW * len(views), viewH + choiceH), (255, 255, 255))
for view_idx, view in enumerate(views):
data.paste(view, (view_idx * viewW, 0))
return data
（4）将题目和选项拼接起来
def draw_image(config, figure_data, choice_data):
# 小正方形边长
square_len = 40
# 画六个正方形
squares = draw_squares(config, square_len)
# 画展开图（题目）
figure = draw_figure(figure_data, squares, square_len)
# 画三视图（选项）
view = draw_view(choice_data, squares, square_len)
# 最终图片，拼接题目和选项
final_image = Image.new('RGB', (figure.size[0] + view.size[0], max(figure.size[1], view.size[1])), (255, 255, 255))
final_image.paste(figure, (0, 0))
final_image.paste(view, (figure.size[0], 0))
# 返回结果
return final_image
3、完整代码
完整代码和相关说明文档请移步我的 Github 仓库