def makeObj(path=''):
## Load SMPL model (here we load the female model)
## Make sure path is correct
m = load_model('../models/basicmodel_m_lbs_10_207_0_v1.0.0.pkl')
if path != '':
m3 = pickle.load(open(path, 'rb'), encoding='iso-8859-1')
m.pose[:] = m3['pose']
m.betas[:] = m3['betas']
else:
# Assign random pose and shape parameters
m.pose[:] = np.random.rand(m.pose.size) * .2
m.betas[:] = np.random.rand(m.betas.size) * .03
## Write to an .obj file
outmesh_path = './hello_smpl.obj'
with open(outmesh_path, 'w') as fp:
for v in m.r:
fp.write('v %f %f %f\n' % (v[0], v[1], v[2]))
for f in m.f + 1: # Faces are 1-based, not 0-based in obj files
fp.write('f %d %d %d\n' % (f[0], f[1], f[2]))
## Print message
print('..Output mesh saved to: ', outmesh_path)
def run_rec():
# This is where we write the images, if an output_dir is given
# in command line:
out_dir = None
# Now read in the image data. This must be a valid path!
[X, y] = read_images('images')
# Then set up a handler for logging:
handler = logging.StreamHandler(sys.stdout)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
# Add handler to facerec modules, so we see what's going on inside:
logger = logging.getLogger("facerec")
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
# Define the Fisherfaces as Feature Extraction method:
feature = Fisherfaces()
# Define a 1-NN classifier with Euclidean Distance:
classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1)
# Define the model as the combination
my_model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
my_model.compute(X, y)
# We then save the model, which uses Pythons pickle module:
save_model('model.pkl', my_model)
model = load_model('model.pkl')
# Then turn the first (at most) 16 eigenvectors into grayscale
# images (note: eigenvectors are stored by column!)
#E = []
#for i in xrange(min(model.feature.eigenvectors.shape[1], 16)):
# e = model.feature.eigenvectors[:,i].reshape(X[0].shape)
# E.append(minmax_normalize(e,0,255, dtype=np.uint8))
# Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf"
#subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png")
# Perform a 10-fold cross validation
cv = KFoldCrossValidation(model, k=10)
cv.validate(X, y)
# And print the result:
cv.print_results()
im = Image.open('search.png')
im = im.convert("L")
predicted_label = model.predict(im)[0]
print(predicted_label)
return predicted_label
def run_rec():
# This is where we write the images, if an output_dir is given
# in command line:
out_dir = None
# Now read in the image data. This must be a valid path!
[X,y] = read_images('images')
# Then set up a handler for logging:
handler = logging.StreamHandler(sys.stdout)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
# Add handler to facerec modules, so we see what's going on inside:
logger = logging.getLogger("facerec")
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
# Define the Fisherfaces as Feature Extraction method:
feature = Fisherfaces()
# Define a 1-NN classifier with Euclidean Distance:
classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1)
# Define the model as the combination
my_model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
my_model.compute(X, y)
# We then save the model, which uses Pythons pickle module:
save_model('model.pkl', my_model)
model = load_model('model.pkl')
# Then turn the first (at most) 16 eigenvectors into grayscale
# images (note: eigenvectors are stored by column!)
#E = []
#for i in xrange(min(model.feature.eigenvectors.shape[1], 16)):
# e = model.feature.eigenvectors[:,i].reshape(X[0].shape)
# E.append(minmax_normalize(e,0,255, dtype=np.uint8))
# Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf"
#subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png")
# Perform a 10-fold cross validation
cv = KFoldCrossValidation(model, k=10)
cv.validate(X, y)
# And print the result:
cv.print_results()
im = Image.open('search.png')
im = im.convert("L")
predicted_label = model.predict(im)[0]
print(predicted_label)
return predicted_label
sys.path.insert(0, '/data/Guha/GR/code/GR19/smpl/smpl_webuser')
sys.path.insert(0, '/data/Guha/GR/code/GR19/smpl/models')
import shutil
import os
import numpy as np
import myUtil
from opendr.renderer import ColoredRenderer
from opendr.lighting import LambertianPointLight
from opendr.camera import ProjectPoints
from serialization import load_model
import cv2
############################ Use SMPL python library packages to instantiate SMPL body model ############
## Load SMPL model (here we load the female model)
m1 = load_model('/data/Guha/GR/code/GR19/smpl/models/basicModel_m_lbs_10_207_0_v1.0.0.pkl')
m1.betas[:] = np.random.rand(m1.betas.size) * .03
m2 = load_model('/data/Guha/GR/code/GR19/smpl/models/basicModel_m_lbs_10_207_0_v1.0.0.pkl')
m2.betas[:] = np.random.rand(m2.betas.size) * .03
## Create OpenDR renderer
rn1 = ColoredRenderer()
rn2 = ColoredRenderer()
## Assign attributes to renderer
w, h = (640, 480)
rn1.camera = ProjectPoints(v=m1, rt=np.zeros(3), t=np.array([0, 0, 2.]), f=np.array([w, w]) / 2.,
c=np.array([w, h]) / 2., k=np.zeros(5))
rn1.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h}
rn1.set(v=m1, f=m1.f, bgcolor=np.zeros(3))
logger = logging.getLogger("facerec")
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
# Define the Fisherfaces as Feature Extraction method:
feature = SpatialHistogram()
#feature = Fisherfaces()
# Define a 1-NN classifier with Euclidean Distance:
classifier = NearestNeighbor(dist_metric=NormalizedCorrelation(), k=1)
#classifier = SVM()
# Define the model as the combination
my_model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
my_model.compute(X, y)
# We then save the model, which uses Pythons pickle module:
save_model('modelTry.pkl', my_model)
model = load_model('modelTry.pkl')
# Then turn the first (at most) 16 eigenvectors into grayscale
# images (note: eigenvectors are stored by column!)
E = []
#for i in range(min(model.feature.eigenvectors.shape[1], 16)):
# e = model.feature.eigenvectors[:,i].reshape(X[0].shape)
# E.append(minmax_normalize(e,0,255, dtype=np.uint8))
# Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf"
subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png")
# Perform a 10-fold cross validation
cv = KFoldCrossValidation(model, k=10)
cv.validate(X, y)
# And print the result:
cv.print_results()
print('mesh saved to: ', filepath)
# -------------- modify this part accordingly -----------------------
dataset_path = '/home/zhixuan/data1/HUMBI/HUMBI_uploaded/Body_81_140'
subject = 82
frame = 1
outmesh_path = './smpl_mesh.obj'
model_path = '../../models/basicModel_neutral_lbs_10_207_0_v1.0.0.pkl'
# -------------------------------------------------------------------
val = np.loadtxt(
'{}/subject_{}/body/{:08d}/reconstruction/smpl_parameter.txt'.format(
dataset_path, subject, frame))
scale = val[0]
trans = val[1:4]
m = load_model(model_path)
m.pose[:] = val[4:76]
m.betas[:] = val[76:]
[v, Jtr] = _verts_core(m.pose,
m.v_posed,
m.J,
m.weights,
m.kintree_table,
want_Jtr=True,
xp=ch)
Jtr = Jtr * scale + trans
v = v * scale + trans
write_simple_obj(mesh_v=v, mesh_f=m.f, filepath=outmesh_path)
import pandas as pd
import pickle
from fractions import gcd
import math
import random
import transformations
from opendr.renderer import ColoredRenderer
from opendr.lighting import LambertianPointLight
from opendr.camera import ProjectPoints
from serialization import load_model
import h5py
import cv2
import transformations
## Load SMPL model (here we load the female model)
m = load_model('models/basicmodel_m_lbs_10_207_0_v1.0.0.pkl')
import pickle
import numpy as np
import os
expmtname = 'expname'
dataset_type = 'Final'
os.mkdir('VISUALIZATION')
os.mkdir('VISUALIZATION/' + expmtname)
os.mkdir('VISUALIZATION/' + expmtname + '/INPUT/')
os.mkdir('VISUALIZATION/' + expmtname + '/OUTPUT/')
os.mkdir('VISUALIZATION/' + expmtname + '/TOGETHER/')
gt = pickle.load(open('dataset/test.p', "rb"))
pred = pickle.load(open('results/preds.p', "rb"))
def run(results_root, split, frame_nb, frame_start, z_min, z_max, texture_zoom,
texture_type, render_body, background_datasets, ambiant_mean,
ambiant_add, grasp_folder, grasp_split_path, min_obj_ratio, _config,
obj_tex_datasets, random_obj_textures, grasp_nb, lsun_path,
smpl_data_path, smpl_model_path, mano_right_path, shapenet_root,
imagenet_path):
print(_config)
scene = bpy.data.scenes['Scene']
# Clear default scene cube
bpy.ops.object.delete()
# Set results folders
folder_meta = os.path.join(results_root, 'meta')
folder_rgb = os.path.join(results_root, 'rgb')
folder_segm = os.path.join(results_root, 'segm')
folder_temp_segm = os.path.join(results_root, 'tmp_segm')
folder_depth = os.path.join(results_root, 'depth')
folders = [
folder_meta, folder_rgb, folder_segm, folder_temp_segm, folder_depth
]
folder_rgb_hand = os.path.join(results_root, 'rgb_hand')
folder_rgb_obj = os.path.join(results_root, 'rgb_obj')
folder_depth_hand = os.path.join(results_root, 'depth_hand')
folder_depth_obj = os.path.join(results_root, 'depth_obj')
folders.extend([folder_rgb_hand, folder_rgb_obj])
# Create results directories
for folder in folders:
os.makedirs(folder, exist_ok=True)
# Load smpl2mano correspondences
right_smpl2mano = np.load('assets/models/smpl2righthand_verts.npy')
# Load SMPL+H model and grasp infos
ncomps = 45
grasp_info = read_grasp_folder(
grasp_folder=grasp_folder,
shapenet_root=shapenet_root,
split_path=grasp_split_path,
split=split,
filter_angle=94,
grasp_nb=grasp_nb,
mano_path=mano_right_path,
obj_models='shapenet',
use_cache=True)
print('Loaded grasp info for {} grasps'.format(len(grasp_info)))
smplh_model = smplh_load_model(
smpl_model_path, ncomps=2 * ncomps, flat_hand_mean=True)
mano_model = load_model(mano_right_path)
mano_mesh = bpy.data.meshes.new('Mano')
mano_mesh.from_pydata(list(np.array(mano_model.r)), [], list(mano_model.f))
mano_obj = bpy.data.objects.new('Mano', mano_mesh)
bpy.context.scene.objects.link(mano_obj)
mano_obj.hide_render = True
print('Loaded mano model')
camutils.set_camera()
backgrounds = imageutils.get_image_paths(
background_datasets, split=split, lsun_path=lsun_path,
imagenet_path=imagenet_path)
print('Got {} backgrounds'.format(len(backgrounds)))
# Get full body textures
body_textures = imageutils.get_bodytexture_paths(
texture_type, split=split, lsun_path=lsun_path, imagenet_path=imagenet_path)
print('Got {} body textures'.format(len(body_textures)))
obj_textures = imageutils.get_image_paths(
obj_tex_datasets,
split=split,
shapenet_folder=shapenet_root,
lsun_path=lsun_path,
imagenet_path=imagenet_path)
print('Got {} object textures'.format(len(obj_textures)))
print('Finished loading textures')
# Load smpl info
smpl_data = np.load(smpl_data_path)
smplh_verts, faces = smplh_model.r, smplh_model.f
smplh_obj = mesh_manip.load_smpl()
# Smooth the edges of the body model
bpy.ops.object.shade_smooth()
# Set camera rendering params
scene.render.resolution_x = 256
scene.render.resolution_y = 256
scene.render.resolution_percentage = 100
# Get camera info
cam_calib = np.array(camutils.get_calib_matrix())
cam_extr = np.array(camutils.get_extrinsic())
scs, materials, sh_path = texturing.initialize_texture(
smplh_obj, texture_zoom=texture_zoom, tmp_suffix='tmp')
# Create object material if none is present
print('Starting loop !')
for i in range(frame_nb):
frame_idx = i + frame_start
np.random.seed(frame_idx)
random.seed(frame_idx)
tmp_files = [] # Keep track of temporary files to delete at the end
grasp = random.choice(grasp_info)
if 'mano_trans' in grasp:
mano_model.trans[:] = [val for val in grasp['mano_trans']]
else:
mano_model.trans[:] = grasp['hand_trans']
mano_model.pose[:] = grasp['hand_pose']
mesh_manip.alter_mesh(mano_obj, mano_model.r.tolist())
smplh_verts, posed_model, meta_info = mesh_manip.randomized_verts(
smplh_model,
smpl_data,
ncomps=2 * ncomps,
z_min=z_min,
z_max=z_max,
side='right',
hand_pose=grasp['pca_pose'],
hand_pose_offset=0,
random_shape=False,
random_pose=True,
split=split)
# Center mesh on center_idx
mesh_manip.alter_mesh(smplh_obj, smplh_verts.tolist())
# Load object
obj_path = grasp['obj_path']
obj = load_obj_model(obj_path)
obj_scale = float(grasp['sample_scale']) / 1000
obj.scale = (obj_scale, obj_scale, obj_scale)
obj.rotation_euler = (0, 0, 0)
bpy.ops.object.shade_smooth()
model_name = obj.name
obj_mesh = bpy.data.meshes[model_name]
obj_scs = []
# Create object material if none is present
materials_tmp = []
if len(obj_mesh.materials) == 0:
mat = bpy.data.materials.new(name='{}_mat'.format(obj_mesh.name))
bpy.ops.object.material_slot_add()
obj.material_slots[0].material = mat
for mat_idx, obj_mat in enumerate(obj_mesh.materials):
materials_tmp.append(obj_mat)
if random_obj_textures:
obj_texture = random.choice(obj_textures)
generated_uv = True
else:
obj_texture = os.path.join(
os.path.dirname(obj_path), 'texture.jpg')
generated_uv = False
obj_sh_path = texturing.add_obj_texture(
obj_mat,
obj_texture,
sh_path,
down_scale=texture_zoom,
tmp_suffix='tmp',
generated_uv=generated_uv)
tmp_files.append(obj_sh_path)
tmp_files.append(obj_sh_path.replace('.osl', '.oso'))
obj_scs.append(obj_mat.node_tree.nodes['Script'])
obj_scs[-1].update()
# Apply transform to object
rigid_transform = coordutils.get_rigid_transform_posed_mano(
posed_model, mano_model)
mano_obj.matrix_world = Matrix(rigid_transform)
obj_transform = rigid_transform.dot(obj.matrix_world)
obj.matrix_world = Matrix(obj_transform)
obj.scale = (obj_scale, obj_scale, obj_scale)
hand_info = coordutils.get_hand_body_info(
posed_model,
render_body=render_body,
side='right',
cam_extr=cam_extr,
cam_calib=cam_calib,
right_smpl2mano=right_smpl2mano)
frame_prefix = '{:08}'.format(frame_idx)
# Save object info
hand_info['affine_transform'] = obj_transform.astype(np.float32)
if random_obj_textures:
hand_info['obj_texture'] = obj_texture
hand_info['obj_path'] = obj_path
hand_info['obj_scale'] = obj_scale
# Save grasp info
for label in [
'sample_id', 'class_id', 'pca_pose', 'grasp_quality',
'grasp_epsilon', 'grasp_volume', 'hand_trans',
'hand_global_rot', 'hand_pose'
]:
hand_info[label] = grasp[label]
hand_infos = {**hand_info, **meta_info}
camutils.set_camera()
camera_name = 'Camera'
# Randomly pick background
bg_path = random.choice(backgrounds)
# Setup depth and segmentation rendering
depth_path = os.path.join(folder_depth, frame_prefix)
tmp_segm_path = render.set_cycle_nodes(
scene, bg_path, segm_path=folder_temp_segm, depth_path=depth_path)
tmp_files.append(tmp_segm_path)
tmp_depth = depth_path + '{:04d}.exr'.format(1)
tmp_files.append(tmp_depth)
# Randomly pick clothing texture
tex_path = random.choice(body_textures)
# Spherical harmonic lighting
sh_coeffs = texturing.get_sh_coeffs(
ambiant_mean=ambiant_mean, ambiant_max_add=ambiant_add)
texturing.set_sh_coeffs(scs, sh_coeffs)
texturing.set_sh_coeffs(obj_scs, sh_coeffs)
# Update body+hands image
tex_img = bpy.data.images.load(tex_path)
for part, material in materials.items():
material.node_tree.nodes['Image Texture'].image = tex_img
# Render
img_path = os.path.join(folder_rgb, '{}.jpg'.format(frame_prefix))
scene.render.filepath = img_path
scene.render.image_settings.file_format = 'JPEG'
bpy.ops.render.render(write_still=True)
# Render obj only
obj_img_path = os.path.join(folder_rgb_obj,
'{}.jpg'.format(frame_prefix))
smplh_obj.hide_render = True
scene.render.filepath = obj_img_path
obj_depth_path = os.path.join(folder_depth_obj, frame_prefix)
tmp_segm_obj_path = render.set_cycle_nodes(
scene,
bg_path,
segm_path=folder_temp_segm,
depth_path=obj_depth_path)
tmp_obj_depth = obj_depth_path + '{:04d}.exr'.format(1)
tmp_files.append(tmp_obj_depth)
tmp_files.append(tmp_segm_obj_path)
bpy.ops.render.render(write_still=True)
# Render hand only
hand_img_path = os.path.join(folder_rgb_hand,
'{}.jpg'.format(frame_prefix))
smplh_obj.hide_render = False
obj.hide_render = True
scene.render.filepath = hand_img_path
hand_depth_path = os.path.join(folder_depth_hand, frame_prefix)
tmp_segm_hand_path = render.set_cycle_nodes(
scene,
bg_path,
segm_path=folder_temp_segm,
depth_path=hand_depth_path)
tmp_hand_depth = hand_depth_path + '{:04d}.exr'.format(1)
tmp_files.append(tmp_hand_depth)
tmp_files.append(tmp_segm_hand_path)
bpy.ops.render.render(write_still=True)
# Delete objects
delete_obj_model(obj)
camutils.check_camera(camera_name=camera_name)
segm_img = cv2.imread(tmp_segm_path)[:, :, 0]
if render_body:
keep_render = True
else:
keep_render = conditions.segm_condition(
segm_img, side='right', use_grasps=True)
depth, depth_min, depth_max = depthutils.convert_depth(tmp_depth)
hand_infos['depth_min'] = depth_min
hand_infos['depth_max'] = depth_max
hand_infos['bg_path'] = bg_path
hand_infos['sh_coeffs'] = sh_coeffs
hand_infos['body_tex'] = tex_path
# Concatenate depth as rgb
hand_depth, hand_depth_min, hand_depth_max = depthutils.convert_depth(
tmp_hand_depth)
obj_depth, obj_depth_min, obj_depth_max = depthutils.convert_depth(
tmp_obj_depth)
depth = np.stack([depth, hand_depth, obj_depth], axis=2)
hand_infos['hand_depth_min'] = hand_depth_min
hand_infos['hand_depth_max'] = hand_depth_max
hand_infos['obj_depth_min'] = obj_depth_min
hand_infos['obj_depth_max'] = obj_depth_max
# Concatenate segm as rgb
obj_segm = cv2.imread(tmp_segm_obj_path)[:, :, 0]
hand_segm = cv2.imread(tmp_segm_hand_path)[:, :, 0]
keep_render_obj, obj_ratio = conditions.segm_obj_condition(
segm_img, obj_segm, min_obj_ratio=min_obj_ratio)
keep_render = keep_render and keep_render_obj
hand_infos['obj_visibility_ratio'] = obj_ratio
segm_img = np.stack([segm_img, hand_segm, obj_segm], axis=2)
# Clean residual files
if keep_render:
# Write depth image
final_depth_path = os.path.join(folder_depth,
'{}.png'.format(frame_prefix))
cv2.imwrite(final_depth_path, depth)
# Save meta
meta_pkl_path = os.path.join(folder_meta,
'{}.pkl'.format(frame_prefix))
with open(meta_pkl_path, 'wb') as meta_f:
pickle.dump(hand_infos, meta_f)
# Write segmentation path
segm_save_path = os.path.join(folder_segm,
'{}.png'.format(frame_prefix))
cv2.imwrite(segm_save_path, segm_img)
ex.log_scalar('generated.idx', frame_idx)
else:
os.remove(img_path)
os.remove(obj_img_path)
os.remove(hand_img_path)
for filepath in tmp_files:
os.remove(filepath)
# Remove materials
for material in materials_tmp:
material.user_clear()
bpy.data.materials.remove(material)
print('DONE')
import sys
sys.path.insert(0, '/data/Guha/GR/code/GR19/smpl/smpl_webuser')
import numpy as np
from opendr.renderer import ColoredRenderer
from opendr.lighting import LambertianPointLight
from opendr.camera import ProjectPoints
from serialization import load_model
import os
import myUtil
import cv2
import matplotlib.pyplot as plt
import itertools
####################################3 Load SMPL model (here we load the female model) ######################################
m1 = load_model('../models/basicModel_m_lbs_10_207_0_v1.0.0.pkl')
m1.betas[:] = np.random.rand(m1.betas.size) * .03
m2 = load_model('../models/basicModel_m_lbs_10_207_0_v1.0.0.pkl')
m2.betas[:] = np.random.rand(m2.betas.size) * .03
## Create OpenDR renderer
rn1 = ColoredRenderer()
rn2 = ColoredRenderer()
## Assign attributes to renderer
w, h = (640, 480)
rn1.camera = ProjectPoints(v=m1,
rt=np.zeros(3),
t=np.array([0, 0, 2.]),
f=np.array([w, w]) / 2.,
c=np.array([w, h]) / 2.,
handler.setFormatter(formatter)
# Add handler to facerec modules, so we see what's going on inside:
logger = logging.getLogger("facerec")
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
# Define the Fisherfaces as Feature Extraction method:
feature = Fisherfaces()
# Define a 1-NN classifier with Euclidean Distance:
classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1)
# Define the model as the combination
my_model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
my_model.compute(X, y)
# We then save the model, which uses Pythons pickle module:
save_model("model.pkl", my_model)
model = load_model("model.pkl")
# Then turn the first (at most) 16 eigenvectors into grayscale
# images (note: eigenvectors are stored by column!)
E = []
for i in xrange(min(model.feature.eigenvectors.shape[1], 16)):
e = model.feature.eigenvectors[:, i].reshape(X[0].shape)
E.append(minmax_normalize(e, 0, 255, dtype=np.uint8))
# Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf"
subplot(
title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png"
)
# Perform a 10-fold cross validation
cv = KFoldCrossValidation(model, k=10)
cv.validate(X, y)
# And print the result:
cv.print_results()
def load_model_file(model_filename):
model = load_model(model_filename)
return model
