Esempio n. 1
0
def generate_mesh(surface, shader):
    # shape = (128, 128)
    shape = (256, 256)

    mesh = MicropolygonMesh(shape)
    shape = mesh.buffer.shape

    dir_path, base_path = os.path.split(__file__)
    texture_path = os.path.abspath(os.path.join(dir_path, 'render', 'texture.tiff'))
    texture = read_texture(texture_path)

    texture_start = generate_numpy_begin(texture)
    texture_width, texture_height = texture.shape

    mesh_width, mesh_height = mesh.buffer.shape

    c_generate_mesh = load_sampler_lib()['generate_mesh']

    c_generate_mesh(
        generate_numpy_begin(mesh.buffer),
        mesh_width, mesh_height,
        texture_start,
        texture_width, texture_height
    )

    return mesh
Esempio n. 2
0
    def downsample(self, sample_rate):
        downrate = int(math.ceil(self.sample_rate / sample_rate))

        in_height, in_width = self.buffer.shape
        buffer = array_view(self.buffer)

        new_shape = [
            int(math.ceil(o / downrate))
            for o in buffer.shape
        ]

        new_shape[-1] = buffer.shape[-1]
        out_height, out_width = new_shape[:2]

        out = np.zeros(shape=new_shape, dtype=np.float32)

        downsample_tile(
            generate_numpy_begin(buffer),
            in_width, in_height,
            downrate, downrate,
            generate_numpy_begin(out),
            out_width, out_height

        )

        return pixel_view(out)
Esempio n. 3
0
def extract_meshes_from_micropolygon_mesh(self, mesh_data):
    from handsome.MicropolygonMesh import MicropolygonMesh, Vertex

    shape = tuple(d - 1 for d in mesh_data.vertices.shape[:-1])
    mesh = MicropolygonMesh(shape)

    mesh.buffer[:] = np.squeeze(mesh_data.vertices.view(Vertex))
    apply_transform_to_mesh(self.current_xform, mesh)

    texture = mesh_data.data.get('texture')

    if texture is not None:
        from handsome.capi import generate_numpy_begin
        import ctypes

        texture_module = load_texture_module()

        subdivide_mesh = texture_module.c_subdivide_mesh

        factor = 1000

        old_cols, old_rows = mesh.shape
        new_cols, new_rows = factor * old_cols, factor * old_rows
        # new_cols, new_rows = 20 * old_cols, 20 * old_rows
        new_mesh = MicropolygonMesh((new_cols, new_rows))

        # TODO: Make this type conversion automatic
        argtypes = subdivide_mesh.argtypes
        new_mesh_pointer = ctypes.cast(generate_numpy_begin(new_mesh.buffer), argtypes[0])
        old_mesh_pointer = ctypes.cast(generate_numpy_begin(mesh.buffer), argtypes[3])
        
        b = subdivide_mesh(
            new_mesh_pointer, new_rows, new_cols,
            old_mesh_pointer, old_rows, old_cols,
        )

        mesh = new_mesh

        sample_texture_to_mesh = texture_module.c_sample_texture_to_mesh

        # TODO: Make this type conversion automatic
        argtypes = sample_texture_to_mesh.argtypes
        mesh_pointer = ctypes.cast(generate_numpy_begin(mesh.buffer), argtypes[0])
        texture_pointer = ctypes.cast(generate_numpy_begin(texture.buffer), argtypes[3])

        mesh_height, mesh_width = mesh.buffer.shape
        texture_height, texture_width = texture.shape

        texture_module.c_sample_texture_to_mesh(
            mesh_pointer, mesh_width, mesh_height,
            texture_pointer, texture_width, texture_height,
        )

    # yield from slice_mesh(mesh, int(factor / 100))
    yield mesh
Esempio n. 4
0
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')
Esempio n. 5
0
def test_coordinate_image(tmpdir):
    try:
        lib = build_test_so(tmpdir)
    except Exception as e:
        import pdb
        pdb.set_trace()

    print_coordinates = lib['print_coordinates']
    print_coordinates.restype = ctypes.c_char_p

    expected = [ 
        [ 0, 3  ], [ 1, 3 ],
        [ 0, 2  ], [ 1, 2 ],
        [ 0, 1, ], [ 1, 1 ],
        [ 0, 0, ], [ 1, 0 ],
    ]

    tile = Tile((0, 0), (2, 4), 1)

    image = tile.coordinate_image
    width, height = image.shape
    size = width * height

    ptr = generate_numpy_begin(image)

    text = print_coordinates(ptr, size)
    coords = json.loads(text.decode('utf-8'))

    assert coords == expected
Esempio n. 6
0
    def bounds(self):
        if self.__bounds is not None:
            return self.__bounds

        buffer = self.__buffer
        mesh_rows, mesh_columns = buffer.shape
        bounds_rows, bounds_columns = mesh_rows - 1, mesh_columns - 1

        self.__bounds = np.zeros((bounds_rows, bounds_columns), dtype=Position)

        outer_bounds = fill_bounds_buffer(
            mesh_rows, mesh_columns,
            generate_numpy_begin(buffer),
            generate_numpy_begin(self.__bounds),
        )

        self.__outer_bounds = outer_bounds
        return self.__bounds
Esempio n. 7
0
def render_mesh(mesh):
    cache = TileCache((16, 16), 4, FloatPixel)

    mesh_bounds = mesh.outer_bounds
    mesh_rows, mesh_columns = mesh.buffer.shape

    for tile in cache.get_tiles_for_bounds(mesh_bounds):
        tile_rows, tile_columns = tile.buffer.shape

        fill_micropolygon_mesh(
            mesh_rows, mesh_columns,
            generate_numpy_begin(mesh.buffer),
            generate_numpy_begin(mesh.bounds),
            tile_rows, tile_columns,
            tile.bounds,
            generate_numpy_begin(tile.coordinate_image),
            generate_numpy_begin(tile.buffer)
        )

    return cache
Esempio n. 8
0
def generate_mesh(surface, shader):
    # shape = (128, 128)
    shape = (256, 256)

    mesh = MicropolygonMesh(shape)
    shape = mesh.buffer.shape

    u_steps = np.linspace(0, 1, shape[1], endpoint=True)
    v_steps = np.linspace(0, 1, shape[0], endpoint=True)

    points = [ [ surface(u, v) for u in u_steps ] for v in v_steps ]
    mesh.buffer[:,:]['position'] = points

    colors = [ [ shader(u, v) for u in u_steps ] for v in v_steps ]
    mesh.buffer[:,:]['color'] = colors

    return mesh


    sample_texture_to_mesh = load_sampler_lib()['sample_texture_to_mesh']

    mesh_start = generate_numpy_begin(mesh.buffer)
    mesh_width, mesh_height = mesh.buffer.shape

    dir_path, base_path = os.path.split(__file__)
    texture_path = os.path.abspath(os.path.join(dir_path, 'render', 'texture.tiff'))
    # texture_path = os.path.abspath(os.path.join(dir_path, 'render', 'texture_black.tif'))
    texture = read_texture(texture_path)

    texture_start = generate_numpy_begin(texture)
    texture_width, texture_height = texture.shape

    sample_texture_to_mesh(
        mesh_start, mesh_width, mesh_height,
        texture_start, texture_width, texture_height,
    )

    return mesh
Esempio n. 9
0
def make_tile_cacher(shape, dtype, cache_size=int(4 * 2 ** 20)):
    from functools import reduce
    from operator import mul

    item_size = dtype.itemsize

    if not isinstance(item_size, int):
        item_size = dtype().itemsize

    items_per_tile = reduce(mul, shape)
    tile_size = item_size * items_per_tile
    tiles_per_cache = max(int(cache_size // tile_size), 1)

    while True:
        cache = np.zeros(tiles_per_cache * items_per_tile, dtype=dtype)
        begin = generate_numpy_begin(cache)

        for offset in range(tiles_per_cache):
            start, end = offset * items_per_tile, (offset + 1) * items_per_tile

            ptr = c_void_p(begin.value + start * item_size)
            out = cache[start:end].reshape(shape)

            yield (ptr, out)
Esempio n. 10
0
def test_tile_render():
    from handsome.MicropolygonMesh import MicropolygonMesh
    from handsome.Tile import Tile

    mesh = MicropolygonMesh((1, 1))

    mesh.buffer[:,:]['position'] = [
        [ (16, 16, 1, 1), (32, 16, 1, 1) ],
        [ (0, 0, 1, 1),   (16, 0, 1, 1) ],
    ]

    red    = color(1, 0, 0)
    green  = color(0, 1, 0)
    orange = color(1, 1, 0)
    black  = color(0, 0, 0, 1)
    zero   = color(0, 0, 0, 0)

    mesh.buffer[:,:]['color'] = [
        [ green, orange, ],
        [ black, red, ],
    ]

    mesh_rows, mesh_columns = mesh.buffer.shape

    tile = Tile((0,0), (32, 16), 1, FloatPixel)

    tile_rows, tile_columns = tile.buffer.shape

    fill_micropolygon_mesh(
        mesh_rows, mesh_columns,
        generate_numpy_begin(mesh.buffer),
        generate_numpy_begin(mesh.bounds),
        tile_rows, tile_columns,
        tile.bounds,
        generate_numpy_begin(tile.coordinate_image),
        generate_numpy_begin(tile.buffer),
    )

    buffer = array_view(tile.buffer)
    rows, columns, channels = buffer.shape

    def image(x, y):
        return buffer[rows - 1 - y, x]

    low, high = 1/16, 15/16

    expected = [
        ((0, 0),   color(0, 0, 0, 1)),
        ((15, 0),  color(15/16, 0, 0, 1)),
        ((16, 0),  color(0, 0, 0, 0)),
        ((31, 0),  color(0, 0, 0, 0)),

        ((0, 8),   color(0, 0, 0, 0)),
        ((8,8),    color(0, 1/2, 0, 1)),
        ((16,8),   color(1/2, 1/2, 0, 1)),
        ((31, 8),  color(0, 0, 0, 0)),

        ((0, 15),  color(0, 0, 0, 0)),
        ((15, 15), low * black + high * green),
        ((30, 15), low * (low * black + high * green) + high * (low * red + high * orange)),
    ]

    for index, c in expected:
        assert points_are_close(image(*index), c)