def load_image(image_file_path):
global last_rect, curr_rect, program, face_cascade, tar_pos, tar_scale, t, last_img, curr_img, last_asp, curr_asp
last_img = curr_img
curr_img = data.load(image_file_path)
asp = curr_img.shape[1] / curr_img.shape[0]
last_asp = curr_asp
print('image asp: {}'.format(asp))
if asp > 1:
curr_asp = (asp, 1)
else:
curr_asp = (1, 1 / asp)
gray = cv2.cvtColor(curr_img, cv2.COLOR_RGB2GRAY)
faces = face_cascade.detectMultiScale(gray,
scaleFactor=1.15,
minNeighbors=5,
minSize=(5, 5))
last_rect = curr_rect
if len(faces) > 0:
curr_rect = faces[0]
if last_rect is not None:
cx = curr_rect[0] + curr_rect[2] / 2
cy = curr_rect[1] + curr_rect[3] / 2
tar_pos = map_coord([cx, cy], curr_img.shape[1::-1])
tar_scale = curr_rect[2] / last_rect[2]
# rest t.
t = 0
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 load_image2(image_file_path):
image = data.load(image_file_path)
if image is None:
print('load image failed, path: ' + image_file_path)
return None
print('image: {}, shape: {}'.format(image_file_path, image.shape))
img_info = {}
img_info['image'] = image
img_info['image_rect'] = normalized_image_vertices(image.shape)
img_info['face_rect'] = detect_face(image)
return img_info
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)
varying vec2 v_texcoord;
void main() {
v_texcoord = (position+1.0)/2.0;
gl_Position = vec4(position.xy, 0.0, 1.0);
}
"""
fragment = """
uniform sampler2D u_texture;
varying vec2 v_texcoord;
void main()
{
gl_FragColor = texture2D(u_texture, v_texcoord);
}
"""
window = app.Window(width=512, height=512, color=(1, 1, 1, 1))
@window.event
def on_draw(dt):
window.clear()
polygon.draw(gl.GL_TRIANGLE_FAN)
P = np.zeros((1+64,2), dtype=np.float32)
T = np.linspace(0,2*np.pi, len(P)-1, endpoint = True)
P[1:,0], P[1:,1] = 0.95*np.cos(T), 0.95*np.sin(T)
polygon = gloo.Program(vertex, fragment, count=len(P))
polygon["position"] = P
polygon['u_texture'] = data.load("wave.png")
app.run()
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)
