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 load_points_from_obj(obj_path):
from glumpy import data
assert os.path.exists(obj_path), 'Path does not exist: {}'.format(obj_path)
vertices, indices = data.objload("{}".format(obj_path), rescale=True)
vertices['position'] = vertices['position'] / 10.
points = np.array(vertices['position'])
return points
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 load_points_from_obj():
from glumpy import app, gl, gloo, glm, data, log
model_path = os.path.join(
cur_dir,
"../data/ModelNet/ModelNet40/airplane/train/airplane_0005.obj")
vertices, indices = data.objload("{}".format(model_path), rescale=True)
vertices["position"] = vertices["position"] / 10.0
points = np.array(vertices["position"])
print(type(points))
print(points.shape, points.min(0), points.max(0),
points.max(0) - points.min(0))
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 _load_object_points_diameters(self):
points = {}
diameters = {}
# print(self.classes)
for cls_idx, cls_name in enumerate(self.classes):
base_cls_name = cls_name.split("/")[-1]
set = "train" if self.phase == "train" else "test"
base_cns = base_cls_name.split("_")
if len(base_cns) == 3:
obj_file = os.path.join(
self._modelnet_path,
"ModelNet40",
base_cns[0] + "_" + base_cns[1],
set,
"{}.obj".format(base_cls_name),
)
elif len(base_cns) == 2:
obj_file = os.path.join(
self._modelnet_path,
"ModelNet40",
base_cns[0],
set,
"{}.obj".format(base_cls_name),
)
else:
raise Exception(
"problem with base_cls_name: {}".format(base_cls_name))
assert os.path.exists(obj_file), "Path does not exist: {}".format(
obj_file)
vertices, indices = data.objload("{}".format(obj_file),
rescale=True)
vertices["position"] = vertices["position"] / 10.0
points[cls_name] = np.array(vertices["position"])
extent = points[cls_name].max(0) - points[cls_name].min(0)
diameters[cls_name] = np.linalg.norm(extent)
return points, diameters
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)
