# Controls how much incluence that specular reflection occurs at head-on # reflections if y == 16 or y == 17: mat.set_roughness(0.0) mat.set_specular(x / 20.0) # Controls the probability of a ray passing through the material if y == 18 or y == 19: mat.set_alpha(x / 20.0) # Create a camera center = visii.get_scene_aabb_center() camera = visii.entity.create( name="camera", transform=visii.transform.create(name="camera_transform"), camera=visii.camera.create(name="camera_camera", aspect=opt.width / opt.height)) camera.get_transform().look_at(at=(center.x, 0, center.z), up=(0, 0, 1), eye=(center.x, -5, center.z)) visii.set_camera_entity(camera) # Render out the final image print("rendering to", opt.out) visii.render_to_file(width=opt.width, height=opt.height, samples_per_pixel=opt.spp, file_path=opt.out) visii.deinitialize()
# Use the hsv to apply color as a function of the angle c = [0, 0, 0] if magnitude > 0.000001: angle = py_ang(angle_vector) if use_magnitude: c = colorsys.hsv_to_rgb(angle / 360, 1, magnitude) else: c = colorsys.hsv_to_rgb(angle / 360, 1, 1) # for i_c in range(3): image[i, j, 0:3] = c return image visii.render_to_file(width=int(opt.width), height=int(opt.height), samples_per_pixel=int(opt.spp), file_path=f"20_frame1.png") obj1.get_transform().set_position(obj1.get_transform().get_position(), previous=True) obj1.get_transform().add_position(visii.vec3(0, 0.5, 0)) obj2.get_transform().set_position(obj2.get_transform().get_position(), previous=True) obj2.get_transform().add_position(visii.vec3(0, 0, 0.5)) obj3.get_transform().set_rotation(obj3.get_transform().get_rotation(), previous=True) obj3.get_transform().add_rotation(visii.quat(0, -1, 0, 0)) motion_vectors_array = visii.render_data(width=int(opt.width),
mesh1.get_transform().set_angular_velocity(visii.angleAxis(0.5, (0, 0, 1))) visii.sample_time_interval((1, 1)) visii.render_data_to_file(width=opt.width, height=opt.height, start_frame=0, frame_count=1, bounce=int(0), options="diffuse_motion_vectors", file_path=f"{opt.outf}/diffuse_motion_vectors.exr") # for the final image, sample the entire pixel area to anti-alias the result visii.sample_pixel_area(x_sample_interval=(0.0, 1.0), y_sample_interval=(0.0, 1.0)) visii.render_to_file(width=opt.width, height=opt.height, samples_per_pixel=opt.spp, file_path=f"{opt.outf}/img.png") visii.render_to_file(width=opt.width, height=opt.height, samples_per_pixel=opt.spp, file_path=f"{opt.outf}/img.exr") visii.render_to_file(width=opt.width, height=opt.height, samples_per_pixel=opt.spp, file_path=f"{opt.outf}/img.hdr") # let's clean up the GPU visii.deinitialize()
normals = np.array(mesh.vertex_normals).flatten().tolist() vertices = np.array(mesh.vertices).flatten().tolist() mesh = visii.mesh.create_from_data('stl_mesh', positions=vertices, normals=normals) # # # # # # # # # # # # # # # # # # # # # # # # # obj_entity = visii.entity.create(name="obj_entity", mesh=mesh, transform=visii.transform.create("obj_entity", scale=(0.3, 0.3, 0.3)), material=visii.material.create("obj_entity")) obj_entity.get_material().set_base_color((0.9, 0.12, 0.08)) obj_entity.get_material().set_roughness(0.7) obj_entity.get_material().set_specular(1) obj_entity.get_material().set_sheen(1) # # # # # # # # # # # # # # # # # # # # # # # # # visii.render_to_file(width=int(opt.width), height=int(opt.height), samples_per_pixel=int(opt.spp), file_path=f"{opt.out}") # let's clean up the GPU visii.deinitialize()
def f(frame_ids): # headless - no window # verbose - output number of frames rendered, etc.. visii.initialize(headless=True, verbose=False) # Use a neural network to denoise ray traced visii.enable_denoiser() # set up dome background negatives = list(glob.glob("negatives/*.jpg")) visii.set_dome_light_intensity(1) # create an entity that will serve as our camera. camera = visii.entity.create(name="camera") # To place the camera into our scene, we'll add a "transform" component. # (All visii objects have a "name" that can be used for easy lookup later.) camera.set_transform(visii.transform.create(name="camera_transform")) # To make our camera entity act like a "camera", we'll add a camera component camera.set_camera( visii.camera.create_from_fov( name="camera_camera", field_of_view=1.4, # note, this is in radians aspect=opt.width / float(opt.height))) # Finally, we'll select this entity to be the current camera entity. # (visii can only use one camera at the time) visii.set_camera_entity(camera) # lets store the camera look at information so we can export it camera_struct_look_at = { 'at': [0, 0, 0], 'up': [0, 0, 1], 'eye': [-1, 0, 0] } # Lets set the camera to look at an object. # We'll do this by editing the transform component. camera.get_transform().look_at(at=camera_struct_look_at['at'], up=camera_struct_look_at['up'], eye=camera_struct_look_at['eye']) # This function loads a mesh ignoring .mtl mesh = visii.mesh.create_from_file(opt.entity, opt.model) # creates visii entity using loaded mesh obj_entity = visii.entity.create( name=opt.entity + "_entity", mesh=mesh, transform=visii.transform.create(opt.entity + "_entity"), material=visii.material.create(opt.entity + "_entity"), ) # obj_entity.get_light().set_intensity(0.05) # you can also set the light color manually # obj_entity.get_light().set_color((1,0,0)) # Add texture to the material material = visii.material.get(opt.entity + "_entity") texture = visii.texture.create_from_file(opt.entity, "./models/Cutie.PNG") material.set_base_color_texture(texture) # Lets add the cuboid to the object we want to export add_cuboid(opt.entity + "_entity", opt.debug) # lets keep track of the entities we want to export entities_to_export = [opt.entity + "_entity"] # Loop where we change and render each frame for i in tqdm(frame_ids): # load a random negtive onto the dome negative = cv2.imread(random.choice(negatives)) # Skip dark backgrounds (20/255) if np.mean(negative) < 20: continue # Fix lighting of background and make it small within the FOV background = make_background(negative) cv2.imwrite("test" + str(i) + ".png", background) dome = visii.texture.create_from_file("dome", "test" + str(i) + ".png") visii.set_dome_light_texture(dome) visii.set_dome_light_rotation( visii.angleAxis(visii.pi() * .5, visii.vec3(0, 0, 1))) stretch_factor = 2 scale = [ random.uniform(1, stretch_factor), # width random.uniform(1, stretch_factor), # length random.uniform(1, stretch_factor) # height ] obj_entity.get_transform().set_scale(scale) # create random rotation while making usre the entity is facing forward in each frame rot = [ random.uniform(-10, 10), # Roll random.uniform(-15, 15), # Pitch random.uniform(-45, 45) # Yaw ] q = Quaternion.from_euler(rot[0], rot[1], rot[2], degrees=True) position = [ random.uniform(0, 4), # X Depth random.uniform(-1, 1), # Y random.uniform(-1, 1) # Z ] # Scale the position based on depth into image to make sure it remains in frame position[1] *= position[0] position[2] *= position[0] obj_entity.get_transform().set_position(tuple(position)) obj_entity.get_transform().set_rotation((q.x, q.y, q.z, q.w)) # use random to make 95 % probability the frame data goes into training and # 5% chance it goes in test folder folder = '' if random.randint(0, 100) < opt.test_percent: folder = opt.entity + '_test/' else: folder = opt.entity + '_training/' # Render the scene visii.render_to_file(width=opt.width, height=opt.height, samples_per_pixel=opt.spp, file_path=opt.out + folder + opt.entity + str(i) + '.png') # set up JSON export_to_ndds_file(filename=opt.out + folder + opt.entity + str(i) + '.json', obj_names=entities_to_export, width=opt.width, height=opt.height, camera_struct=camera_struct_look_at) # remove current negative from the dome visii.clear_dome_light_texture() visii.texture.remove("dome") os.remove("test" + str(i) + ".png") visii.deinitialize()
# We use frames per second here to internally convert velocity in meters / second into meters / frame. # The "mix" parameter smooths out the motion blur temporally, reducing flickering from linear motion blur obj_entity.get_transform().set_linear_velocity(dpos, frames_per_second, mix=.7) # visii quat expects w as the first argument new_rot = visii.quat(rot[3], rot[0], rot[1], rot[2]) drot = visii.vec3(_drot[0], _drot[1], _drot[2]) obj_entity.get_transform().set_rotation(new_rot) # Use angular velocity to blur the object in motion. Same concepts as above, but for # angular velocity instead of scalar. obj_entity.get_transform().set_angular_velocity(visii.quat(1.0, drot), frames_per_second, mix=.7) print(f'rendering frame {str(i).zfill(5)}/{str(opt.nb_frames).zfill(5)}') visii.render_to_file(width=int(opt.width), height=int(opt.height), samples_per_pixel=int(opt.spp), file_path=f"{opt.outf}/{str(i).zfill(5)}.png") p.disconnect() visii.deinitialize() subprocess.call([ 'ffmpeg', '-y', '-framerate', '30', '-i', r"%05d.png", '-vcodec', 'libx264', '-pix_fmt', 'yuv420p', '../pybullet_motion_blur.mp4' ], cwd=os.path.realpath(opt.outf))
mat = floor.get_material() # mat = visii.material.get("material_floor") # <- this also works # Mirrors are smooth and "metallic". mat.set_base_color((0.19, 0.16, 0.19)) mat.set_metallic(1) mat.set_roughness(0) # Make the floor large by scaling it trans = floor.get_transform() trans.set_scale((5, 5, 1)) # Let's also add a sphere sphere = visii.entity.create(name="sphere", mesh=visii.mesh.create_sphere("sphere"), transform=visii.transform.create("sphere"), material=visii.material.create("sphere")) sphere.get_transform().set_position((0, 0, 0.41)) sphere.get_transform().set_scale((0.4, 0.4, 0.4)) sphere.get_material().set_base_color((0.1, 0.9, 0.08)) sphere.get_material().set_roughness(0.7) # Now that we have a simple scene, let's render it print("rendering to", "01_simple_scene.png") visii.render_to_file(width=opt.width, height=opt.height, samples_per_pixel=opt.spp, file_path="01_simple_scene.png") visii.deinitialize()