def create_obj(
name = 'name',
path_obj = "",
scale = 0.01,
rot_base = None, #visii quat
pos_base = None, # visii vec3
):
# This is for YCB like dataset
obj_mesh = visii.mesh.create_from_obj(name, path_obj)
obj_entity = visii.entity.create(
name = name,
# mesh = visii.mesh.create_sphere("mesh1", 1, 128, 128),
mesh = obj_mesh,
transform = visii.transform.create(name),
material = visii.material.create(name)
)
# should randomize
obj_entity.get_material().set_metallic(0) # should 0 or 1
obj_entity.get_material().set_transmission(0) # should 0 or 1
obj_entity.get_material().set_roughness(1) # default is 1
obj_entity.get_transform().set_scale(visii.vec3(scale))
if not rot_base is None:
obj_entity.get_transform().set_rotation(rot_base)
if not pos_base is None:
obj_entity.get_transform().set_position(pos_base)
return obj_entity
def get_add(obj1, obj2, pos1, pos2, quat1, quat2):
obj1.get_transform().set_position(visii.vec3(pos1[0],pos1[1],pos1[2]))
obj1.get_transform().set_rotation(visii.quat(quat1[0],quat1[1],quat1[2],quat1[3]))
obj2.get_transform().set_position(visii.vec3(pos2[0],pos2[1],pos2[2]))
obj2.get_transform().set_rotation(visii.quat(quat2[0],quat2[1],quat2[2],quat2[3]))
dist = []
vertices = obj1.get_mesh().get_vertices()
for i in range(len(vertices)):
v = visii.vec4(vertices[i][0],vertices[i][1],vertices[i][2],1)
p0 = obj1.get_transform().get_local_to_world_matrix() * v
p1 = obj2.get_transform().get_local_to_world_matrix() * v
dist.append(visii.distance(p0, p1))
dist = np.mean(dist)
return dist
def interact():
global speed_camera
global cursor
global rot
# visii camera matrix
cam_matrix = camera.get_transform().get_local_to_world_matrix()
dt = visii.vec4(0,0,0,0)
# translation
if visii.is_button_held("W"): dt[2] = -speed_camera
if visii.is_button_held("S"): dt[2] = speed_camera
if visii.is_button_held("A"): dt[0] = -speed_camera
if visii.is_button_held("D"): dt[0] = speed_camera
if visii.is_button_held("Q"): dt[1] = -speed_camera
if visii.is_button_held("E"): dt[1] = speed_camera
# control the camera
if visii.length(dt) > 0.0:
w_dt = cam_matrix * dt
camera.get_transform().add_position(visii.vec3(w_dt))
# camera rotation
cursor[2] = cursor[0]
cursor[3] = cursor[1]
cursor[0] = visii.get_cursor_pos().x
cursor[1] = visii.get_cursor_pos().y
if visii.is_button_held("MOUSE_LEFT"):
visii.set_cursor_mode("DISABLED")
rotate_camera = True
else:
visii.set_cursor_mode("NORMAL")
rotate_camera = False
if rotate_camera:
rot.x -= (cursor[0] - cursor[2]) * 0.001
rot.y -= (cursor[1] - cursor[3]) * 0.001
init_rot = visii.angleAxis(visii.pi() * .5, (1,0,0))
yaw = visii.angleAxis(rot.x, (0,1,0))
pitch = visii.angleAxis(rot.y, (1,0,0))
camera.get_transform().set_rotation(init_rot * yaw * pitch)
# change speed movement
if visii.is_button_pressed("UP"):
speed_camera *= 0.5
print('decrease speed camera', speed_camera)
if visii.is_button_pressed("DOWN"):
speed_camera /= 0.5
print('increase speed camera', speed_camera)
def rotateLight(rx=0, ry=0., rz=0):
areaLight1.get_transform().set_rotation(v.angleAxis(rx, v.vec3(1, 0, 0)))
areaLight1.get_transform().add_rotation(v.angleAxis(ry, v.vec3(0, 1, 0)))
areaLight1.get_transform().add_rotation(v.angleAxis(rz, v.vec3(0, 0, 1)))
def moveLight(x=0, y=0, z=3):
areaLight1.get_transform().set_position(v.vec3(x, y, z))
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),
height=int(opt.height),
start_frame=0,
frame_count=1,
bounce=int(0),
options="diffuse_motion_vectors")
# # # # # # # # # # # # # # # # # # # # # # # # #
visii.initialize_headless()
if not opt.noise is True:
visii.enable_denoiser()
camera = visii.entity.create(name="camera",
transform=visii.transform.create("camera"),
camera=visii.camera.create_perspective_from_fov(
name="camera",
field_of_view=0.785398,
aspect=float(opt.width) / float(opt.height)))
camera.get_transform().look_at(
visii.vec3(0, 0.1, 0.1), # look at (world coordinate)
visii.vec3(0, 0, 1), # up vector
visii.vec3(1, 0.7, 0.2), # camera_origin
)
visii.set_camera_entity(camera)
visii.set_dome_light_intensity(1)
# # # # # # # # # # # # # # # # # # # # # # # # #
# This function loads the obj meshes, it will ignore
# other content like materials
mesh = visii.mesh.create_from_obj("obj", opt.path_obj)
obj_entity = visii.entity.create(
name="obj_entity",
showbelief=opt.showbelief,
P_matrix=P_matrix,
gt_keypoints=gt_keypoints)
# transfer from dope to visii frame
for name in Metric:
temp = Metric[name]['orientation']
if not temp is None:
'''
q_dope = Quaternion(w=temp[3],x=temp[0],y=temp[1],z=temp[2])
q_dope_trans = q_dope * quat_trans_dope_to_visii
Metric[name]['orientation'] = q_dope_trans
'''
rot = visii.quat(temp[3], temp[0], temp[1], temp[2])
if opt.transform_visii:
rot = rot * visii.angleAxis(-1.57, visii.vec3(
0, 0, 1)) * visii.angleAxis(-1.57, visii.vec3(0, 1, 0))
rot.w, rot.x, rot.y, rot.z = rot.w, rot.x, -rot.y, -rot.z
if opt.transform_hope:
rot = rot * visii.angleAxis(1.57, visii.vec3(
1, 0, 0)) * visii.angleAxis(1.57, visii.vec3(0, 0, 1))
Metric[name]['orientation'] = Quaternion(w=rot.w,
x=rot.x,
y=rot.y,
z=rot.z)
# add ground truth
if not opt.real_world:
objects_gt = visii_camera['objects']
for object_gt in objects_gt:
if object_gt['class'] in Metric:
location_gt = np.array(object_gt['location'])
def add_random_obj(name="name"):
# this function adds a random object from the pre loaded meshes
# it will give it a random pose and an random material
obj = visii.entity.create(name=name,
transform=visii.transform.create(name),
material=visii.material.create(name))
obj_id = random.randint(0, 15)
# set the mesh, the meshes can be shared
mesh = visii.mesh.get(f'mesh_{obj_id}')
obj.set_mesh(mesh)
obj.get_transform().set_position(
visii.vec3(random.uniform(-5, 5), random.uniform(-5, 5),
random.uniform(-10, 3)))
obj.get_transform().set_rotation(
visii.quat(random.uniform(0, 1), random.uniform(0, 1),
random.uniform(0, 1), random.uniform(0, 1)))
obj.get_transform().set_scale(
visii.vec3(random.uniform(0.15, 0.2), random.uniform(0.15, 0.2),
random.uniform(0.15, 0.2)))
rgb = colorsys.hsv_to_rgb(random.uniform(0, 1), random.uniform(0.7, 1),
random.uniform(0.7, 1))
obj.get_material().set_base_color(visii.vec3(
rgb[0],
rgb[1],
rgb[2],
))
obj_mat = obj.get_material()
r = random.randint(0, 2)
# This is a simple logic for more natural random materials, e.g.,
# mirror or glass like objects
if r == 0:
# Plastic / mat
obj_mat.set_metallic(0) # should 0 or 1
obj_mat.set_transmission(0) # should 0 or 1
obj_mat.set_roughness(random.uniform(0, 1)) # default is 1
if r == 1:
# metallic
obj_mat.set_metallic(random.uniform(0.9, 1)) # should 0 or 1
obj_mat.set_transmission(0) # should 0 or 1
if r == 2:
# glass
obj_mat.set_metallic(0) # should 0 or 1
obj_mat.set_transmission(random.uniform(0.9, 1)) # should 0 or 1
if r > 0: # for metallic and glass
r2 = random.randint(0, 1)
if r2 == 1:
obj_mat.set_roughness(random.uniform(0, .1)) # default is 1
else:
obj_mat.set_roughness(random.uniform(0.9, 1)) # default is 1
obj_mat.set_sheen(random.uniform(0, 1)) # degault is 0
obj_mat.set_clearcoat(random.uniform(0, 1)) # degault is 0
obj_mat.set_specular(random.uniform(0, 1)) # degault is 0
r = random.randint(0, 1)
if r == 0:
obj_mat.set_anisotropic(random.uniform(0, 0.1)) # degault is 0
else:
obj_mat.set_anisotropic(random.uniform(0.9, 1)) # degault is 0
visii.initialize_interactive()
# visii.initialize_headless()
camera_entity = visii.entity.create(
name="my_camera_entity",
transform=visii.transform.create("my_camera_transform"),
camera=visii.camera.create_perspective_from_fov(name="my_camera",
field_of_view=0.785398,
aspect=1.,
near=.1))
visii.set_camera_entity(camera_entity)
camera_entity.get_transform().set_position(0, 0.0, -5.)
camera_entity.get_camera().use_perspective_from_fov(0.785398, 1.0, .01)
camera_entity.get_camera().set_view(
visii.lookAt(
visii.vec3(0, 0, 30),
visii.vec3(0, 0, 0),
visii.vec3(1, 0, 0),
))
visii.set_dome_light_intensity(0)
# Create floor
floor = visii.entity.create(name="floor",
mesh=visii.mesh.create_plane("floor"),
transform=visii.transform.create("floor"),
material=visii.material.create("floor"))
floor.get_transform().set_scale(1000)
floor.get_material().set_roughness(1.0)
# # # # # # # # # # # # # # # # # # # # # # # # #
# Lets set some objects in the scene
# Create a box that'll act like a room for the objects
room = visii.entity.create(
name="room",
mesh=visii.mesh.create_box('room'),
transform=visii.transform.create("room"),
material=visii.material.create("room"),
)
room.get_transform().set_scale((2, 2, 2))
room.get_transform().set_position((0, 0, 2))
mat = visii.material.get("room")
mat.set_base_color(visii.vec3(0.19, 0.16, 0.19))
mat.set_roughness(1)
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(visii.vec3(0.4, 0, 0.2))
sphere.get_transform().set_scale(visii.vec3(0.2))
sphere.get_material().set_base_color(visii.vec3(0.1, 0.96, 0.4))
sphere.get_material().set_roughness(0.7)
sphere.get_material().set_specular(1)
sphere2 = visii.entity.create(name="sphere2",
mesh=visii.mesh.create_sphere("sphere2"),
transform=visii.transform.create("sphere2"),
if not opt.noise is True:
visii.enable_denoiser()
# Create a camera
# Lets create an entity that will serve as our camera.
camera = visii.entity.create(name="camera",
transform=visii.transform.create("camera"),
camera=visii.camera.create_perspective_from_fov(
name="camera",
field_of_view=0.785398,
aspect=float(opt.width) / float(opt.height)))
# set the view camera transform
camera.get_transform().look_at(
visii.vec3(0, 0, 0), # look at (world coordinate)
visii.vec3(0, 0, 1), # up vector
visii.vec3(10, 0, 5), # camera_origin
)
# set the camera
visii.set_camera_entity(camera)
# Change the dome light intensity
visii.set_dome_light_intensity(1)
# Physics init
seconds_per_step = .01
frames_per_second = 30.0
physicsClient = p.connect(p.DIRECT) # non-graphical version
p.setGravity(0, 0, -10)
p.setTimeStep(seconds_per_step)
saturation=1.0)
# Lets add a sun light
sun = visii.entity.create(name="sun",
mesh=visii.mesh.create_sphere("sphere"),
transform=visii.transform.create("sun"),
light=visii.light.create("sun"))
sun.get_transform().set_position((10, 10, 10))
sun.get_light().set_temperature(5780)
sun.get_light().set_intensity(1000)
floor = visii.entity.create(name="floor",
mesh=visii.mesh.create_plane("floor"),
transform=visii.transform.create("floor"),
material=visii.material.create("floor"))
floor.get_transform().set_position(visii.vec3(0, 0, 0))
floor.get_transform().set_scale(visii.vec3(10))
floor.get_material().set_roughness(0.1)
floor.get_material().set_base_color(visii.vec3(0.5, 0.5, 0.5))
# Set the collision with the floor mesh
# first lets get the vertices
vertices = floor.get_mesh().get_vertices()
# get the position of the object
pos = floor.get_transform().get_position()
pos = [pos[0], pos[1], pos[2]]
scale = floor.get_transform().get_scale()
scale = [scale[0], scale[1], scale[2]]
rot = floor.get_transform().get_rotation()
rot = [rot[0], rot[1], rot[2], rot[3]]
# # # # # # # # # # # # # # # # # # # # # # # # #
visii.initialize_headless()
if not opt.noise is True:
visii.enable_denoiser()
camera = visii.entity.create(name="camera",
transform=visii.transform.create("camera"),
camera=visii.camera.create_perspective_from_fov(
name="camera",
field_of_view=0.785398,
aspect=float(opt.width) / float(opt.height)))
camera.get_transform().look_at(
visii.vec3(0, 0, 1.2), # look at (world coordinate)
visii.vec3(0, 0, 1), # up vector
visii.vec3(1, -1.5, 1.8))
visii.set_camera_entity(camera)
# # # # # # # # # # # # # # # # # # # # # # # # #
# This function loads the
sdb = visii.import_obj(
"sdb", # prefix name
'content/salle_de_bain_separated/salle_de_bain_separated.obj', #obj path
'content/salle_de_bain_separated/', # mtl folder
visii.vec3(1, 0, 0), # translation
visii.vec3(0.1), # scale here
visii.angleAxis(3.14 * .5, visii.vec3(1, 0, 0)) #rotation here
)
obj_entity.get_transform().set_scale((0.2, 0.2, 0.2))
obj_entity.get_transform().set_position((1, 0, 2))
obj_entity.get_transform().look_at(
at=(0, 0, 0),
up=(0, 0, 1),
)
# Lets set some objects in the scene
entity = visii.entity.create(
name="floor",
mesh=visii.mesh.create_plane("mesh_floor"),
transform=visii.transform.create("transform_floor"),
material=visii.material.create("material_floor"))
entity.get_transform().set_scale(visii.vec3(2))
mat = visii.material.get("material_floor")
mat.set_metallic(0)
mat.set_roughness(1)
# # # # # # # # # # # # # # # # # # # # # # # # #
# load the texture
color_tex = visii.texture.create_from_file("color",
'content/Bricks051_2K_Color.jpg')
normal_tex = visii.texture.create_from_file("normal",
'content/Bricks051_2K_Normal.jpg',
linear=True)
rough_tex = visii.texture.create_from_file(
"rough", 'content/Bricks051_2K_Roughness.jpg', linear=True)
visii.initialize(headless = True, verbose = True)
if not opt.noise is True:
visii.enable_denoiser()
camera = visii.entity.create(
name = "camera",
transform = visii.transform.create("camera"),
camera = visii.camera.create(
name = "camera",
aspect = float(opt.width)/float(opt.height)
)
)
camera.get_transform().look_at(
visii.vec3(0,0,0), # look at (world coordinate)
visii.vec3(0,0,1), # up vector
visii.vec3(-2,0,1), # camera_origin
)
visii.set_camera_entity(camera)
# # # # # # # # # # # # # # # # # # # # # # # # #
# lets turn off the ambiant lights
visii.set_dome_light_intensity(0)
tex = visii.texture.create_from_file("tex", "content/gradient.png")
obj_entity = visii.entity.create(
name="light",
if USE_DENOISER is True:
visii.enable_denoiser()
# Create a camera
# Lets create an entity that will serve as our camera.
camera = visii.entity.create(name="camera",
transform=visii.transform.create("camera"),
camera=visii.camera.create_perspective_from_fov(
name="camera",
field_of_view=0.785398,
aspect=float(WIDTH) / float(HEIGHT)))
# set the view camera transform
camera.get_transform().look_at(
visii.vec3(0, 0, 0), # look at (world coordinate)
visii.vec3(1, 0, 0), # up vector
visii.vec3(0, 0, 5), # camera_origin
)
# set the camera
visii.set_camera_entity(camera)
# Change the dome light intensity
visii.set_dome_light_intensity(1)
# # # # # # # # # # # # # # # # # # # # # # # # #
# lets create a random scene, first lets pre load some mesh
# we are going to use the mesh.get() to retrieve the meshes
visii.mesh.create_sphere('mesh_0')
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()
# # # # # # # # # # # # # # # # # # # # # # # # #
visii.initialize_headless()
if not opt.noise is True:
visii.enable_denoiser()
camera = visii.entity.create(name="camera",
transform=visii.transform.create("camera"),
camera=visii.camera.create_perspective_from_fov(
name="camera",
field_of_view=0.785398,
aspect=float(opt.width) / float(opt.height)))
camera.get_transform().look_at(
visii.vec3(0, 0, 0), # look at (world coordinate)
visii.vec3(0, 0, 1), # up vector
visii.vec3(-2, 0, 1), # camera_origin
)
visii.set_camera_entity(camera)
# # # # # # # # # # # # # # # # # # # # # # # # #
# lets turn off the ambiant lights
visii.set_dome_light_intensity(0)
tex = visii.texture.create_from_image("tex", "content/gradient.png")
obj_entity = visii.entity.create(
name="light",
mesh=visii.mesh.create_plane('light'),
def add_cuboid(name, debug=False):
"""
Add cuboid children to the transform tree to a given object for exporting
:param name: string name of the visii entity to add a cuboid
:param debug: bool - add sphere on the visii entity to make sure the
cuboid is located at the right place.
:return: return a list of cuboid in canonical space of the object.
"""
obj = visii.entity.get(name)
min_obj = obj.get_mesh().get_min_aabb_corner()
max_obj = obj.get_mesh().get_max_aabb_corner()
centroid_obj = obj.get_mesh().get_aabb_center()
cuboid = [
visii.vec3(max_obj[0], max_obj[1], max_obj[2]),
visii.vec3(min_obj[0], max_obj[1], max_obj[2]),
visii.vec3(max_obj[0], min_obj[1], max_obj[2]),
visii.vec3(max_obj[0], max_obj[1], min_obj[2]),
visii.vec3(min_obj[0], min_obj[1], max_obj[2]),
visii.vec3(max_obj[0], min_obj[1], min_obj[2]),
visii.vec3(min_obj[0], max_obj[1], min_obj[2]),
visii.vec3(min_obj[0], min_obj[1], min_obj[2]),
visii.vec3(centroid_obj[0], centroid_obj[1], centroid_obj[2]),
]
dimensions_dict = {
'width': max_obj[0] - min_obj[0],
'height': max_obj[1] - min_obj[1],
'length': max_obj[2] - min_obj[2]
}
with open(opt.out + "dimensions.json", "w+") as fp:
json.dump(dimensions_dict, fp, indent=4, sort_keys=True)
# change the ids to be like ndds / DOPE
cuboid = [
cuboid[2], cuboid[0], cuboid[3], cuboid[5], cuboid[4], cuboid[1],
cuboid[6], cuboid[7], cuboid[-1]
]
cuboid.append(visii.vec3(centroid_obj[0], centroid_obj[1],
centroid_obj[2]))
for i_p, p in enumerate(cuboid):
child_transform = visii.transform.create(f"{name}_cuboid_{i_p}")
child_transform.set_position(p)
child_transform.set_scale(visii.vec3(0.3))
child_transform.set_parent(obj.get_transform())
if debug:
visii.entity.create(
name=f"{name}_cuboid_{i_p}",
mesh=visii.mesh.create_sphere(f"{name}_cuboid_{i_p}"),
transform=child_transform,
material=visii.material.create(f"{name}_cuboid_{i_p}"))
for i_v, v in enumerate(cuboid):
cuboid[i_v] = [v[0], v[1], v[2]]
return cuboid
# # # # # # # # # # # # # # # # # # # # # # # # #
visii.initialize_headless()
if not opt.noise is True:
visii.enable_denoiser()
camera = visii.entity.create(name="camera",
transform=visii.transform.create("camera"),
camera=visii.camera.create_perspective_from_fov(
name="camera",
field_of_view=0.785398,
aspect=float(opt.width) / float(opt.height)))
camera.get_transform().look_at(
visii.vec3(0, 0, 0), # look at (world coordinate)
visii.vec3(0, 0, 1), # up vector
visii.vec3(-2, 0, 2), # camera_origin
)
visii.set_camera_entity(camera)
# # # # # # # # # # # # # # # # # # # # # # # # #
# Lets use noise package to create a 2d perlin noise
# texture
shape = (1024, 1024)
img = np.zeros(shape)
for i in range(shape[0]):
for j in range(shape[1]):
os.add_dll_directory(os.path.join(os.getcwd(), '..', 'install'))
sys.path.append(os.path.join(os.getcwd(), "..", "install"))
import visii
# %%
visii.initialize_interactive()
# %%
camera_entity = visii.entity.create(
name="my_camera_entity",
transform=visii.transform.create("my_camera_transform"),
camera=visii.camera.create_perspective_from_fov(name = "my_camera", field_of_view = 0.785398, aspect = 1., near = .1))
visii.set_camera_entity(camera_entity)
camera_entity.get_transform().set_position(0, 0.0, -5.)
camera_entity.get_camera().use_perspective_from_fov(0.785398, 1.0, .01)
camera_entity.get_camera().set_view(
visii.lookAt(
visii.vec3(2,2,2),
visii.vec3(0,0,.5),
visii.vec3(0,0,1),
)
)
# %%
tex = visii.texture.create("texture")
# %%
visii.set_dome_light_texture(tex)
# %%
# # # # # # # # # # # # # # # # # # # # # # # # #
visii.initialize_headless()
if not opt.noise is True:
visii.enable_denoiser()
camera = visii.entity.create(name="camera",
transform=visii.transform.create("camera"),
camera=visii.camera.create_perspective_from_fov(
name="camera",
field_of_view=0.785398,
aspect=float(opt.width) / float(opt.height)))
camera.get_transform().look_at(
visii.vec3(0, 0.1, 0.1), # look at (world coordinate)
visii.vec3(0, 0, 1), # up vector
visii.vec3(0, 3.0, 0.2), # camera_origin
)
visii.set_camera_entity(camera)
visii.set_dome_light_intensity(1)
# # # # # # # # # # # # # # # # # # # # # # # # #
floor = visii.entity.create(
name="floor",
mesh=visii.mesh.create_plane("floor", size=visii.vec2(10, 10)),
material=visii.material.create("floor",
base_color=visii.vec3(.5, .5, .5),
roughness=0.0,
if not opt.noise is True:
visii.enable_denoiser()
camera = visii.entity.create(
name = "camera",
transform = visii.transform.create("camera"),
camera = visii.camera.create_perspective_from_fov(
name = "camera",
field_of_view = 0.785398,
aspect = float(opt.width)/float(opt.height)
)
)
camera.get_transform().look_at(
visii.vec3(0,0,0), # look at (world coordinate)
visii.vec3(0,0,1), # up vector
visii.vec3(0,1,1)
)
visii.set_camera_entity(camera)
# # # # # # # # # # # # # # # # # # # # # # # # #
floor = visii.entity.create(
name="floor",
mesh = visii.mesh.create_plane("floor"),
transform = visii.transform.create("floor"),
material = visii.material.create("floor")
)
floor.get_transform().set_scale(visii.vec3(100))
material=v.material.create("floor"))
#%%
mesh1 = v.entity.create(name="mesh1",
mesh=v.mesh.create_from_obj("mesh2",
"../data/dragon.obj"),
transform=v.transform.create("mesh1"),
material=v.material.create("mesh1"))
#%%
mesh2 = v.entity.create(name="mesh2",
mesh=v.mesh.create_sphere("sphere2"),
transform=v.transform.create("mesh2"),
material=v.material.create("mesh2"))
# %%
mesh1.get_transform().set_scale(v.vec3(4))
mesh1.get_transform().set_rotation(v.angleAxis(1.57, v.vec3(1, 0, 0)))
mesh1.get_transform().set_position(v.vec3(0, 0, 1.0))
#%%
areaLight1 = v.entity.create(
name="areaLight1",
light=v.light.create("areaLight1"),
transform=v.transform.create("areaLight1"),
mesh=v.mesh.create_sphere("areaLight1"),
)
# %%
areaLight1.get_transform().set_scale(v.vec3(.25))
#%%
floor.get_transform().set_scale(v.vec3(1000))
mesh1.get_transform().set_scale(v.vec3(.5))
opt.out = '15_camera_motion_car_blur.png'
opt.control = True
# # # # # # # # # # # # # # # # # # # # # # # # #
visii.initialize()
visii.set_dome_light_intensity(.8)
visii.resize_window(int(opt.width), int(opt.height))
# # # # # # # # # # # # # # # # # # # # # # # # #
# load the textures
dome = visii.texture.create_from_file("dome", "content/teatro_massimo_2k.hdr")
# we can add HDR images to act as dome
visii.set_dome_light_texture(dome)
visii.set_dome_light_rotation(
visii.angleAxis(visii.pi() * .5, visii.vec3(0, 0, 1)))
car_speed = 0
car_speed_x = car_speed
car_speed_y = -2 * car_speed
camera_height = 80
# # # # # # # # # # # # # # # # # # # # # # # # #
if not opt.noise is True:
visii.enable_denoiser()
camera = visii.entity.create(name="camera",
transform=visii.transform.create("camera"),
camera=visii.camera.create(
name="camera",
def scaleLight(sx=1, sy=1., sz=1):
areaLight1.get_transform().set_scale(v.vec3(sx, sy, sz))
# Lets add a camera component to the entity
camera.set_camera(
visii.camera.create_perspective_from_fov(
name = "camera_camera",
field_of_view = 0.785398,
aspect = float(WIDTH)/float(HEIGHT)
)
)
# visii can only use one camera at the time
visii.set_camera_entity(camera)
# Lets place our camera to look at the scene
# all the position are defined by visii.vector3
camera.get_transform().set_position(
visii.vec3(0, 5, 1)
)
# Lets set the view camera, we only offer look_at
camera.get_transform().look_at(
visii.vec3(0,0,0.9), # at
visii.vec3(0,0,1), # up vector
)
# Lets at a floor
visii.entity.create(
name = "floor",
mesh = visii.mesh.create_plane("mesh_floor"),
transform = visii.transform.create("transform_floor"),
material = visii.material.create("material_floor")
)
def moveCamera(x=3, y=3, z=2):
camera_entity.get_transform().look_at(
v.vec3(0, 0, 2.0),
v.vec3(0, 0, 1),
v.vec3(x, y, z),
)
opt.noise = False
opt.out = '15_camera_motion_car_blur.png'
opt.control = True
# # # # # # # # # # # # # # # # # # # # # # # # #
visii.initialize()
visii.set_dome_light_intensity(.8)
visii.resize_window(int(opt.width), int(opt.height))
# # # # # # # # # # # # # # # # # # # # # # # # #
# load the textures
dome = visii.texture.create_from_file("dome", "content/teatro_massimo_2k.hdr")
# we can add HDR images to act as dome
visii.set_dome_light_texture(dome)
visii.set_dome_light_rotation(visii.angleAxis(visii.pi() * .5, visii.vec3(0, 0, 1)))
car_speed = 0
car_speed_x = car_speed
car_speed_y = -2 * car_speed
camera_height = 80
# # # # # # # # # # # # # # # # # # # # # # # # #
if not opt.noise is True:
visii.enable_denoiser()
camera = visii.entity.create(
name = "camera",
transform = visii.transform.create("camera"),
camera = visii.camera.create(
