Пример #1
0
def build_scene(num_cubes, color_array):
    # Generate positions of each cube
    cube_position_array, barycenter = generate_block_positions(num_cubes)

    # Place cubes
    scene = rtx.Scene(ambient_color=(0, 0, 0))
    for position in cube_position_array:
        geometry = rtx.BoxGeometry(cube_size, cube_size, cube_size)
        geometry.set_position((
            position[0] - barycenter[0],
            position[1] - barycenter[1],
            position[2] - barycenter[2],
        ))
        material = rtx.LambertMaterial(0.3)
        mapping = rtx.SolidColorMapping(random.choice(color_array))
        cube = rtx.Object(geometry, material, mapping)
        scene.add(cube)

    # Place a light
    size = 50
    geometry = rtx.SphereGeometry(size)
    geometry.set_position((size * 2, size * 2, 0))
    material = rtx.EmissiveMaterial(100, visible=False)
    mapping = rtx.SolidColorMapping((1, 1, 1))
    light = rtx.Object(geometry, material, mapping)
    scene.add(light)

    return scene
Пример #2
0
def build_scene(floor_textures, wall_textures, fix_light_position=False):
    scene = rtx.Scene(ambient_color=(153 / 255, 226 / 255, 249 / 255))

    texture = load_texture_image(random.choice(wall_textures))
    mapping = generate_texture_mapping(texture, floor_size / wall_height)

    # Place walls
    ## 1
    geometry = rtx.PlainGeometry(floor_size, wall_height)
    geometry.set_rotation((0, 0, 0))
    geometry.set_position((0, wall_height / 2, -floor_size / 2))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    ## 2
    geometry = rtx.PlainGeometry(floor_size, wall_height)
    geometry.set_rotation((0, -math.pi / 2, 0))
    geometry.set_position((floor_size / 2, wall_height / 2, 0))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    ## 3
    geometry = rtx.PlainGeometry(floor_size, wall_height)
    geometry.set_rotation((0, math.pi, 0))
    geometry.set_position((0, wall_height / 2, floor_size / 2))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    ## 4
    geometry = rtx.PlainGeometry(floor_size, wall_height)
    geometry.set_rotation((0, math.pi / 2, 0))
    geometry.set_position((-floor_size / 2, wall_height / 2, 0))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    # floor
    geometry = rtx.PlainGeometry(floor_size, floor_size)
    geometry.set_rotation((-math.pi / 2, 0, 0))
    geometry.set_position((0, 0, 0))
    material = rtx.LambertMaterial(0.95)
    texture = load_texture_image(random.choice(floor_textures))
    mapping = generate_texture_mapping(texture, scale=0.5)
    floor = rtx.Object(geometry, material, mapping)
    scene.add(floor)

    # Place a light
    geometry = rtx.SphereGeometry(2)
    spread = floor_size / 2 - 1
    geometry.set_position(
        (random.uniform(-spread, spread), 8, random.uniform(-spread, spread)))
    material = rtx.EmissiveMaterial(20, visible=False)
    mapping = rtx.SolidColorMapping((1, 1, 1))
    light = rtx.Object(geometry, material, mapping)
    scene.add(light)

    return scene
Пример #3
0
def create_geometry_by_type(geometry_type):
    if geometry_type == GeometryType.box:
        return rtx.BoxGeometry(width=0.75, height=0.75, depth=0.75), 0.375

    if geometry_type == GeometryType.shpere:
        return rtx.SphereGeometry(radius=0.375), 0.375

    if geometry_type == GeometryType.cylinder:
        return rtx.CylinderGeometry(radius=0.25, height=1), 0.5

    if geometry_type == GeometryType.cone:
        return rtx.ConeGeometry(radius=0.375, height=1), 0.375

    raise NotImplementedError
def build_geometry_by_type(geometry_type):
    if geometry_type == GeometryType.box:
        return rtx.BoxGeometry(width=1, height=1, depth=1)

    if geometry_type == GeometryType.shpere:
        return rtx.SphereGeometry(radius=0.5)

    if geometry_type == GeometryType.cylinder:
        return rtx.CylinderGeometry(radius=0.5, height=1)

    if geometry_type == GeometryType.cone:
        return rtx.ConeGeometry(radius=0.5, height=1)

    raise NotImplementedError
Пример #5
0
def build_scene(mnist_image_array,
                wall_texture_filename_array,
                floor_texture_filename_array,
                grid_size=8):
    assert len(mnist_image_array) == 6

    wall_height = 3
    eps = 0.1
    scene = rtx.Scene(ambient_color=(0.5, 1, 1))

    texture = load_texture_image(random.choice(wall_texture_filename_array))
    mapping = build_mapping(texture, grid_size / wall_height)

    # 1
    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, 0, 0))
    geometry.set_position((0, 0, -grid_size / 2))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    # 2
    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, -math.pi / 2, 0))
    geometry.set_position((grid_size / 2, 0, 0))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    # 3
    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, math.pi, 0))
    geometry.set_position((0, 0, grid_size / 2))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    # 4
    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, math.pi / 2, 0))
    geometry.set_position((-grid_size / 2, 0, 0))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    # floor
    geometry = rtx.PlainGeometry(grid_size + eps, grid_size + eps)
    geometry.set_rotation((-math.pi / 2, 0, 0))
    geometry.set_position((0, -wall_height / 2, 0))
    material = rtx.LambertMaterial(0.95)
    texture = load_texture_image(random.choice(floor_texture_filename_array))
    mapping = build_mapping(texture, scale=0.5)
    floor = rtx.Object(geometry, material, mapping)
    scene.add(floor)

    # Place lights
    ## Primary light
    primary_light = rtx.ObjectGroup()
    geometry = rtx.SphereGeometry(2)
    material = rtx.EmissiveMaterial(40, visible=False)
    mapping = rtx.SolidColorMapping((1, 1, 1))
    light = rtx.Object(geometry, material, mapping)
    primary_light.add(light)

    spread = grid_size / 2 - 1
    primary_light.set_position((spread * random.uniform(-1, 1), 8,
                                spread * random.uniform(-1, 1)))
    scene.add(primary_light)

    ## Ambient light
    ambient_lights = rtx.ObjectGroup()

    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, 0, 0))
    geometry.set_position((0, 0, -grid_size / 2))
    material = rtx.EmissiveMaterial(1, visible=False)
    wall = rtx.Object(geometry, material, mapping)
    ambient_lights.add(wall)

    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, -math.pi / 2, 0))
    geometry.set_position((grid_size / 2, 0, 0))
    material = rtx.EmissiveMaterial(1, visible=False)
    wall = rtx.Object(geometry, material, mapping)
    ambient_lights.add(wall)

    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, math.pi, 0))
    geometry.set_position((0, 0, grid_size / 2))
    material = rtx.EmissiveMaterial(1, visible=False)
    wall = rtx.Object(geometry, material, mapping)
    ambient_lights.add(wall)

    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, math.pi / 2, 0))
    geometry.set_position((-grid_size / 2, 0, 0))
    material = rtx.EmissiveMaterial(1, visible=False)
    wall = rtx.Object(geometry, material, mapping)
    ambient_lights.add(wall)

    ambient_lights.set_position((0, wall_height, 0))
    scene.add(ambient_lights)

    # Place a dice
    dice = build_dice(mnist_image_array)
    spread = grid_size / 3
    dice.set_position((spread * random.uniform(-1, 1), 1 - wall_height / 2,
                       spread * random.uniform(-1, 1)))
    dice.set_rotation((0, random.uniform(0, math.pi * 2), 0))
    scene.add(dice)

    return scene
def build_scene(color_array, wall_texture_filename_array,
                floor_texture_filename_array, grid_size, wall_height):
    eps = 0.1
    scene = rtx.Scene(ambient_color=(0.5, 1, 1))

    texture = load_texture_image(random.choice(wall_texture_filename_array))
    mapping = build_mapping(texture, grid_size / wall_height)

    # 1
    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, 0, 0))
    geometry.set_position((0, 0, -grid_size / 2))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    # 2
    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, -math.pi / 2, 0))
    geometry.set_position((grid_size / 2, 0, 0))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    # 3
    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, math.pi, 0))
    geometry.set_position((0, 0, grid_size / 2))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    # 4
    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, math.pi / 2, 0))
    geometry.set_position((-grid_size / 2, 0, 0))
    material = rtx.LambertMaterial(0.95)
    wall = rtx.Object(geometry, material, mapping)
    scene.add(wall)

    # floor
    geometry = rtx.PlainGeometry(grid_size + eps, grid_size + eps)
    geometry.set_rotation((-math.pi / 2, 0, 0))
    geometry.set_position((0, -wall_height / 2, 0))
    material = rtx.LambertMaterial(0.95)
    texture = load_texture_image(random.choice(floor_texture_filename_array))
    mapping = build_mapping(texture, scale=0.5)
    floor = rtx.Object(geometry, material, mapping)
    scene.add(floor)

    # Place lights
    ## Primary light
    primary_light = rtx.ObjectGroup()
    geometry = rtx.SphereGeometry(2)
    material = rtx.EmissiveMaterial(40, visible=False)
    mapping = rtx.SolidColorMapping((1, 1, 1))
    light = rtx.Object(geometry, material, mapping)
    primary_light.add(light)

    spread = grid_size / 2 - 1
    primary_light.set_position(
        (spread * random.uniform(-1, 1), 8, spread * random.uniform(-1, 1)))
    scene.add(primary_light)

    ## Ambient light
    ambient_lights = rtx.ObjectGroup()

    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, 0, 0))
    geometry.set_position((0, 0, -grid_size / 2))
    material = rtx.EmissiveMaterial(1, visible=False)
    wall = rtx.Object(geometry, material, mapping)
    ambient_lights.add(wall)

    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, -math.pi / 2, 0))
    geometry.set_position((grid_size / 2, 0, 0))
    material = rtx.EmissiveMaterial(1, visible=False)
    wall = rtx.Object(geometry, material, mapping)
    ambient_lights.add(wall)

    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, math.pi, 0))
    geometry.set_position((0, 0, grid_size / 2))
    material = rtx.EmissiveMaterial(1, visible=False)
    wall = rtx.Object(geometry, material, mapping)
    ambient_lights.add(wall)

    geometry = rtx.PlainGeometry(grid_size + eps, wall_height)
    geometry.set_rotation((0, math.pi / 2, 0))
    geometry.set_position((-grid_size / 2, 0, 0))
    material = rtx.EmissiveMaterial(1, visible=False)
    wall = rtx.Object(geometry, material, mapping)
    ambient_lights.add(wall)

    ambient_lights.set_position((0, wall_height, 0))
    scene.add(ambient_lights)

    # Place objects
    r = grid_size // 4
    r2 = r * 2
    object_positions = generate_object_positions(args.num_objects, r2 - 1)
    for position_index in object_positions:
        geometry_type = random.choice(geometry_type_array)
        geometry = build_geometry_by_type(geometry_type)
        geometry.set_rotation((0, random.uniform(0, math.pi * 2), 0))

        noise = np.random.uniform(-0.125, 0.125, size=2)
        spread = 1.5
        geometry.set_position((
            spread * (position_index[0] - r + 1) + noise[0],
            -wall_height / 2 + 0.5,
            spread * (position_index[1] - r + 1) + noise[1],
        ))
        material = rtx.LambertMaterial(0.9)
        color = random.choice(color_array)
        mapping = rtx.SolidColorMapping(color)
        obj = rtx.Object(geometry, material, mapping)
        scene.add(obj)
    return scene
Пример #7
0
scene.add(teapot)

# place dragon
faces, vertices = gm.load("../geometries/dragon")
bottom = np.amin(vertices, axis=0)
geometry = rtx.StandardGeometry(faces, vertices, 25)
geometry.set_position((0.75, -bottom[2] * 1.5, 0))
geometry.set_scale((1.5, 1.5, 1.5))
geometry.set_rotation((0, -math.pi / 4, 0))
material = rtx.LambertMaterial(1.0)
mapping = rtx.SolidColorMapping((1, 0, 1))
dragon = rtx.Object(geometry, material, mapping)
scene.add(dragon)

# place ball
geometry = rtx.SphereGeometry(0.5)
geometry.set_position((2.25, 0.5, 0))
material = rtx.LambertMaterial(1.0)
mapping = rtx.SolidColorMapping((0, 1, 1))
sphere = rtx.Object(geometry, material, mapping)
scene.add(sphere)

# place light
geometry = rtx.PlainGeometry(2.0, 0.5)
geometry.set_rotation((0, 0, math.pi / 2))
geometry.set_position((-2, 1, -3))
material = rtx.EmissiveMaterial(5.0)
mapping = rtx.SolidColorMapping((1, 0, 0))
rect_area_light = rtx.Object(geometry, material, mapping)
scene.add(rect_area_light)
Пример #8
0
material = rtx.EmissiveMaterial(1.0, visible=False)
mapping = rtx.SolidColorMapping((1, 1, 1))
light = rtx.Object(geometry, material, mapping)
group.add(light)

geometry = rtx.PlainGeometry(100, 100)
geometry.set_rotation((0, -math.pi / 2, 0))
geometry.set_position((box_width / 2 + 5, 0, 0))
material = rtx.EmissiveMaterial(0.1, visible=False)
mapping = rtx.SolidColorMapping((1, 1, 1))
light = rtx.Object(geometry, material, mapping)
group.add(light)

# scene.add(group)

geometry = rtx.SphereGeometry(2)
geometry.set_position((0, 4, 0))
material = rtx.EmissiveMaterial(1, visible=True)
mapping = rtx.SolidColorMapping((1, 1, 1))
light = rtx.Object(geometry, material, mapping)
scene.add(light)

geometry = rtx.PlainGeometry(2, 2)
geometry.set_rotation((math.pi / 2, 0, 0))
geometry.set_position((0, 5, 0))
material = rtx.EmissiveMaterial(1, visible=True)
mapping = rtx.SolidColorMapping((1, 1, 1))
light = rtx.Object(geometry, material, mapping)
# scene.add(light)

# place cylinder