def main():
tool = DataTool("./Material Glaucoma/refuge_images")
tool.loadData(r'[n|g]\d{4}[^_]')
"""
handmade_p_tile_method, sobel_watershed_method, otsu_local_method, funcionan decente con disc
"""
if(1>2):
met_list = []
#ch.handmade_p_tile_method, ch.sobel_watershed_method, ch.otsu_local_method
for alg in [ch.sobel_watershed_method]:
masks = l.run_all(tool,alg, op="cup")
ss = (alg,l.metrics(masks, l.sensitivity), l.metrics(masks, l.specificity))
jd = (alg,l.metrics(masks, l.DICE), l.metrics(masks, l.jaccard))
met_list.append(ss)
met_list.append(jd)
vi.plot_scatter(met_list,3,2,"metrics")
vi.show()
else:
# tool_entry = tool.data["g0406.png"]
tool_entry = tool.data["n0012.png"]
# tool_entry = tool.data["n0012.png"]
# tool_entry = tool.data["n0005.png"]
# tool_entry = tool.data["n0013.png"]
img = tool_entry["img"]
(_,cut, _) = ch.sobel_watershed_method(img,test=True)
# ch.snakes(cut, op="cup", test=True)
vi.show()
def segments(image, k, i_sigma=2.2):
blur = skimage.color.rgb2gray(image)
blur = skimage.filters.gaussian(blur, sigma=i_sigma)
image_gray = blur.reshape(blur.shape[0] * blur.shape[1], 1)
kmeans = KMeans(n_clusters=k, random_state=0).fit(image_gray)
clustered = kmeans.cluster_centers_[kmeans.labels_]
labels = kmeans.labels_
for i in range(k):
image_cluster = []
for i in range(len(labels)):
if (labels[i]) == k:
image_cluster.append(float(clustered[i]))
else:
image_cluster.append(1)
if (k == 1):
image_fix = np.array(image_cluster).reshape(blur.shape)
reshape_clustered = np.array(image_cluster).reshape(blur.shape)
vi.pltImage(blur)
vi.show()
def plot_jornet_joints_global_depth(joints_global_depth, filenamebase,
gt_joints=None, color_jornet_joints='C6'):
if gt_joints is None:
visualize.plot_3D_joints(joints_global_depth)
else:
fig, ax = visualize.plot_3D_joints(gt_joints)
visualize.plot_3D_joints(joints_global_depth, fig=fig, ax=ax, color=color_jornet_joints)
visualize.title('JORNet (GT multi-coloured; JORNet single color): ' + filenamebase)
visualize.show()
return joints_global_depth
def plot_halnet_joints_from_heatmaps_crop(halnet_main_out, img_numpy, filenamebase, plot=True):
labels_colorspace = conv.heatmaps_to_joints_colorspace(halnet_main_out)
data_crop, crop_coords, labels_heatmaps, labels_colorspace = \
converter.crop_image_get_labels(img_numpy, labels_colorspace, range(21))
if plot:
fig = visualize.create_fig()
visualize.plot_image(data_crop, title=filenamebase, fig=fig)
visualize.plot_joints_from_colorspace(labels_colorspace, title=filenamebase, fig=fig, data=data_crop)
visualize.title('HALNet (joints from heatmaps - cropped): ' + filenamebase)
visualize.show()
return data_crop
def firstExperiment (st):
for i in range(2):
print ('recording...')
fr = record (st)
print (fr)
from visualize import getWave_pivot_jump as gpj, getMax
mx, idx = getMax (fr)
trim, L = gpj (fr, pivot=idx, outPick = True)
sd.play (trim)
vz.plot (fr)
vz.plot (trim, L)
vz.show ()
def main():
hidden_size = 3
dataset = SupervisedDataSet(1, 1)
for i in range(1, 9):
dataset.addSample(i, i)
net = buildNetwork(1, hidden_size, 1, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, dataset)
trainer.trainUntilConvergence(verbose=False, validationProportion=0.15,
maxEpochs=1000, continueEpochs=10)
print latex.format(net)
visualize.show(net)
help='Total number of examples to check')
parser.add_argument('-r',
dest='root_folder',
default='',
required=True,
help='Root folder for dataset')
args = parser.parse_args()
train_loader = synthhands_handler.get_SynthHands_trainloader(
root_folder=args.root_folder,
joint_ixs=range(21),
heatmap_res=(320, 240),
batch_size=1,
verbose=True)
print("Checking " + str(NUM_EXAMPLES) + " examples from the training set")
for batch_idx, (data, target) in enumerate(train_loader):
filenamebase = train_loader.dataset.get_filenamebase(batch_idx)
target_heatmaps, target_joints, target_roothand = target
visualize.plot_image_and_heatmap(target_heatmaps[0][4].cpu().data.numpy(),
data=data[0].cpu().data.numpy(),
title='Training set\n' + filenamebase +
'\nImage + Heatmap(thumb tip)')
visualize.show()
visualize.plot_joints_from_heatmaps(target_heatmaps[0].data.cpu().numpy(),
title='Joints: ' + filenamebase,
data=data[0].data.cpu().numpy())
visualize.show()
if (batch_idx + 1) == args.num_examples:
break
import folium
import visualize as vs
# Query the Data and grab data
# put in 2d array [zip][essential]
# call function like below
nyMap = folium.Map(location=[40.7128, -74.0060],
titles='Stamen Toner',
zoom_start=11)
dataset1, dataset2 = None, None
vs.choropleth(nyMap, 'Layer1', "Test1", dataset1)
vs.choropleth(nyMap, 'Layer2', "Test2", dataset2)
vs.show(nyMap)
def validate(valid_loader, model, optimizer, valid_vars, control_vars, verbose=True):
curr_epoch_iter = 1
for batch_idx, (data, target) in enumerate(valid_loader):
control_vars['batch_idx'] = batch_idx
if batch_idx < control_vars['iter_size']:
print_verbose("\rPerforming first iteration; current mini-batch: " +
str(batch_idx + 1) + "/" + str(control_vars['iter_size']), verbose, n_tabs=0, erase_line=True)
# start time counter
start = time.time()
# get data and targetas cuda variables
target_heatmaps, target_joints, target_joints_z = target
data, target_heatmaps = Variable(data), Variable(target_heatmaps)
if valid_vars['use_cuda']:
data = data.cuda()
target_heatmaps = target_heatmaps.cuda()
# visualize if debugging
# get model output
output = model(data)
# accumulate loss for sub-mini-batch
if valid_vars['cross_entropy']:
loss_func = my_losses.cross_entropy_loss_p_logq
else:
loss_func = my_losses.euclidean_loss
loss = my_losses.calculate_loss_HALNet(loss_func,
output, target_heatmaps, model.joint_ixs, model.WEIGHT_LOSS_INTERMED1,
model.WEIGHT_LOSS_INTERMED2, model.WEIGHT_LOSS_INTERMED3,
model.WEIGHT_LOSS_MAIN, control_vars['iter_size'])
if DEBUG_VISUALLY:
for i in range(control_vars['max_mem_batch']):
filenamebase_idx = (batch_idx * control_vars['max_mem_batch']) + i
filenamebase = valid_loader.dataset.get_filenamebase(filenamebase_idx)
fig = visualize.create_fig()
#visualize.plot_joints_from_heatmaps(output[3][i].data.numpy(), fig=fig,
# title=filenamebase, data=data[i].data.numpy())
#visualize.plot_image_and_heatmap(output[3][i][8].data.numpy(),
# data=data[i].data.numpy(),
# title=filenamebase)
#visualize.savefig('/home/paulo/' + filenamebase.replace('/', '_') + '_heatmap')
labels_colorspace = conv.heatmaps_to_joints_colorspace(output[3][i].data.numpy())
data_crop, crop_coords, labels_heatmaps, labels_colorspace = \
converter.crop_image_get_labels(data[i].data.numpy(), labels_colorspace, range(21))
visualize.plot_image(data_crop, title=filenamebase, fig=fig)
visualize.plot_joints_from_colorspace(labels_colorspace, title=filenamebase, fig=fig, data=data_crop)
#visualize.savefig('/home/paulo/' + filenamebase.replace('/', '_') + '_crop')
visualize.show()
#loss.backward()
valid_vars['total_loss'] += loss
# accumulate pixel dist loss for sub-mini-batch
valid_vars['total_pixel_loss'] = my_losses.accumulate_pixel_dist_loss_multiple(
valid_vars['total_pixel_loss'], output[3], target_heatmaps, control_vars['batch_size'])
if valid_vars['cross_entropy']:
valid_vars['total_pixel_loss_sample'] = my_losses.accumulate_pixel_dist_loss_from_sample_multiple(
valid_vars['total_pixel_loss_sample'], output[3], target_heatmaps, control_vars['batch_size'])
else:
valid_vars['total_pixel_loss_sample'] = [-1] * len(model.joint_ixs)
# get boolean variable stating whether a mini-batch has been completed
minibatch_completed = (batch_idx+1) % control_vars['iter_size'] == 0
if minibatch_completed:
# append total loss
valid_vars['losses'].append(valid_vars['total_loss'].item())
# erase total loss
total_loss = valid_vars['total_loss'].item()
valid_vars['total_loss'] = 0
# append dist loss
valid_vars['pixel_losses'].append(valid_vars['total_pixel_loss'])
# erase pixel dist loss
valid_vars['total_pixel_loss'] = [0] * len(model.joint_ixs)
# append dist loss of sample from output
valid_vars['pixel_losses_sample'].append(valid_vars['total_pixel_loss_sample'])
# erase dist loss of sample from output
valid_vars['total_pixel_loss_sample'] = [0] * len(model.joint_ixs)
# check if loss is better
if valid_vars['losses'][-1] < valid_vars['best_loss']:
valid_vars['best_loss'] = valid_vars['losses'][-1]
#print_verbose(" This is a best loss found so far: " + str(valid_vars['losses'][-1]), verbose)
# log checkpoint
if control_vars['curr_iter'] % control_vars['log_interval'] == 0:
trainer.print_log_info(model, optimizer, 1, total_loss, valid_vars, control_vars)
model_dict = {
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'control_vars': control_vars,
'train_vars': valid_vars,
}
trainer.save_checkpoint(model_dict,
filename=valid_vars['checkpoint_filenamebase'] +
str(control_vars['num_iter']) + '.pth.tar')
# print time lapse
prefix = 'Validating (Epoch #' + str(1) + ' ' + str(control_vars['curr_epoch_iter']) + '/' +\
str(control_vars['tot_iter']) + ')' + ', (Batch ' + str(control_vars['batch_idx']+1) +\
'(' + str(control_vars['iter_size']) + ')' + '/' +\
str(control_vars['num_batches']) + ')' + ', (Iter #' + str(control_vars['curr_iter']) +\
'(' + str(control_vars['batch_size']) + ')' +\
' - log every ' + str(control_vars['log_interval']) + ' iter): '
control_vars['tot_toc'] = display_est_time_loop(control_vars['tot_toc'] + time.time() - start,
control_vars['curr_iter'], control_vars['num_iter'],
prefix=prefix)
control_vars['curr_iter'] += 1
control_vars['start_iter'] = control_vars['curr_iter'] + 1
control_vars['curr_epoch_iter'] += 1
return valid_vars, control_vars
from recorder import record
from numpy import savetxt as save
from numpy import array
import os
import csv
if not os.path.isfile('test.txt'):
data = record('Start speaking ...')
data.reshape(44100)
save('test.txt', data, delimiter=' ')
else:
tmp = csv.reader(open('test.txt', 'r'), delimiter=' ')
data = []
for i in tmp:
data.append(float(i[0]))
data = array(data)
print(data)
import python_speech_features as psf
mfcc = psf.mfcc(data, 44100, nfft=1103)
save('testMfcc.txt', mfcc, delimiter=' ')
print(mfcc.shape)
import visualize as vz
vz.plot(mfcc)
vz.show()
def validate(valid_loader,
model,
optimizer,
valid_vars,
control_vars,
verbose=True):
curr_epoch_iter = 1
for batch_idx, (data, target) in enumerate(valid_loader):
control_vars['batch_idx'] = batch_idx
if batch_idx < control_vars['iter_size']:
print_verbose(
"\rPerforming first iteration; current mini-batch: " +
str(batch_idx + 1) + "/" + str(control_vars['iter_size']),
verbose,
n_tabs=0,
erase_line=True)
# start time counter
start = time.time()
# get data and targetas cuda variables
target_heatmaps, target_joints, target_handroot = target
# make target joints be relative
target_joints = target_joints[:, 3:]
data, target_heatmaps = Variable(data), Variable(target_heatmaps)
if valid_vars['use_cuda']:
data = data.cuda()
target_joints = target_joints.cuda()
target_heatmaps = target_heatmaps.cuda()
target_handroot = target_handroot.cuda()
# visualize if debugging
# get model output
output = model(data)
# accumulate loss for sub-mini-batch
if model.cross_entropy:
loss_func = my_losses.cross_entropy_loss_p_logq
else:
loss_func = my_losses.euclidean_loss
weights_heatmaps_loss, weights_joints_loss = get_loss_weights(
control_vars['curr_iter'])
loss, loss_heatmaps, loss_joints = my_losses.calculate_loss_JORNet(
loss_func, output, target_heatmaps, target_joints,
valid_vars['joint_ixs'], weights_heatmaps_loss,
weights_joints_loss, control_vars['iter_size'])
valid_vars['total_loss'] += loss
valid_vars['total_joints_loss'] += loss_joints
valid_vars['total_heatmaps_loss'] += loss_heatmaps
# accumulate pixel dist loss for sub-mini-batch
valid_vars[
'total_pixel_loss'] = my_losses.accumulate_pixel_dist_loss_multiple(
valid_vars['total_pixel_loss'], output[3], target_heatmaps,
control_vars['batch_size'])
valid_vars[
'total_pixel_loss_sample'] = my_losses.accumulate_pixel_dist_loss_from_sample_multiple(
valid_vars['total_pixel_loss_sample'], output[3],
target_heatmaps, control_vars['batch_size'])
# get boolean variable stating whether a mini-batch has been completed
for i in range(control_vars['max_mem_batch']):
filenamebase_idx = (batch_idx * control_vars['max_mem_batch']) + i
filenamebase = valid_loader.dataset.get_filenamebase(
filenamebase_idx)
print('')
print(filenamebase)
visualize.plot_image(data[i].data.numpy())
visualize.show()
output_batch_numpy = output[7][i].data.cpu().numpy()
print('\n-------------------------------')
reshaped_out = output_batch_numpy.reshape((20, 3))
for j in range(20):
print('[{}, {}, {}],'.format(reshaped_out[j, 0],
reshaped_out[j, 1],
reshaped_out[j, 2]))
print('-------------------------------')
fig, ax = visualize.plot_3D_joints(target_joints[i])
visualize.plot_3D_joints(output_batch_numpy,
fig=fig,
ax=ax,
color='C6')
visualize.title(filenamebase)
visualize.show()
temp = np.zeros((21, 3))
output_batch_numpy_abs = output_batch_numpy.reshape((20, 3))
temp[1:, :] = output_batch_numpy_abs
output_batch_numpy_abs = temp
output_joints_colorspace = camera.joints_depth2color(
output_batch_numpy_abs,
depth_intr_matrix=synthhands_handler.DEPTH_INTR_MTX,
handroot=target_handroot[i].data.cpu().numpy())
visualize.plot_3D_joints(output_joints_colorspace)
visualize.show()
aa1 = target_joints[i].data.cpu().numpy().reshape((20, 3))
aa2 = output[7][i].data.cpu().numpy().reshape((20, 3))
print('\n----------------------------------')
print(np.sum(np.abs(aa1 - aa2)) / 60)
print('----------------------------------')
#loss.backward()
valid_vars['total_loss'] += loss
valid_vars['total_joints_loss'] += loss_joints
valid_vars['total_heatmaps_loss'] += loss_heatmaps
# accumulate pixel dist loss for sub-mini-batch
valid_vars[
'total_pixel_loss'] = my_losses.accumulate_pixel_dist_loss_multiple(
valid_vars['total_pixel_loss'], output[3], target_heatmaps,
control_vars['batch_size'])
valid_vars[
'total_pixel_loss_sample'] = my_losses.accumulate_pixel_dist_loss_from_sample_multiple(
valid_vars['total_pixel_loss_sample'], output[3],
target_heatmaps, control_vars['batch_size'])
# get boolean variable stating whether a mini-batch has been completed
minibatch_completed = (batch_idx + 1) % control_vars['iter_size'] == 0
if minibatch_completed:
# append total loss
valid_vars['losses'].append(valid_vars['total_loss'].data[0])
# erase total loss
total_loss = valid_vars['total_loss'].data[0]
valid_vars['total_loss'] = 0
# append total joints loss
valid_vars['losses_joints'].append(
valid_vars['total_joints_loss'].data[0])
# erase total joints loss
valid_vars['total_joints_loss'] = 0
# append total joints loss
valid_vars['losses_heatmaps'].append(
valid_vars['total_heatmaps_loss'].data[0])
# erase total joints loss
valid_vars['total_heatmaps_loss'] = 0
# append dist loss
valid_vars['pixel_losses'].append(valid_vars['total_pixel_loss'])
# erase pixel dist loss
valid_vars['total_pixel_loss'] = [0] * len(model.joint_ixs)
# append dist loss of sample from output
valid_vars['pixel_losses_sample'].append(
valid_vars['total_pixel_loss_sample'])
# erase dist loss of sample from output
valid_vars['total_pixel_loss_sample'] = [0] * len(model.joint_ixs)
# check if loss is better
#if valid_vars['losses'][-1] < valid_vars['best_loss']:
# valid_vars['best_loss'] = valid_vars['losses'][-1]
# print_verbose(" This is a best loss found so far: " + str(valid_vars['losses'][-1]), verbose)
# log checkpoint
if control_vars['curr_iter'] % control_vars['log_interval'] == 0:
trainer.print_log_info(model, optimizer, 1, total_loss,
valid_vars, control_vars)
model_dict = {
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'control_vars': control_vars,
'train_vars': valid_vars,
}
trainer.save_checkpoint(
model_dict,
filename=valid_vars['checkpoint_filenamebase'] +
str(control_vars['num_iter']) + '.pth.tar')
# print time lapse
prefix = 'Validating (Epoch #' + str(1) + ' ' + str(control_vars['curr_epoch_iter']) + '/' +\
str(control_vars['tot_iter']) + ')' + ', (Batch ' + str(control_vars['batch_idx']+1) +\
'(' + str(control_vars['iter_size']) + ')' + '/' +\
str(control_vars['num_batches']) + ')' + ', (Iter #' + str(control_vars['curr_iter']) +\
'(' + str(control_vars['batch_size']) + ')' +\
' - log every ' + str(control_vars['log_interval']) + ' iter): '
control_vars['tot_toc'] = display_est_time_loop(
control_vars['tot_toc'] + time.time() - start,
control_vars['curr_iter'],
control_vars['num_iter'],
prefix=prefix)
control_vars['curr_iter'] += 1
control_vars['start_iter'] = control_vars['curr_iter'] + 1
control_vars['curr_epoch_iter'] += 1
return valid_vars, control_vars
def secondOne (st): wrd = nextWord (st, hearable = 280, chunk=1024) # print (wrd) sd.play (wrd) vz.plot (wrd) vz.show ()
mesh = None
with open("test/test.stl","rb") as f:
gen = stl.read_stl(f)
next(gen) # ignore the length
mesh = convert_mesh.triangles_to_mesh(map(stl.points, gen))
zbuf = convex_roughing.construct_intervals(mesh,np.array([0,0,1]))
hull = convex_roughing.hull_on_plane(mesh, zbuf, z, np.array([0,0,1]))
points = list(hull.points[i] for i in hull.vertices)
points.append(points[0])
points.reverse()
polygon = shape.LinearRing(points)
region = shape.LinearRing([(-10,0),(100,0),(100,100),(-10,100)])
c = cell.Cell(region, region, polygon, cell.offsetting)
c.construct()
visualize.show_paths(to_visual(c.emit()))
visualize.show_paths(to_visual([shape.LinearRing([(0,0),(100,0),(100,100),(0,100)])]))
visualize.show_mesh(*mesh)
visualize.show()
import pandas
from k_means_clustering import K_Means_Clustering
from visualize import plot_clusters_2d,show
data_frame = pandas.read_csv("iris.csv", sep=";")
df = data_frame.drop('Species', axis=1)
for column in df.columns.to_list():
df[column] = df[column].str.replace(",", ".").astype(float)
k_means_wrapper = K_Means_Clustering(df, 2)
centroids, clusters = k_means_wrapper.k_means_algorithm()
sepal_centroids = centroids[["Sepal.Length","Sepal.Width"]]
petal_centroids = centroids[["Petal.Length","Petal.Width"]]
plot_clusters_2d(clusters, sepal_centroids, "Sepal.Length", "Sepal.Width")
plot_clusters_2d(clusters, petal_centroids, "Petal.Length", "Petal.Width")
show()
# leaf = 0.05
# downsampled_intf = clouds.uniform_voxelgrid_sample(intf, voxel_size=leaf * 0.5)
# normal_pts, normals = clouds.robust_normals(downsampled_intf, leaf_size=leaf)
vertices, normals = test_half_mesh(mesh)
normal_pts = vertices
# Build spinimages
tic = time.time()
spin_images = build_spinimages(vertices, normal_pts, normals, scale=1.0)
toc = time.time() - tic
print 'Spin image library construction took {} seconds'.format(toc)
# Choose a test image
# test_spin = spin(intf, normal_pts[0], normals[0])
for k in range(20):
n = np.random.randint(len(spin_images))
test_spin = spin_images[n]
tic = time.time()
similarity = np.array(map(lambda q: rpq(test_spin, q), spin_images))
toc = time.time() - tic
print 'Similarity estimation took {} seconds'.format(toc)
print np.min(similarity), np.max(similarity)
similarity = np.clip(similarity, 0.0, 1.0)
visualize.color_points3d(normal_pts, similarity, scale_factor=0.1)
visualize.points3d(normal_pts[n], scale_factor=0.05, opacity=0.7)
visualize.show(axis_scale=0.2)
def plot_halnet_joints_from_heatmaps(halnet_main_out, img_numpy, filenamebase):
fig = visualize.create_fig()
visualize.plot_joints_from_heatmaps(halnet_main_out, fig=fig, data=img_numpy)
visualize.title('HALNet (joints from heatmaps): ' + filenamebase)
visualize.show()
def plot_halnet_heatmap(halnet_mainout, img_numpy, heatmap_ix, filenamebase):
visualize.plot_image_and_heatmap(halnet_mainout[heatmap_ix], data=img_numpy)
joint_name = synthhands_handler.get_joint_name_from_ix(heatmap_ix)
visualize.title('HALNet (heatmap for ' + joint_name + '): ' + filenamebase)
visualize.show()
def test(self, error_func_list=None, is_visualize=False):
from demorender import demoAll
total_task = len(self.test_data)
print('total img:', total_task)
model = self.net.model
total_error_list = []
num_output = self.mode[3]
num_input = self.mode[4]
data_generator = DataGenerator(all_image_data=self.test_data,
mode=self.mode[2],
is_aug=False,
is_pre_read=self.is_pre_read)
with torch.no_grad():
model.eval()
for i in range(len(self.test_data)):
data = data_generator.__getitem__(i)
x = data[0]
x = x.to(self.net.device).float()
y = [data[j] for j in range(1, 1 + num_input)]
for j in range(num_input):
y[j] = y[j].to(x.device).float()
y[j] = torch.unsqueeze(y[j], 0)
x = torch.unsqueeze(x, 0)
outputs = model(x, *y)
p = outputs[-1]
x = x.squeeze().cpu().numpy().transpose(1, 2, 0)
p = p.squeeze().cpu().numpy().transpose(1, 2, 0) * 280
b = sio.loadmat(self.test_data[i].bbox_info_path)
gt_y = y[0]
gt_y = gt_y.squeeze().cpu().numpy().transpose(1, 2, 0) * 280
temp_errors = []
for error_func_name in error_func_list:
error_func = getErrorFunction(error_func_name)
error = error_func(gt_y, p, b['Bbox'], b['Kpt'])
temp_errors.append(error)
total_error_list.append(temp_errors)
print(self.test_data[i].init_image_path, end=' ')
for er in temp_errors:
print('%.5f' % er, end=' ')
print('')
if is_visualize:
if temp_errors[0] > 0.00:
tex = np.load(self.test_data[i].texture_path.replace(
'zeroz2', 'full')).astype(np.float32)
init_image = np.load(
self.test_data[i].cropped_image_path).astype(
np.float32) / 255.0
show([p, tex, init_image], mode='uvmap')
init_image = np.load(
self.test_data[i].cropped_image_path).astype(
np.float32) / 255.0
show([gt_y, tex, init_image], mode='uvmap')
demobg = np.load(
self.test_data[i].cropped_image_path).astype(
np.float32)
init_image = demobg / 255.0
img1, img2 = demoAll(p, demobg, is_render=False)
mean_errors = np.mean(total_error_list, axis=0)
for er in mean_errors:
print('%.5f' % er, end=' ')
print('')
for i in range(len(error_func_list)):
print(error_func_list[i], mean_errors[i])
se_idx = np.argsort(np.sum(total_error_list, axis=-1))
se_data_list = np.array(self.test_data)[se_idx]
se_path_list = [a.cropped_image_path for a in se_data_list]
sep = '\n'
fout = open('errororder.txt', 'w', encoding='utf-8')
fout.write(sep.join(se_path_list))
fout.close()
hand_gt_filepath = dataset_root + hand_gt_folder + subject + '/' + action + '/' + seq + 'skeleton.txt'
hand_joints = fpa_io.read_action_joints_sequence(hand_gt_filepath)[int(31)]
hand_joints = hand_joints.reshape((21, 3))
hand_joints -= hand_joints[0, :]
hand_joints_unreal = np.copy(hand_joints)
i = 0
for finger_idx in range(5):
finger_start_joint_idx = (finger_idx * 4) + 1
for j in range(3):
parent_joint_idx = finger_start_joint_idx + j
parent_joint_before = np.copy(hand_joints_unreal[parent_joint_idx, :])
curr_bone_prop = bone_prop[parent_joint_idx - 1]
hand_joints_unreal[parent_joint_idx, :] *= curr_bone_prop
parent_joint_transl = hand_joints_unreal[
parent_joint_idx, :] - parent_joint_before
print(
str(parent_joint_transl) + " " + str(curr_bone_prop) + " " +
str(1 / curr_bone_prop))
for k in range(3 - j):
joint2_idx = parent_joint_idx + k + 1
hand_joints_unreal[joint2_idx, :] += parent_joint_transl
print(str(parent_joint_idx) + " " + str(joint2_idx))
a = 0
fig, ax = vis.plot_3D_joints(hand_joints)
vis.plot_3D_joints(hand_joints_unreal, fig=fig, ax=ax)
vis.show()
most_bottom = None
for p in group:
# print(p)
if most_left is None or p[0] < most_left:
most_left = p[0]
if most_top is None or p[1] < most_top:
most_top = p[1]
if most_right is None or p[0] > most_right:
most_right = p[0]
if most_bottom is None or p[1] > most_bottom:
most_bottom = p[1]
# tl_dist = (tl[0] - p[0]) ** 2 + (tl[1] - p[1]) ** 2
# br_dist = (br[0] - p[0]) ** 2 + (br[1] - p[1]) ** 2
#
# if best_tl_dist is None or best_tl_dist > tl_dist:
# best_tl_dist = tl_dist
# best_tl_ind = p
#
# if best_br_dist is None or best_br_dist > br_dist:
# best_br_dist = br_dist
# best_br_ind = p
# bounding_box = [best_tl_ind[1], best_tl_ind[0], best_br_ind[1], best_br_ind[0]]
# bounding_boxes.append(bounding_box)
bounding_box = [most_top, most_left, most_bottom, most_right]
bounding_boxes.append(bounding_box)
viz.visualize_image_with_bounding_boxes(image, bounding_boxes)
viz.show()
