这些错觉以清晰而明确的方式告诉我们:我们并非直接体验这个世界。

我们常常相信“眼见为实”,但知觉错觉告诉我们:事实并非如此。

我们的大脑并非直接复制世界,而是在构建一个基于经验与期望的“最佳猜测模型”。

今天,我们将通过 5 种经典的知觉错觉,来探索视觉的奥秘。

前三种是静态图像错觉,后两种则是动态错觉,我们将尝试用Manim来重现它们的动态效果。

1. 静态的欺骗

这三种错觉不需要动画,仅仅通过静态的排列和色彩对比,就能欺骗我们的大脑。

1.1. 彩纸屑错觉

这是David Novick创作的Munker错觉的变体。

下面图中所有的圆圈颜色完全相同,唯一不同的是围绕它们的线条颜色。

探索视觉的边界:用 Manim 重现有趣的知觉错觉

这个错觉生动地证明:我们并非直接感知物体在现实中的颜色。相反,知觉系统会根据物体周围的环境,做出一个有根据的”猜测”。

1.2. 米饭波浪错觉

这看起来像是一个动态GIF,但其实不是。所有的”运动”都发生在你的大脑中。

它的作者:Akiyoshi Kitaoka。

探索视觉的边界:用 Manim 重现有趣的知觉错觉

黄色斑块的阴影和排列顺序会触发大脑的运动感知区域,从而在一个实际静止的图像中产生运动的知觉。有趣的是,大约5%的人似乎对这个错觉”免疫”。

1.3. 倾斜道路错觉

这看起来像是从不同角度拍摄的同一道路的两张照片。但实际上,这只是同一张照片复制了两次。

探索视觉的边界:用 Manim 重现有趣的知觉错觉

显然,视觉系统将这张图像当作两张独立道路的照片来处理。在二维图像中,两条道路的轮廓是相互平行的。

如果现实世界中的两条道路在图像中呈现这种效果,那么它们在现实中必须是强烈地向外倾斜的。因此,视觉系统便做出了这样的推断。

2. 动态的魔法

接下来,我们使用 Manim 来制作后两种动态错觉。

2.1. 动态艾宾浩斯错觉

图中的橙色圆圈实际上并没有改变大小。

与颜色和明度一样,我们并非直接感知物体的大小。知觉系统会根据感官数据中的线索(包括附近其他物体的相对大小)来推断物体的尺寸。

Manim代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
from manim import *
import numpy as np
from numpy import array
run_time = 1
data = [[1, 2], [3, 4]]
def dot(pos, **kwargs):
return Dot(pos, **kwargs)
import numpy as np
config.background_color = WHITE
class DynamicMullerLyer(Scene):
def construct(self):
self.vertexes = []
count = 11
# 所有线都一样长,蓝色和红色的线段也是一样长。
lines = self.create_lines(count)
self.play(Create(lines))
self.wait(1)
self.clear()
wings = self.create_wings(self.vertexes)
self.play(*[FadeIn(_o) for _o in [*wings]], run_time=1.0)
self.rotate_wings(
wings,
self.vertexes,
list(np.random.uniform(0.5, 1.5, len(wings))),
repeat=4,
)
self.wait(1)
# 放在一起
self.play(*[FadeIn(_o) for _o in [lines]], run_time=1.0)
self.rotate_wings(
wings,
self.vertexes,
list(np.random.uniform(0.5, 1.5, len(wings))),
repeat=8,
)
self.wait(0.5)
def create_lines(self, count=11, interval=0.4) -> VGroup:
l_group = VGroup()
for i in range(count // 2 + 1):
vertical_l_group = VGroup()
vertical_l_group.add(
Line(UP * 2.5, UP * 1.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.add(
Line(UP * 1.5, UP * 0.5, stroke_width=2, color=PURE_RED)
)
vertical_l_group.add(
Line(UP * 0.5, DOWN * 0.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.add(
Line(DOWN * 0.5, DOWN * 1.5, stroke_width=2, color=PURE_RED)
)
vertical_l_group.add(
Line(DOWN * 1.5, DOWN * 2.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.shift(LEFT * i * interval)
self.vertexes.append(UP * 2.5 + LEFT * i * interval)
self.vertexes.append(UP * 1.5 + LEFT * i * interval)
self.vertexes.append(UP * 0.5 + LEFT * i * interval)
self.vertexes.append(DOWN * 0.5 + LEFT * i * interval)
self.vertexes.append(DOWN * 1.5 + LEFT * i * interval)
self.vertexes.append(DOWN * 2.5 + LEFT * i * interval)
l_group.add(vertical_l_group)
for i in range(1, count // 2 + 1):
vertical_l_group = VGroup()
vertical_l_group.add(
Line(UP * 2.5, UP * 1.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.add(
Line(UP * 1.5, UP * 0.5, stroke_width=2, color=PURE_RED)
)
vertical_l_group.add(
Line(UP * 0.5, DOWN * 0.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.add(
Line(DOWN * 0.5, DOWN * 1.5, stroke_width=2, color=PURE_RED)
)
vertical_l_group.add(
Line(DOWN * 1.5, DOWN * 2.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.shift(RIGHT * i * interval)
self.vertexes.append(UP * 2.5 + RIGHT * i * interval)
self.vertexes.append(UP * 1.5 + RIGHT * i * interval)
self.vertexes.append(UP * 0.5 + RIGHT * i * interval)
self.vertexes.append(DOWN * 0.5 + RIGHT * i * interval)
self.vertexes.append(DOWN * 1.5 + RIGHT * i * interval)
self.vertexes.append(DOWN * 2.5 + RIGHT * i * interval)
l_group.add(vertical_l_group)
return l_group
def create_wings(self, vertexes, wing_radio=0.1):
groups = []
# 创建两条线,呈V字形
for vertex in vertexes:
left_line = Line(
vertex, vertex + (UP + LEFT) * wing_radio, stroke_width=2, color=BLACK
)
right_line = Line(
vertex, vertex + (UP + RIGHT) * wing_radio, stroke_width=2, color=BLACK
)
groups.append(VGroup(left_line, right_line))
return groups
def rotate_wings(self, wings, vertexes, run_times, repeat=4):
anims = []
for i in range(len(wings)):
ag1 = AnimationGroup(
Rotate(
wings[i][0], angle=90 * DEGREES, about_point=vertexes[i]
).set_run_time(run_times[i]),
Rotate(
wings[i][1], angle=-90 * DEGREES, about_point=vertexes[i]
).set_run_time(run_times[i]),
)
ag2 = AnimationGroup(
Rotate(
wings[i][0], angle=-90 * DEGREES, about_point=vertexes[i]
).set_run_time(run_times[i]),
Rotate(
wings[i][1], angle=90 * DEGREES, about_point=vertexes[i]
).set_run_time(run_times[i]),
)
anim = Succession([ag1, ag2] * repeat)
anims.append(anim)
self.play(
AnimationGroup(*anims),
run_time=max(run_times) * repeat,
)

下载 Python 脚本

2.2. 动态穆勒-莱尔错觉

这是我见过最棒的错觉之一。蓝色和红色的线条长度完全相同;没有任何线条在移动或改变大小,它们都处于同一水平线上。只有两端的箭头在移动。

这个错觉是经典”穆勒-莱尔错觉”的新变体。关于它的原理有许多理论,但没有人能100%确定。甚至还存在争议:这种错觉是适用于全人类,还是某种特定文化下的现象?

Manim代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
from manim import *
import numpy as np

config.background_color = WHITE

class DynamicMullerLyer(Scene):
def construct(self):
self.vertexes = []
count = 11

# 所有线都一样长,蓝色和红色的线段也是一样长。
lines = self.create_lines(count)
self.play(Create(lines))
self.wait(1)
self.clear()

wings = self.create_wings(self.vertexes)
self.add(*wings)
self.rotate_wings(
wings,
self.vertexes,
list(np.random.uniform(0.5, 1.5, len(wings))),
repeat=4,
)
self.wait(1)

# 放在一起
self.add(lines)
self.rotate_wings(
wings,
self.vertexes,
list(np.random.uniform(0.5, 1.5, len(wings))),
repeat=8,
)

self.wait(0.5)

def create_lines(self, count=11, interval=0.4) -> VGroup:
l_group = VGroup()

for i in range(count // 2 + 1):
vertical_l_group = VGroup()
vertical_l_group.add(
Line(UP * 2.5, UP * 1.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.add(
Line(UP * 1.5, UP * 0.5, stroke_width=2, color=PURE_RED)
)
vertical_l_group.add(
Line(UP * 0.5, DOWN * 0.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.add(
Line(DOWN * 0.5, DOWN * 1.5, stroke_width=2, color=PURE_RED)
)
vertical_l_group.add(
Line(DOWN * 1.5, DOWN * 2.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.shift(LEFT * i * interval)
self.vertexes.append(UP * 2.5 + LEFT * i * interval)
self.vertexes.append(UP * 1.5 + LEFT * i * interval)
self.vertexes.append(UP * 0.5 + LEFT * i * interval)
self.vertexes.append(DOWN * 0.5 + LEFT * i * interval)
self.vertexes.append(DOWN * 1.5 + LEFT * i * interval)
self.vertexes.append(DOWN * 2.5 + LEFT * i * interval)
l_group.add(vertical_l_group)

for i in range(1, count // 2 + 1):
vertical_l_group = VGroup()
vertical_l_group.add(
Line(UP * 2.5, UP * 1.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.add(
Line(UP * 1.5, UP * 0.5, stroke_width=2, color=PURE_RED)
)
vertical_l_group.add(
Line(UP * 0.5, DOWN * 0.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.add(
Line(DOWN * 0.5, DOWN * 1.5, stroke_width=2, color=PURE_RED)
)
vertical_l_group.add(
Line(DOWN * 1.5, DOWN * 2.5, stroke_width=2, color=PURE_BLUE)
)
vertical_l_group.shift(RIGHT * i * interval)
self.vertexes.append(UP * 2.5 + RIGHT * i * interval)
self.vertexes.append(UP * 1.5 + RIGHT * i * interval)
self.vertexes.append(UP * 0.5 + RIGHT * i * interval)
self.vertexes.append(DOWN * 0.5 + RIGHT * i * interval)
self.vertexes.append(DOWN * 1.5 + RIGHT * i * interval)
self.vertexes.append(DOWN * 2.5 + RIGHT * i * interval)
l_group.add(vertical_l_group)

return l_group

def create_wings(self, vertexes, wing_radio=0.1):
groups = []
# 创建两条线,呈V字形
for vertex in vertexes:
left_line = Line(
vertex, vertex + (UP + LEFT) * wing_radio, stroke_width=2, color=BLACK
)
right_line = Line(
vertex, vertex + (UP + RIGHT) * wing_radio, stroke_width=2, color=BLACK
)

groups.append(VGroup(left_line, right_line))

return groups

def rotate_wings(self, wings, vertexes, run_times, repeat=4):

anims = []
for i in range(len(wings)):
ag1 = AnimationGroup(
Rotate(
wings[i][0], angle=90 * DEGREES, about_point=vertexes[i]
).set_run_time(run_times[i]),
Rotate(
wings[i][1], angle=-90 * DEGREES, about_point=vertexes[i]
).set_run_time(run_times[i]),
)
ag2 = AnimationGroup(
Rotate(
wings[i][0], angle=-90 * DEGREES, about_point=vertexes[i]
).set_run_time(run_times[i]),
Rotate(
wings[i][1], angle=90 * DEGREES, about_point=vertexes[i]
).set_run_time(run_times[i]),
)

anim = Succession([ag1, ag2] * repeat)
anims.append(anim)

self.play(
AnimationGroup(*anims),
run_time=max(run_times) * repeat,
)

下载 Python 脚本

3. 总结

这些错觉共同揭示了一个深刻的事实——我们的知觉并非对世界的“直接复制”,而是大脑基于有限感官信息、结合经验与期望所构建的“最佳猜测模型”。

通过 Manim 重现这些错觉,我们不仅理解了视觉心理学,也掌握了如何用代码精确控制视觉元素来传达信息。

理解这一点,不仅能让我们更谦逊地看待自己的认知,也能帮助我们在日常生活中更理性地判断所见所闻。