-
Notifications
You must be signed in to change notification settings - Fork 0
/
recursive_art.py
195 lines (162 loc) · 6.27 KB
/
recursive_art.py
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
"""
Mini Project 2: Computational Art
@author: Sampei Omichi
"""
from random import *
from math import *
from PIL import Image
def build_random_function(min_depth, max_depth):
"""Build a random function.
Builds a random function of depth at least min_depth and depth at most
max_depth. (See the assignment write-up for the definition of depth
in this context)
Args:
min_depth: the minimum depth of the random function
max_depth: the maximum depth of the random function
Returns:
The randomly generated function represented as a nested list.
(See the assignment writ-eup for details on the representation of
these functions)
"""
# TODO: implement this
bas = ['x','y']
func = ['x','y','cos_pi','sin_pi','prod','avg']
if max_depth == 1:
return bas[randint(0,1)]
else:
block = func[randint(2,5)]
if block == 'prod' or 'avg': # When Block needs two inputs
return [block, build_random_function(min_depth-1, max_depth-1), build_random_function(min_depth-1, max_depth-1)]
elif not block == 'prod':
return [block, build_random_function(min_depth-1, max_depth-1)]
def evaluate_random_function(f, x, y):
"""Evaluate the random function f with inputs x,y.
The representation of the function f is defined in the assignment write-up.
Args:
f: the function to evaluate
x: the value of x to be used to evaluate the function
y: the value of y to be used to evaluate the function
Returns:
The function value
Examples:
>>> evaluate_random_function(["x"],-0.5, 0.75)
-0.5
>>> evaluate_random_function(["y"],0.1,0.02)
0.02
"""
# Complete
if f[0] == 'x':
return x
elif f[0] == 'y':
return y
elif f[0] == 'avg':
return (evaluate_random_function(f[1],x,y)+evaluate_random_function(f[2],x,y))/2
elif f[0] == 'cos_pi':
return cos(pi*evaluate_random_function(f[1],x,y))
elif f[0] == 'sin_pi':
return sin(pi*evaluate_random_function(f[1],x,y))
elif f[0] == 'prod':
return evaluate_random_function(f[1],x,y)*evaluate_random_function(f[2],x,y)
def remap_interval(val,
input_interval_start,
input_interval_end,
output_interval_start,
output_interval_end):
"""Remap a value from one interval to another.
Given an input value in the interval [input_interval_start,
input_interval_end], return an output value scaled to fall within
the output interval [output_interval_start, output_interval_end].
Args:
val: the value to remap
input_interval_start: the start of the interval that contains all
possible values for val
input_interval_end: the end of the interval that contains all possible
values for val
output_interval_start: the start of the interval that contains all
possible output values
output_inteval_end: the end of the interval that contains all possible
output values
Returns:
The value remapped from the input to the output interval
Examples:
>>> remap_interval(0.5, 0, 1, 0, 10)
5.0
>>> remap_interval(5, 4, 6, 0, 2)
1.0
>>> remap_interval(5, 4, 6, 1, 2)
1.5
"""
# Complete
scale = (val - input_interval_start) / \
(input_interval_end - input_interval_start)
scale = abs(scale)
output_val = (scale * (output_interval_end - output_interval_start)) \
+ output_interval_start
return output_val
def color_map(val):
"""Maps input value between -1 and 1 to an integer 0-255, suitable for use as an RGB color code.
Args:
val: value to remap, must be a float in the interval [-1, 1]
Returns:
An integer in the interval [0,255]
Examples:
>>> color_map(-1.0)
0
>>> color_map(1.0)
255
>>> color_map(0.0)
127
>>> color_map(0.5)
191
"""
# Complete
color_code = remap_interval(val, -1, 1, 0, 255)
return int(color_code)
def test_image(filename, x_size=350, y_size=350):
"""Generate a test image with random pixels and save as an image file.
Args:
filename: string filename for image (should be .png)
x_size, y_size: optional args to set image dimensions (default: 350)
"""
# Create image and loop over all pixels
im = Image.new("RGB", (x_size, y_size))
pixels = im.load()
for i in range(x_size):
for j in range(y_size):
x = remap_interval(i, 0, x_size, -1, 1)
y = remap_interval(j, 0, y_size, -1, 1)
pixels[i, j] = (randint(0, 255), # Red channel
randint(0, 255), # Green channel
randint(0, 255)) # Blue channel
im.save(filename)
def generate_art(filename, x_size=350, y_size=350):
"""Generate computational art and save as an image file.
Args:
filename: string filename for image (should be .png)
x_size, y_size: optional args to set image dimensions (default: 350)
"""
# Functions for red, green, and blue channels - where the magic happens!
red_function = build_random_function(7, 9)
green_function = build_random_function(7, 9)
blue_function = build_random_function(7, 9)
# Create image and loop over all pixels
im = Image.new("RGB", (x_size, y_size))
pixels = im.load()
for i in range(x_size):
for j in range(y_size):
x = remap_interval(i, 0, x_size, -1, 1)
y = remap_interval(j, 0, y_size, -1, 1)
pixels[i, j] = (
color_map(evaluate_random_function(red_function, x, y)),
color_map(evaluate_random_function(green_function, x, y)),
color_map(evaluate_random_function(blue_function, x, y))
)
im.save(filename)
if __name__ == '__main__':
import doctest
doctest.testmod()
# Create some computational art!
# TODO: Un-comment the generate_art function call after you
# implement remap_interval and evaluate_random_function
generate_art("example1.png")
generate_art("example2.png")