More clean up and added a requirement.txt file

Author: Dannydigr

.gitattributes

@@ -0,0 +1 @@
+*.zip filter=lfs diff=lfs merge=lfs -text

ANN.py

@@ -31,7 +31,6 @@ def ann(query_mesh, feature_list, num_of_trees=1000, top_k=25, search_k=-1, quer
     is known by the parameter query: if True, the shape is new, if False, the shape is present in feature_list.
     """
 
-
     all_feat = pd.read_csv(feature_list, header=0)
 
     non_features = ['file_name', 'shape_number', 'Class']
@@ -137,6 +136,9 @@ def ann(query_mesh, feature_list, num_of_trees=1000, top_k=25, search_k=-1, quer
 
 
 def ann_fast(query_mesh, features, map, num_of_trees=1000, top_k=10, search_k=-1, metric='euclidean'):
+    """
+    Fast because each time is called, it should not read all the features from scratch, but they are passed as input.
+    """
 
     all_feat = features
     non_features = ['file_name', 'shape_number', 'Class']

Evaluation.py

@@ -25,7 +25,7 @@ def evaluate_db(mesh_db_path="./all_features.csv", query_num=25):
     db_size = len(mesh_db['file_name'])
     class_count_dict, class_metrics = class_count(mesh_db['Class'].tolist())
 
-    avg_metrics = {'avg_accuracy': 0, 'avg_sensitivity': 0, 'avg_specificity': 0, 'avg_precision':0, 'avg_f1':0}
+    avg_metrics = {'avg_accuracy': 0, 'avg_sensitivity': 0, 'avg_specificity': 0, 'avg_precision': 0, 'avg_f1': 0}
     class_acc = class_metrics.copy()
     class_sens = class_metrics.copy()
     class_spec = class_metrics.copy()
@@ -79,15 +79,13 @@ def evaluate_db(mesh_db_path="./all_features.csv", query_num=25):
         avg_metrics['avg_precision'] += precision
         class_prec[mesh_class] += precision
 
-
         if precision + sensitivity == 0:
             f1_score = 0
         else:
             f1_score = 2 * ((precision * sensitivity) / (precision + sensitivity))
         avg_metrics['avg_f1'] += f1_score
         class_f1sc[mesh_class] += f1_score
 
-
     for item in list(class_count_dict):
         class_acc[item] /= class_count_dict[item]
         class_sens[item] /= class_count_dict[item]
@@ -101,11 +99,10 @@ def evaluate_db(mesh_db_path="./all_features.csv", query_num=25):
     time2 = time.time()
     print(f"Time to evaluate: {time2-time1}")
 
-
     print("\nAverage metrics")
     print(avg_metrics)
 
-    """print("\nClass accuracy:")
+    print("\nClass accuracy:")
     print(class_acc)
     print("\nClass sensitivity:")
     print(class_sens)
@@ -114,19 +111,21 @@ def evaluate_db(mesh_db_path="./all_features.csv", query_num=25):
     print("\nClass precision")
     print(class_prec)
     print("\nClass F1-score")
-    print(class_f1sc)"""
+    print(class_f1sc)
 
     results = [avg_metrics, class_acc, class_sens, class_spec, class_prec, class_f1sc, "DIST_RESULTS"]
 
     return results
 
+
 def evaluate_ann(mesh_db_path="./all_features.csv", query_num=25):
+
     time1 = time.time()
     mesh_db = pd.read_csv(mesh_db_path, header=0)
     db_size = len(mesh_db['file_name'])
     class_count_dict, class_metrics = class_count(mesh_db['Class'].tolist())
 
-    avg_metrics = {'avg_accuracy': 0, 'avg_sensitivity': 0, 'avg_specificity': 0, 'avg_precision': 0, 'avg_f1':0}
+    avg_metrics = {'avg_accuracy': 0, 'avg_sensitivity': 0, 'avg_specificity': 0, 'avg_precision': 0, 'avg_f1': 0}
     class_acc = class_metrics.copy()
     class_sens = class_metrics.copy()
     class_spec = class_metrics.copy()
@@ -206,7 +205,7 @@ def evaluate_ann(mesh_db_path="./all_features.csv", query_num=25):
     print("\nAverage metrics")
     print(avg_metrics)
 
-    """print("\nClass accuracy:")
+    print("\nClass accuracy:")
     print(class_acc)
     print("\nClass sensitivity:")
     print(class_sens)
@@ -215,14 +214,15 @@ def evaluate_ann(mesh_db_path="./all_features.csv", query_num=25):
     print("\nClass precision")
     print(class_prec)
     print("\nClass F1-score")
-    print(class_f1sc)"""
+    print(class_f1sc)
 
     results = [avg_metrics, class_acc, class_sens, class_spec, class_prec, class_f1sc, "ANN_RESULTS"]
 
     return results
 
 
 def compute_roc_curve():
+
     query_nums = [5, 10, 25, 50, 75, 100, 150, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
 
     tpr_dist = [0]
@@ -231,13 +231,13 @@ def compute_roc_curve():
     fpr_ann = [0]
     all_dist_results = []
     all_ann_results = []
+
     for num in query_nums:
         result_dist = evaluate_db(query_num=num)
         all_dist_results.append((len(all_dist_results), result_dist))
         tpr_dist.append(result_dist[0]['avg_sensitivity'])
         fpr_dist.append(1-result_dist[0]['avg_specificity'])
 
-
         result_ann = evaluate_ann(query_num=num)
         all_ann_results.append((len(all_ann_results), result_ann))
         tpr_ann.append(result_ann[0]['avg_sensitivity'])
@@ -248,7 +248,6 @@ def compute_roc_curve():
     tpr_ann.append(1)
     fpr_ann.append(1)
 
-
     auc_dist = auc(fpr_dist, tpr_dist)
     auc_ann = auc(fpr_ann, tpr_ann)
 
@@ -261,18 +260,7 @@ def compute_roc_curve():
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-compute_roc_curve()
+#compute_roc_curve()
 #evaluate_db()
 #evaluate_ann()
 #[(closest_meshes[i][0], mesh_db['Class'].loc[mesh_db['file_name'] == closest_meshes[i][0]].item()) for i in range(len(closest_meshes))]

Mesh_Reading.py

@@ -89,8 +89,6 @@ def view_mesh(mesh, draw_coordinates=False, show_wireframe=True, aabbox=False):
     """
 
     # compute the light of the mesh
-    #mesh.vertex_normals = o3d.utility.Vector3dVector([])
-    #mesh.triangle_normals = o3d.utility.Vector3dVector([])
     mesh.compute_vertex_normals()
     mesh.compute_triangle_normals()
 

Mesh_refining.py

@@ -24,12 +24,13 @@ def refine_single_mesh(mesh, target_faces_number=5000):
 
     actual_faces_number = len(mesh.triangles)
     splitpoint = int(target_faces_number * 0.4)  # eg: 5000 - x = 4x - 5000
-    # splitpoint identifies the value for which is the same refine or not refine the mesh, given the target.
-    # In fact, not all meshes with < 5000 faces should be refined, since for every value above 2000,
-    # if the refining will be done even only once, the number of faces obtained would be
-    # far from 5000 compared to the case that we haven't refined the original mesh.
-    # 2000 is the split point: 5000 - 2000 = 3000 and 2000 * 4 - 5000 = 3000.
-    # The distance from 5000 of the refined vs not refined is the same.
+
+    """splitpoint identifies the value for which is the same refine or not refine the mesh, given the target.
+    In fact, not all meshes with < 5000 faces should be refined, since for every value above 2000,
+    if the refining will be done even only once, the number of faces obtained would be
+    far from 5000 compared to the case that we haven't refined the original mesh.
+    2000 is the split point: 5000 - 2000 = 3000 and 2000 * 4 - 5000 = 3000.
+    The distance from 5000 of the refined vs not refined is the same."""
 
     if actual_faces_number < splitpoint:
 
@@ -39,11 +40,9 @@ def refine_single_mesh(mesh, target_faces_number=5000):
     # for the submeshing, the algorithm would take care about the target number
     # of faces and we don't have to calculate a splitpoint.
     elif actual_faces_number > target_faces_number:
-
         new_mesh = mesh.simplify_quadric_decimation(target_number_of_triangles=target_faces_number)
 
     else:
-
         new_mesh = mesh
 
     new_mesh.remove_duplicated_triangles()

Normalization.py

@@ -3,8 +3,6 @@
 import open3d as o3d
 import numpy as np
 import os
-import trimesh as tm
-import copy
 
 
 def get_barycenter(mesh):
@@ -221,50 +219,26 @@ def align_eigenvectors(mesh):
 
     return mesh
 
-"""
 
-def flip_test(mesh):
-
-    print("Flipping the mesh....")
-
-    f_x = 0
-    f_y = 0
-    f_z = 0
-
-    for face in np.asarray(mesh.triangles):
-        a = np.asarray(mesh.vertices)[face[0]]
-        b = np.asarray(mesh.vertices)[face[1]]
-        c = np.asarray(mesh.vertices)[face[2]]
-        tri_center = np.asarray([(a[0]+b[0]+c[0])/3, (a[1]+b[1]+c[1])/3, (a[2]+b[2]+c[2])/3])
-
-        f_x += np.sign(tri_center[0])*(tri_center[0])**2
-        f_y += np.sign(tri_center[1])*(tri_center[1])**2
-        f_z += np.sign(tri_center[2])*(tri_center[2])**2
-
-    if np.sign(f_x) == -1:
-        center = get_barycenter(mesh)
-        R = np.asarray([[np.cos(np.pi), 0, np.sin(np.pi)],[0, 1, 0],[-np.sin(np.pi), 0, np.cos(np.pi)]])
-        mesh.rotate(R, center=center)
+def eigenvectors_check(mesh):
 
-    if np.sign(f_y) == -1:
-        center = get_barycenter(mesh)
-        R = np.asarray([[1, 0, 0], [0, np.cos(np.pi), -np.sin(np.pi)], [0, np.sin(np.pi), np.cos(np.pi)]])
-        mesh.rotate(R, center=center)
+    eig_vec, eig_val = compute_pca(mesh)
+    sort_eig_val = sorted(eig_val)
+    index_maj = np.where(eig_val == sort_eig_val[2])[0][0]
+    maj_eig_vec = eig_vec[:, index_maj]
 
-    if np.sign(f_z) == -1:
-        center = get_barycenter(mesh)
-        R = np.asarray([[np.cos(np.pi), 0, np.sin(np.pi)], [0, 1, 0], [-np.sin(np.pi), 0, np.cos(np.pi)]])
-        mesh.rotate(R, center=center)
+    index_med = np.where(eig_val == sort_eig_val[1])[0][0]
+    med_eig_vec = eig_vec[:, index_med]
+    maj_cross_med = np.cross(maj_eig_vec, med_eig_vec)
 
-        center = get_barycenter(mesh)
-        R = np.asarray([[np.cos(-1/4 * np.pi), -np.sin(-1/4 * np.pi), 0], [np.sin(-1/4*np.pi), np.cos(-1/4*np.pi), 0], [0,0,1]])
-        mesh.rotate(R, center=center)
+    dot_x = np.absolute(np.dot(maj_eig_vec, [1, 0, 0]))
+    dot_y = np.absolute(np.dot(med_eig_vec, [0, 1, 0]))
+    dot_z = np.absolute(np.dot(maj_cross_med, [0, 0, 1]))
 
-    print("Mesh flipped.")
+    value = (dot_x + dot_y + dot_z) / 3
 
-    return mesh
+    return value
 
-"""
 
 def flip_test(mesh):
     """
@@ -319,51 +293,23 @@ def flip_test(mesh):
     return mesh
 
 
+def flip_test_check(mesh):
 
+    f_x = 0
+    f_y = 0
+    f_z = 0
 
-"""def testing():
-
-    coord_frame = o3d.geometry.TriangleMesh.create_coordinate_frame(origin=[0, 0, 0])
-
-    #mesh = load_mesh("./benchmark/db_refined/14/m1450/m1450.off") #random mesh
-
-    #mesh = load_mesh("./benchmark/db_refined/11/m1112/m1112.off") #f_x negative #very not watertight, like not at allllll
-    #mesh = load_mesh("./benchmark/db_refined/6/m672/m672.off") #f_x negative --> needs inversion
-    #mesh = load_mesh("./benchmark/db_refined/0/m12/m12.off") #f_y negative --> needs inversion
-    #mesh = load_mesh("./benchmark/db_refined/17/m1777/m1777.off") #f_z negative --> needs inversion #rotate around y axis 180 degrees
-
-    #mesh = load_mesh("./benchmark/db_refined/14/m1450/m1450.off") #f_x and f_y negative --> no inversion
-    #mesh = load_mesh("./benchmark/db_refined/5/m556/m556.off") #f_x and f_z negative #flip only x axis --> no inversion
-    mesh = load_mesh("./benchmark/db_refined/0/m99/m99.off") #f_y and f_z negative #seems to work --> no inversion
-
-
-    #mesh = load_mesh("./benchmark/db_refined/5/m558/m558.off")  # f_x, f_y and f_z negative #rotate around the y axis 180 degrees
-    #mesh = load_mesh("./benchmark/db_refined/18/m1800/m1800.off") #all positive
-
-    print(f"Mesh barycenter before normalisation:{get_barycenter(mesh)}")
-    mesh_norm = copy.deepcopy(mesh)
-    mesh = translate_to_origin(mesh)
-    mesh = align_eigenvectors(mesh)
-    mesh.translate(translation=[-1.5, 0, 0])
-
-    mesh_norm = translate_to_origin(mesh_norm)
-    #view_mesh(mesh_norm, draw_coordinates=True)
-    #R = mesh.get_rotation_matrix_from_xyz((np.pi / 2, 0, np.pi / 4))
-    #mesh_norm.rotate(R, center=get_barycenter(mesh))
-    print(f"Mesh barycenter before rotation:{get_barycenter(mesh_norm)}")
-
-    mesh_copy = copy.deepcopy(mesh_norm)
-
-    mesh_norm = align_eigenvectors(mesh_norm)
-    mesh_norm = flip_test(mesh_norm)
-
-    mesh.compute_vertex_normals()
-    mesh_norm.compute_vertex_normals()
-
-
-    o3d.visualization.draw_geometries([mesh, mesh_norm])
-
-
-testing()"""
+    for face in np.asarray(mesh.triangles):
+        a = np.asarray(mesh.vertices)[face[0]]
+        b = np.asarray(mesh.vertices)[face[1]]
+        c = np.asarray(mesh.vertices)[face[2]]
+        tri_center = np.asarray([(a[0]+b[0]+c[0])/3, (a[1]+b[1]+c[1])/3, (a[2]+b[2]+c[2])/3])
 
+        f_x += np.sign(tri_center[0])*(tri_center[0])**2
+        f_y += np.sign(tri_center[1])*(tri_center[1])**2
+        f_z += np.sign(tri_center[2])*(tri_center[2])**2
 
+    if f_x > 0 and f_y > 0 and f_z > 0:
+        return 1
+    else:
+        return -1