def __init__(self, model_folder, K, width=640, height=480, zNear=0.25, zFar=6.0):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder = model_folder
log.info("Loading mesh")
vertices, indices = data.objload("{}/textured.obj"
.format(model_folder), rescale=False)
self.render_kernel = gloo.Program(vertex, fragment)
self.render_kernel.bind(vertices)
log.info("Loading texture")
self.render_kernel['u_texture'] = np.copy(data.load("{}/texture_map.png"
.format(model_folder))[::-1, :, :])
self.render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear, zFar)
self.render_kernel['u_projection'] = np.copy(u_projection)
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
global trans
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernel.draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def __init__(self,
model_folder,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder = model_folder
self.rgb_buffer = np.zeros((self.height, self.width, 4),
dtype=np.float32)
self.depth_buffer = np.zeros((self.height, self.width),
dtype=np.float32)
log.info("Loading mesh")
vertices, indices = data.objload(
"{}/textured.obj".format(model_folder), rescale=False)
self.render_kernel = gloo.Program(self.vertex, self.fragment)
self.render_kernel.bind(vertices)
log.info("Loading texture")
self.render_kernel["u_texture"] = np.copy(
data.load("{}/texture_map.png".format(model_folder))[::-1, :, :])
self.render_kernel["u_model"] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
self.render_kernel["u_projection"] = np.copy(u_projection)
self.window = app.Window(width=width, height=height, visible=False)
print("self.window: ", self.window)
print("self.render_kernel at init: ", self.render_kernel)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernel.draw(gl.GL_TRIANGLES)
gl.glReadPixels(0, 0, self.width, self.height, gl.GL_RGBA,
gl.GL_FLOAT, self.rgb_buffer)
gl.glReadPixels(
0,
0,
self.width,
self.height,
gl.GL_DEPTH_COMPONENT,
gl.GL_FLOAT,
self.depth_buffer,
)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def __init__(
self,
model_path,
texture_path,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0,
brightness_ratios=[0.7],
):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_path = model_path
log.info("Loading mesh")
vertices, indices = data.objload("{}".format(model_path), rescale=True)
vertices["position"] = vertices["position"] / 10.0
self.render_kernels = []
for brightness_ratio in brightness_ratios:
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading texture")
render_kernel["u_texture"] = np.copy(
data.load("{}".format(texture_path))[::-1, :, :])
render_kernel["u_model"] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
render_kernel["u_projection"] = np.copy(u_projection)
render_kernel["u_light_intensity"] = 1, 1, 1
self.render_kernels.append(render_kernel)
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
# print('brightness_k', self.brightness_k) # this function runs when running app.run()
self.render_kernels[self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def __init__(self, class_name_list, model_folder_dict, K, width=640, height=480, zNear=0.25, zFar=6.0, brightness_ratios=[0.4, 0.3, 0.2]):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder_dict = model_folder_dict
self.class_name_list = class_name_list
self.render_kernels = {} # self.render_kernels[class_name][brightness_ratio]
for cls_name in class_name_list:
if cls_name == "__background__":
continue
model_folder = model_folder_dict[cls_name]
log.info("Loading mesh")
vertices, indices = data.objload("{}/textured.obj"
.format(model_folder), rescale=False)
if not cls_name in self.render_kernels.keys():
self.render_kernels[cls_name] = []
for brightness_ratio in brightness_ratios:
print('class_name: {}, brightness_ratio: {}, model_folder: {}'.format(cls_name, brightness_ratio,
model_folder))
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading texture")
render_kernel['u_texture'] = np.copy(data.load("{}/texture_map.png"
.format(model_folder))[::-1, :, :])
render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear, zFar)
render_kernel['u_projection'] = np.copy(u_projection)
render_kernel['u_light_intensity'] = 1, 1, 1
self.render_kernels[cls_name].append(render_kernel)
self.class_name = class_name_list[-1]
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
# print('brightness_k', self.brightness_k) # this function runs when running app.run()
self.render_kernels[self.class_name][self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def __init__(self,
model_folder,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0,
brightness_ratios=[0.4, 0.3, 0.2]):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder = model_folder
log.info("Loading brain mesh")
vertices, indices = data.objload(
"{}/textured.obj".format(model_folder), rescale=False)
self.render_kernels = []
for brightness_ratio in brightness_ratios:
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading brain texture")
render_kernel['u_texture'] = np.copy(
data.load(
"{}/texture_map.png".format(model_folder))[::-1, :, :])
render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
render_kernel['u_projection'] = np.copy(u_projection)
render_kernel['u_light_intensity'] = 1, 1, 1
self.render_kernels.append(render_kernel)
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernels[self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def __init__(self, model_path_list, texture_path, K, width=640, height=480, zNear=0.25, zFar=6.0, brightness_ratios=[0.7]):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_path_list = model_path_list
self.model_path = model_path_list[0]
self.render_kernels = {model_path: [] for model_path in model_path_list}
log.info("Loading mesh")
for model_i, model_path in enumerate(model_path_list):
print('loading model: {}/{}, {}'.format(model_i+1, len(model_path_list), model_path))
vertices, indices = data.objload("{}"
.format(model_path), rescale=True)
vertices['position'] = vertices['position'] / 10.
for brightness_ratio in brightness_ratios:
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading texture")
render_kernel['u_texture'] = np.copy(data.load("{}"
.format(texture_path))[::-1, :, :])
render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear, zFar)
render_kernel['u_projection'] = np.copy(u_projection)
render_kernel['u_light_intensity'] = 1, 1, 1
self.render_kernels[model_path].append(render_kernel)
print('************Finish loading models in Render_Py_Light_ModelNet_Multi********************')
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernels[self.model_path][self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def __init__(self,
model_dir,
classes,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_dir = model_dir
self.rgb_buffer = np.zeros((self.height, self.width, 4),
dtype=np.float32)
self.depth_buffer = np.zeros((self.height, self.width),
dtype=np.float32)
log.info("Loading mesh")
self.render_kernel_list = [[] for cls in classes]
self.classes = classes
self.cls_idx = 0
for class_id, cur_class in enumerate(classes):
model_folder = os.path.join(model_dir, cur_class)
print("Loading {}".format(model_folder))
vertices, indices = data.objload(
"{}/textured.obj".format(model_folder), rescale=False)
render_kernel = gloo.Program(self.vertex, self.fragment)
render_kernel.bind(vertices)
log.info("Loading texture")
render_kernel["u_texture"] = np.copy(
data.load(
"{}/texture_map.png".format(model_folder))[::-1, :, :])
render_kernel["u_model"] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
render_kernel["u_projection"] = np.copy(u_projection)
self.render_kernel_list[class_id] = render_kernel
print("************Finish loading models*************")
self.window = app.Window(width=width, height=height, visible=False)
print("self.window: ", self.window)
print("self.render_kernel at init: ", self.render_kernel_list)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernel_list[self.cls_idx].draw(gl.GL_TRIANGLES)
gl.glReadPixels(0, 0, self.width, self.height, gl.GL_RGBA,
gl.GL_FLOAT, self.rgb_buffer)
gl.glReadPixels(0, 0, self.width, self.height,
gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT,
self.depth_buffer)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
if (lambertian > 0.0)
{
vec3 view_direction = normalize(-v_position);
vec3 half_direction = normalize(light_direction + view_direction);
float specular_angle = max(dot(half_direction, normal), 0.0);
specular = pow(specular_angle, shininess);
}
vec3 color_linear = ambient_color +
lambertian * diffuse_color +
specular * specular_color;
vec3 color_gamma = pow(color_linear, vec3(1.0/gamma));
gl_FragColor = vec4(color_gamma, 1.0);
}
"""
log.info("Loading brain mesh")
vertices,indices = data.get("brain.obj")
brain = gloo.Program(vertex, fragment)
brain.bind(vertices)
trackball = Trackball(Position("position"))
brain['transform'] = trackball
trackball.theta, trackball.phi, trackball.zoom = 80, -135, 15
window = app.Window(width=1024, height=768)
def update():
model = brain['transform']['model'].reshape(4,4)
view = brain['transform']['view'].reshape(4,4)
brain['m_view'] = view
brain['m_model'] = model
brain['m_normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
if (lambertian > 0.0)
{
vec3 view_direction = normalize(-v_position);
vec3 half_direction = normalize(light_direction + view_direction);
float specular_angle = max(dot(half_direction, normal), 0.0);
specular = pow(specular_angle, shininess);
}
vec3 color_linear = ambient_color +
lambertian * diffuse_color +
specular * specular_color;
vec3 color_gamma = pow(color_linear, vec3(1.0/gamma));
gl_FragColor = vec4(color_gamma, 1.0);
}
"""
log.info("Loading brain mesh")
vertices, indices = data.get("brain.obj")
brain = gloo.Program(vertex, fragment)
brain.bind(vertices)
trackball = Trackball(Position("position"))
brain['transform'] = trackball
trackball.theta, trackball.phi, trackball.zoom = 80, -135, 15
window = app.Window(width=1024, height=768)
def update():
model = brain['transform']['model'].reshape(4, 4)
view = brain['transform']['view'].reshape(4, 4)
brain['m_view'] = view
brain['m_model'] = model
