Spaces:
Runtime error
Runtime error
| import torch | |
| class LossGConMesh(torch.nn.Module): | |
| def __init__(self , n_verts=3889): | |
| super(LossGConMesh, self).__init__() | |
| self.n_verts = n_verts | |
| self.criterion_class = torch.nn.CrossEntropyLoss(reduction='mean') | |
| def forward(self, pred_gc, target_gc, has_gc, loss_type_gcmesh='ce'): | |
| # pred_gc has shape (bs, n_verts, 2) | |
| # target_gc has shape (bs, n_verts, 3) | |
| # with [first: no-contact=0 contact=1 | |
| # second: index of closest vertex with opposite label | |
| # third: dist to that closest vertex] | |
| target_gc_class = target_gc[:, :, 0] | |
| target_gc_nearoppvert_ind = target_gc[:, :, 1] | |
| target_gc_nearoppvert_dist = target_gc[:, :, 2] | |
| # bs = pred_gc.shape[0] | |
| bs = has_gc.sum() | |
| if loss_type_gcmesh == 'ce': # cross entropy | |
| # import pdb; pdb.set_trace() | |
| # classification_loss = self.criterion_class(pred_gc.reshape((bs*self.n_verts, 2)), target_gc_class.reshape((bs*self.n_verts))) | |
| classification_loss = self.criterion_class(pred_gc[has_gc==True, ...].reshape((bs*self.n_verts, 2)), target_gc_class[has_gc==True, ...].reshape((bs*self.n_verts))) | |
| loss = classification_loss | |
| else: | |
| raise ValueError | |
| return loss | |
| def calculate_plane_errors_batch(vertices, target_gc_class, target_has_gc, has_gc_is_touching, return_error_under_plane=True): | |
| # remarks: | |
| # visualization of the plane: debug_code/curve_fitting_v2.py | |
| # theory: https://www.ltu.se/cms_fs/1.51590!/svd-fitting.pdf | |
| # remark: torch.svd is depreciated | |
| # new plane equation: | |
| # a(x−x0)+b(y−y0)+c(z−z0)=0 | |
| # ax+by+cz=d with d=ax0+by0+cz0 | |
| # z = (d-ax-by)/c | |
| # here: | |
| # a, b, c describe the plane normal | |
| # d can be calculated (from a, b, c, x0, y0, z0) | |
| # (x0, y0, z0) are the coordinates of a point on the | |
| # plane, for example points_centroid | |
| # (x, y, z) are the coordinates of a query point on the plane | |
| # | |
| # input: | |
| # vertices: (bs, 3889, 3) | |
| # target_gc_class: (bs, 3889) | |
| # | |
| bs = vertices.shape[0] | |
| error_list = [] | |
| error_under_plane_list = [] | |
| for ind_b in range(bs): | |
| if target_has_gc[ind_b] == 1 and has_gc_is_touching[ind_b] == 1: | |
| try: | |
| points_npx3 = vertices[ind_b, target_gc_class[ind_b, :]==1, :] | |
| points = torch.transpose(points_npx3, 0, 1) # (3, n_points) | |
| points_centroid = torch.mean(points, dim=1) | |
| input_svd = points - points_centroid[:, None] | |
| # U_svd, sigma_svd, V_svd = torch.svd(input_svd, compute_uv=True) | |
| # plane_normal = U_svd[:, 2] | |
| # _, sigma_svd, _ = torch.svd(input_svd, compute_uv=False) | |
| # _, sigma_svd, _ = torch.svd(input_svd, compute_uv=True) | |
| U_svd, sigma_svd, V_svd = torch.svd(input_svd, compute_uv=True) | |
| plane_squaredsumofdists = sigma_svd[2] | |
| error_list.append(plane_squaredsumofdists) | |
| if return_error_under_plane: | |
| # plane information | |
| # plane_centroid = points_centroid | |
| plane_normal = U_svd[:, 2] | |
| # non-plane points | |
| nonplane_points_npx3 = vertices[ind_b, target_gc_class[ind_b, :]==0, :] # (n_points_3) | |
| nonplane_points = torch.transpose(nonplane_points_npx3, 0, 1) # (3, n_points) | |
| nonplane_points_centered = nonplane_points - points_centroid[:, None] | |
| nonplane_points_projected = torch.matmul(plane_normal[None, :], nonplane_points_centered) # plane normal already has length 1 | |
| if nonplane_points_projected.sum() > 0: | |
| # bug corrected 07.11.22 | |
| # error_under_plane = nonplane_points_projected[nonplane_points_projected<0].sum() / 100 | |
| error_under_plane = - nonplane_points_projected[nonplane_points_projected<0].sum() / 100 | |
| else: | |
| error_under_plane = nonplane_points_projected[nonplane_points_projected>0].sum() / 100 | |
| error_under_plane_list.append(error_under_plane) | |
| except: | |
| print('was not able to calculate plane error for this image') | |
| error_list.append(torch.zeros((1), dtype=vertices.dtype, device=vertices.device)[0]) | |
| error_under_plane_list.append(torch.zeros((1), dtype=vertices.dtype, device=vertices.device)[0]) | |
| else: | |
| error_list.append(torch.zeros((1), dtype=vertices.dtype, device=vertices.device)[0]) | |
| error_under_plane_list.append(torch.zeros((1), dtype=vertices.dtype, device=vertices.device)[0]) | |
| errors = torch.stack(error_list, dim=0) | |
| errors_under_plane = torch.stack(error_under_plane_list, dim=0) | |
| if return_error_under_plane: | |
| return errors, errors_under_plane | |
| else: | |
| return errors | |
| # def calculate_vertex_wise_labeling_error(): | |
| # vertexwise_ground_contact | |
| ''' | |
| def paws_to_groundplane_error_batch(vertices, return_details=False): | |
| # list of feet vertices (some of them) | |
| # remark: we did annotate left indices and find the right insices using sym_ids_dict | |
| # REMARK: this loss is not yet for batches! | |
| import pdb; pdb.set_trace() | |
| print('this loss is not yet for batches!') | |
| list_back_left = [1524, 1517, 1512, 1671, 1678, 1664, 1956, 1680, 1685, 1602, 1953, 1569] | |
| list_front_left = [1331, 1327, 1332, 1764, 1767, 1747, 1779, 1789, 1944, 1339, 1323, 1420] | |
| list_back_right = [3476, 3469, 3464, 3623, 3630, 3616, 3838, 3632, 3637, 3554, 3835, 3521] | |
| list_front_right = [3283, 3279, 3284, 3715, 3718, 3698, 3730, 3740, 3826, 3291, 3275, 3372] | |
| assert vertices.shape[0] == 3889 | |
| assert vertices.shape[1] == 3 | |
| all_paw_vert_idxs = list_back_left + list_front_left + list_back_right + list_front_right | |
| verts_paws = vertices[all_paw_vert_idxs, :] | |
| plane_centroid, plane_normal, error = fit_plane_batch(verts_paws) | |
| if return_details: | |
| return plane_centroid, plane_normal, error | |
| else: | |
| return error | |
| def paws_to_groundplane_error_batch_new(vertices, return_details=False): | |
| # list of feet vertices (some of them) | |
| # remark: we did annotate left indices and find the right insices using sym_ids_dict | |
| # REMARK: this loss is not yet for batches! | |
| import pdb; pdb.set_trace() | |
| print('this loss is not yet for batches!') | |
| list_back_left = [1524, 1517, 1512, 1671, 1678, 1664, 1956, 1680, 1685, 1602, 1953, 1569] | |
| list_front_left = [1331, 1327, 1332, 1764, 1767, 1747, 1779, 1789, 1944, 1339, 1323, 1420] | |
| list_back_right = [3476, 3469, 3464, 3623, 3630, 3616, 3838, 3632, 3637, 3554, 3835, 3521] | |
| list_front_right = [3283, 3279, 3284, 3715, 3718, 3698, 3730, 3740, 3826, 3291, 3275, 3372] | |
| assert vertices.shape[0] == 3889 | |
| assert vertices.shape[1] == 3 | |
| all_paw_vert_idxs = list_back_left + list_front_left + list_back_right + list_front_right | |
| verts_paws = vertices[all_paw_vert_idxs, :] | |
| plane_centroid, plane_normal, error = fit_plane_batch(verts_paws) | |
| print('this loss is not yet for batches!') | |
| points = torch.transpose(points_npx3, 0, 1) # (3, n_points) | |
| points_centroid = torch.mean(points, dim=1) | |
| input_svd = points - points_centroid[:, None] | |
| U_svd, sigma_svd, V_svd = torch.svd(input_svd, compute_uv=True) | |
| plane_normal = U_svd[:, 2] | |
| plane_squaredsumofdists = sigma_svd[2] | |
| error = plane_squaredsumofdists | |
| print('error: ' + str(error.item())) | |
| return error | |
| ''' |