def render_frame(frame_no, frame_count):
from handsome.util import save_array_as_image
time = 2 * frame_no / (frame_count - 1)
if time > 1.:
time = 2 - time
set_time = load_sampler_lib()['set_time']
set_time(time)
canvas = make_canvas({
'extents' : (512, 512),
'color' : '#fff',
})
surface = generate_surface()
shader = generate_shader()
mesh = generate_mesh(surface, shader)
meshes = subdivide_mesh(mesh)
for mesh in meshes:
cache = render_mesh(mesh)
cache.composite_into(canvas)
buffer = array_view(canvas.downsample(1))
buffer = np.clip(buffer, 0., 1.)
buffer = (255 * buffer).astype(np.uint8)
frame_path = 'render/008/frame_{:03}.tiff'.format(frame_no)
save_array_as_image(pixel_view(buffer), frame_path, 'RGBA')
return frame_path
def main():
colors = {
'red' : '#f00',
'white' : '#fff',
}
float_colors = { }
for key, value in colors.items():
color = parse_color(value)
colors[key] = np.array([ color ], dtype=Pixel)
float_colors[key] = np.array(tuple(c / 255. for c in color), dtype=FloatPixel)
image = Tile((0, 0), (512, 512), sample_rate=4, dtype=FloatPixel)
image.buffer[:,:] = float_colors['white']
tile_width, tile_height = image.buffer.shape
mesh = MicropolygonMesh((1,1))
mesh_width, mesh_height = mesh.buffer.shape
margin = 16
width = 128
right = image.shape[0]
top = image.shape[1]
buffer = np.array([
[
(right - margin - width, top - margin, 1, 1, 1.5, 0, 0, 1),
(right - margin , top - margin, 1, 1, 0 , 0, 0, 1)
],
[
(margin , margin, 1, 1, .5, 0, 0, 1),
(margin + width, margin, 1, 1, 0 , 0, 0, 1)
],
],
dtype=np.float32
)
mesh.buffer.view(dtype=(np.float32, 8))[:] = buffer
fill_micropolygon_mesh(
mesh_width, mesh_height,
generate_numpy_begin(mesh.buffer),
tile_width, tile_height,
generate_numpy_begin(image.coordinate_image),
generate_numpy_begin(image.buffer)
)
buffer = array_view(image.downsample(1))
buffer = np.clip(buffer, 0., 1.)
buffer = (255. * buffer).astype(dtype=np.uint8)
save_array_as_image(pixel_view(buffer), 'render/002_micropolygon.tiff', 'RGBA')
def generate_texture():
from handsome.util import save_array_as_image
scene = generate_texture_scene()
canvas = render_scene(scene)
buffer = array_view(canvas.downsample(1))
buffer = np.clip(buffer, 0., 1.)
buffer = (255. * buffer).astype(dtype=np.uint8)
save_array_as_image(pixel_view(buffer), 'render/texture.tiff', 'RGBA')
def render_image(scene_path, out_path):
from handsome.util import save_array_as_image
scene = parse_scene(scene_path)
canvas = render_scene(scene)
buffer = array_view(canvas.downsample(1))
buffer = np.clip(buffer, 0., 1.)
buffer = (255. * buffer).astype(dtype=np.uint8)
save_array_as_image(pixel_view(buffer), out_path, 'RGBA')
def main():
from handsome.opencl_api import fill_micropolygon_mesh
from handsome.util import save_array_as_image, parse_color
mesh = generate_mesh()
tile = Tile((0, 0), (512, 512), 4, dtype=FloatPixel)
fill_micropolygon_mesh(mesh, tile)
buffer = array_view(tile.downsample(1))
# buffer = array_view(tile.buffer)
buffer = np.clip(buffer, 0., 1.)
buffer = (255 * buffer).astype(np.uint8)
save_array_as_image(pixel_view(buffer), 'render/009_opencl.tiff', 'RGBA')
def test_tile_intersection_slices():
master = Tile((0, 0), (640, 400))
tile = Tile((100, 100), (100, 300))
blue = np.array([(0, 0, 153, 255)], dtype=Pixel)
red = np.array([(153, 0, 0, 255)], dtype=Pixel)
white = np.array([(255, 255, 255, 255)], dtype=Pixel)
master.buffer[::] = white
tile.buffer[::] = red
m, t = master.intersection_slices(tile)
master.buffer[m] = tile.buffer[t]
save_array_as_image('test_tile_2.tiff', master.buffer, 'RGBA')
def render_frame(frame_no):
print('rendering frame {}'.format(frame_no))
image = Tile((0, 0), (512,512), 4, dtype=FloatPixel)
image.buffer[:,:] = palette['white'].view(dtype=FloatPixel)
center = (256, 256)
radius = 192
mesh = star(center, radius)
cache = render_mesh(mesh)
cache.composite_into(image)
buffer = array_view(image.downsample(1))
buffer = np.clip(buffer, 0., 1.)
buffer = (255. * buffer).astype(dtype=np.uint8)
path = 'render/004/frame_{:03}.tiff'.format(frame_no)
save_array_as_image(pixel_view(buffer), path, 'RGBA')
def main():
from handsome.util import save_array_as_image
canvas = make_canvas({
'extents' : (512, 512),
'color' : '#fff',
})
surface = generate_surface()
shader = generate_texture_shader()
mesh = generate_mesh(surface, shader)
cache = render_mesh(mesh)
cache.composite_into(canvas)
buffer = array_view(canvas.downsample(1))
buffer = np.clip(buffer, 0., 1.)
buffer = (255 * buffer).astype(np.uint8)
save_array_as_image(pixel_view(buffer), 'render/006_texture.tiff', 'RGBA')
def render_tile():
import random
mode = 'RGBA'
image_shape = (640, 480)
image = Tile((0,0), image_shape)
r = random.SystemRandom()
colors = {
'white' : '#ffff',
'black' : '#000f',
'205A8C' : '205A8C',
'6596BF' : '6596BF',
'98F2EC' : '98F2EC',
'BF6865' : 'BF6865',
'F4DBD6' : 'F4DBD6',
}
for name, color in colors.items():
colors[name] = parse_color(color)
image.buffer[:,:] = colors['white']
tile_colors = [ color for name, color in colors.items() if name not in ('black', 'white') ]
# tile = Tile((0, 0), (100, 100))
tile = Tile((0, 0), (16, 16))
for x in range(0, image_shape[0], 16):
for y in range(0, image_shape[1], 16):
# x = int(r.random() * image_shape[0])
# y = int(r.random() * image_shape[1])
tile.set_origin((x, y))
tile.buffer[:] = r.sample(tile_colors, 1)
i, t = image.intersection_slices(tile)
image.buffer[i] = tile.buffer[t]
save_array_as_image('test_tile.gif', image.buffer, 'RGBA')
def main():
colors = {
'white' : (255 , 255 , 255 , 255),
'red' : (255 , 0 , 0 , 255),
'green' : (0 , 255 , 0 , 255),
'blue' : (0 , 0 , 255 , 255),
'yellow' : (255 , 255 , 000 , 255),
}
for key, value in colors.items():
colors[key] = np.array([value], dtype=Pixel)
image = Tile((0, 0), (100, 100), dtype=Pixel)
image.buffer[:,:] = colors['white']
image.buffer[:50,:50] = colors['red'] # upper left
image.buffer[50:,:50] = colors['green'] # upper right
image.buffer[:50,50:] = colors['blue'] # lower left
image.buffer[50:,50:] = colors['yellow'] # lower right
save_array_as_image(image.buffer, 'render/001_tile.tiff', 'RGBA')
def test_fill():
shape=[640,480]
p = point(100, 100)
l = Line(
point(100, 100),
point(0, 200)
)
coords = make_coordinate_image(shape)
delta = coords - l.start[:2].reshape(1,1,2)
direction = (l.end - l.start)[:2].reshape(1,1,2)
mask = np.inner(delta, direction).reshape(640, 480) >= 0.
white = np.array([(255, 255, 255, 255)], dtype=Pixel)
red = np.array([(180, 0, 0, 255)], dtype=Pixel)
image = np.empty(shape, dtype=Pixel, order='F')
image[:,:] = white
image[mask] = red
save_array_as_image(image, 'red_white.tiff', 'RGBA')
def render_frame(frame_no):
print('rendering frame {}'.format(frame_no))
from math import sin, pi
tau = 2. * pi
image = Tile((0, 0), (512,512), 4, dtype=FloatPixel)
image.buffer[:,:] = palette['white'].view(dtype=FloatPixel)
center = (256, 256)
radius = 100
surface = circle(center, radius)
global transform
transform = np.array(
[
[ 1., .0 ],
[ .5 * sin(tau * frame_no / 60.), 1. ]
],
dtype=np.float32
)
meshes = generate_meshes(surface)
for mesh in meshes:
cache = render_mesh(mesh)
cache.composite_into(image)
buffer = array_view(image.downsample(1))
buffer = np.clip(buffer, 0., 1.)
buffer = (255. * buffer).astype(dtype=np.uint8)
path = 'render/003/frame_{:03}.tiff'.format(frame_no)
save_array_as_image(pixel_view(buffer), path, 'RGBA')
def test_line():
shape = [640,480]
lines = [
[ (100, 100), (300, 300) ],
[ (100, 300), (300, 100) ],
[ (100, 200), (300, 200) ],
[ (200, 100), (200, 300) ],
]
width = 10.
white = np.array([(255, 255, 255, 255)], dtype=Pixel)
image = np.empty(shape, dtype=Pixel, order='F')
image[::] = white
red = np.array([(180, 0, 0, 127)], dtype=Pixel)
for line in lines:
line = Line(point(*line[0]), point(*line[1]))
composite_image(draw_line(line, width, red), image)
save_array_as_image('test_line.tiff', image, 'RGBA')
def test_open_cl():
from handsome.util import save_array_as_image, parse_color
from handsome.Scene import make_canvas
canvas = make_canvas({
'extents' : (640, 480),
'color' : '#fff',
})
context = cl.create_some_context()
queue = cl.CommandQueue(context)
mf = cl.mem_flags
source = r'''
__kernel void shade_square(
__global float4 * result_g
)
{
int y = get_global_id(0),
height = get_global_size(0);
int x = get_global_id(1),
width = get_global_size(1);
int index = y * width + x;
const float2 center = (float2)(width / 2, height / 2),
dimensions = (float2)(height) / 2,
upper_left = center - dimensions / 2;
float x_blend = ((float)x - upper_left.x) / dimensions.x,
y_blend = ((float)y - upper_left.y) / dimensions.y
;
float4 upper_left_c = (float4)(1, 1, 1, 1),
upper_right_c = (float4)(1, 0, 0, 1),
lower_left_c = (float4)(0, 0, 1, 1),
lower_right_c = (float4)(0, 0, 0, 1)
;
if (0. <= x_blend && x_blend <= 1. && 0. <= y_blend && y_blend <= 1.) {
result_g[index]
= (1 - x_blend) * (1 - y_blend) * upper_left_c
+ x_blend * (1 - y_blend) * upper_right_c
+ (1 - x_blend) * y_blend * lower_left_c
+ x_blend * y_blend * lower_right_c
;
}
else{
result_g[index] = (float4)(0, 0, 0, 1);
}
}
'''
program = cl.Program(context, source).build()
result = cl.Buffer(context, mf.WRITE_ONLY, canvas.buffer.nbytes)
program.shade_square(queue, canvas.buffer.shape, None, result)
cl.enqueue_copy(queue, array_view(canvas.buffer), result)
buffer = array_view(canvas.downsample(1))
buffer = np.clip(buffer, 0., 1.)
buffer = (255 * buffer).astype(np.uint8)
save_array_as_image(pixel_view(buffer), 'render/009_opencl.tiff', 'RGBA')
def blocktopus():
import random
import math
r = random.SystemRandom()
mode = 'RGBA'
image_shape = (1280, 960)
# image_shape = (640, 480)
image = Tile((0, 0), image_shape)
colors = {
'white' : '#ffff',
'black' : '#000f',
'205A8C' : '205A8C',
'6596BF' : '6596BF',
'98F2EC' : '98F2EC',
'BF6865' : 'BF6865',
'F4DBD6' : 'F4DBD6',
'dark_blue' : '05115B',
'light_blue' : '60CAF0',
'brown_yellow' : 'DAB32B',
'brown' : '855E14',
'yellow' : 'FFDD06',
}
for name, color in colors.items():
colors[name] = parse_color(color)
def make_tile(color):
tile = Tile((0, 0), (16, 16))
tile.buffer[:] = color
return tile
blocktopus_colors = (
'brown',
'brown_yellow',
'dark_blue',
'light_blue',
'yellow',
)
tiles = { }
def get_tile(tile_id):
tile = tiles.get(tile_id)
if tile is not None:
return tile
color = r.choice(blocktopus_colors)
tiles[tile_id] = out = make_tile(color)
out.buffer[:] = colors[color]
return out
spine = Line(
point(.1 * image_shape[0], .5 * image_shape[1]),
point(.9 * image_shape[0], .5 * image_shape[1])
)
direction = normalize(spine.direction)
up = normalize(rotate_left(spine.direction))
steps = 30
step_size = 1. / steps
frequency = 2.5 * 2. * math.pi * step_size
frames = 10 * 30
for frame in range(frames):
image.buffer[:] = colors['white']
phase = 2 * 2. * math.pi * frame / frames
phase_offset = .5 - math.cos(phase)
for i in range(steps):
width_factor = (1. - float(i) / (steps - 1))
width = width_factor * .15 * image_shape[1]
s = math.cos(frequency * i + phase) + phase_offset
base = spine(i * step_size)
offsets = [
s * width * up,
(s - 1) * width * up,
]
for (j, offset) in enumerate(offsets):
p = base + offset
tile = get_tile((i, j))
tile.set_origin(p[:2])
intersection = image.intersection_slices(tile)
if intersection is None: continue
m, t = intersection
image.buffer[m] = tile.buffer[t]
path = 'blocktopus/frame_{frame:03}.tiff'.format(frame=frame)
save_array_as_image(path, image.buffer, 'RGBA')
