Add plot centeral line function

Author: user

d3dslic3r/d3dslic3r_common.py

@@ -154,6 +154,95 @@ def get_polydata_from_stl(fname):
 
     return polydata
 
+def get_skeleton_dict(outline,whole_angle,step_size,suggested_hatching_offset):
+    """
+    Returns a dictionary of skeleton lines for each hatch angle
+
+    skeleton_dict structure:
+    {
+        hatch_angle1: {  
+            skeleton1: [midpoint1, midpoint2, ...]
+            skeleton2: [midpoint1, midpoint2, ...]
+        }
+        hatch_angle2: {
+            skeleton1: [midpoint1, midpoint2, ...]
+            skeleton2: [midpoint1, midpoint2, ...]
+        }
+    }
+    """
+
+    midpoint_line_dict = {hatch_angle: [] for hatch_angle in np.arange(0, whole_angle, step_size)}
+    for hatch_angle in np.arange(0, whole_angle, step_size):
+        intersecting_lines, _, num_of_line_list = get_intersections(outline,hatch_angle,
+                                                                    suggested_hatching_offset,0.5)
+
+        # Get all the unique values in num_of_line_list
+        lines_index_list = list(set(num_of_line_list))
+        midpoint_line_dict[hatch_angle] = {line_index: [] for line_index in lines_index_list}
+        
+        for line_index, number_of_line in enumerate(num_of_line_list):
+            if number_of_line in lines_index_list:
+                midpoint = (intersecting_lines[line_index][0] + intersecting_lines[line_index][1]) / 2
+                midpoint_line_dict[hatch_angle][number_of_line].append(midpoint)
+    return midpoint_line_dict
+
+def get_central_line_path(skeleton_dict, entry):
+    """
+    Returns a list of central line paths for each entry
+    """
+    certral_line_path = []
+    for rotate_angle_line1, path_index_line1 in skeleton_dict.items():
+        for skeleton_line1 in path_index_line1.values():
+            if len(skeleton_line1) > 1:
+                for line_index1 in range(len(skeleton_line1) - 1):
+                    P1 = skeleton_line1[line_index1][:2]
+                    P2 = skeleton_line1[line_index1 + 1][:2]
+                    line1 = [P1, P2]
+                    for rotate_angle_line2, path_index_line2 in skeleton_dict.items():
+                        if rotate_angle_line2 != rotate_angle_line1:
+                            for skeleton_line2 in path_index_line2.values():
+                                if len(skeleton_line2) > 1:
+                                    for line_index2 in range(len(skeleton_line2) - 1):
+                                        P3 = skeleton_line2[line_index2][:2]
+                                        P4 = skeleton_line2[line_index2 + 1][:2]
+                                        line2 = [P3, P4]
+                                        local_intersection = line_intersection(line1, line2)
+                                        if local_intersection is not None:
+                                            certral_line_path.append(np.array([local_intersection[0],
+                                                                    local_intersection[1],entry]))
+    return np.array(certral_line_path)
+
+def reorder_points_based_on_intersetion(cleaned_certral_line_path, outline):
+    """
+    Reorder the points in the central line path based on the intersection with the outline
+    If intersection is found, the points before the intersection will be reversed
+    if the distance between the first point and the intersection is less than 1, 
+    (this needs to be adjusted based on the actual distance, need to be improved)
+    the points after the interseciton will also be reversed.
+    """
+    reordered_certral_line_path = []
+    for line1_index in range(len(cleaned_certral_line_path) - 1):
+        P1 = cleaned_certral_line_path[line1_index]
+        P2 = cleaned_certral_line_path[line1_index + 1]
+        line1 = [P1, P2]
+        for line2_index in range(len(outline) - 1):
+            P3 = outline[line2_index]
+            P4 = outline[line2_index + 1]
+            line2 = [P3, P4]
+            local_intersection = line_intersection(line1, line2)
+            if local_intersection is not None:
+                distance = np.linalg.norm(np.array(P2) - np.array(cleaned_certral_line_path[0]))
+                # To be improved
+                if distance < 1:
+                    reordered_certral_line_path = np.concatenate((cleaned_certral_line_path[:line1_index+1][::-1], 
+                                                cleaned_certral_line_path[line1_index+1:]))
+                    return reordered_certral_line_path
+                else:
+                    reordered_certral_line_path = np.concatenate((cleaned_certral_line_path[:line1_index+1][::-1], 
+                                                cleaned_certral_line_path[line1_index+1:][::-1]))
+                    return reordered_certral_line_path
+    return reordered_certral_line_path
+
 def actor_from_polydata(polydata):
     """
     Wrap the provided vtkPolyData object in a mapper and an actor, returning
@@ -170,6 +259,24 @@ def actor_from_polydata(polydata):
 
     return stl_actor
 
+def get_starting_point(inp):
+    """
+    get the starting point of the outline based on the distance between points
+    if the distance between two points is the largest, the starting point is the first point
+    """
+    
+    points = inp[:,0:2]
+    dist = []
+    for i in range(len(points)-1):
+        distance = np.linalg.norm(points[i+1] - points[i])
+        dist.append(distance)
+        
+    mean = np.mean(dist)
+    std = np.std(dist)
+    z_scores = [(x - mean) / std for x in dist]
+    outliers = np.argmax(z_scores)
+    return outliers
+
 def sort_ccw(inp):
     """
     Sorts in 2D x,y pairs according to ccw position from the centroid.
@@ -319,31 +426,54 @@ def get_intersections(outline, angular_offset, width, bead_offset = 0.5):
     #break up on the basis of bead width
     num_passes = int(np.floor((limits[1]-(width*bead_offset) - limits[0]+(width*bead_offset))/(width*bead_offset)))
     xrange = np.linspace(limits[0]+(width*bead_offset),limits[1]-(width*bead_offset),num_passes)
-    
-    actual_bead_offset = (xrange[1]-xrange[0])/width
+
+    if len(xrange) < 2:
+        actual_bead_offset = 0
+    else:
+        actual_bead_offset = (xrange[1]-xrange[0])/width
 
     intersections = []
+    point_list = []  
+    previous_max_point_num = 0
+    mode_change_times = 0
     for k in range(len(xrange)):
         line = np.array([[xrange[k],yrange[0]], [xrange[k],yrange[1]]])
         line1 = tuple([tuple(x) for x in line.tolist()])
 
+        point_index = 0
+        
         for i in range(len(X)-1):
             line2 = tuple([tuple(x) for x in X[i:i+2,:]])
             local_intersection = line_intersection(line1, line2)
             if local_intersection is not None:
+                point_index += 1
+                
                 intersections.append(np.array([local_intersection[0],local_intersection[1],zval]))
+        if point_index != previous_max_point_num:
+            previous_max_point_num = point_index
+            mode_change_times += 1
+        temp_list = [x + mode_change_times*100 for x in range(point_index)]
+        temp_list = [str(x) for x in temp_list]
+        point_list.extend(temp_list)
+    
     #Needs to be 3D for transformation
     intersections = np.asarray(intersections)
-    intersections = intersections[np.lexsort((intersections[:, 1], intersections[:, 0]))]
-    trans_intersections = do_transform(intersections,np.linalg.inv(trans))
-    trans_intersections = do_transform(trans_intersections,np.linalg.inv(trans_cent))
+    if len(intersections) > 1:
+        intersections = intersections[np.lexsort((intersections[:, 1], intersections[:, 0]))]
+        trans_intersections = do_transform(intersections,np.linalg.inv(trans))
+        trans_intersections = do_transform(trans_intersections,np.linalg.inv(trans_cent))
 
-    #pack up/pair intersections for line paths
-    path_list = []
-    for i in np.arange(len(trans_intersections)-1)[::2]:
-        path_list.append(np.array([trans_intersections[i,:], trans_intersections[i+1,:]]))
+        #pack up/pair intersections for line paths
+        path_list = []
+        line_index_list = []
+        for i in np.arange(len(trans_intersections)-1)[::2]:
+            path_list.append(np.array([trans_intersections[i,:], trans_intersections[i+1,:]]))
+            line_index_list.append(point_list[i])
+    else:
+        path_list = []
+        line_index_list = []
     #return intersections , actual bead offset
-    return path_list, actual_bead_offset
+    return path_list, actual_bead_offset, line_index_list
 
 def line_intersection(line1, line2):
     '''
@@ -370,9 +500,9 @@ def line_intersection(line1, line2):
 
     if det == 0.0:  # lines are parallel
 
-        if line1[0] == line2[0] or line1[1] == line2[0]:
+        if np.array_equal(line1[0], line2[0]) or np.array_equal(line1[1], line2[0]):
             return line2[0]
-        elif line1[0] == line2[1] or line1[1] == line2[1]:
+        elif np.array_equal(line1[0], line2[1]) or np.array_equal(line1[1], line2[1]):
             return line2[1]
 
         #Special cases

d3dslic3r/slic3_widget.py

@@ -178,6 +178,8 @@ def setup(self, MainWindow):
         self.path_all_cb.setToolTip('Apply to all slices')
         self.path_outline_cb = QtWidgets.QCheckBox('Path outline')
         self.path_outline_cb.setToolTip('Include outline in pathing')
+        self.path_central_line_cb = QtWidgets.QCheckBox('Path central line')
+        self.path_central_line_cb.setToolTip('Get the central line of the outline')
         self.rotate_z_path_sb = QtWidgets.QDoubleSpinBox()
         self.rotate_z_path_sb.setToolTip('Rotational offset for pathing of slice. Positive is clockwise.')
         self.rotate_z_path_sb.setSingleStep(5.00)
@@ -209,11 +211,12 @@ def setup(self, MainWindow):
         #populate pathing layout
         path_gen_layout.addWidget(self.path_all_cb,0,0,1,1)
         path_gen_layout.addWidget(self.path_outline_cb,0,1,1,1)
-        path_gen_layout.addWidget(self.rotate_z_path_sb,0,2,1,1)
-        path_gen_layout.addWidget(self.by_width_sb,0,3,1,1)
-        path_gen_layout.addWidget(self.bead_offset_sb,0,4,1,1)
+        path_gen_layout.addWidget(self.path_central_line_cb,0,2,1,1)
+        path_gen_layout.addWidget(self.rotate_z_path_sb,0,3,1,1)
+        path_gen_layout.addWidget(self.by_width_sb,0,4,1,1)
+        path_gen_layout.addWidget(self.bead_offset_sb,0,5,1,1)
         path_gen_layout.addWidget(self.num_paths_label,1,0,1,2)
-        path_gen_layout.addWidget(self.activate_path_pb,1,4,1,1)
+        path_gen_layout.addWidget(self.activate_path_pb,1,5,1,1)
 
         self.path_box.setEnabled(False)
 
@@ -661,6 +664,8 @@ def draw_slice(self):
             self.slice_data[entry] = slice_obj(self.outlines[entry])
 
         outline = self.slice_data[entry].outline
+        central_line = self.slice_data[entry].central_line
+        intermediate_line = self.slice_data[entry].intermediate_line
 
         self.current_outline_actor = gen_outline_actor(outline, (1,0,0), 4)
         self.outline_caption_actor = gen_caption_actor('%s'%entry, self.current_outline_actor, (1,0,0))
@@ -674,6 +679,15 @@ def draw_slice(self):
 
         ax = self.ui.figure.add_subplot(111)
         ax.plot(outline[:,0], outline[:,1], 'k-')
+        if intermediate_line != []:
+            for line in intermediate_line:
+                x_coords = [point[0] for point in line]
+                y_coords = [point[1] for point in line]
+                ax.plot(x_coords, y_coords, 'g-')
+        #         # plot the points
+        #         ax.plot(x_coords, y_coords, 'ro')
+        if len(central_line) != 0:
+            ax.plot(central_line[:,0], central_line[:,1], 'r-')
         ax.set_ylabel("y (mm)")
         ax.set_xlabel("x (mm)")
         ax.grid(visible=True, which='major', color='#666666', linestyle='-', alpha=0.1)
@@ -734,14 +748,25 @@ def make_paths(self):
                 interior = offset_poly(outline,-self.ui.by_width_sb.value())
                 midline = offset_poly(outline,-self.ui.by_width_sb.value()*0.5)
                 innie = offset_poly(outline,-self.ui.by_width_sb.value())
-                intersecting_lines, param = get_intersections(innie,theta,self.ui.by_width_sb.value(),offset)
+                intersecting_lines, param, _ = get_intersections(
+                                        innie,theta,self.ui.by_width_sb.value(),offset)
                 local_path_collection.append(midline)
                 local_path_collection.extend(intersecting_lines)
+                self.ui.num_paths_label.setText('N = %i at %0.2f%%'%(len(intersecting_lines),param*100))
+                # update interactor with result
+                self.ui.num_paths_label.setText('N = %i at %0.2f%%'%(len(intersecting_lines),param*100))
+
+            elif self.ui.path_central_line_cb.isChecked():
+                ordered_certral_line_path, skeleton_path = self.get_ordered_central_line_path(outline, entry)
+                self.slice_data[entry].central_line = np.array(ordered_certral_line_path)
+                self.slice_data[entry].intermediate_line = skeleton_path
+
             else:
-                intersecting_lines, param = get_intersections(outline,theta,self.ui.by_width_sb.value(),offset)
+                intersecting_lines, param, _ = get_intersections(
+                                        outline,theta,self.ui.by_width_sb.value(),offset)
                 local_path_collection = intersecting_lines
 
-            self.slice_data[entry].paths = local_path_collection #list of paths
+                self.slice_data[entry].paths = local_path_collection #list of paths
 
         else: #iterate over all entries
             for i in range(self.ui.slice_num_cb.count()):
@@ -754,20 +779,61 @@ def make_paths(self):
                     interior = offset_poly(outline,-self.ui.by_width_sb.value())
                     midline = offset_poly(outline,-self.ui.by_width_sb.value()*0.5)
                     innie = offset_poly(outline,-self.ui.by_width_sb.value())
-                    intersecting_lines, param = get_intersections(innie,theta,self.ui.by_width_sb.value(),offset)
+                    intersecting_lines, param, _ = get_intersections(
+                                                innie,theta,self.ui.by_width_sb.value(),offset)
                     local_path_collection.append(midline)
                     local_path_collection.extend(intersecting_lines)
+                    # update interactor with result
+                    self.ui.num_paths_label.setText('N = %i at %0.2f%%'%(len(intersecting_lines),param*100))
+
+                elif self.ui.path_central_line_cb.isChecked():
+                    ordered_certral_line_path, skeleton_path = self.get_ordered_central_line_path(outline, entry)
+                    self.slice_data[entry].central_line = np.array(ordered_certral_line_path)
+                    self.slice_data[entry].intermediate_line = skeleton_path
+
                 else:
-                    intersecting_lines, param = get_intersections(outline,theta,self.ui.by_width_sb.value(),offset)
+                    intersecting_lines, param, _ = get_intersections(
+                                        outline,theta,self.ui.by_width_sb.value(),offset)
                     local_path_collection = intersecting_lines
 
                 self.slice_data[entry].paths = local_path_collection #list of paths
 
-        # update interactor with result
-        self.ui.num_paths_label.setText('N = %i at %0.2f%%'%(len(intersecting_lines),param*100))
+        
         self.ui.export_slice.setEnabled(True)
         self.draw_slice() #to clear any existing intersections
 
+    def get_ordered_central_line_path(self, outline, entry):
+        step_size = 30.01
+        limits = get_limits(outline,0)
+        suggested_hatching_offset = min((limits[1]-limits[0]),(limits[3]-limits[2]))/15
+        whole_angle = 180
+        skeleton_dict = get_skeleton_dict(outline,whole_angle,step_size,
+                                                    suggested_hatching_offset)
+
+        certral_line_path = get_central_line_path(skeleton_dict, entry)
+        ordered_certral_line_path = order_points_in_loop(certral_line_path)
+        starting_point_index = get_starting_point(ordered_certral_line_path)
+        ordered_certral_line_path = np.concatenate((ordered_certral_line_path[starting_point_index:], 
+                                                    ordered_certral_line_path[:starting_point_index]), axis=0)
+        ordered_certral_line_path = self.remove_repeated_points_preserve_order(ordered_certral_line_path)
+        ordered_certral_line_path = order_points_in_loop(ordered_certral_line_path)[:-1]
+        # get the skeleton of the outline
+        skeleton = []
+        for key in skeleton_dict.keys():
+            for value in skeleton_dict[key].values():
+                skeleton.append(value)
+        return ordered_certral_line_path, skeleton
+
+    def remove_repeated_points_preserve_order(self, points):
+        seen = set()
+        unique_points = []
+        for point in points:
+            point_tuple = tuple(point)
+            if point_tuple not in seen:
+                seen.add(point_tuple)
+                unique_points.append(point)
+        return np.array(unique_points)
+
     def draw_paths(self):
 
         #get active outline
@@ -797,6 +863,8 @@ def __init__(self, outline):
         self.outline = outline
         self.alpha = None
         self.paths = None
+        self.central_line = []
+        self.intermediate_line = []
 
 if __name__ == "__main__":
     launch()