diff options
| author | lijenstina <lijenstina@gmail.com> | 2017-04-14 06:01:08 +0300 |
|---|---|---|
| committer | lijenstina <lijenstina@gmail.com> | 2017-04-14 06:01:08 +0300 |
| commit | b7b4e2fbe72a69a7f24b1d7dcb4baf0975606f8a (patch) | |
| tree | 9ff7b823cc59f6a8ab6051e4811e7f9da4b83272 /mesh_bsurfaces.py | |
| parent | 40c74f1ff85f73a9f942ce433ad671626a187277 (diff) | |
Bsurfaces: Update panel Rename, Cleanup
Bumped version to 1.5.1
As a part of the task T50726:
Update the Panel rename code to more generic one
PEP8 cleanup:
Tuple imports and use them for class types
Consistent Scene props definitions
Update url link
Note:
Moved the Scene Properties into a PropertyGroup
Access them with bpy.context.scene.bsurfaces
There are still some possibly unused variables
In the future, during a refactor that could
be adressed (as they are not all function calls)
Fixed some crashes that i got during testing:
line 1402:
The Remove Doubles treshold calc in one case
caused divide by zero - fallback to 0.0001
line 458:
Index out of range error
line 2955:
zero Vector angles
If there are some better solutions, these are the
places to look
Diffstat (limited to 'mesh_bsurfaces.py')
| -rw-r--r-- | mesh_bsurfaces.py | 2284 |
1 files changed, 1227 insertions, 1057 deletions
diff --git a/mesh_bsurfaces.py b/mesh_bsurfaces.py index 21c6e50e..80943858 100644 --- a/mesh_bsurfaces.py +++ b/mesh_bsurfaces.py @@ -20,27 +20,45 @@ bl_info = { "name": "Bsurfaces GPL Edition", "author": "Eclectiel", - "version": (1, 5), + "version": (1, 5, 1), "blender": (2, 76, 0), "location": "View3D > EditMode > ToolShelf", - "description": "Modeling and retopology tool.", - "wiki_url": "http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.64/Bsurfaces_1.5", + "description": "Modeling and retopology tool", + "wiki_url": "https://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.64/Bsurfaces_1.5", "category": "Mesh", } import bpy import bmesh -import math -import mathutils -import operator - -from math import * - - - -class VIEW3D_PT_tools_SURFSK_mesh(bpy.types.Panel): +import operator +from mathutils import Vector +from mathutils.geometry import ( + intersect_line_line, + intersect_point_line, + ) +from math import ( + degrees, + pi, + sqrt, + ) +from bpy.props import ( + BoolProperty, + FloatProperty, + IntProperty, + StringProperty, + PointerProperty, + ) +from bpy.types import ( + Operator, + Panel, + PropertyGroup, + AddonPreferences, + ) + + +class VIEW3D_PT_tools_SURFSK_mesh(Panel): bl_space_type = 'VIEW_3D' bl_region_type = 'TOOLS' bl_category = 'Tools' @@ -51,12 +69,9 @@ class VIEW3D_PT_tools_SURFSK_mesh(bpy.types.Panel): def poll(cls, context): return context.active_object - def draw(self, context): layout = self.layout - - scn = context.scene - ob = context.object + scn = context.scene.bsurfaces col = layout.column(align=True) row = layout.row() @@ -70,8 +85,7 @@ class VIEW3D_PT_tools_SURFSK_mesh(bpy.types.Panel): col.prop(scn, "SURFSK_keep_strokes") - -class VIEW3D_PT_tools_SURFSK_curve(bpy.types.Panel): +class VIEW3D_PT_tools_SURFSK_curve(Panel): bl_space_type = 'VIEW_3D' bl_region_type = 'TOOLS' bl_context = "curve_edit" @@ -82,13 +96,9 @@ class VIEW3D_PT_tools_SURFSK_curve(bpy.types.Panel): def poll(cls, context): return context.active_object - def draw(self, context): layout = self.layout - scn = context.scene - ob = context.object - col = layout.column(align=True) row = layout.row() row.separator() @@ -97,16 +107,14 @@ class VIEW3D_PT_tools_SURFSK_curve(bpy.types.Panel): col.operator("curve.surfsk_reorder_splines", text="Reorder Splines") - - -#### Returns the type of strokes used. +# Returns the type of strokes used def get_strokes_type(main_object): strokes_type = "" strokes_num = 0 # Check if they are grease pencil try: - #### Get the active grease pencil layer. + # Get the active grease pencil layer strokes_num = len(main_object.grease_pencil.layers.active.active_frame.strokes) if strokes_num > 0: @@ -114,8 +122,7 @@ def get_strokes_type(main_object): except: pass - - # Check if they are curves, if there aren't grease pencil strokes. + # Check if they are curves, if there aren't grease pencil strokes if strokes_type == "": if len(bpy.context.selected_objects) == 2: for ob in bpy.context.selected_objects: @@ -123,7 +130,7 @@ def get_strokes_type(main_object): strokes_type = "EXTERNAL_CURVE" strokes_num = len(ob.data.splines) - # Check if there is any non-bezier spline. + # Check if there is any non-bezier spline for i in range(len(ob.data.splines)): if ob.data.splines[i].type != "BEZIER": strokes_type = "CURVE_WITH_NON_BEZIER_SPLINES" @@ -134,8 +141,7 @@ def get_strokes_type(main_object): elif len(bpy.context.selected_objects) > 2: strokes_type = "MORE_THAN_ONE_EXTERNAL" - - # Check if there is a single stroke without any selection in the object. + # Check if there is a single stroke without any selection in the object if strokes_num == 1 and main_object.data.total_vert_sel == 0: if strokes_type == "EXTERNAL_CURVE": strokes_type = "SINGLE_CURVE_STROKE_NO_SELECTION" @@ -145,69 +151,66 @@ def get_strokes_type(main_object): if strokes_num == 0 and main_object.data.total_vert_sel > 0: strokes_type = "SELECTION_ALONE" - if strokes_type == "": strokes_type = "NO_STROKES" - - return strokes_type - - -# Surface generator operator. -class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): +# Surface generator operator +class GPENCIL_OT_SURFSK_add_surface(Operator): bl_idname = "gpencil.surfsk_add_surface" bl_label = "Bsurfaces add surface" bl_description = "Generates surfaces from grease pencil strokes, bezier curves or loose edges" bl_options = {'REGISTER', 'UNDO'} - - edges_U = bpy.props.IntProperty(name = "Cross", - description = "Number of face-loops crossing the strokes", - default = 1, - min = 1, - max = 200) - - edges_V = bpy.props.IntProperty(name = "Follow", - description = "Number of face-loops following the strokes", - default = 1, - min = 1, - max = 200) - - cyclic_cross = bpy.props.BoolProperty(name = "Cyclic Cross", - description = "Make cyclic the face-loops crossing the strokes", - default = False) - - cyclic_follow = bpy.props.BoolProperty(name = "Cyclic Follow", - description = "Make cyclic the face-loops following the strokes", - default = False) - - loops_on_strokes = bpy.props.BoolProperty(name = "Loops on strokes", - description = "Make the loops match the paths of the strokes", - default = False) - - automatic_join = bpy.props.BoolProperty(name = "Automatic join", - description = "Join automatically vertices of either surfaces generated by crosshatching, or from the borders of closed shapes", - default = False) - - join_stretch_factor = bpy.props.FloatProperty(name = "Stretch", - description = "Amount of stretching or shrinking allowed for edges when joining vertices automatically", - default = 1, - min = 0, - max = 3, - subtype = 'FACTOR') - - - + edges_U = IntProperty( + name="Cross", + description="Number of face-loops crossing the strokes", + default=1, + min=1, + max=200 + ) + edges_V = IntProperty( + name="Follow", + description="Number of face-loops following the strokes", + default=1, + min=1, + max=200 + ) + cyclic_cross = BoolProperty( + name="Cyclic Cross", + description="Make cyclic the face-loops crossing the strokes", + default=False + ) + cyclic_follow = BoolProperty( + name="Cyclic Follow", + description="Make cyclic the face-loops following the strokes", + default=False + ) + loops_on_strokes = BoolProperty( + name="Loops on strokes", + description="Make the loops match the paths of the strokes", + default=False + ) + automatic_join = BoolProperty( + name="Automatic join", + description="Join automatically vertices of either surfaces generated " + "by crosshatching, or from the borders of closed shapes", + default=False + ) + join_stretch_factor = FloatProperty( + name="Stretch", + description="Amount of stretching or shrinking allowed for " + "edges when joining vertices automatically", + default=1, + min=0, + max=3, + subtype='FACTOR' + ) def draw(self, context): layout = self.layout - - scn = context.scene - ob = context.object - col = layout.column(align=True) row = layout.row() @@ -225,14 +228,19 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): row.separator() if not self.selection_U_exists: - if not ((self.selection_V_exists and not self.selection_V_is_closed) or (self.selection_V2_exists and not self.selection_V2_is_closed)): + if not ( + (self.selection_V_exists and not self.selection_V_is_closed) or + (self.selection_V2_exists and not self.selection_V2_is_closed) + ): col.prop(self, "cyclic_cross") if not self.selection_V_exists: - if not ((self.selection_U_exists and not self.selection_U_is_closed) or (self.selection_U2_exists and not self.selection_U2_is_closed)): + if not ( + (self.selection_U_exists and not self.selection_U_is_closed) or + (self.selection_U2_exists and not self.selection_U2_is_closed) + ): col.prop(self, "cyclic_follow") - col.prop(self, "loops_on_strokes") col.prop(self, "automatic_join") @@ -243,10 +251,9 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): row.separator() col.prop(self, "join_stretch_factor") - - - #### Get an ordered list of a chain of vertices. - def get_ordered_verts(self, ob, all_selected_edges_idx, all_selected_verts_idx, first_vert_idx, middle_vertex_idx, closing_vert_idx): + # Get an ordered list of a chain of vertices + def get_ordered_verts(self, ob, all_selected_edges_idx, all_selected_verts_idx, + first_vert_idx, middle_vertex_idx, closing_vert_idx): # Order selected vertices. verts_ordered = [] if closing_vert_idx is not None: @@ -259,11 +266,15 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): while True: edges_non_matched = 0 for i in all_selected_edges_idx: - if ob.data.edges[i] != prev_ed and ob.data.edges[i].vertices[0] == prev_v and ob.data.edges[i].vertices[1] in all_selected_verts_idx: + if ob.data.edges[i] != prev_ed and ob.data.edges[i].vertices[0] == prev_v and \ + ob.data.edges[i].vertices[1] in all_selected_verts_idx: + verts_ordered.append(ob.data.vertices[ob.data.edges[i].vertices[1]]) prev_v = ob.data.edges[i].vertices[1] prev_ed = ob.data.edges[i] - elif ob.data.edges[i] != prev_ed and ob.data.edges[i].vertices[1] == prev_v and ob.data.edges[i].vertices[0] in all_selected_verts_idx: + elif ob.data.edges[i] != prev_ed and ob.data.edges[i].vertices[1] == prev_v and \ + ob.data.edges[i].vertices[0] in all_selected_verts_idx: + verts_ordered.append(ob.data.vertices[ob.data.edges[i].vertices[0]]) prev_v = ob.data.edges[i].vertices[0] prev_ed = ob.data.edges[i] @@ -285,8 +296,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return tuple(verts_ordered) - - #### Calculates length of a chain of points. + # Calculates length of a chain of points. def get_chain_length(self, object, verts_ordered): matrix = object.matrix_world @@ -308,8 +318,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return edges_lengths, edges_lengths_sum - - #### Calculates the proportion of the edges of a chain of edges, relative to the full chain length. + # Calculates the proportion of the edges of a chain of edges, relative to the full chain length. def get_edges_proportions(self, edges_lengths, edges_lengths_sum, use_boundaries, fixed_edges_num): edges_proportions = [] if use_boundaries: @@ -325,22 +334,22 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return edges_proportions - - #### Calculates the angle between two pairs of points in space. - def orientation_difference(self, points_A_co, points_B_co): # each parameter should be a list with two elements, and each element should be a x,y,z coordinate. + # Calculates the angle between two pairs of points in space + def orientation_difference(self, points_A_co, points_B_co): + # each parameter should be a list with two elements, + # and each element should be a x,y,z coordinate vec_A = points_A_co[0] - points_A_co[1] vec_B = points_B_co[0] - points_B_co[1] angle = vec_A.angle(vec_B) - if angle > 0.5 * math.pi: - angle = abs(angle - math.pi) + if angle > 0.5 * pi: + angle = abs(angle - pi) return angle - - - #### Calculate the which vert of verts_idx list is the nearest one to the point_co coordinates, and the distance. + # Calculate the which vert of verts_idx list is the nearest one + # to the point_co coordinates, and the distance def shortest_distance(self, object, point_co, verts_idx): matrix = object.matrix_world @@ -358,8 +367,8 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return nearest_vert_idx, shortest_dist - - #### Returns the index of the opposite vert tip in a chain, given a vert tip index as parameter, and a multidimentional list with all pairs of tips. + # Returns the index of the opposite vert tip in a chain, given a vert tip index + # as parameter, and a multidimentional list with all pairs of tips def opposite_tip(self, vert_tip_idx, all_chains_tips_idx): opposite_vert_tip_idx = None for i in range(0, len(all_chains_tips_idx)): @@ -370,9 +379,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return opposite_vert_tip_idx - - - #### Simplifies a spline and returns the new points coordinates. + # Simplifies a spline and returns the new points coordinates def simplify_spline(self, spline_coords, segments_num): simplified_spline = [] points_between_segments = round(len(spline_coords) / segments_num) @@ -385,11 +392,11 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return simplified_spline - - - #### Cleans up the scene and gets it the same it was at the beginning, in case the script is interrupted in the middle of the execution. + # Cleans up the scene and gets it the same it was at the beginning, + # in case the script is interrupted in the middle of the execution def cleanup_on_interruption(self): - # If the original strokes curve comes from conversion from grease pencil and wasn't made by hand, delete it. + # If the original strokes curve comes from conversion + # from grease pencil and wasn't made by hand, delete it if not self.using_external_curves: try: bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') @@ -411,58 +418,61 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - #### Returns a list with the coords of the points distributed over the splines passed to this method according to the proportions parameter. + # Returns a list with the coords of the points distributed over the splines + # passed to this method according to the proportions parameter def distribute_pts(self, surface_splines, proportions): - # Calculate the length of each final surface spline. + + # Calculate the length of each final surface spline surface_splines_lengths = [] surface_splines_parsed = [] + for sp_idx in range(0, len(surface_splines)): # Calculate spline length surface_splines_lengths.append(0) + for i in range(0, len(surface_splines[sp_idx].bezier_points)): if i == 0: prev_p = surface_splines[sp_idx].bezier_points[i] else: p = surface_splines[sp_idx].bezier_points[i] - edge_length = (prev_p.co - p.co).length - surface_splines_lengths[sp_idx] += edge_length prev_p = p - - # Calculate vertex positions with appropriate edge proportions, and ordered, for each spline. + # Calculate vertex positions with appropriate edge proportions, and ordered, for each spline for sp_idx in range(0, len(surface_splines)): surface_splines_parsed.append([]) surface_splines_parsed[sp_idx].append(surface_splines[sp_idx].bezier_points[0].co) prev_p_co = surface_splines[sp_idx].bezier_points[0].co p_idx = 0 + for prop_idx in range(len(proportions) - 1): target_length = surface_splines_lengths[sp_idx] * proportions[prop_idx] - partial_segment_length = 0 - - finish_while = False - while True: - p_co = surface_splines[sp_idx].bezier_points[p_idx].co - new_dist = (prev_p_co - p_co).length - - potential_segment_length = partial_segment_length + new_dist # The new distance that could have the partial segment if it is still shorter than the target length. + while True: + # if not it'll pass the p_idx as an index bellow and crash + if p_idx < len(surface_splines[sp_idx].bezier_points): + p_co = surface_splines[sp_idx].bezier_points[p_idx].co + new_dist = (prev_p_co - p_co).length + # The new distance that could have the partial segment if + # it is still shorter than the target length + potential_segment_length = partial_segment_length + new_dist - if potential_segment_length < target_length: # If the potential is still shorter, keep adding. + # If the potential is still shorter, keep adding + if potential_segment_length < target_length: partial_segment_length = potential_segment_length p_idx += 1 prev_p_co = p_co - elif potential_segment_length > target_length: # If the potential is longer than the target, calculate the target (a point between the last two points), and assign. + # If the potential is longer than the target, calculate the target + # (a point between the last two points), and assign + elif potential_segment_length > target_length: remaining_dist = target_length - partial_segment_length vec = p_co - prev_p_co vec.normalize() @@ -475,9 +485,9 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): finish_while = True - elif potential_segment_length == target_length: # If the potential is equal to the target, assign. + # If the potential is equal to the target, assign + elif potential_segment_length == target_length: surface_splines_parsed[sp_idx].append(p_co) - prev_p_co = p_co finish_while = True @@ -486,25 +496,23 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): break # last point of the spline - surface_splines_parsed[sp_idx].append(surface_splines[sp_idx].bezier_points[len(surface_splines[sp_idx].bezier_points) - 1].co) - + surface_splines_parsed[sp_idx].append( + surface_splines[sp_idx].bezier_points[len(surface_splines[sp_idx].bezier_points) - 1].co + ) return surface_splines_parsed - - - #### Counts the number of faces that belong to each edge. + # Counts the number of faces that belong to each edge def edge_face_count(self, ob): ed_keys_count_dict = {} for face in ob.data.polygons: for ed_keys in face.edge_keys: - if not ed_keys in ed_keys_count_dict: + if ed_keys not in ed_keys_count_dict: ed_keys_count_dict[ed_keys] = 1 else: ed_keys_count_dict[ed_keys] += 1 - edge_face_count = [] for i in range(len(ob.data.edges)): edge_face_count.append(0) @@ -520,19 +528,15 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): elif (v2, v1) in ed_keys_count_dict: edge_face_count[i] = ed_keys_count_dict[(v2, v1)] - return edge_face_count - - - #### Fills with faces all the selected vertices which form empty triangles or quads. + # Fills with faces all the selected vertices which form empty triangles or quads def fill_with_faces(self, object): all_selected_verts_count = self.main_object_selected_verts_count - bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT') - #### Calculate average length of selected edges. + # Calculate average length of selected edges all_selected_verts = [] original_sel_edges_count = 0 for ed in object.data.edges: @@ -549,17 +553,13 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if not ed.vertices[1] in all_selected_verts: all_selected_verts.append(ed.vertices[1]) - tuple(all_selected_verts) - - #### Check if there is any edge selected. If not, interrupt the script. + # Check if there is any edge selected. If not, interrupt the script if original_sel_edges_count == 0 and all_selected_verts_count > 0: return 0 - - - #### Get all edges connected to selected verts. + # Get all edges connected to selected verts all_edges_around_sel_verts = [] edges_connected_to_sel_verts = {} verts_connected_to_every_vert = {} @@ -581,12 +581,10 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): edges_connected_to_sel_verts[ed.vertices[1]].append(ed_idx) include_edge = True - - if include_edge == True: + if include_edge is True: all_edges_around_sel_verts.append(ed_idx) - - # Get all connected verts to each vert. + # Get all connected verts to each vert if not ed.vertices[0] in verts_connected_to_every_vert: verts_connected_to_every_vert[ed.vertices[0]] = [] @@ -596,10 +594,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): verts_connected_to_every_vert[ed.vertices[0]].append(ed.vertices[1]) verts_connected_to_every_vert[ed.vertices[1]].append(ed.vertices[0]) - - - - #### Get all verts connected to faces. + # Get all verts connected to faces all_verts_part_of_faces = [] all_edges_faces_count = [] all_edges_faces_count += self.edge_face_count(object) @@ -624,28 +619,32 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): tuple(selected_verts_with_faces) - - - #### Discard unneeded verts from calculations. + # Discard unneeded verts from calculations participating_verts = [] movable_verts = [] for v_idx in all_selected_verts: vert_has_edges_with_one_face = False - for ed_idx in edges_connected_to_sel_verts[v_idx]: # Check if the actual vert has at least one edge connected to only one face. + # Check if the actual vert has at least one edge connected to only one face + for ed_idx in edges_connected_to_sel_verts[v_idx]: if count_faces_of_edges_around_sel_verts[ed_idx] == 1: vert_has_edges_with_one_face = True - # If the vert has two or less edges connected and the vert is not part of any face. Or the vert is part of any face and at least one of the connected edges has only one face attached to it. - if (len(edges_connected_to_sel_verts[v_idx]) == 2 and not v_idx in all_verts_part_of_faces) or len(edges_connected_to_sel_verts[v_idx]) == 1 or (v_idx in all_verts_part_of_faces and vert_has_edges_with_one_face): + # If the vert has two or less edges connected and the vert is not part of any face. + # Or the vert is part of any face and at least one of + # the connected edges has only one face attached to it. + if (len(edges_connected_to_sel_verts[v_idx]) == 2 and + v_idx not in all_verts_part_of_faces) or \ + len(edges_connected_to_sel_verts[v_idx]) == 1 or \ + (v_idx in all_verts_part_of_faces and + vert_has_edges_with_one_face): + participating_verts.append(v_idx) - if not v_idx in all_verts_part_of_faces: + if v_idx not in all_verts_part_of_faces: movable_verts.append(v_idx) - - - #### Remove from movable verts list those that are part of closed geometry (ie: triangles, quads) + # Remove from movable verts list those that are part of closed geometry (ie: triangles, quads) for mv_idx in movable_verts: freeze_vert = False mv_connected_verts = verts_connected_to_every_vert[mv_idx] @@ -656,11 +655,11 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): for mv_conn_v_idx in mv_connected_verts: if mv_idx != actual_v_idx: - if mv_conn_v_idx in verts_connected_to_every_vert[actual_v_idx] and not mv_conn_v_idx in checked_verts: + if mv_conn_v_idx in verts_connected_to_every_vert[actual_v_idx] and \ + mv_conn_v_idx not in checked_verts: count_shared_neighbors += 1 checked_verts.append(mv_conn_v_idx) - if actual_v_idx in mv_connected_verts: freeze_vert = True break @@ -675,9 +674,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if freeze_vert: movable_verts.remove(mv_idx) - - - #### Calculate merge distance for participating verts. + # Calculate merge distance for participating verts shortest_edge_length = None for ed in object.data.edges: if ed.vertices[0] in movable_verts and ed.vertices[1] in movable_verts: @@ -697,10 +694,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): else: edges_merge_distance = 0 - - - - #### Get together the verts near enough. They will be merged later. + # Get together the verts near enough. They will be merged later remaining_verts = [] remaining_verts += participating_verts for v1_idx in participating_verts: @@ -713,23 +707,20 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): v1_co = object.data.vertices[v1_idx].co coords_verts_to_merge[v1_idx] = (v1_co[0], v1_co[1], v1_co[2]) - for v2_idx in remaining_verts: if v1_idx != v2_idx: v2_co = object.data.vertices[v2_idx].co dist = (v1_co - v2_co).length - if dist <= edges_merge_distance: # Add the verts which are near enough. + if dist <= edges_merge_distance: # Add the verts which are near enough verts_to_merge.append(v2_idx) coords_verts_to_merge[v2_idx] = (v2_co[0], v2_co[1], v2_co[2]) - for vm_idx in verts_to_merge: remaining_verts.remove(vm_idx) - if len(verts_to_merge) > 1: # Calculate middle point of the verts to merge. sum_x_co = 0 @@ -746,23 +737,28 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): movable_verts_to_merge_count += 1 - middle_point_co = [sum_x_co / movable_verts_to_merge_count, sum_y_co / movable_verts_to_merge_count, sum_z_co / movable_verts_to_merge_count] + middle_point_co = [ + sum_x_co / movable_verts_to_merge_count, + sum_y_co / movable_verts_to_merge_count, + sum_z_co / movable_verts_to_merge_count + ] - - # Check if any vert to be merged is not movable. + # Check if any vert to be merged is not movable shortest_dist = None are_verts_not_movable = False verts_not_movable = [] for v_merge_idx in verts_to_merge: - if v_merge_idx in participating_verts and not v_merge_idx in movable_verts: + if v_merge_idx in participating_verts and v_merge_idx not in movable_verts: are_verts_not_movable = True verts_not_movable.append(v_merge_idx) if are_verts_not_movable: - # Get the vert connected to faces, that is nearest to the middle point of the movable verts. + # Get the vert connected to faces, that is nearest to + # the middle point of the movable verts shortest_dist = None for vcf_idx in verts_not_movable: - dist = abs((object.data.vertices[vcf_idx].co - mathutils.Vector(middle_point_co)).length) + dist = abs((object.data.vertices[vcf_idx].co - + Vector(middle_point_co)).length) if shortest_dist is None: shortest_dist = dist @@ -775,28 +771,24 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): coords = object.data.vertices[nearest_vert_idx].co target_point_co = [coords[0], coords[1], coords[2]] else: - target_point_co = middle_point_co - + target_point_co = middle_point_co - # Move verts to merge to the middle position. + # Move verts to merge to the middle position for v_merge_idx in verts_to_merge: - if v_merge_idx in movable_verts: # Only move the verts that are not part of faces. + if v_merge_idx in movable_verts: # Only move the verts that are not part of faces object.data.vertices[v_merge_idx].co[0] = target_point_co[0] object.data.vertices[v_merge_idx].co[1] = target_point_co[1] object.data.vertices[v_merge_idx].co[2] = target_point_co[2] - - - #### Perform "Remove Doubles" to weld all the disconnected verts + # Perform "Remove Doubles" to weld all the disconnected verts bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT') bpy.ops.mesh.remove_doubles(threshold=0.0001) bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT') - - #### Get all the definitive selected edges, after weldding. + # Get all the definitive selected edges, after weldding selected_edges = [] - edges_per_vert = {} # Number of faces of each selected edge. + edges_per_vert = {} # Number of faces of each selected edge for ed in object.data.edges: if object.data.vertices[ed.vertices[0]].select and object.data.vertices[ed.vertices[1]].select: selected_edges.append(ed.index) @@ -811,15 +803,16 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): edges_per_vert[ed.vertices[0]].append(ed.index) edges_per_vert[ed.vertices[1]].append(ed.index) - # Check if all the edges connected to each vert have two faces attached to them. To discard them later and make calculations faster. + # Check if all the edges connected to each vert have two faces attached to them. + # To discard them later and make calculations faster a = [] a += self.edge_face_count(object) tuple(a) verts_surrounded_by_faces = {} for v_idx in edges_per_vert: edges = edges_per_vert[v_idx] - edges_with_two_faces_count = 0 + for ed_idx in edges_per_vert[v_idx]: if a[ed_idx] == 2: edges_with_two_faces_count += 1 @@ -829,15 +822,13 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): else: verts_surrounded_by_faces[v_idx] = False - - #### Get all the selected vertices. + # Get all the selected vertices selected_verts_idx = [] for v in object.data.vertices: if v.select: selected_verts_idx.append(v.index) - - #### Get all the faces of the object. + # Get all the faces of the object all_object_faces_verts_idx = [] for face in object.data.polygons: face_verts = [] @@ -850,15 +841,12 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): all_object_faces_verts_idx.append(face_verts) - - #### Deselect all vertices. + # Deselect all vertices bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT') bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT') - - - #### Make a dictionary with the verts related to each vert. + # Make a dictionary with the verts related to each vert related_key_verts = {} for ed_idx in selected_edges: ed = object.data.edges[ed_idx] @@ -877,18 +865,17 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if not ed.vertices[0] in related_key_verts[ed.vertices[1]]: related_key_verts[ed.vertices[1]].append(ed.vertices[0]) - - - #### Get groups of verts forming each face. + # Get groups of verts forming each face faces_verts_idx = [] - for v1 in related_key_verts: # verts-1 .... - for v2 in related_key_verts: # verts-2 + for v1 in related_key_verts: # verts-1 .... + for v2 in related_key_verts: # verts-2 if v1 != v2: related_verts_in_common = [] v2_in_rel_v1 = False v1_in_rel_v2 = False for rel_v1 in related_key_verts[v1]: - if rel_v1 in related_key_verts[v2]: # Check if related verts of verts-1 are related verts of verts-2. + # Check if related verts of verts-1 are related verts of verts-2 + if rel_v1 in related_key_verts[v2]: related_verts_in_common.append(rel_v1) if v2 in related_key_verts[v1]: @@ -897,31 +884,37 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if v1 in related_key_verts[v2]: v1_in_rel_v2 = True - repeated_face = False - # If two verts have two related verts in common, they form a quad. + # If two verts have two related verts in common, they form a quad if len(related_verts_in_common) == 2: - # Check if the face is already saved. + # Check if the face is already saved all_faces_to_check_idx = faces_verts_idx + all_object_faces_verts_idx - for f_verts in all_faces_to_check_idx: repeated_verts = 0 if len(f_verts) == 4: - if v1 in f_verts: repeated_verts += 1 - if v2 in f_verts: repeated_verts += 1 - if related_verts_in_common[0] in f_verts: repeated_verts += 1 - if related_verts_in_common[1] in f_verts: repeated_verts += 1 + if v1 in f_verts: + repeated_verts += 1 + if v2 in f_verts: + repeated_verts += 1 + if related_verts_in_common[0] in f_verts: + repeated_verts += 1 + if related_verts_in_common[1] in f_verts: + repeated_verts += 1 if repeated_verts == len(f_verts): repeated_face = True break if not repeated_face: - faces_verts_idx.append([v1, related_verts_in_common[0], v2, related_verts_in_common[1]]) + faces_verts_idx.append( + [v1, related_verts_in_common[0], v2, related_verts_in_common[1]] + ) - elif v2_in_rel_v1 and v1_in_rel_v2 and len(related_verts_in_common) == 1: # If Two verts have one related vert in common and they are related to each other, they form a triangle. + # If Two verts have one related vert in common and + # they are related to each other, they form a triangle + elif v2_in_rel_v1 and v1_in_rel_v2 and len(related_verts_in_common) == 1: # Check if the face is already saved. all_faces_to_check_idx = faces_verts_idx + all_object_faces_verts_idx @@ -929,9 +922,12 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): repeated_verts = 0 if len(f_verts) == 3: - if v1 in f_verts: repeated_verts += 1 - if v2 in f_verts: repeated_verts += 1 - if related_verts_in_common[0] in f_verts: repeated_verts += 1 + if v1 in f_verts: + repeated_verts += 1 + if v2 in f_verts: + repeated_verts += 1 + if related_verts_in_common[0] in f_verts: + repeated_verts += 1 if repeated_verts == len(f_verts): repeated_face = True @@ -940,9 +936,9 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if not repeated_face: faces_verts_idx.append([v1, related_verts_in_common[0], v2]) - - #### Keep only the faces that don't overlap by ignoring quads that overlap with two adjacent triangles. - faces_to_not_include_idx = [] # Indices of faces_verts_idx to eliminate. + # Keep only the faces that don't overlap by ignoring quads + # that overlap with two adjacent triangles + faces_to_not_include_idx = [] # Indices of faces_verts_idx to eliminate all_faces_to_check_idx = faces_verts_idx + all_object_faces_verts_idx for i in range(len(faces_verts_idx)): for t in range(len(all_faces_to_check_idx)): @@ -953,71 +949,63 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): for v_idx in all_faces_to_check_idx[t]: if v_idx in faces_verts_idx[i]: verts_in_common += 1 - - if verts_in_common == 3: # If it doesn't have all it's vertices repeated in the other face. - if not i in faces_to_not_include_idx: + # If it doesn't have all it's vertices repeated in the other face + if verts_in_common == 3: + if i not in faces_to_not_include_idx: faces_to_not_include_idx.append(i) - - #### Build faces discarding the ones in faces_to_not_include. + # Build faces discarding the ones in faces_to_not_include me = object.data bm = bmesh.new() bm.from_mesh(me) num_faces_created = 0 for i in range(len(faces_verts_idx)): - if not i in faces_to_not_include_idx: - bm.faces.new([ bm.verts[v] for v in faces_verts_idx[i] ]) + if i not in faces_to_not_include_idx: + bm.faces.new([bm.verts[v] for v in faces_verts_idx[i]]) num_faces_created += 1 bm.to_mesh(me) bm.free() - - for v_idx in selected_verts_idx: self.main_object.data.vertices[v_idx].select = True - bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT') bpy.ops.mesh.normals_make_consistent(inside=False) bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT') - return num_faces_created - - - #### Crosshatch skinning. + # Crosshatch skinning def crosshatch_surface_invoke(self, ob_original_splines): self.is_crosshatch = False self.crosshatch_merge_distance = 0 + objects_to_delete = [] # duplicated strokes to be deleted. - objects_to_delete = [] # duplicated strokes to be deleted. - - # If the main object uses modifiers deactivate them temporarily until the surface is joined. (without this the surface verts merging with the main object doesn't work well) + # If the main object uses modifiers deactivate them temporarily until the surface is joined + # (without this the surface verts merging with the main object doesn't work well) self.modifiers_prev_viewport_state = [] if len(self.main_object.modifiers) > 0: for m_idx in range(len(self.main_object.modifiers)): - self.modifiers_prev_viewport_state.append(self.main_object.modifiers[m_idx].show_viewport) - + self.modifiers_prev_viewport_state.append( + self.main_object.modifiers[m_idx].show_viewport + ) self.main_object.modifiers[m_idx].show_viewport = False - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob_original_splines.name].select = True bpy.context.scene.objects.active = bpy.data.objects[ob_original_splines.name] - if len(ob_original_splines.data.splines) >= 2: bpy.ops.object.duplicate('INVOKE_REGION_WIN') ob_splines = bpy.context.object ob_splines.name = "SURFSKIO_NE_STR" - - #### Get estimative merge distance (sum up the distances from the first point to all other points, then average them and then divide them). + # Get estimative merge distance (sum up the distances from the first point to + # all other points, then average them and then divide them) first_point_dist_sum = 0 first_dist = 0 second_dist = 0 @@ -1033,26 +1021,21 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): first_point_dist_sum += first_dist + second_dist - if i == 0: if first_dist != 0: shortest_dist = first_dist elif second_dist != 0: shortest_dist = second_dist - if shortest_dist > first_dist and first_dist != 0: shortest_dist = first_dist if shortest_dist > second_dist and second_dist != 0: shortest_dist = second_dist - self.crosshatch_merge_distance = shortest_dist / 20 - - - #### Recalculation of merge distance. + # Recalculation of merge distance bpy.ops.object.duplicate('INVOKE_REGION_WIN') @@ -1061,9 +1044,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): objects_to_delete.append(ob_calc_merge_dist) - - - #### Smooth out strokes a little to improve crosshatch detection. + # Smooth out strokes a little to improve crosshatch detection bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='SELECT') @@ -1073,20 +1054,19 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - #### Convert curves into mesh. + # Convert curves into mesh ob_calc_merge_dist.data.resolution_u = 12 bpy.ops.object.convert(target='MESH', keep_original=False) - # Find "intersection-nodes". + # Find "intersection-nodes" bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='SELECT') - bpy.ops.mesh.remove_doubles('INVOKE_REGION_WIN', threshold=self.crosshatch_merge_distance) + bpy.ops.mesh.remove_doubles('INVOKE_REGION_WIN', + threshold=self.crosshatch_merge_distance) bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - # Remove verts with less than three edges. + # Remove verts with less than three edges verts_edges_count = {} for ed in ob_calc_merge_dist.data.edges: v = ed.vertices @@ -1107,20 +1087,23 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if verts_edges_count[v_idx] < 3: v.select = True - - # Remove them. + # Remove them bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.mesh.delete('INVOKE_REGION_WIN', type='VERT') bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='SELECT') - # Remove doubles to discard very near verts from calculations of distance. - bpy.ops.mesh.remove_doubles('INVOKE_REGION_WIN', threshold=self.crosshatch_merge_distance * 4.0) + # Remove doubles to discard very near verts from calculations of distance + bpy.ops.mesh.remove_doubles( + 'INVOKE_REGION_WIN', + threshold=self.crosshatch_merge_distance * 4.0 + ) bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - # Get all coords of the resulting nodes. - nodes_verts_coords = [(v.co[0], v.co[1], v.co[2]) for v in ob_calc_merge_dist.data.vertices] + # Get all coords of the resulting nodes + nodes_verts_coords = [(v.co[0], v.co[1], v.co[2]) for + v in ob_calc_merge_dist.data.vertices] - #### Check if the strokes are a crosshatch. + # Check if the strokes are a crosshatch if len(nodes_verts_coords) >= 3: self.is_crosshatch = True @@ -1128,7 +1111,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): for co_1 in nodes_verts_coords: for co_2 in nodes_verts_coords: if co_1 != co_2: - dist = (mathutils.Vector(co_1) - mathutils.Vector(co_2)).length + dist = (Vector(co_1) - Vector(co_2)).length if shortest_dist is not None: if dist < shortest_dist: @@ -1138,25 +1121,25 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): self.crosshatch_merge_distance = shortest_dist / 3 - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob_splines.name].select = True bpy.context.scene.objects.active = bpy.data.objects[ob_splines.name] - #### Deselect all points. + # Deselect all points bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - #### Smooth splines in a localized way, to eliminate "saw-teeth" like shapes when there are many points. + # Smooth splines in a localized way, to eliminate "saw-teeth" + # like shapes when there are many points for sp in ob_splines.data.splines: angle_sum = 0 - angle_limit = 2 # Degrees + angle_limit = 2 # Degrees for t in range(len(sp.bezier_points)): - if t <= len(sp.bezier_points) - 3: # Because on each iteration it checks the "next two points" of the actual. This way it doesn't go out of range. + # Because on each iteration it checks the "next two points" + # of the actual. This way it doesn't go out of range + if t <= len(sp.bezier_points) - 3: p1 = sp.bezier_points[t] p2 = sp.bezier_points[t + 1] p3 = sp.bezier_points[t + 2] @@ -1168,13 +1151,20 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): angle = vec_1.angle(vec_2) angle_sum += degrees(angle) - if angle_sum >= angle_limit: # If sum of angles is grater than the limit. + if angle_sum >= angle_limit: # If sum of angles is grater than the limit if (p1.co - p2.co).length <= self.crosshatch_merge_distance: - p1.select_control_point = True; p1.select_left_handle = True; p1.select_right_handle = True - p2.select_control_point = True; p2.select_left_handle = True; p2.select_right_handle = True + p1.select_control_point = True + p1.select_left_handle = True + p1.select_right_handle = True + + p2.select_control_point = True + p2.select_left_handle = True + p2.select_right_handle = True if (p1.co - p2.co).length <= self.crosshatch_merge_distance: - p3.select_control_point = True; p3.select_left_handle = True; p3.select_right_handle = True + p3.select_control_point = True + p3.select_left_handle = True + p3.select_right_handle = True angle_sum = 0 @@ -1184,11 +1174,9 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): sp.bezier_points[len(sp.bezier_points) - 1].select_control_point = False sp.bezier_points[len(sp.bezier_points) - 1].select_left_handle = False - sp.bezier_points[len(sp.bezier_points) - 1].select_right_handle = False - + sp.bezier_points[len(sp.bezier_points) - 1].select_right_handle = False - - #### Smooth out strokes a little to improve crosshatch detection. + # Smooth out strokes a little to improve crosshatch detection bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') for i in range(15): @@ -1197,10 +1185,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - - #### Simplify the splines. + # Simplify the splines for sp in ob_splines.data.splines: angle_sum = 0 @@ -1210,12 +1195,13 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): sp.bezier_points[len(sp.bezier_points) - 1].select_control_point = True sp.bezier_points[len(sp.bezier_points) - 1].select_left_handle = True - sp.bezier_points[len(sp.bezier_points) - 1].select_right_handle = True + sp.bezier_points[len(sp.bezier_points) - 1].select_right_handle = True - - angle_limit = 15 # Degrees + angle_limit = 15 # Degrees for t in range(len(sp.bezier_points)): - if t <= len(sp.bezier_points) - 3: # Because on each iteration it checks the "next two points" of the actual. This way it doesn't go out of range. + # Because on each iteration it checks the "next two points" + # of the actual. This way it doesn't go out of range + if t <= len(sp.bezier_points) - 3: p1 = sp.bezier_points[t] p2 = sp.bezier_points[t + 1] p3 = sp.bezier_points[t + 2] @@ -1226,41 +1212,43 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if p2.co != p1.co and p2.co != p3.co: angle = vec_1.angle(vec_2) angle_sum += degrees(angle) + # If sum of angles is grater than the limit + if angle_sum >= angle_limit: + p1.select_control_point = True + p1.select_left_handle = True + p1.select_right_handle = True - if angle_sum >= angle_limit: # If sum of angles is grater than the limit. - p1.select_control_point = True; p1.select_left_handle = True; p1.select_right_handle = True - p2.select_control_point = True; p2.select_left_handle = True; p2.select_right_handle = True - p3.select_control_point = True; p3.select_left_handle = True; p3.select_right_handle = True - - angle_sum = 0 + p2.select_control_point = True + p2.select_left_handle = True + p2.select_right_handle = True + p3.select_control_point = True + p3.select_left_handle = True + p3.select_right_handle = True + angle_sum = 0 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - bpy.ops.curve.select_all(action = 'INVERT') + bpy.ops.curve.select_all(action='INVERT') bpy.ops.curve.delete(type='VERT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - objects_to_delete.append(ob_splines) - bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - #### Check if the strokes are a crosshatch. + # Check if the strokes are a crosshatch if self.is_crosshatch: all_points_coords = [] for i in range(len(ob_splines.data.splines)): all_points_coords.append([]) - all_points_coords[i] = [mathutils.Vector((x, y, z)) for x, y, z in [bp.co for bp in ob_splines.data.splines[i].bezier_points]] - + all_points_coords[i] = [Vector((x, y, z)) for + x, y, z in [bp.co for + bp in ob_splines.data.splines[i].bezier_points]] all_intersections = [] checked_splines = [] @@ -1271,68 +1259,73 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bp2_co = all_points_coords[i][t + 1] for i2 in range(len(all_points_coords)): - if i != i2 and not i2 in checked_splines: + if i != i2 and i2 not in checked_splines: for t2 in range(len(all_points_coords[i2]) - 1): bp3_co = all_points_coords[i2][t2] bp4_co = all_points_coords[i2][t2 + 1] - - intersec_coords = mathutils.geometry.intersect_line_line(bp1_co, bp2_co, bp3_co, bp4_co) - + intersec_coords = intersect_line_line( + bp1_co, bp2_co, bp3_co, bp4_co + ) if intersec_coords is not None: dist = (intersec_coords[0] - intersec_coords[1]).length if dist <= self.crosshatch_merge_distance * 1.5: - temp_co, percent1 = mathutils.geometry.intersect_point_line(intersec_coords[0], bp1_co, bp2_co) - + temp_co, percent1 = intersect_point_line( + intersec_coords[0], bp1_co, bp2_co + ) if (percent1 >= -0.02 and percent1 <= 1.02): - temp_co, percent2 = mathutils.geometry.intersect_point_line(intersec_coords[1], bp3_co, bp4_co) + temp_co, percent2 = intersect_point_line( + intersec_coords[1], bp3_co, bp4_co + ) if (percent2 >= -0.02 and percent2 <= 1.02): - all_intersections.append((i, t, percent1, ob_splines.matrix_world * intersec_coords[0])) # Format: spline index, first point index from corresponding segment, percentage from first point of actual segment, coords of intersection point. - all_intersections.append((i2, t2, percent2, ob_splines.matrix_world * intersec_coords[1])) - - + # Format: spline index, first point index from + # corresponding segment, percentage from first point of + # actual segment, coords of intersection point + all_intersections.append( + (i, t, percent1, + ob_splines.matrix_world * intersec_coords[0]) + ) + all_intersections.append( + (i2, t2, percent2, + ob_splines.matrix_world * intersec_coords[1]) + ) checked_splines.append(i) - - - all_intersections.sort(key = operator.itemgetter(0,1,2)) # Sort list by spline, then by corresponding first point index of segment, and then by percentage from first point of segment: elements 0 and 1 respectively. - - + # Sort list by spline, then by corresponding first point index of segment, + # and then by percentage from first point of segment: elements 0 and 1 respectively + all_intersections.sort(key=operator.itemgetter(0, 1, 2)) self.crosshatch_strokes_coords = {} for i in range(len(all_intersections)): if not all_intersections[i][0] in self.crosshatch_strokes_coords: self.crosshatch_strokes_coords[all_intersections[i][0]] = [] - self.crosshatch_strokes_coords[all_intersections[i][0]].append(all_intersections[i][3]) # Save intersection coords. - + self.crosshatch_strokes_coords[all_intersections[i][0]].append( + all_intersections[i][3] + ) # Save intersection coords else: self.is_crosshatch = False - - #### Delete all duplicates. + # Delete all duplicates for o in objects_to_delete: bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[o.name].select = True bpy.context.scene.objects.active = bpy.data.objects[o.name] bpy.ops.object.delete() - - #### If the main object has modifiers, turn their "viewport view status" to what it was before the forced deactivation above. + # If the main object has modifiers, turn their "viewport view status" to + # what it was before the forced deactivation above if len(self.main_object.modifiers) > 0: for m_idx in range(len(self.main_object.modifiers)): self.main_object.modifiers[m_idx].show_viewport = self.modifiers_prev_viewport_state[m_idx] - - return - - - #### Part of the Crosshatch process that is repeated when the operator is tweaked. + # Part of the Crosshatch process that is repeated when the operator is tweaked def crosshatch_surface_execute(self): - # If the main object uses modifiers deactivate them temporarily until the surface is joined. (without this the surface verts merging with the main object doesn't work well) + # If the main object uses modifiers deactivate them temporarily until the surface is joined + # (without this the surface verts merging with the main object doesn't work well) self.modifiers_prev_viewport_state = [] if len(self.main_object.modifiers) > 0: for m_idx in range(len(self.main_object.modifiers)): @@ -1340,11 +1333,8 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): self.main_object.modifiers[m_idx].show_viewport = False - bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - me_name = "SURFSKIO_STK_TMP" me = bpy.data.meshes.new(me_name) @@ -1359,7 +1349,6 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if co_idx > 0: all_edges.append((len(all_verts_coords) - 2, len(all_verts_coords) - 1)) - me.from_pydata(all_verts_coords, all_edges, []) me.update() @@ -1368,21 +1357,19 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): ob.data = me bpy.context.scene.objects.link(ob) - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob.name].select = True bpy.context.scene.objects.active = bpy.data.objects[ob.name] - - #### Get together each vert and its nearest, to the middle position. + # Get together each vert and its nearest, to the middle position verts = ob.data.vertices checked_verts = [] for i in range(len(verts)): shortest_dist = None - if not i in checked_verts: + if i not in checked_verts: for t in range(len(verts)): - if i != t and not t in checked_verts: + if i != t and t not in checked_verts: dist = (verts[i].co - verts[t].co).length if shortest_dist is not None: @@ -1401,10 +1388,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): checked_verts.append(i) checked_verts.append(nearest_vert) - - - - #### Calculate average length between all the generated edges. + # Calculate average length between all the generated edges ob = bpy.context.object lengths_sum = 0 for ed in ob.data.edges: @@ -1414,19 +1398,18 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): lengths_sum += (v1.co - v2.co).length edges_count = len(ob.data.edges) - - average_edge_length = lengths_sum / edges_count - + # possible division by zero here + average_edge_length = lengths_sum / edges_count if edges_count != 0 else 0.0001 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='SELECT') - bpy.ops.mesh.remove_doubles('INVOKE_REGION_WIN', threshold=average_edge_length / 15.0) + bpy.ops.mesh.remove_doubles('INVOKE_REGION_WIN', + threshold=average_edge_length / 15.0) bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') final_points_ob = bpy.context.scene.objects.active - - #### Make a dictionary with the verts related to each vert. + # Make a dictionary with the verts related to each vert related_key_verts = {} for ed in final_points_ob.data.edges: if not ed.vertices[0] in related_key_verts: @@ -1435,25 +1418,23 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if not ed.vertices[1] in related_key_verts: related_key_verts[ed.vertices[1]] = [] - if not ed.vertices[1] in related_key_verts[ed.vertices[0]]: related_key_verts[ed.vertices[0]].append(ed.vertices[1]) if not ed.vertices[0] in related_key_verts[ed.vertices[1]]: related_key_verts[ed.vertices[1]].append(ed.vertices[0]) - - - #### Get groups of verts forming each face. + # Get groups of verts forming each face faces_verts_idx = [] - for v1 in related_key_verts: # verts-1 .... - for v2 in related_key_verts: # verts-2 + for v1 in related_key_verts: # verts-1 .... + for v2 in related_key_verts: # verts-2 if v1 != v2: related_verts_in_common = [] v2_in_rel_v1 = False v1_in_rel_v2 = False for rel_v1 in related_key_verts[v1]: - if rel_v1 in related_key_verts[v2]: # Check if related verts of verts-1 are related verts of verts-2. + # Check if related verts of verts-1 are related verts of verts-2 + if rel_v1 in related_key_verts[v2]: related_verts_in_common.append(rel_v1) if v2 in related_key_verts[v1]: @@ -1462,36 +1443,45 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if v1 in related_key_verts[v2]: v1_in_rel_v2 = True - repeated_face = False - # If two verts have two related verts in common, they form a quad. + # If two verts have two related verts in common, they form a quad if len(related_verts_in_common) == 2: - # Check if the face is already saved. + # Check if the face is already saved for f_verts in faces_verts_idx: repeated_verts = 0 if len(f_verts) == 4: - if v1 in f_verts: repeated_verts += 1 - if v2 in f_verts: repeated_verts += 1 - if related_verts_in_common[0] in f_verts: repeated_verts += 1 - if related_verts_in_common[1] in f_verts: repeated_verts += 1 + if v1 in f_verts: + repeated_verts += 1 + if v2 in f_verts: + repeated_verts += 1 + if related_verts_in_common[0] in f_verts: + repeated_verts += 1 + if related_verts_in_common[1] in f_verts: + repeated_verts += 1 if repeated_verts == len(f_verts): repeated_face = True break if not repeated_face: - faces_verts_idx.append([v1, related_verts_in_common[0], v2, related_verts_in_common[1]]) + faces_verts_idx.append([v1, related_verts_in_common[0], + v2, related_verts_in_common[1]]) - elif v2_in_rel_v1 and v1_in_rel_v2 and len(related_verts_in_common) == 1: # If Two verts have one related vert in common and they are related to each other, they form a triangle. + # If Two verts have one related vert in common and they are + # related to each other, they form a triangle + elif v2_in_rel_v1 and v1_in_rel_v2 and len(related_verts_in_common) == 1: # Check if the face is already saved. for f_verts in faces_verts_idx: repeated_verts = 0 if len(f_verts) == 3: - if v1 in f_verts: repeated_verts += 1 - if v2 in f_verts: repeated_verts += 1 - if related_verts_in_common[0] in f_verts: repeated_verts += 1 + if v1 in f_verts: + repeated_verts += 1 + if v2 in f_verts: + repeated_verts += 1 + if related_verts_in_common[0] in f_verts: + repeated_verts += 1 if repeated_verts == len(f_verts): repeated_face = True @@ -1500,9 +1490,9 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if not repeated_face: faces_verts_idx.append([v1, related_verts_in_common[0], v2]) - - #### Keep only the faces that don't overlap by ignoring quads that overlap with two adjacent triangles. - faces_to_not_include_idx = [] # Indices of faces_verts_idx to eliminate. + # Keep only the faces that don't overlap by ignoring + # quads that overlap with two adjacent triangles + faces_to_not_include_idx = [] # Indices of faces_verts_idx to eliminate for i in range(len(faces_verts_idx)): for t in range(len(faces_verts_idx)): if i != t: @@ -1512,13 +1502,12 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): for v_idx in faces_verts_idx[t]: if v_idx in faces_verts_idx[i]: verts_in_common += 1 - - if verts_in_common == 3: # If it doesn't have all it's vertices repeated in the other face. - if not i in faces_to_not_include_idx: + # If it doesn't have all it's vertices repeated in the other face + if verts_in_common == 3: + if i not in faces_to_not_include_idx: faces_to_not_include_idx.append(i) - - #### Build surface. + # Build surface all_surface_verts_co = [] verts_idx_translation = {} for i in range(len(final_points_ob.data.vertices)): @@ -1528,14 +1517,14 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): # Verts of each face. all_surface_faces = [] for i in range(len(faces_verts_idx)): - if not i in faces_to_not_include_idx: + if i not in faces_to_not_include_idx: face = [] for v_idx in faces_verts_idx[i]: face.append(v_idx) all_surface_faces.append(face) - # Build the mesh. + # Build the mesh surf_me_name = "SURFSKIO_surface" me_surf = bpy.data.meshes.new(surf_me_name) @@ -1553,8 +1542,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.delete() - - # Delete isolated verts if there are any. + # Delete isolated verts if there are any bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob_surface.name].select = True bpy.context.scene.objects.active = bpy.data.objects[ob_surface.name] @@ -1565,14 +1553,15 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.mesh.delete() bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') + # Join crosshatch results with original mesh - - #### Join crosshatch results with original mesh. - - # Calculate a distance to merge the verts of the crosshatch surface to the main object. + # Calculate a distance to merge the verts of the crosshatch surface to the main object edges_length_sum = 0 for ed in ob_surface.data.edges: - edges_length_sum += (ob_surface.data.vertices[ed.vertices[0]].co - ob_surface.data.vertices[ed.vertices[1]].co).length + edges_length_sum += ( + ob_surface.data.vertices[ed.vertices[0]].co - + ob_surface.data.vertices[ed.vertices[1]].co + ).length if len(ob_surface.data.edges) > 0: average_surface_edges_length = edges_length_sum / len(ob_surface.data.edges) @@ -1587,15 +1576,13 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): surface_connected_verts[ed.vertices[0]].append(ed.vertices[1]) - - if not ed.vertices[1] in surface_connected_verts: + if ed.vertices[1] not in surface_connected_verts: surface_connected_verts[ed.vertices[1]] = [] surface_connected_verts[ed.vertices[1]].append(ed.vertices[0]) - - - # Duplicate the new surface object, and use shrinkwrap to calculate later the nearest verts to the main object. + # Duplicate the new surface object, and use shrinkwrap to + # calculate later the nearest verts to the main object bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') @@ -1610,13 +1597,13 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.modifier_apply('INVOKE_REGION_WIN', apply_as='DATA', modifier='Shrinkwrap') - - # Make list with verts of original mesh as index and coords as value. + # Make list with verts of original mesh as index and coords as value main_object_verts_coords = [] for v in self.main_object.data.vertices: coords = self.main_object.matrix_world * v.co - for c in range(len(coords)): # To avoid problems when taking "-0.00" as a different value as "0.00". + # To avoid problems when taking "-0.00" as a different value as "0.00" + for c in range(len(coords)): if "%.3f" % coords[c] == "-0.00": coords[c] = 0 @@ -1624,12 +1611,14 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): tuple(main_object_verts_coords) - - # Determine which verts will be merged, snap them to the nearest verts on the original verts, and get them selected. + # Determine which verts will be merged, snap them to the nearest verts + # on the original verts, and get them selected crosshatch_verts_to_merge = [] if self.automatic_join: for i in range(len(ob_surface.data.vertices)): - # Calculate the distance from each of the connected verts to the actual vert, and compare it with the distance they would have if joined. If they don't change much, that vert can be joined. + # Calculate the distance from each of the connected verts to the actual vert, + # and compare it with the distance they would have if joined. + # If they don't change much, that vert can be joined merge_actual_vert = True if len(surface_connected_verts[i]) < 4: for c_v_idx in surface_connected_verts[i]: @@ -1647,52 +1636,56 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): dist_A = (points_original[0] - points_original[1]).length dist_B = (points_target[0] - points_target[1]).length + if not ( + points_original[0] == points_original[1] or + points_target[0] == points_target[1] + ): # If any vector's length is zero - if not (points_original[0] == points_original[1] or points_target[0] == points_target[1]): # If any vector's length is zero. - angle = vec_A.angle(vec_B) / math.pi + angle = vec_A.angle(vec_B) / pi else: - angle= 0 + angle = 0 + # Set a range of acceptable variation in the connected edges + if dist_B > dist_A * 1.7 * self.join_stretch_factor or \ + dist_B < dist_A / 2 / self.join_stretch_factor or \ + angle >= 0.15 * self.join_stretch_factor: - if dist_B > dist_A * 1.7 * self.join_stretch_factor or dist_B < dist_A / 2 / self.join_stretch_factor or angle >= 0.15 * self.join_stretch_factor: # Set a range of acceptable variation in the connected edges. merge_actual_vert = False break else: merge_actual_vert = False - if merge_actual_vert: coords = final_ob_duplicate.data.vertices[i].co - - for c in range(len(coords)): # To avoid problems when taking "-0.000" as a different value as "0.00". + # To avoid problems when taking "-0.000" as a different value as "0.00" + for c in range(len(coords)): if "%.3f" % coords[c] == "-0.00": coords[c] = 0 comparison_coords = ["%.3f" % coords[0], "%.3f" % coords[1], "%.3f" % coords[2]] - if comparison_coords in main_object_verts_coords: - main_object_related_vert_idx = main_object_verts_coords.index(comparison_coords) # Get the index of the vert with those coords in the main object. + # Get the index of the vert with those coords in the main object + main_object_related_vert_idx = main_object_verts_coords.index(comparison_coords) + + if self.main_object.data.vertices[main_object_related_vert_idx].select is True or \ + self.main_object_selected_verts_count == 0: - if self.main_object.data.vertices[main_object_related_vert_idx].select == True or self.main_object_selected_verts_count == 0: ob_surface.data.vertices[i].co = final_ob_duplicate.data.vertices[i].co ob_surface.data.vertices[i].select = True crosshatch_verts_to_merge.append(i) - # Make sure the vert in the main object is selected, in case it wasn't selected and the "join crosshatch" option is active. + # Make sure the vert in the main object is selected, + # in case it wasn't selected and the "join crosshatch" option is active self.main_object.data.vertices[main_object_related_vert_idx].select = True - - - - # Delete duplicated object. + # Delete duplicated object bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[final_ob_duplicate.name].select = True bpy.context.scene.objects.active = bpy.data.objects[final_ob_duplicate.name] bpy.ops.object.delete() - - # Join crosshatched surface and main object. + # Join crosshatched surface and main object bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob_surface.name].select = True bpy.data.objects[self.main_object.name].select = True @@ -1701,26 +1694,22 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.join('INVOKE_REGION_WIN') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - # Perform Remove doubles to merge verts. - if not (self.automatic_join == False and self.main_object_selected_verts_count == 0): + # Perform Remove doubles to merge verts + if not (self.automatic_join is False and self.main_object_selected_verts_count == 0): bpy.ops.mesh.remove_doubles(threshold=0.0001) bpy.ops.mesh.select_all(action='DESELECT') - - #### If the main object has modifiers, turn their "viewport view status" to what it was before the forced deactivation above. + # If the main object has modifiers, turn their "viewport view status" + # to what it was before the forced deactivation above if len(self.main_object.modifiers) > 0: for m_idx in range(len(self.main_object.modifiers)): self.main_object.modifiers[m_idx].show_viewport = self.modifiers_prev_viewport_state[m_idx] - - - return{'FINISHED'} - - + return {'FINISHED'} def rectangular_surface(self): - #### Selected edges. + # Selected edges all_selected_edges_idx = [] all_selected_verts = [] all_verts_idx = [] @@ -1728,95 +1717,131 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if ed.select: all_selected_edges_idx.append(ed.index) - # Selected vertices. + # Selected vertices if not ed.vertices[0] in all_selected_verts: all_selected_verts.append(self.main_object.data.vertices[ed.vertices[0]]) if not ed.vertices[1] in all_selected_verts: all_selected_verts.append(self.main_object.data.vertices[ed.vertices[1]]) - # All verts (both from each edge) to determine later which are at the tips (those not repeated twice). + # All verts (both from each edge) to determine later + # which are at the tips (those not repeated twice) all_verts_idx.append(ed.vertices[0]) all_verts_idx.append(ed.vertices[1]) - - - #### Identify the tips and "middle-vertex" that separates U from V, if there is one. + # Identify the tips and "middle-vertex" that separates U from V, if there is one all_chains_tips_idx = [] for v_idx in all_verts_idx: if all_verts_idx.count(v_idx) < 2: all_chains_tips_idx.append(v_idx) - - edges_connected_to_tips = [] for ed in self.main_object.data.edges: - if (ed.vertices[0] in all_chains_tips_idx or ed.vertices[1] in all_chains_tips_idx) and not (ed.vertices[0] in all_verts_idx and ed.vertices[1] in all_verts_idx): - edges_connected_to_tips.append(ed) + if (ed.vertices[0] in all_chains_tips_idx or ed.vertices[1] in all_chains_tips_idx) and \ + not (ed.vertices[0] in all_verts_idx and ed.vertices[1] in all_verts_idx): + edges_connected_to_tips.append(ed) - #### Check closed selections. - single_unselected_verts_and_neighbors = [] # List with groups of three verts, where the first element of the pair is the unselected vert of a closed selection and the other two elements are the selected neighbor verts (it will be useful to determine which selection chain the unselected vert belongs to, and determine the "middle-vertex") - - # To identify a "closed" selection (a selection that is a closed chain except for one vertex) find the vertex in common that have the edges connected to tips. If there is a vertex in common, that one is the unselected vert that closes the selection or is a "middle-vertex". + # Check closed selections + # List with groups of three verts, where the first element of the pair is + # the unselected vert of a closed selection and the other two elements are the + # selected neighbor verts (it will be useful to determine which selection chain + # the unselected vert belongs to, and determine the "middle-vertex") + single_unselected_verts_and_neighbors = [] + + # To identify a "closed" selection (a selection that is a closed chain except + # for one vertex) find the vertex in common that have the edges connected to tips. + # If there is a vertex in common, that one is the unselected vert that closes + # the selection or is a "middle-vertex" single_unselected_verts = [] for ed in edges_connected_to_tips: for ed_b in edges_connected_to_tips: if ed != ed_b: - if ed.vertices[0] == ed_b.vertices[0] and not self.main_object.data.vertices[ed.vertices[0]].select and ed.vertices[0] not in single_unselected_verts: - single_unselected_verts_and_neighbors.append([ed.vertices[0], ed.vertices[1], ed_b.vertices[1]]) # The second element is one of the tips of the selected vertices of the closed selection. + if ed.vertices[0] == ed_b.vertices[0] and \ + not self.main_object.data.vertices[ed.vertices[0]].select and \ + ed.vertices[0] not in single_unselected_verts: + + # The second element is one of the tips of the selected + # vertices of the closed selection + single_unselected_verts_and_neighbors.append( + [ed.vertices[0], ed.vertices[1], ed_b.vertices[1]] + ) single_unselected_verts.append(ed.vertices[0]) break - elif ed.vertices[0] == ed_b.vertices[1] and not self.main_object.data.vertices[ed.vertices[0]].select and ed.vertices[0] not in single_unselected_verts: - single_unselected_verts_and_neighbors.append([ed.vertices[0], ed.vertices[1], ed_b.vertices[0]]) + elif ed.vertices[0] == ed_b.vertices[1] and \ + not self.main_object.data.vertices[ed.vertices[0]].select and \ + ed.vertices[0] not in single_unselected_verts: + + single_unselected_verts_and_neighbors.append( + [ed.vertices[0], ed.vertices[1], ed_b.vertices[0]] + ) single_unselected_verts.append(ed.vertices[0]) break - elif ed.vertices[1] == ed_b.vertices[0] and not self.main_object.data.vertices[ed.vertices[1]].select and ed.vertices[1] not in single_unselected_verts: - single_unselected_verts_and_neighbors.append([ed.vertices[1], ed.vertices[0], ed_b.vertices[1]]) + elif ed.vertices[1] == ed_b.vertices[0] and \ + not self.main_object.data.vertices[ed.vertices[1]].select and \ + ed.vertices[1] not in single_unselected_verts: + + single_unselected_verts_and_neighbors.append( + [ed.vertices[1], ed.vertices[0], ed_b.vertices[1]] + ) single_unselected_verts.append(ed.vertices[1]) break - elif ed.vertices[1] == ed_b.vertices[1] and not self.main_object.data.vertices[ed.vertices[1]].select and ed.vertices[1] not in single_unselected_verts: - single_unselected_verts_and_neighbors.append([ed.vertices[1], ed.vertices[0], ed_b.vertices[0]]) + elif ed.vertices[1] == ed_b.vertices[1] and \ + not self.main_object.data.vertices[ed.vertices[1]].select and \ + ed.vertices[1] not in single_unselected_verts: + + single_unselected_verts_and_neighbors.append( + [ed.vertices[1], ed.vertices[0], ed_b.vertices[0]] + ) single_unselected_verts.append(ed.vertices[1]) break - middle_vertex_idx = None tips_to_discard_idx = [] - # Check if there is a "middle-vertex", and get its index. + + # Check if there is a "middle-vertex", and get its index for i in range(0, len(single_unselected_verts_and_neighbors)): - actual_chain_verts = self.get_ordered_verts(self.main_object, all_selected_edges_idx, all_verts_idx, single_unselected_verts_and_neighbors[i][1], None, None) + actual_chain_verts = self.get_ordered_verts( + self.main_object, all_selected_edges_idx, + all_verts_idx, single_unselected_verts_and_neighbors[i][1], + None, None + ) + + if single_unselected_verts_and_neighbors[i][2] != \ + actual_chain_verts[len(actual_chain_verts) - 1].index: - if single_unselected_verts_and_neighbors[i][2] != actual_chain_verts[len(actual_chain_verts) - 1].index: middle_vertex_idx = single_unselected_verts_and_neighbors[i][0] tips_to_discard_idx.append(single_unselected_verts_and_neighbors[i][1]) tips_to_discard_idx.append(single_unselected_verts_and_neighbors[i][2]) - - #### List with pairs of verts that belong to the tips of each selection chain (row). + # List with pairs of verts that belong to the tips of each selection chain (row) verts_tips_same_chain_idx = [] if len(all_chains_tips_idx) >= 2: checked_v = [] for i in range(0, len(all_chains_tips_idx)): if all_chains_tips_idx[i] not in checked_v: - v_chain = self.get_ordered_verts(self.main_object, all_selected_edges_idx, all_verts_idx, all_chains_tips_idx[i], middle_vertex_idx, None) + v_chain = self.get_ordered_verts( + self.main_object, all_selected_edges_idx, + all_verts_idx, all_chains_tips_idx[i], + middle_vertex_idx, None + ) verts_tips_same_chain_idx.append([v_chain[0].index, v_chain[len(v_chain) - 1].index]) checked_v.append(v_chain[0].index) checked_v.append(v_chain[len(v_chain) - 1].index) - - #### Selection tips (vertices). + # Selection tips (vertices). verts_tips_parsed_idx = [] if len(all_chains_tips_idx) >= 2: for spec_v_idx in all_chains_tips_idx: if (spec_v_idx not in tips_to_discard_idx): verts_tips_parsed_idx.append(spec_v_idx) - - #### Identify the type of selection made by the user. + # Identify the type of selection made by the user if middle_vertex_idx is not None: - if len(all_chains_tips_idx) == 4 and len(single_unselected_verts_and_neighbors) == 1: # If there are 4 tips (two selection chains), and there is only one single unselected vert (the middle vert). + # If there are 4 tips (two selection chains), and + # there is only one single unselected vert (the middle vert) + if len(all_chains_tips_idx) == 4 and len(single_unselected_verts_and_neighbors) == 1: selection_type = "TWO_CONNECTED" else: # The type of the selection was not identified, the script stops. @@ -1827,15 +1852,16 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return{'CANCELLED'} else: - if len(all_chains_tips_idx) == 2: # If there are 2 tips + if len(all_chains_tips_idx) == 2: # If there are 2 tips selection_type = "SINGLE" - elif len(all_chains_tips_idx) == 4: # If there are 4 tips + elif len(all_chains_tips_idx) == 4: # If there are 4 tips selection_type = "TWO_NOT_CONNECTED" elif len(all_chains_tips_idx) == 0: if len(self.main_splines.data.splines) > 1: selection_type = "NO_SELECTION" else: - # If the selection was not identified and there is only one stroke, there's no possibility to build a surface, so the script is interrupted. + # If the selection was not identified and there is only one stroke, + # there's no possibility to build a surface, so the script is interrupted self.report({'WARNING'}, "The selection isn't valid.") bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') self.cleanup_on_interruption() @@ -1843,7 +1869,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return{'CANCELLED'} else: - # The type of the selection was not identified, the script stops. + # The type of the selection was not identified, the script stops self.report({'WARNING'}, "The selection isn't valid.") bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') @@ -1853,27 +1879,23 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return{'CANCELLED'} - - - #### If the selection type is TWO_NOT_CONNECTED and there is only one stroke, stop the script. + # If the selection type is TWO_NOT_CONNECTED and there is only one stroke, stop the script if selection_type == "TWO_NOT_CONNECTED" and len(self.main_splines.data.splines) == 1: - self.report({'WARNING'}, "At least two strokes are needed when there are two not connected selections.") + self.report({'WARNING'}, + "At least two strokes are needed when there are two not connected selections") bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') self.cleanup_on_interruption() self.stopping_errors = True return{'CANCELLED'} - - bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[self.main_splines.name].select = True bpy.context.scene.objects.active = bpy.context.scene.objects[self.main_splines.name] - - #### Enter editmode for the new curve (converted from grease pencil strokes), to smooth it out. + # Enter editmode for the new curve (converted from grease pencil strokes), to smooth it out bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.curve.smooth('INVOKE_REGION_WIN') bpy.ops.curve.smooth('INVOKE_REGION_WIN') @@ -1883,7 +1905,6 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.curve.smooth('INVOKE_REGION_WIN') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - self.selection_U_exists = False self.selection_U2_exists = False self.selection_V_exists = False @@ -1894,7 +1915,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): self.selection_V_is_closed = False self.selection_V2_is_closed = False - #### Define what vertices are at the tips of each selection and are not the middle-vertex. + # Define what vertices are at the tips of each selection and are not the middle-vertex if selection_type == "TWO_CONNECTED": self.selection_U_exists = True self.selection_V_exists = True @@ -1904,19 +1925,31 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): closing_vert_U2_idx = None closing_vert_V2_idx = None - # Determine which selection is Selection-U and which is Selection-V. + # Determine which selection is Selection-U and which is Selection-V points_A = [] points_B = [] points_first_stroke_tips = [] - points_A.append(self.main_object.matrix_world * self.main_object.data.vertices[verts_tips_parsed_idx[0]].co) - points_A.append(self.main_object.matrix_world * self.main_object.data.vertices[middle_vertex_idx].co) - - points_B.append(self.main_object.matrix_world * self.main_object.data.vertices[verts_tips_parsed_idx[1]].co) - points_B.append(self.main_object.matrix_world * self.main_object.data.vertices[middle_vertex_idx].co) - - points_first_stroke_tips.append(self.main_splines.data.splines[0].bezier_points[0].co) - points_first_stroke_tips.append(self.main_splines.data.splines[0].bezier_points[len(self.main_splines.data.splines[0].bezier_points) - 1].co) + points_A.append( + self.main_object.matrix_world * self.main_object.data.vertices[verts_tips_parsed_idx[0]].co + ) + points_A.append( + self.main_object.matrix_world * self.main_object.data.vertices[middle_vertex_idx].co + ) + points_B.append( + self.main_object.matrix_world * self.main_object.data.vertices[verts_tips_parsed_idx[1]].co + ) + points_B.append( + self.main_object.matrix_world * self.main_object.data.vertices[middle_vertex_idx].co + ) + points_first_stroke_tips.append( + self.main_splines.data.splines[0].bezier_points[0].co + ) + points_first_stroke_tips.append( + self.main_splines.data.splines[0].bezier_points[ + len(self.main_splines.data.splines[0].bezier_points) - 1 + ].co + ) angle_A = self.orientation_difference(points_A, points_first_stroke_tips) angle_B = self.orientation_difference(points_B, points_first_stroke_tips) @@ -1930,66 +1963,115 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): elif selection_type == "SINGLE" or selection_type == "TWO_NOT_CONNECTED": first_sketched_point_first_stroke_co = self.main_splines.data.splines[0].bezier_points[0].co - last_sketched_point_first_stroke_co = self.main_splines.data.splines[0].bezier_points[len(self.main_splines.data.splines[0].bezier_points) - 1].co - first_sketched_point_last_stroke_co = self.main_splines.data.splines[len(self.main_splines.data.splines) - 1].bezier_points[0].co + last_sketched_point_first_stroke_co = \ + self.main_splines.data.splines[0].bezier_points[ + len(self.main_splines.data.splines[0].bezier_points) - 1 + ].co + first_sketched_point_last_stroke_co = \ + self.main_splines.data.splines[ + len(self.main_splines.data.splines) - 1 + ].bezier_points[0].co if len(self.main_splines.data.splines) > 1: first_sketched_point_second_stroke_co = self.main_splines.data.splines[1].bezier_points[0].co - last_sketched_point_second_stroke_co = self.main_splines.data.splines[1].bezier_points[len(self.main_splines.data.splines[1].bezier_points) - 1].co + last_sketched_point_second_stroke_co = \ + self.main_splines.data.splines[1].bezier_points[ + len(self.main_splines.data.splines[1].bezier_points) - 1 + ].co - - single_unselected_neighbors = [] # Only the neighbors of the single unselected verts. + single_unselected_neighbors = [] # Only the neighbors of the single unselected verts for verts_neig_idx in single_unselected_verts_and_neighbors: single_unselected_neighbors.append(verts_neig_idx[1]) single_unselected_neighbors.append(verts_neig_idx[2]) - all_chains_tips_and_middle_vert = [] for v_idx in all_chains_tips_idx: if v_idx not in single_unselected_neighbors: all_chains_tips_and_middle_vert.append(v_idx) - all_chains_tips_and_middle_vert += single_unselected_verts all_participating_verts = all_chains_tips_and_middle_vert + all_verts_idx - # The tip of the selected vertices nearest to the first point of the first sketched stroke. - nearest_tip_to_first_st_first_pt_idx, shortest_distance_to_first_stroke = self.shortest_distance(self.main_object, first_sketched_point_first_stroke_co, all_chains_tips_and_middle_vert) - # If the nearest tip is not from a closed selection, get the opposite tip vertex index. - if nearest_tip_to_first_st_first_pt_idx not in single_unselected_verts or nearest_tip_to_first_st_first_pt_idx == middle_vertex_idx: - nearest_tip_to_first_st_first_pt_opposite_idx = self.opposite_tip(nearest_tip_to_first_st_first_pt_idx, verts_tips_same_chain_idx) - - # The tip of the selected vertices nearest to the last point of the first sketched stroke. - nearest_tip_to_first_st_last_pt_idx, temp_dist = self.shortest_distance(self.main_object, last_sketched_point_first_stroke_co, all_chains_tips_and_middle_vert) - - # The tip of the selected vertices nearest to the first point of the last sketched stroke. - nearest_tip_to_last_st_first_pt_idx, shortest_distance_to_last_stroke = self.shortest_distance(self.main_object, first_sketched_point_last_stroke_co, all_chains_tips_and_middle_vert) - + # The tip of the selected vertices nearest to the first point of the first sketched stroke + nearest_tip_to_first_st_first_pt_idx, shortest_distance_to_first_stroke = \ + self.shortest_distance( + self.main_object, + first_sketched_point_first_stroke_co, + all_chains_tips_and_middle_vert + ) + # If the nearest tip is not from a closed selection, get the opposite tip vertex index + if nearest_tip_to_first_st_first_pt_idx not in single_unselected_verts or \ + nearest_tip_to_first_st_first_pt_idx == middle_vertex_idx: + + nearest_tip_to_first_st_first_pt_opposite_idx = \ + self.opposite_tip( + nearest_tip_to_first_st_first_pt_idx, + verts_tips_same_chain_idx + ) + # The tip of the selected vertices nearest to the last point of the first sketched stroke + nearest_tip_to_first_st_last_pt_idx, temp_dist = \ + self.shortest_distance( + self.main_object, + last_sketched_point_first_stroke_co, + all_chains_tips_and_middle_vert + ) + # The tip of the selected vertices nearest to the first point of the last sketched stroke + nearest_tip_to_last_st_first_pt_idx, shortest_distance_to_last_stroke = \ + self.shortest_distance( + self.main_object, + first_sketched_point_last_stroke_co, + all_chains_tips_and_middle_vert + ) if len(self.main_splines.data.splines) > 1: - # The selected vertex nearest to the first point of the second sketched stroke. (This will be useful to determine the direction of the closed selection V when extruding along strokes) - nearest_vert_to_second_st_first_pt_idx, temp_dist = self.shortest_distance(self.main_object, first_sketched_point_second_stroke_co, all_verts_idx) - - # The selected vertex nearest to the first point of the second sketched stroke. (This will be useful to determine the direction of the closed selection V2 when extruding along strokes) - nearest_vert_to_second_st_last_pt_idx, temp_dist = self.shortest_distance(self.main_object, last_sketched_point_second_stroke_co, all_verts_idx) - - - - # Determine if the single selection will be treated as U or as V. + # The selected vertex nearest to the first point of the second sketched stroke + # (This will be useful to determine the direction of the closed + # selection V when extruding along strokes) + nearest_vert_to_second_st_first_pt_idx, temp_dist = \ + self.shortest_distance( + self.main_object, + first_sketched_point_second_stroke_co, + all_verts_idx + ) + # The selected vertex nearest to the first point of the second sketched stroke + # (This will be useful to determine the direction of the closed + # selection V2 when extruding along strokes) + nearest_vert_to_second_st_last_pt_idx, temp_dist = \ + self.shortest_distance( + self.main_object, + last_sketched_point_second_stroke_co, + all_verts_idx + ) + # Determine if the single selection will be treated as U or as V edges_sum = 0 for i in all_selected_edges_idx: - edges_sum += ((self.main_object.matrix_world * self.main_object.data.vertices[self.main_object.data.edges[i].vertices[0]].co) - (self.main_object.matrix_world * self.main_object.data.vertices[self.main_object.data.edges[i].vertices[1]].co)).length + edges_sum += ( + (self.main_object.matrix_world * + self.main_object.data.vertices[self.main_object.data.edges[i].vertices[0]].co) - + (self.main_object.matrix_world * + self.main_object.data.vertices[self.main_object.data.edges[i].vertices[1]].co) + ).length average_edge_length = edges_sum / len(all_selected_edges_idx) + # Get shortest distance from the first point of the last stroke to any participating vertex + temp_idx, shortest_distance_to_last_stroke = \ + self.shortest_distance( + self.main_object, + first_sketched_point_last_stroke_co, + all_participating_verts + ) + # If the beginning of the first stroke is near enough, and its orientation + # difference with the first edge of the nearest selection chain is not too high, + # interpret things as an "extrude along strokes" instead of "extrude through strokes" + if shortest_distance_to_first_stroke < average_edge_length / 4 and \ + shortest_distance_to_last_stroke < average_edge_length and \ + len(self.main_splines.data.splines) > 1: - # Get shortest distance from the first point of the last stroke to any participating vertex. - temp_idx, shortest_distance_to_last_stroke = self.shortest_distance(self.main_object, first_sketched_point_last_stroke_co, all_participating_verts) - - - if shortest_distance_to_first_stroke < average_edge_length / 4 and shortest_distance_to_last_stroke < average_edge_length and len(self.main_splines.data.splines) > 1: # If the beginning of the first stroke is near enough, and its orientation difference with the first edge of the nearest selection chain is not too high, interpret things as an "extrude along strokes" instead of "extrude through strokes" self.selection_U_exists = False self.selection_V_exists = True - if nearest_tip_to_first_st_first_pt_idx not in single_unselected_verts or nearest_tip_to_first_st_first_pt_idx == middle_vertex_idx: # If the first selection is not closed. + # If the first selection is not closed + if nearest_tip_to_first_st_first_pt_idx not in single_unselected_verts or \ + nearest_tip_to_first_st_first_pt_idx == middle_vertex_idx: self.selection_V_is_closed = False first_neighbor_V_idx = None closing_vert_U_idx = None @@ -2015,34 +2097,38 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): vert_neighbors.append(verts[2]) break - verts_V = self.get_ordered_verts(self.main_object, all_selected_edges_idx, all_verts_idx, vert_neighbors[0], middle_vertex_idx, None) + verts_V = self.get_ordered_verts( + self.main_object, all_selected_edges_idx, + all_verts_idx, vert_neighbors[0], middle_vertex_idx, None + ) for i in range(0, len(verts_V)): if verts_V[i].index == nearest_vert_to_second_st_first_pt_idx: - if i >= len(verts_V) / 2: # If the vertex nearest to the first point of the second stroke is in the first half of the selected verts. + # If the vertex nearest to the first point of the second stroke + # is in the first half of the selected verts + if i >= len(verts_V) / 2: first_vert_V_idx = vert_neighbors[1] break else: first_vert_V_idx = vert_neighbors[0] break - - if selection_type == "TWO_NOT_CONNECTED": self.selection_V2_exists = True + # If the second selection is not closed + if nearest_tip_to_first_st_last_pt_idx not in single_unselected_verts or \ + nearest_tip_to_first_st_last_pt_idx == middle_vertex_idx: - if nearest_tip_to_first_st_last_pt_idx not in single_unselected_verts or nearest_tip_to_first_st_last_pt_idx == middle_vertex_idx: # If the second selection is not closed. self.selection_V2_is_closed = False first_neighbor_V2_idx = None closing_vert_V2_idx = None - first_vert_V2_idx = nearest_tip_to_first_st_last_pt_idx else: self.selection_V2_is_closed = True closing_vert_V2_idx = nearest_tip_to_first_st_last_pt_idx - # Get the neighbors of the first (unselected) vert of the closed selection U. + # Get the neighbors of the first (unselected) vert of the closed selection U vert_neighbors = [] for verts in single_unselected_verts_and_neighbors: if verts[0] == nearest_tip_to_first_st_last_pt_idx: @@ -2050,41 +2136,55 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): vert_neighbors.append(verts[2]) break - - verts_V2 = self.get_ordered_verts(self.main_object, all_selected_edges_idx, all_verts_idx, vert_neighbors[0], middle_vertex_idx, None) + verts_V2 = self.get_ordered_verts( + self.main_object, all_selected_edges_idx, + all_verts_idx, vert_neighbors[0], middle_vertex_idx, None + ) for i in range(0, len(verts_V2)): if verts_V2[i].index == nearest_vert_to_second_st_last_pt_idx: - if i >= len(verts_V2) / 2: # If the vertex nearest to the first point of the second stroke is in the first half of the selected verts. + # If the vertex nearest to the first point of the second stroke + # is in the first half of the selected verts + if i >= len(verts_V2) / 2: first_vert_V2_idx = vert_neighbors[1] break else: first_vert_V2_idx = vert_neighbors[0] break - else: self.selection_V2_exists = False else: self.selection_U_exists = True self.selection_V_exists = False - if nearest_tip_to_first_st_first_pt_idx not in single_unselected_verts or nearest_tip_to_first_st_first_pt_idx == middle_vertex_idx: # If the first selection is not closed. + # If the first selection is not closed + if nearest_tip_to_first_st_first_pt_idx not in single_unselected_verts or \ + nearest_tip_to_first_st_first_pt_idx == middle_vertex_idx: self.selection_U_is_closed = False first_neighbor_U_idx = None closing_vert_U_idx = None points_tips = [] - points_tips.append(self.main_object.matrix_world * self.main_object.data.vertices[nearest_tip_to_first_st_first_pt_idx].co) - points_tips.append(self.main_object.matrix_world * self.main_object.data.vertices[nearest_tip_to_first_st_first_pt_opposite_idx].co) - + points_tips.append( + self.main_object.matrix_world * + self.main_object.data.vertices[nearest_tip_to_first_st_first_pt_idx].co + ) + points_tips.append( + self.main_object.matrix_world * + self.main_object.data.vertices[nearest_tip_to_first_st_first_pt_opposite_idx].co + ) points_first_stroke_tips = [] points_first_stroke_tips.append(self.main_splines.data.splines[0].bezier_points[0].co) - points_first_stroke_tips.append(self.main_splines.data.splines[0].bezier_points[len(self.main_splines.data.splines[0].bezier_points) - 1].co) - + points_first_stroke_tips.append( + self.main_splines.data.splines[0].bezier_points[ + len(self.main_splines.data.splines[0].bezier_points) - 1 + ].co + ) vec_A = points_tips[0] - points_tips[1] vec_B = points_first_stroke_tips[0] - points_first_stroke_tips[1] - # Compare the direction of the selection and the first grease pencil stroke to determine which is the "first" vertex of the selection. + # Compare the direction of the selection and the first + # grease pencil stroke to determine which is the "first" vertex of the selection if vec_A.dot(vec_B) < 0: first_vert_U_idx = nearest_tip_to_first_st_first_pt_opposite_idx else: @@ -2094,7 +2194,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): self.selection_U_is_closed = True closing_vert_U_idx = nearest_tip_to_first_st_first_pt_idx - # Get the neighbors of the first (unselected) vert of the closed selection U. + # Get the neighbors of the first (unselected) vert of the closed selection U vert_neighbors = [] for verts in single_unselected_verts_and_neighbors: if verts[0] == nearest_tip_to_first_st_first_pt_idx: @@ -2103,9 +2203,14 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): break points_first_and_neighbor = [] - points_first_and_neighbor.append(self.main_object.matrix_world * self.main_object.data.vertices[nearest_tip_to_first_st_first_pt_idx].co) - points_first_and_neighbor.append(self.main_object.matrix_world * self.main_object.data.vertices[vert_neighbors[0]].co) - + points_first_and_neighbor.append( + self.main_object.matrix_world * + self.main_object.data.vertices[nearest_tip_to_first_st_first_pt_idx].co + ) + points_first_and_neighbor.append( + self.main_object.matrix_world * + self.main_object.data.vertices[vert_neighbors[0]].co + ) points_first_stroke_tips = [] points_first_stroke_tips.append(self.main_splines.data.splines[0].bezier_points[0].co) points_first_stroke_tips.append(self.main_splines.data.splines[0].bezier_points[1].co) @@ -2113,29 +2218,29 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): vec_A = points_first_and_neighbor[0] - points_first_and_neighbor[1] vec_B = points_first_stroke_tips[0] - points_first_stroke_tips[1] - # Compare the direction of the selection and the first grease pencil stroke to determine which is the vertex neighbor to the first vertex (unselected) of the closed selection. This will determine the direction of the closed selection. + # Compare the direction of the selection and the first grease pencil stroke to + # determine which is the vertex neighbor to the first vertex (unselected) of + # the closed selection. This will determine the direction of the closed selection if vec_A.dot(vec_B) < 0: first_vert_U_idx = vert_neighbors[1] else: first_vert_U_idx = vert_neighbors[0] - - if selection_type == "TWO_NOT_CONNECTED": self.selection_U2_exists = True + # If the second selection is not closed + if nearest_tip_to_last_st_first_pt_idx not in single_unselected_verts or \ + nearest_tip_to_last_st_first_pt_idx == middle_vertex_idx: - if nearest_tip_to_last_st_first_pt_idx not in single_unselected_verts or nearest_tip_to_last_st_first_pt_idx == middle_vertex_idx: # If the second selection is not closed. self.selection_U2_is_closed = False first_neighbor_U2_idx = None closing_vert_U2_idx = None - first_vert_U2_idx = nearest_tip_to_last_st_first_pt_idx - else: self.selection_U2_is_closed = True closing_vert_U2_idx = nearest_tip_to_last_st_first_pt_idx - # Get the neighbors of the first (unselected) vert of the closed selection U. + # Get the neighbors of the first (unselected) vert of the closed selection U vert_neighbors = [] for verts in single_unselected_verts_and_neighbors: if verts[0] == nearest_tip_to_last_st_first_pt_idx: @@ -2144,22 +2249,35 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): break points_first_and_neighbor = [] - points_first_and_neighbor.append(self.main_object.matrix_world * self.main_object.data.vertices[nearest_tip_to_last_st_first_pt_idx].co) - points_first_and_neighbor.append(self.main_object.matrix_world * self.main_object.data.vertices[vert_neighbors[0]].co) - + points_first_and_neighbor.append( + self.main_object.matrix_world * + self.main_object.data.vertices[nearest_tip_to_last_st_first_pt_idx].co + ) + points_first_and_neighbor.append( + self.main_object.matrix_world * + self.main_object.data.vertices[vert_neighbors[0]].co + ) points_last_stroke_tips = [] - points_last_stroke_tips.append(self.main_splines.data.splines[len(self.main_splines.data.splines) - 1].bezier_points[0].co) - points_last_stroke_tips.append(self.main_splines.data.splines[len(self.main_splines.data.splines) - 1].bezier_points[1].co) - + points_last_stroke_tips.append( + self.main_splines.data.splines[ + len(self.main_splines.data.splines) - 1 + ].bezier_points[0].co + ) + points_last_stroke_tips.append( + self.main_splines.data.splines[ + len(self.main_splines.data.splines) - 1 + ].bezier_points[1].co + ) vec_A = points_first_and_neighbor[0] - points_first_and_neighbor[1] vec_B = points_last_stroke_tips[0] - points_last_stroke_tips[1] - # Compare the direction of the selection and the last grease pencil stroke to determine which is the vertex neighbor to the first vertex (unselected) of the closed selection. This will determine the direction of the closed selection. + # Compare the direction of the selection and the last grease pencil stroke to + # determine which is the vertex neighbor to the first vertex (unselected) of + # the closed selection. This will determine the direction of the closed selection if vec_A.dot(vec_B) < 0: first_vert_U2_idx = vert_neighbors[1] else: first_vert_U2_idx = vert_neighbors[0] - else: self.selection_U2_exists = False @@ -2167,110 +2285,137 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): self.selection_U_exists = False self.selection_V_exists = False - - - #### Get an ordered list of the vertices of Selection-U. + # Get an ordered list of the vertices of Selection-U verts_ordered_U = [] if self.selection_U_exists: - verts_ordered_U = self.get_ordered_verts(self.main_object, all_selected_edges_idx, all_verts_idx, first_vert_U_idx, middle_vertex_idx, closing_vert_U_idx) + verts_ordered_U = self.get_ordered_verts( + self.main_object, all_selected_edges_idx, + all_verts_idx, first_vert_U_idx, + middle_vertex_idx, closing_vert_U_idx + ) verts_ordered_U_indices = [x.index for x in verts_ordered_U] - #### Get an ordered list of the vertices of Selection-U2. + # Get an ordered list of the vertices of Selection-U2 verts_ordered_U2 = [] if self.selection_U2_exists: - verts_ordered_U2 = self.get_ordered_verts(self.main_object, all_selected_edges_idx, all_verts_idx, first_vert_U2_idx, middle_vertex_idx, closing_vert_U2_idx) + verts_ordered_U2 = self.get_ordered_verts( + self.main_object, all_selected_edges_idx, + all_verts_idx, first_vert_U2_idx, + middle_vertex_idx, closing_vert_U2_idx + ) verts_ordered_U2_indices = [x.index for x in verts_ordered_U2] - #### Get an ordered list of the vertices of Selection-V. + # Get an ordered list of the vertices of Selection-V verts_ordered_V = [] if self.selection_V_exists: - verts_ordered_V = self.get_ordered_verts(self.main_object, all_selected_edges_idx, all_verts_idx, first_vert_V_idx, middle_vertex_idx, closing_vert_V_idx) + verts_ordered_V = self.get_ordered_verts( + self.main_object, all_selected_edges_idx, + all_verts_idx, first_vert_V_idx, + middle_vertex_idx, closing_vert_V_idx + ) verts_ordered_V_indices = [x.index for x in verts_ordered_V] - #### Get an ordered list of the vertices of Selection-V2. + # Get an ordered list of the vertices of Selection-V2 verts_ordered_V2 = [] if self.selection_V2_exists: - verts_ordered_V2 = self.get_ordered_verts(self.main_object, all_selected_edges_idx, all_verts_idx, first_vert_V2_idx, middle_vertex_idx, closing_vert_V2_idx) + verts_ordered_V2 = self.get_ordered_verts( + self.main_object, all_selected_edges_idx, + all_verts_idx, first_vert_V2_idx, + middle_vertex_idx, closing_vert_V2_idx + ) verts_ordered_V2_indices = [x.index for x in verts_ordered_V2] - - - #### Check if when there are two-not-connected selections both have the same number of verts. If not terminate the script. - if ((self.selection_U2_exists and len(verts_ordered_U) != len(verts_ordered_U2)) or (self.selection_V2_exists and len(verts_ordered_V) != len(verts_ordered_V2))): - # Display a warning. + # Check if when there are two-not-connected selections both have the same + # number of verts. If not terminate the script + if ((self.selection_U2_exists and len(verts_ordered_U) != len(verts_ordered_U2)) or + (self.selection_V2_exists and len(verts_ordered_V) != len(verts_ordered_V2))): + # Display a warning self.report({'WARNING'}, "Both selections must have the same number of edges") self.cleanup_on_interruption() - self.stopping_errors = True return{'CANCELLED'} - - - #### Calculate edges U proportions. - - # Sum selected edges U lengths. + # Calculate edges U proportions + # Sum selected edges U lengths edges_lengths_U = [] edges_lengths_sum_U = 0 if self.selection_U_exists: - edges_lengths_U, edges_lengths_sum_U = self.get_chain_length(self.main_object, verts_ordered_U) - + edges_lengths_U, edges_lengths_sum_U = self.get_chain_length( + self.main_object, + verts_ordered_U + ) if self.selection_U2_exists: - edges_lengths_U2, edges_lengths_sum_U2 = self.get_chain_length(self.main_object, verts_ordered_U2) - - # Sum selected edges V lengths. + edges_lengths_U2, edges_lengths_sum_U2 = self.get_chain_length( + self.main_object, + verts_ordered_U2 + ) + # Sum selected edges V lengths edges_lengths_V = [] edges_lengths_sum_V = 0 if self.selection_V_exists: - edges_lengths_V, edges_lengths_sum_V = self.get_chain_length(self.main_object, verts_ordered_V) - + edges_lengths_V, edges_lengths_sum_V = self.get_chain_length( + self.main_object, + verts_ordered_V + ) if self.selection_V2_exists: - edges_lengths_V2, edges_lengths_sum_V2 = self.get_chain_length(self.main_object, verts_ordered_V2) - + edges_lengths_V2, edges_lengths_sum_V2 = self.get_chain_length( + self.main_object, + verts_ordered_V2 + ) bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts = bpy.context.scene.SURFSK_precision) + bpy.ops.curve.subdivide('INVOKE_REGION_WIN', + number_cuts=bpy.context.scene.bsurfaces.SURFSK_precision) bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - # Proportions U. + # Proportions U edges_proportions_U = [] - edges_proportions_U = self.get_edges_proportions(edges_lengths_U, edges_lengths_sum_U, self.selection_U_exists, self.edges_U) + edges_proportions_U = self.get_edges_proportions( + edges_lengths_U, edges_lengths_sum_U, + self.selection_U_exists, self.edges_U + ) verts_count_U = len(edges_proportions_U) + 1 if self.selection_U2_exists: edges_proportions_U2 = [] - edges_proportions_U2 = self.get_edges_proportions(edges_lengths_U2, edges_lengths_sum_U2, self.selection_U2_exists, self.edges_V) + edges_proportions_U2 = self.get_edges_proportions( + edges_lengths_U2, edges_lengths_sum_U2, + self.selection_U2_exists, self.edges_V + ) verts_count_U2 = len(edges_proportions_U2) + 1 - # Proportions V. + # Proportions V edges_proportions_V = [] - edges_proportions_V = self.get_edges_proportions(edges_lengths_V, edges_lengths_sum_V, self.selection_V_exists, self.edges_V) + edges_proportions_V = self.get_edges_proportions( + edges_lengths_V, edges_lengths_sum_V, + self.selection_V_exists, self.edges_V + ) verts_count_V = len(edges_proportions_V) + 1 if self.selection_V2_exists: edges_proportions_V2 = [] - edges_proportions_V2 = self.get_edges_proportions(edges_lengths_V2, edges_lengths_sum_V2, self.selection_V2_exists, self.edges_V) + edges_proportions_V2 = self.get_edges_proportions( + edges_lengths_V2, edges_lengths_sum_V2, + self.selection_V2_exists, self.edges_V + ) verts_count_V2 = len(edges_proportions_V2) + 1 + # Cyclic Follow: simplify sketched curves, make them Cyclic, and complete + # the actual sketched curves with a "closing segment" + if self.cyclic_follow and not self.selection_V_exists and not \ + ((self.selection_U_exists and not self.selection_U_is_closed) or + (self.selection_U2_exists and not self.selection_U2_is_closed)): - - - - - - - #### Cyclic Follow: simplify sketched curves, make them Cyclic, and complete the actual sketched curves with a "closing segment". - if self.cyclic_follow and not self.selection_V_exists and not ((self.selection_U_exists and not self.selection_U_is_closed) or (self.selection_U2_exists and not self.selection_U2_is_closed)): simplified_spline_coords = [] simplified_curve = [] ob_simplified_curve = [] splines_first_v_co = [] for i in range(len(self.main_splines.data.splines)): - # Create a curve object for the actual spline "cyclic extension". + # Create a curve object for the actual spline "cyclic extension" simplified_curve.append(bpy.data.curves.new('SURFSKIO_simpl_crv', 'CURVE')) ob_simplified_curve.append(bpy.data.objects.new('SURFSKIO_simpl_crv', simplified_curve[i])) bpy.context.scene.objects.link(ob_simplified_curve[i]) @@ -2281,20 +2426,19 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): for bp in self.main_splines.data.splines[i].bezier_points: spline_coords.append(bp.co) - # Simplification. + # Simplification simplified_spline_coords.append(self.simplify_spline(spline_coords, 5)) - # Get the coordinates of the first vert of the actual spline. + # Get the coordinates of the first vert of the actual spline splines_first_v_co.append(simplified_spline_coords[i][0]) - - # Generate the spline. + # Generate the spline spline = simplified_curve[i].splines.new('BEZIER') - spline.bezier_points.add(len(simplified_spline_coords[i]) - 1) # less one because one point is added when the spline is created. + # less one because one point is added when the spline is created + spline.bezier_points.add(len(simplified_spline_coords[i]) - 1) for p in range(0, len(simplified_spline_coords[i])): spline.bezier_points[p].co = simplified_spline_coords[i][p] - spline.use_cyclic_u = True spline_bp_count = len(spline.bezier_points) @@ -2309,8 +2453,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - # Select the "closing segment", and subdivide it. + # Select the "closing segment", and subdivide it ob_simplified_curve[i].data.splines[0].bezier_points[0].select_control_point = True ob_simplified_curve[i].data.splines[0].bezier_points[0].select_left_handle = True ob_simplified_curve[i].data.splines[0].bezier_points[0].select_right_handle = True @@ -2320,41 +2463,47 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): ob_simplified_curve[i].data.splines[0].bezier_points[spline_bp_count - 1].select_right_handle = True bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - segments = sqrt((ob_simplified_curve[i].data.splines[0].bezier_points[0].co - ob_simplified_curve[i].data.splines[0].bezier_points[spline_bp_count - 1].co).length / self.average_gp_segment_length) + segments = sqrt( + (ob_simplified_curve[i].data.splines[0].bezier_points[0].co - + ob_simplified_curve[i].data.splines[0].bezier_points[spline_bp_count - 1].co).length / + self.average_gp_segment_length + ) for t in range(2): - bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts = segments) - + bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=segments) - # Delete the other vertices and make it non-cyclic to keep only the needed verts of the "closing segment". - bpy.ops.curve.select_all(action = 'INVERT') + # Delete the other vertices and make it non-cyclic to + # keep only the needed verts of the "closing segment" + bpy.ops.curve.select_all(action='INVERT') bpy.ops.curve.delete(type='VERT') ob_simplified_curve[i].data.splines[0].use_cyclic_u = False bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - # Add the points of the "closing segment" to the original curve from grease pencil stroke. + # Add the points of the "closing segment" to the original curve from grease pencil stroke first_new_index = len(self.main_splines.data.splines[i].bezier_points) - self.main_splines.data.splines[i].bezier_points.add(len(ob_simplified_curve[i].data.splines[0].bezier_points) - 1) + self.main_splines.data.splines[i].bezier_points.add( + len(ob_simplified_curve[i].data.splines[0].bezier_points) - 1 + ) for t in range(1, len(ob_simplified_curve[i].data.splines[0].bezier_points)): - self.main_splines.data.splines[i].bezier_points[t - 1 + first_new_index].co = ob_simplified_curve[i].data.splines[0].bezier_points[t].co - + self.main_splines.data.splines[i].bezier_points[t - 1 + first_new_index].co = \ + ob_simplified_curve[i].data.splines[0].bezier_points[t].co - # Delete the temporal curve. + # Delete the temporal curve bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob_simplified_curve[i].name].select = True bpy.context.scene.objects.active = bpy.context.scene.objects[ob_simplified_curve[i].name] bpy.ops.object.delete() - - - #### Get the coords of the points distributed along the sketched strokes, with proportions-U of the first selection. - pts_on_strokes_with_proportions_U = self.distribute_pts(self.main_splines.data.splines, edges_proportions_U) - + # Get the coords of the points distributed along the sketched strokes, + # with proportions-U of the first selection + pts_on_strokes_with_proportions_U = self.distribute_pts( + self.main_splines.data.splines, + edges_proportions_U + ) sketched_splines_parsed = [] if self.selection_U2_exists: - # Initialize the multidimensional list with the proportions of all the segments. + # Initialize the multidimensional list with the proportions of all the segments proportions_loops_crossing_strokes = [] for i in range(len(pts_on_strokes_with_proportions_U)): proportions_loops_crossing_strokes.append([]) @@ -2362,35 +2511,46 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): for t in range(len(pts_on_strokes_with_proportions_U[0])): proportions_loops_crossing_strokes[i].append(None) - - # Calculate the proportions of each segment of the loops-U from pts_on_strokes_with_proportions_U. + # Calculate the proportions of each segment of the loops-U from pts_on_strokes_with_proportions_U for lp in range(len(pts_on_strokes_with_proportions_U[0])): loop_segments_lengths = [] for st in range(len(pts_on_strokes_with_proportions_U)): - if st == 0: # When on the first stroke, add the segment from the selection to the dirst stroke. - loop_segments_lengths.append(((self.main_object.matrix_world * verts_ordered_U[lp].co) - pts_on_strokes_with_proportions_U[0][lp]).length) - - if st != len(pts_on_strokes_with_proportions_U) - 1: # For all strokes except for the last, calculate the distance from the actual stroke to the next. - loop_segments_lengths.append((pts_on_strokes_with_proportions_U[st][lp] - pts_on_strokes_with_proportions_U[st + 1][lp]).length) - - if st == len(pts_on_strokes_with_proportions_U) - 1: # When on the last stroke, add the segments from the last stroke to the second selection. - loop_segments_lengths.append((pts_on_strokes_with_proportions_U[st][lp] - (self.main_object.matrix_world * verts_ordered_U2[lp].co)).length) - - # Calculate full loop length. + # When on the first stroke, add the segment from the selection to the dirst stroke + if st == 0: + loop_segments_lengths.append( + ((self.main_object.matrix_world * verts_ordered_U[lp].co) - + pts_on_strokes_with_proportions_U[0][lp]).length + ) + # For all strokes except for the last, calculate the distance + # from the actual stroke to the next + if st != len(pts_on_strokes_with_proportions_U) - 1: + loop_segments_lengths.append( + (pts_on_strokes_with_proportions_U[st][lp] - + pts_on_strokes_with_proportions_U[st + 1][lp]).length + ) + # When on the last stroke, add the segments + # from the last stroke to the second selection + if st == len(pts_on_strokes_with_proportions_U) - 1: + loop_segments_lengths.append( + (pts_on_strokes_with_proportions_U[st][lp] - + (self.main_object.matrix_world * verts_ordered_U2[lp].co)).length + ) + # Calculate full loop length loop_seg_lengths_sum = 0 for i in range(len(loop_segments_lengths)): loop_seg_lengths_sum += loop_segments_lengths[i] - # Fill the multidimensional list with the proportions of all the segments. + # Fill the multidimensional list with the proportions of all the segments for st in range(len(pts_on_strokes_with_proportions_U)): - proportions_loops_crossing_strokes[st][lp] = loop_segments_lengths[st] / loop_seg_lengths_sum - + proportions_loops_crossing_strokes[st][lp] = \ + loop_segments_lengths[st] / loop_seg_lengths_sum - # Calculate proportions for each stroke. + # Calculate proportions for each stroke for st in range(len(pts_on_strokes_with_proportions_U)): actual_stroke_spline = [] - actual_stroke_spline.append(self.main_splines.data.splines[st]) # Needs to be a list for the "distribute_pts" method. + # Needs to be a list for the "distribute_pts" method + actual_stroke_spline.append(self.main_splines.data.splines[st]) # Calculate the proportions for the actual stroke. actual_edges_proportions_U = [] @@ -2400,37 +2560,39 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): # Sum the proportions of this loop up to the actual. for t in range(0, st + 1): proportions_sum += proportions_loops_crossing_strokes[t][i] - - actual_edges_proportions_U.append(edges_proportions_U[i] - ((edges_proportions_U[i] - edges_proportions_U2[i]) * proportions_sum)) # i + 1, because proportions_loops_crossing_strokes refers to loops, and the proportions refer to edges, so we start at the element 1 of proportions_loops_crossing_strokes instead of element 0. - - + # i + 1, because proportions_loops_crossing_strokes refers to loops, + # and the proportions refer to edges, so we start at the element 1 + # of proportions_loops_crossing_strokes instead of element 0 + actual_edges_proportions_U.append( + edges_proportions_U[i] - + ((edges_proportions_U[i] - edges_proportions_U2[i]) * proportions_sum) + ) points_actual_spline = self.distribute_pts(actual_stroke_spline, actual_edges_proportions_U) sketched_splines_parsed.append(points_actual_spline[0]) - else: sketched_splines_parsed = pts_on_strokes_with_proportions_U - - - #### If the selection type is "TWO_NOT_CONNECTED" replace the points of the last spline with the points in the "target" selection. + # If the selection type is "TWO_NOT_CONNECTED" replace the + # points of the last spline with the points in the "target" selection if selection_type == "TWO_NOT_CONNECTED": if self.selection_U2_exists: for i in range(0, len(sketched_splines_parsed[len(sketched_splines_parsed) - 1])): - sketched_splines_parsed[len(sketched_splines_parsed) - 1][i] = self.main_object.matrix_world * verts_ordered_U2[i].co + sketched_splines_parsed[len(sketched_splines_parsed) - 1][i] = \ + self.main_object.matrix_world * verts_ordered_U2[i].co - - #### Create temporary curves along the "control-points" found on the sketched curves and the mesh selection. + # Create temporary curves along the "control-points" found + # on the sketched curves and the mesh selection mesh_ctrl_pts_name = "SURFSKIO_ctrl_pts" me = bpy.data.meshes.new(mesh_ctrl_pts_name) ob_ctrl_pts = bpy.data.objects.new(mesh_ctrl_pts_name, me) ob_ctrl_pts.data = me bpy.context.scene.objects.link(ob_ctrl_pts) - cyclic_loops_U = [] first_verts = [] second_verts = [] last_verts = [] + for i in range(0, verts_count_U): vert_num_in_spline = 1 @@ -2441,17 +2603,17 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): vert_num_in_spline += 1 - for t in range(0, len(sketched_splines_parsed)): ob_ctrl_pts.data.vertices.add(1) v = ob_ctrl_pts.data.vertices[len(ob_ctrl_pts.data.vertices) - 1] v.co = sketched_splines_parsed[t][i] - if vert_num_in_spline > 1: ob_ctrl_pts.data.edges.add(1) - ob_ctrl_pts.data.edges[len(ob_ctrl_pts.data.edges) - 1].vertices[0] = len(ob_ctrl_pts.data.vertices) - 2 - ob_ctrl_pts.data.edges[len(ob_ctrl_pts.data.edges) - 1].vertices[1] = len(ob_ctrl_pts.data.vertices) - 1 + ob_ctrl_pts.data.edges[len(ob_ctrl_pts.data.edges) - 1].vertices[0] = \ + len(ob_ctrl_pts.data.vertices) - 2 + ob_ctrl_pts.data.edges[len(ob_ctrl_pts.data.edges) - 1].vertices[1] = \ + len(ob_ctrl_pts.data.vertices) - 1 if t == 0: first_verts.append(v.index) @@ -2462,12 +2624,9 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if t == len(sketched_splines_parsed) - 1: last_verts.append(v.index) - last_v = v - vert_num_in_spline += 1 - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob_ctrl_pts.name].select = True bpy.context.scene.objects.active = bpy.data.objects[ob_ctrl_pts.name] @@ -2476,44 +2635,53 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.mesh.select_all(action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - #### Determine which loops-U will be "Cyclic". + # Determine which loops-U will be "Cyclic" for i in range(0, len(first_verts)): - if self.automatic_join and not self.cyclic_cross and selection_type != "TWO_CONNECTED" and len(self.main_splines.data.splines) >= 3: # When there is Cyclic Cross there is no need of Automatic Join, (and there are at least three strokes). - v = ob_ctrl_pts.data.vertices + # When there is Cyclic Cross there is no need of + # Automatic Join, (and there are at least three strokes) + if self.automatic_join and not self.cyclic_cross and \ + selection_type != "TWO_CONNECTED" and len(self.main_splines.data.splines) >= 3: + v = ob_ctrl_pts.data.vertices first_point_co = v[first_verts[i]].co second_point_co = v[second_verts[i]].co last_point_co = v[last_verts[i]].co # Coordinates of the point in the center of both the first and last verts. - verts_center_co = [(first_point_co[0] + last_point_co[0]) / 2, (first_point_co[1] + last_point_co[1]) / 2, (first_point_co[2] + last_point_co[2]) / 2] - + verts_center_co = [ + (first_point_co[0] + last_point_co[0]) / 2, + (first_point_co[1] + last_point_co[1]) / 2, + (first_point_co[2] + last_point_co[2]) / 2 + ] vec_A = second_point_co - first_point_co - vec_B = second_point_co - mathutils.Vector(verts_center_co) + vec_B = second_point_co - Vector(verts_center_co) - - # Calculate the length of the first segment of the loop, and the length it would have after moving the first vert to the middle position between first and last. + # Calculate the length of the first segment of the loop, + # and the length it would have after moving the first vert + # to the middle position between first and last length_original = (second_point_co - first_point_co).length - length_target = (second_point_co - mathutils.Vector(verts_center_co)).length + length_target = (second_point_co - Vector(verts_center_co)).length - angle = vec_A.angle(vec_B) / math.pi + angle = vec_A.angle(vec_B) / pi + # If the target length doesn't stretch too much, and the + # its angle doesn't change to much either + if length_target <= length_original * 1.03 * self.join_stretch_factor and \ + angle <= 0.008 * self.join_stretch_factor and not self.selection_U_exists: - if length_target <= length_original * 1.03 * self.join_stretch_factor and angle <= 0.008 * self.join_stretch_factor and not self.selection_U_exists: # If the target length doesn't stretch too much, and the its angle doesn't change to much either. cyclic_loops_U.append(True) - - # Move the first vert to the center coordinates. + # Move the first vert to the center coordinates ob_ctrl_pts.data.vertices[first_verts[i]].co = verts_center_co - - # Select the last verts from Cyclic loops, for later deletion all at once. + # Select the last verts from Cyclic loops, for later deletion all at once v[last_verts[i]].select = True - else: cyclic_loops_U.append(False) - else: - if self.cyclic_cross and not self.selection_U_exists and not ((self.selection_V_exists and not self.selection_V_is_closed) or (self.selection_V2_exists and not self.selection_V2_is_closed)): # If "Cyclic Cross" is active then "all" crossing curves become cyclic. + # If "Cyclic Cross" is active then "all" crossing curves become cyclic + if self.cyclic_cross and not self.selection_U_exists and not \ + ((self.selection_V_exists and not self.selection_V_is_closed) or + (self.selection_V2_exists and not self.selection_V2_is_closed)): + cyclic_loops_U.append(True) else: cyclic_loops_U.append(False) @@ -2537,8 +2705,9 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): for i in range(0, len(cyclic_loops_U)): ob_curves_surf.data.splines[i].use_cyclic_u = cyclic_loops_U[i] - - #### Get the coords of all points on first loop-U, for later comparison with its subdivided version, to know which points of the loops-U are crossed by the original strokes. The indices wiil be the same for the other loops-U. + # Get the coords of all points on first loop-U, for later comparison with its + # subdivided version, to know which points of the loops-U are crossed by the + # original strokes. The indices wiil be the same for the other loops-U if self.loops_on_strokes: coords_loops_U_control_points = [] for p in ob_ctrl_pts.data.splines[0].bezier_points: @@ -2546,29 +2715,27 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): tuple(coords_loops_U_control_points) - - # Calculate number of edges-V in case option "Loops on strokes" is active or inactive. + # Calculate number of edges-V in case option "Loops on strokes" is active or inactive if self.loops_on_strokes and not self.selection_V_exists: edges_V_count = len(self.main_splines.data.splines) * self.edges_V else: edges_V_count = len(edges_proportions_V) - - # The Follow precision will vary depending on the number of Follow face-loops. + # The Follow precision will vary depending on the number of Follow face-loops precision_multiplier = round(2 + (edges_V_count / 15)) + curve_cuts = bpy.context.scene.bsurfaces.SURFSK_precision * precision_multiplier - curve_cuts = bpy.context.scene.SURFSK_precision * precision_multiplier - - # Subdivide the curves. - bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts = curve_cuts) + # Subdivide the curves + bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=curve_cuts) - # The verts position shifting that happens with splines subdivision. For later reorder splines points. + # The verts position shifting that happens with splines subdivision. + # For later reorder splines points verts_position_shift = curve_cuts + 1 - bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - # Reorder coordinates of the points of each spline to put the first point of the spline starting at the position it was the first point before sudividing the curve. And make a new curve object per spline (to handle memory better later). + # Reorder coordinates of the points of each spline to put the first point of + # the spline starting at the position it was the first point before sudividing + # the curve. And make a new curve object per spline (to handle memory better later) splines_U_objects = [] for i in range(len(ob_curves_surf.data.splines)): spline_U_curve = bpy.data.curves.new('SURFSKIO_spline_U_' + str(i), 'CURVE') @@ -2577,64 +2744,64 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): spline_U_curve.dimensions = "3D" - - # Add points to the spline in the new curve object. + # Add points to the spline in the new curve object ob_spline_U.data.splines.new('BEZIER') for t in range(len(ob_curves_surf.data.splines[i].bezier_points)): - if cyclic_loops_U[i] == True and not self.selection_U_exists: # If the loop is cyclic. + if cyclic_loops_U[i] is True and not self.selection_U_exists: # If the loop is cyclic if t + verts_position_shift <= len(ob_curves_surf.data.splines[i].bezier_points) - 1: point_index = t + verts_position_shift else: point_index = t + verts_position_shift - len(ob_curves_surf.data.splines[i].bezier_points) else: point_index = t - - if t > 0: # to avoid adding the first point since it's added when the spline is created. + # to avoid adding the first point since it's added when the spline is created + if t > 0: ob_spline_U.data.splines[0].bezier_points.add(1) - ob_spline_U.data.splines[0].bezier_points[t].co = ob_curves_surf.data.splines[i].bezier_points[point_index].co + ob_spline_U.data.splines[0].bezier_points[t].co = \ + ob_curves_surf.data.splines[i].bezier_points[point_index].co - - if cyclic_loops_U[i] == True and not self.selection_U_exists: # If the loop is cyclic. - # Add a last point at the same location as the first one. + if cyclic_loops_U[i] is True and not self.selection_U_exists: # If the loop is cyclic + # Add a last point at the same location as the first one ob_spline_U.data.splines[0].bezier_points.add(1) - ob_spline_U.data.splines[0].bezier_points[len(ob_spline_U.data.splines[0].bezier_points) - 1].co = ob_spline_U.data.splines[0].bezier_points[0].co + ob_spline_U.data.splines[0].bezier_points[len(ob_spline_U.data.splines[0].bezier_points) - 1].co = \ + ob_spline_U.data.splines[0].bezier_points[0].co else: ob_spline_U.data.splines[0].use_cyclic_u = False - splines_U_objects.append(ob_spline_U) - - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob_spline_U.name].select = True bpy.context.scene.objects.active = bpy.data.objects[ob_spline_U.name] - - - #### When option "Loops on strokes" is active each "Cross" loop will have its own proportions according to where the original strokes "touch" them. + # When option "Loops on strokes" is active each "Cross" loop will have + # its own proportions according to where the original strokes "touch" them if self.loops_on_strokes: - # Get the indices of points where the original strokes "touch" loops-U. + # Get the indices of points where the original strokes "touch" loops-U points_U_crossed_by_strokes = [] for i in range(len(splines_U_objects[0].data.splines[0].bezier_points)): bp = splines_U_objects[0].data.splines[0].bezier_points[i] if ["%.4f" % bp.co[0], "%.4f" % bp.co[1], "%.4f" % bp.co[2]] in coords_loops_U_control_points: points_U_crossed_by_strokes.append(i) - # Make a dictionary with the number of the edge, in the selected chain V, corresponding to each stroke. + # Make a dictionary with the number of the edge, in the selected chain V, corresponding to each stroke edge_order_number_for_splines = {} if self.selection_V_exists: # For two-connected selections add a first hypothetic stroke at the begining. if selection_type == "TWO_CONNECTED": edge_order_number_for_splines[0] = 0 - for i in range(len(self.main_splines.data.splines)): sp = self.main_splines.data.splines[i] - v_idx, dist_temp = self.shortest_distance(self.main_object, sp.bezier_points[0].co, verts_ordered_V_indices) - - edge_idx_in_chain = verts_ordered_V_indices.index(v_idx) # Get the position (edges count) of the vert v_idx in the selected chain V. - - # For two-connected selections the strokes go after the hypothetic stroke added before, so the index adds one per spline. + v_idx, dist_temp = self.shortest_distance( + self.main_object, + sp.bezier_points[0].co, + verts_ordered_V_indices + ) + # Get the position (edges count) of the vert v_idx in the selected chain V + edge_idx_in_chain = verts_ordered_V_indices.index(v_idx) + + # For two-connected selections the strokes go after the + # hypothetic stroke added before, so the index adds one per spline if selection_type == "TWO_CONNECTED": spline_number = i + 1 else: @@ -2642,34 +2809,36 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): edge_order_number_for_splines[spline_number] = edge_idx_in_chain - - # Get the first and last verts indices for later comparison. + # Get the first and last verts indices for later comparison if i == 0: first_v_idx = v_idx elif i == len(self.main_splines.data.splines) - 1: last_v_idx = v_idx - if self.selection_V_is_closed: - # If there is no last stroke on the last vertex (same as first vertex), add a hypothetic spline at last vert order. + # If there is no last stroke on the last vertex (same as first vertex), + # add a hypothetic spline at last vert order if first_v_idx != last_v_idx: - edge_order_number_for_splines[(len(self.main_splines.data.splines) - 1) + 1] = len(verts_ordered_V_indices) - 1 + edge_order_number_for_splines[(len(self.main_splines.data.splines) - 1) + 1] = \ + len(verts_ordered_V_indices) - 1 else: if self.cyclic_cross: - edge_order_number_for_splines[len(self.main_splines.data.splines) - 1] = len(verts_ordered_V_indices) - 2 - edge_order_number_for_splines[(len(self.main_splines.data.splines) - 1) + 1] = len(verts_ordered_V_indices) - 1 + edge_order_number_for_splines[len(self.main_splines.data.splines) - 1] = \ + len(verts_ordered_V_indices) - 2 + edge_order_number_for_splines[(len(self.main_splines.data.splines) - 1) + 1] = \ + len(verts_ordered_V_indices) - 1 else: - edge_order_number_for_splines[len(self.main_splines.data.splines) - 1] = len(verts_ordered_V_indices) - 1 - + edge_order_number_for_splines[len(self.main_splines.data.splines) - 1] = \ + len(verts_ordered_V_indices) - 1 - - #### Get the coords of the points distributed along the "crossing curves", with appropriate proportions-V. + # Get the coords of the points distributed along the + # "crossing curves", with appropriate proportions-V surface_splines_parsed = [] for i in range(len(splines_U_objects)): sp_ob = splines_U_objects[i] - # If "Loops on strokes" option is active, calculate the proportions for each loop-U. + # If "Loops on strokes" option is active, calculate the proportions for each loop-U if self.loops_on_strokes: - # Segments distances from stroke to stroke. + # Segments distances from stroke to stroke dist = 0 full_dist = 0 segments_distances = [] @@ -2704,11 +2873,15 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if self.selection_V2_exists: segment_edges_length_V2 += edges_lengths_V2[order] - for order in range(order_number_last_stroke, edge_order_number_for_splines[t + 1]): - # Calculate each "sub-segment" (the ones between each stroke) length. + # Calculate each "sub-segment" (the ones between each stroke) length if self.selection_V2_exists: - proportion_sub_seg = (edges_lengths_V2[order] - ((edges_lengths_V2[order] - edges_lengths_V[order]) / len(splines_U_objects) * i)) / (segment_edges_length_V2 - (segment_edges_length_V2 - segment_edges_length_V) / len(splines_U_objects) * i) + proportion_sub_seg = (edges_lengths_V2[order] - + ((edges_lengths_V2[order] - edges_lengths_V[order]) / + len(splines_U_objects) * i)) / (segment_edges_length_V2 - + (segment_edges_length_V2 - segment_edges_length_V) / + len(splines_U_objects) * i) + sub_seg_dist = segments_distances[t] * proportion_sub_seg else: proportion_sub_seg = edges_lengths_V[order] / segment_edges_length_V @@ -2720,7 +2893,7 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): else: for c in range(self.edges_V): - # Calculate each "sub-segment" (the ones between each stroke) length. + # Calculate each "sub-segment" (the ones between each stroke) length sub_seg_dist = segments_distances[t] / self.edges_V used_edges_proportions_V.append(sub_seg_dist / full_dist) @@ -2731,72 +2904,81 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): if self.selection_V2_exists: used_edges_proportions_V = [] for p in range(len(edges_proportions_V)): - used_edges_proportions_V.append(edges_proportions_V2[p] - ((edges_proportions_V2[p] - edges_proportions_V[p]) / len(splines_U_objects) * i)) + used_edges_proportions_V.append( + edges_proportions_V2[p] - + ((edges_proportions_V2[p] - + edges_proportions_V[p]) / len(splines_U_objects) * i) + ) else: used_edges_proportions_V = edges_proportions_V actual_spline = self.distribute_pts(sp_ob.data.splines, used_edges_proportions_V) surface_splines_parsed.append(actual_spline[0]) - - - - # Set the verts of the first and last splines to the locations of the respective verts in the selections. + # Set the verts of the first and last splines to the locations + # of the respective verts in the selections if self.selection_V_exists: for i in range(0, len(surface_splines_parsed[0])): - surface_splines_parsed[len(surface_splines_parsed) - 1][i] = self.main_object.matrix_world * verts_ordered_V[i].co + surface_splines_parsed[len(surface_splines_parsed) - 1][i] = \ + self.main_object.matrix_world * verts_ordered_V[i].co if selection_type == "TWO_NOT_CONNECTED": if self.selection_V2_exists: for i in range(0, len(surface_splines_parsed[0])): surface_splines_parsed[0][i] = self.main_object.matrix_world * verts_ordered_V2[i].co - - - - # When "Automatic join" option is active (and the selection type is not "TWO_CONNECTED"), merge the verts of the tips of the loops when they are "near enough". + # When "Automatic join" option is active (and the selection type is not "TWO_CONNECTED"), + # merge the verts of the tips of the loops when they are "near enough" if self.automatic_join and selection_type != "TWO_CONNECTED": - #### Join the tips of "Follow" loops that are near enough and must be "closed". + # Join the tips of "Follow" loops that are near enough and must be "closed" if not self.selection_V_exists and len(edges_proportions_U) >= 3: for i in range(len(surface_splines_parsed[0])): sp = surface_splines_parsed loop_segment_dist = (sp[0][i] - sp[1][i]).length full_loop_dist = loop_segment_dist * self.edges_U - verts_middle_position_co = [(sp[0][i][0] + sp[len(sp) - 1][i][0]) / 2, (sp[0][i][1] + sp[len(sp) - 1][i][1]) / 2, (sp[0][i][2] + sp[len(sp) - 1][i][2]) / 2] - + verts_middle_position_co = [ + (sp[0][i][0] + sp[len(sp) - 1][i][0]) / 2, + (sp[0][i][1] + sp[len(sp) - 1][i][1]) / 2, + (sp[0][i][2] + sp[len(sp) - 1][i][2]) / 2 + ] points_original = [] points_original.append(sp[1][i]) points_original.append(sp[0][i]) points_target = [] points_target.append(sp[1][i]) - points_target.append(mathutils.Vector(verts_middle_position_co)) + points_target.append(Vector(verts_middle_position_co)) vec_A = points_original[0] - points_original[1] vec_B = points_target[0] - points_target[1] + # check for zero angles, not sure if it is a great fix + if vec_A.length != 0 and vec_B.length != 0: + angle = vec_A.angle(vec_B) / pi + edge_new_length = (Vector(verts_middle_position_co) - sp[1][i]).length + else: + angle = 0 + edge_new_length = 0 + # If after moving the verts to the middle point, the segment doesn't stretch too much + if edge_new_length <= loop_segment_dist * 1.5 * \ + self.join_stretch_factor and angle < 0.25 * self.join_stretch_factor: - angle = vec_A.angle(vec_B) / math.pi - - edge_new_length = (mathutils.Vector(verts_middle_position_co) - sp[1][i]).length + # Avoid joining when the actual loop must be merged with the original mesh + if not (self.selection_U_exists and i == 0) and \ + not (self.selection_U2_exists and i == len(surface_splines_parsed[0]) - 1): - if edge_new_length <= loop_segment_dist * 1.5 * self.join_stretch_factor and angle < 0.25 * self.join_stretch_factor: # If after moving the verts to the middle point, the segment doesn't stretch too much. - if not (self.selection_U_exists and i == 0) and not (self.selection_U2_exists and i == len(surface_splines_parsed[0]) - 1): # Avoid joining when the actual loop must be merged with the original mesh. - # Change the coords of both verts to the middle position. + # Change the coords of both verts to the middle position surface_splines_parsed[0][i] = verts_middle_position_co surface_splines_parsed[len(surface_splines_parsed) - 1][i] = verts_middle_position_co - - - #### Delete object with control points and object from grease pencil convertion. + # Delete object with control points and object from grease pencil convertion bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob_ctrl_pts.name].select = True bpy.context.scene.objects.active = bpy.data.objects[ob_ctrl_pts.name] bpy.ops.object.delete() - for sp_ob in splines_U_objects: bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[sp_ob.name].select = True @@ -2804,27 +2986,24 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.delete() + # Generate surface - - - #### Generate surface. - - # Get all verts coords. + # Get all verts coords all_surface_verts_co = [] for i in range(0, len(surface_splines_parsed)): # Get coords of all verts and make a list with them for pt_co in surface_splines_parsed[i]: all_surface_verts_co.append(pt_co) - - # Define verts for each face. + # Define verts for each face all_surface_faces = [] for i in range(0, len(all_surface_verts_co) - len(surface_splines_parsed[0])): if ((i + 1) / len(surface_splines_parsed[0]) != int((i + 1) / len(surface_splines_parsed[0]))): - all_surface_faces.append([i+1, i , i + len(surface_splines_parsed[0]), i + len(surface_splines_parsed[0]) + 1]) - - - # Build the mesh. + all_surface_faces.append( + [i + 1, i, i + len(surface_splines_parsed[0]), + i + len(surface_splines_parsed[0]) + 1] + ) + # Build the mesh surf_me_name = "SURFSKIO_surface" me_surf = bpy.data.meshes.new(surf_me_name) @@ -2835,13 +3014,12 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): ob_surface = bpy.data.objects.new(surf_me_name, me_surf) bpy.context.scene.objects.link(ob_surface) - - # Select all the "unselected but participating" verts, from closed selection or double selections with middle-vertex, for later join with remove doubles. + # Select all the "unselected but participating" verts, from closed selection + # or double selections with middle-vertex, for later join with remove doubles for v_idx in single_unselected_verts: self.main_object.data.vertices[v_idx].select = True - - #### Join the new mesh to the main object. + # Join the new mesh to the main object ob_surface.select = True self.main_object.select = True bpy.context.scene.objects.active = bpy.data.objects[self.main_object.name] @@ -2854,19 +3032,15 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.mesh.normals_make_consistent('INVOKE_REGION_WIN', inside=False) bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='DESELECT') - - return{'FINISHED'} - - def execute(self, context): -# self.initial_global_undo_state = bpy.context.user_preferences.edit.use_global_undo bpy.context.user_preferences.edit.use_global_undo = False if not self.is_fill_faces: - bpy.ops.wm.context_set_value(data_path='tool_settings.mesh_select_mode', value='True, False, False') + bpy.ops.wm.context_set_value(data_path='tool_settings.mesh_select_mode', + value='True, False, False') # Build splines from the "last saved splines". last_saved_curve = bpy.data.curves.new('SURFSKIO_last_crv', 'CURVE') @@ -2877,11 +3051,11 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): for sp in self.last_strokes_splines_coords: spline = self.main_splines.data.splines.new('BEZIER') - spline.bezier_points.add(len(sp) - 1) # less one because one point is added when the spline is created. + # less one because one point is added when the spline is created + spline.bezier_points.add(len(sp) - 1) for p in range(0, len(sp)): spline.bezier_points[p].co = [sp[p][0], sp[p][1], sp[p][2]] - bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') @@ -2891,15 +3065,15 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='SELECT') - bpy.ops.curve.handle_type_set(type='VECTOR') # Important to make it vector first and then automatic, otherwise the tips handles get too big and distort the shrinkwrap results later. + # Important to make it vector first and then automatic, otherwise the + # tips handles get too big and distort the shrinkwrap results later + bpy.ops.curve.handle_type_set(type='VECTOR') bpy.ops.curve.handle_type_set('INVOKE_REGION_WIN', type='AUTOMATIC') bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - self.main_splines.name = "SURFSKIO_temp_strokes" - if self.is_crosshatch: strokes_for_crosshatch = True strokes_for_rectangular_surface = False @@ -2907,21 +3081,18 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): strokes_for_rectangular_surface = True strokes_for_crosshatch = False - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[self.main_object.name].select = True bpy.context.scene.objects.active = bpy.data.objects[self.main_object.name] bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - if strokes_for_rectangular_surface: self.rectangular_surface() elif strokes_for_crosshatch: self.crosshatch_surface_execute() - - #### Delete main splines + # Delete main splines bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') @@ -2936,36 +3107,30 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - bpy.context.user_preferences.edit.use_global_undo = self.initial_global_undo_state return{'FINISHED'} - - def invoke(self, context, event): self.initial_global_undo_state = bpy.context.user_preferences.edit.use_global_undo self.main_object = bpy.context.scene.objects.active self.main_object_selected_verts_count = int(self.main_object.data.total_vert_sel) - bpy.context.user_preferences.edit.use_global_undo = False + bpy.ops.wm.context_set_value(data_path='tool_settings.mesh_select_mode', + value='True, False, False') - - bpy.ops.wm.context_set_value(data_path='tool_settings.mesh_select_mode', value='True, False, False') - - # Out Edit mode and In again to make sure the actual mesh selections are being taken. + # Out Edit mode and In again to make sure the actual mesh selections are being taken bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - self.cyclic_cross = bpy.context.scene.SURFSK_cyclic_cross - self.cyclic_follow = bpy.context.scene.SURFSK_cyclic_follow - self.automatic_join = bpy.context.scene.SURFSK_automatic_join - self.loops_on_strokes = bpy.context.scene.SURFSK_loops_on_strokes - self.keep_strokes = bpy.context.scene.SURFSK_keep_strokes + bsurfaces_props = bpy.context.scene.bsurfaces + self.cyclic_cross = bsurfaces_props.SURFSK_cyclic_cross + self.cyclic_follow = bsurfaces_props.SURFSK_cyclic_follow + self.automatic_join = bsurfaces_props.SURFSK_automatic_join + self.loops_on_strokes = bsurfaces_props.SURFSK_loops_on_strokes + self.keep_strokes = bsurfaces_props.SURFSK_keep_strokes self.edges_U = 5 @@ -2975,24 +3140,22 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): self.edges_V = 5 self.is_fill_faces = False - self.stopping_errors = False - self.last_strokes_splines_coords = [] - - #### Determine the type of the strokes. + # Determine the type of the strokes self.strokes_type = get_strokes_type(self.main_object) - #### Check if it will be used grease pencil strokes or curves. - if self.strokes_type == "GP_STROKES" or self.strokes_type == "EXTERNAL_CURVE": # If there are strokes to be used. + # Check if it will be used grease pencil strokes or curves + # If there are strokes to be used + if self.strokes_type == "GP_STROKES" or self.strokes_type == "EXTERNAL_CURVE": if self.strokes_type == "GP_STROKES": - # Convert grease pencil strokes to curve. + # Convert grease pencil strokes to curve bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.gpencil.convert('INVOKE_REGION_WIN', type='CURVE', use_link_strokes=False) # XXX gpencil.convert now keep org object as active/selected, *not* newly created curve! # XXX This is far from perfect, but should work in most cases... -# self.original_curve = bpy.context.object + # self.original_curve = bpy.context.object for ob in bpy.context.selected_objects: if ob != bpy.context.scene.objects.active and ob.name.startswith("GP_Layer"): self.original_curve = ob @@ -3005,8 +3168,8 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - #### Make sure there are no objects left from erroneous executions of this operator, with the reserved names used here. + # Make sure there are no objects left from erroneous + # executions of this operator, with the reserved names used here for o in bpy.data.objects: if o.name.find("SURFSKIO_") != -1: bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') @@ -3015,25 +3178,20 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.delete() - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[self.original_curve.name].select = True bpy.context.scene.objects.active = bpy.data.objects[self.original_curve.name] bpy.ops.object.duplicate('INVOKE_REGION_WIN') - self.temporary_curve = bpy.context.scene.objects.active - # Deselect all points of the curve bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - # Delete splines with only a single isolated point. + # Delete splines with only a single isolated point for i in range(len(self.temporary_curve.data.splines)): sp = self.temporary_curve.data.splines[i] @@ -3044,16 +3202,17 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.curve.delete(type='VERT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[self.temporary_curve.name].select = True bpy.context.scene.objects.active = bpy.data.objects[self.temporary_curve.name] - #### Set a minimum number of points for crosshatch + # Set a minimum number of points for crosshatch minimum_points_num = 15 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - # Check if the number of points of each curve has at least the number of points of minimum_points_num, which is a bit more than the face-loops limit. If not, subdivide to reach at least that number of ponts. + # Check if the number of points of each curve has at least the number of points + # of minimum_points_num, which is a bit more than the face-loops limit. + # If not, subdivide to reach at least that number of ponts for i in range(len(self.temporary_curve.data.splines)): sp = self.temporary_curve.data.splines[i] @@ -3062,23 +3221,24 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bp.select_control_point = True if (len(sp.bezier_points) - 1) != 0: - subdivide_cuts = int((minimum_points_num - len(sp.bezier_points)) / (len(sp.bezier_points) - 1)) + 1 # Formula to get the number of cuts that will make a curve of N number of points have near to "minimum_points_num" points, when subdividing with this number of cuts. + # Formula to get the number of cuts that will make a curve + # of N number of points have near to "minimum_points_num" + # points, when subdividing with this number of cuts + subdivide_cuts = int( + (minimum_points_num - len(sp.bezier_points)) / + (len(sp.bezier_points) - 1) + ) + 1 else: subdivide_cuts = 0 - - bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts = subdivide_cuts) + bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=subdivide_cuts) bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - # Detect if the strokes are a crosshatch and do it if it is. + # Detect if the strokes are a crosshatch and do it if it is self.crosshatch_surface_invoke(self.temporary_curve) - - if not self.is_crosshatch: bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[self.temporary_curve.name].select = True @@ -3086,10 +3246,12 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - #### Set a minimum number of points for rectangular surfaces. + # Set a minimum number of points for rectangular surfaces minimum_points_num = 60 - # Check if the number of points of each curve has at least the number of points of minimum_points_num, which is a bit more than the face-loops limit. If not, subdivide to reach at least that number of ponts. + # Check if the number of points of each curve has at least the number of points + # of minimum_points_num, which is a bit more than the face-loops limit. + # If not, subdivide to reach at least that number of ponts for i in range(len(self.temporary_curve.data.splines)): sp = self.temporary_curve.data.splines[i] @@ -3098,43 +3260,51 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bp.select_control_point = True if (len(sp.bezier_points) - 1) != 0: - subdivide_cuts = int((minimum_points_num - len(sp.bezier_points)) / (len(sp.bezier_points) - 1)) + 1 # Formula to get the number of cuts that will make a curve of N number of points have near to "minimum_points_num" points, when subdividing with this number of cuts. + # Formula to get the number of cuts that will make a curve of + # N number of points have near to "minimum_points_num" points, + # when subdividing with this number of cuts + subdivide_cuts = int( + (minimum_points_num - len(sp.bezier_points)) / + (len(sp.bezier_points) - 1) + ) + 1 else: subdivide_cuts = 0 - - bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts = subdivide_cuts) + bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=subdivide_cuts) bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - - # Save coordinates of the actual strokes (as the "last saved splines"). + # Save coordinates of the actual strokes (as the "last saved splines") for sp_idx in range(len(self.temporary_curve.data.splines)): self.last_strokes_splines_coords.append([]) for bp_idx in range(len(self.temporary_curve.data.splines[sp_idx].bezier_points)): - coords = self.temporary_curve.matrix_world * self.temporary_curve.data.splines[sp_idx].bezier_points[bp_idx].co + coords = self.temporary_curve.matrix_world * \ + self.temporary_curve.data.splines[sp_idx].bezier_points[bp_idx].co self.last_strokes_splines_coords[sp_idx].append([coords[0], coords[1], coords[2]]) - - # Check for cyclic splines, put the first and last points in the middle of their actual positions. + # Check for cyclic splines, put the first and last points in the middle of their actual positions for sp_idx in range(len(self.temporary_curve.data.splines)): - if self.temporary_curve.data.splines[sp_idx].use_cyclic_u == True: + if self.temporary_curve.data.splines[sp_idx].use_cyclic_u is True: first_p_co = self.last_strokes_splines_coords[sp_idx][0] - last_p_co = self.last_strokes_splines_coords[sp_idx][len(self.last_strokes_splines_coords[sp_idx]) - 1] - - target_co = [(first_p_co[0] + last_p_co[0]) / 2, (first_p_co[1] + last_p_co[1]) / 2, (first_p_co[2] + last_p_co[2]) / 2] + last_p_co = self.last_strokes_splines_coords[sp_idx][ + len(self.last_strokes_splines_coords[sp_idx]) - 1 + ] + target_co = [ + (first_p_co[0] + last_p_co[0]) / 2, + (first_p_co[1] + last_p_co[1]) / 2, + (first_p_co[2] + last_p_co[2]) / 2 + ] self.last_strokes_splines_coords[sp_idx][0] = target_co - self.last_strokes_splines_coords[sp_idx][len(self.last_strokes_splines_coords[sp_idx]) - 1] = target_co - + self.last_strokes_splines_coords[sp_idx][ + len(self.last_strokes_splines_coords[sp_idx]) - 1 + ] = target_co tuple(self.last_strokes_splines_coords) - - - # Estimation of the average length of the segments between each point of the grease pencil strokes. Will be useful to determine whether a curve should be made "Cyclic". + # Estimation of the average length of the segments between + # each point of the grease pencil strokes. + # Will be useful to determine whether a curve should be made "Cyclic" segments_lengths_sum = 0 segments_count = 0 random_spline = self.temporary_curve.data.splines[0].bezier_points @@ -3145,27 +3315,24 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): self.average_gp_segment_length = segments_lengths_sum / segments_count - - #### Delete temporary strokes curve object + # Delete temporary strokes curve object bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[self.temporary_curve.name].select = True bpy.context.scene.objects.active = bpy.data.objects[self.temporary_curve.name] bpy.ops.object.delete() - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[self.main_object.name].select = True bpy.context.scene.objects.active = bpy.data.objects[self.main_object.name] bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - self.execute(context) - bpy.context.user_preferences.edit.use_global_undo = False # Set again since "execute()" will turn it again to its initial value. - + # Set again since "execute()" will turn it again to its initial value + bpy.context.user_preferences.edit.use_global_undo = False - #### If "Keep strokes" option is not active, delete original strokes curve object. + # If "Keep strokes" option is not active, delete original strokes curve object if (not self.stopping_errors and not self.keep_strokes) or self.is_crosshatch: bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') @@ -3180,16 +3347,12 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - #### Delete grease pencil strokes. + # Delete grease pencil strokes if self.strokes_type == "GP_STROKES" and not self.stopping_errors: bpy.ops.gpencil.active_frame_delete('INVOKE_REGION_WIN') - bpy.context.user_preferences.edit.use_global_undo = self.initial_global_undo_state - if not self.stopping_errors: return {"FINISHED"} else: @@ -3197,11 +3360,9 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): elif self.strokes_type == "SELECTION_ALONE": self.is_fill_faces = True - created_faces_count = self.fill_with_faces(self.main_object) bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - bpy.context.user_preferences.edit.use_global_undo = self.initial_global_undo_state if created_faces_count == 0: @@ -3210,7 +3371,6 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): else: return {"FINISHED"} - bpy.context.user_preferences.edit.use_global_undo = self.initial_global_undo_state if self.strokes_type == "EXTERNAL_NO_CURVE": @@ -3221,7 +3381,9 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): self.report({'WARNING'}, "There shouldn't be more than one secondary object selected.") return{"CANCELLED"} - elif self.strokes_type == "SINGLE_GP_STROKE_NO_SELECTION" or self.strokes_type == "SINGLE_CURVE_STROKE_NO_SELECTION": + elif self.strokes_type == "SINGLE_GP_STROKE_NO_SELECTION" or \ + self.strokes_type == "SINGLE_CURVE_STROKE_NO_SELECTION": + self.report({'WARNING'}, "It's needed at least one stroke and one selection, or two strokes.") return{"CANCELLED"} @@ -3237,17 +3399,16 @@ class GPENCIL_OT_SURFSK_add_surface(bpy.types.Operator): return{"CANCELLED"} -# Edit strokes operator. -class GPENCIL_OT_SURFSK_edit_strokes(bpy.types.Operator): +# Edit strokes operator +class GPENCIL_OT_SURFSK_edit_strokes(Operator): bl_idname = "gpencil.surfsk_edit_strokes" bl_label = "Bsurfaces edit strokes" bl_description = "Edit the grease pencil strokes or curves used" - def execute(self, context): - #### Determine the type of the strokes. + # Determine the type of the strokes self.strokes_type = get_strokes_type(self.main_object) - #### Check if strokes are grease pencil strokes or a curves object. + # Check if strokes are grease pencil strokes or a curves object selected_objs = bpy.context.selected_objects if self.strokes_type == "EXTERNAL_CURVE" or self.strokes_type == "SINGLE_CURVE_STROKE_NO_SELECTION": for ob in selected_objs: @@ -3262,24 +3423,23 @@ class GPENCIL_OT_SURFSK_edit_strokes(bpy.types.Operator): bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') elif self.strokes_type == "GP_STROKES" or self.strokes_type == "SINGLE_GP_STROKE_NO_SELECTION": - #### Convert grease pencil strokes to curve. + # Convert grease pencil strokes to curve bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.gpencil.convert('INVOKE_REGION_WIN', type='CURVE', use_link_strokes=False) for ob in bpy.context.selected_objects: if ob != bpy.context.scene.objects.active and ob.name.startswith("GP_Layer"): ob_gp_strokes = ob - #ob_gp_strokes = bpy.context.object + # ob_gp_strokes = bpy.context.object - #### Delete grease pencil strokes. + # Delete grease pencil strokes bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[self.main_object.name].select = True bpy.context.scene.objects.active = bpy.data.objects[self.main_object.name] bpy.ops.gpencil.active_frame_delete('INVOKE_REGION_WIN') - - #### Clean up curves. + # Clean up curves bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[ob_gp_strokes.name].select = True bpy.context.scene.objects.active = bpy.data.objects[ob_gp_strokes.name] @@ -3294,26 +3454,26 @@ class GPENCIL_OT_SURFSK_edit_strokes(bpy.types.Operator): elif self.strokes_type == "EXTERNAL_NO_CURVE": self.report({'WARNING'}, "The secondary object is not a Curve.") return{"CANCELLED"} + elif self.strokes_type == "MORE_THAN_ONE_EXTERNAL": self.report({'WARNING'}, "There shouldn't be more than one secondary object selected.") return{"CANCELLED"} + elif self.strokes_type == "NO_STROKES" or self.strokes_type == "SELECTION_ALONE": self.report({'WARNING'}, "There aren't any strokes attatched to the object") return{"CANCELLED"} + else: return{"CANCELLED"} - - - def invoke (self, context, event): + def invoke(self, context, event): self.main_object = bpy.context.object - self.execute(context) return {"FINISHED"} -class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): +class CURVE_OT_SURFSK_reorder_splines(Operator): bl_idname = "curve.surfsk_reorder_splines" bl_label = "Bsurfaces reorder splines" bl_description = "Defines the order of the splines by using grease pencil strokes" @@ -3321,24 +3481,23 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): def execute(self, context): objects_to_delete = [] - #### Convert grease pencil strokes to curve. + # Convert grease pencil strokes to curve. bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.gpencil.convert('INVOKE_REGION_WIN', type='CURVE', use_link_strokes=False) for ob in bpy.context.selected_objects: if ob != bpy.context.scene.objects.active and ob.name.startswith("GP_Layer"): GP_strokes_curve = ob - #GP_strokes_curve = bpy.context.object + # GP_strokes_curve = bpy.context.object objects_to_delete.append(GP_strokes_curve) bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[GP_strokes_curve.name].select = True bpy.context.scene.objects.active = bpy.data.objects[GP_strokes_curve.name] - bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='SELECT') - bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts = 100) + bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=100) bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.object.duplicate('INVOKE_REGION_WIN') @@ -3348,7 +3507,6 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): GP_strokes_mesh.data.resolution_u = 1 bpy.ops.object.convert(target='MESH', keep_original=False) - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[self.main_curve.name].select = True bpy.context.scene.objects.active = bpy.data.objects[self.main_curve.name] @@ -3357,13 +3515,13 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): curves_duplicate_1 = bpy.context.object objects_to_delete.append(curves_duplicate_1) - - minimum_points_num = 500 - - for x in range(round(minimum_points_num / 100)): # Some iterations since the subdivision operator has a limit of 100 subdivisions per iteration. - #### Check if the number of points of each curve has at least the number of points of minimum_points_num. If not, subdivide to reach at least that number of ponts. + # Some iterations since the subdivision operator + # has a limit of 100 subdivisions per iteration + for x in range(round(minimum_points_num / 100)): + # Check if the number of points of each curve has at least the number of points + # of minimum_points_num. If not, subdivide to reach at least that number of ponts for i in range(len(curves_duplicate_1.data.splines)): sp = curves_duplicate_1.data.splines[i] @@ -3372,22 +3530,26 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): bp.select_control_point = True if (len(sp.bezier_points) - 1) != 0: - subdivide_cuts = int((minimum_points_num - len(sp.bezier_points)) / (len(sp.bezier_points) - 1)) + 1 # Formula to get the number of cuts that will make a curve of N number of points have near to "minimum_points_num" points, when subdividing with this number of cuts. + # Formula to get the number of cuts that will make a curve of N + # number of points have near to "minimum_points_num" points, + # when subdividing with this number of cuts + subdivide_cuts = int( + (minimum_points_num - len(sp.bezier_points)) / + (len(sp.bezier_points) - 1) + ) + 1 else: subdivide_cuts = 0 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts = subdivide_cuts) + bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=subdivide_cuts) bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - bpy.ops.object.duplicate('INVOKE_REGION_WIN') curves_duplicate_2 = bpy.context.object objects_to_delete.append(curves_duplicate_2) - - #### Duplicate the duplicate and add Shrinkwrap to it, with the grease pencil strokes curve as target. + # Duplicate the duplicate and add Shrinkwrap to it, with the grease pencil strokes curve as target bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[curves_duplicate_2.name].select = True bpy.context.scene.objects.active = bpy.data.objects[curves_duplicate_2.name] @@ -3397,57 +3559,67 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): curves_duplicate_2.modifiers["Shrinkwrap"].target = GP_strokes_mesh bpy.ops.object.modifier_apply('INVOKE_REGION_WIN', apply_as='DATA', modifier='Shrinkwrap') - - #### Get the distance of each vert from its original position to its position with Shrinkwrap. + # Get the distance of each vert from its original position to its position with Shrinkwrap nearest_points_coords = {} for st_idx in range(len(curves_duplicate_1.data.splines)): for bp_idx in range(len(curves_duplicate_1.data.splines[st_idx].bezier_points)): - bp_1_co = curves_duplicate_1.matrix_world * curves_duplicate_1.data.splines[st_idx].bezier_points[bp_idx].co - bp_2_co = curves_duplicate_2.matrix_world * curves_duplicate_2.data.splines[st_idx].bezier_points[bp_idx].co + bp_1_co = curves_duplicate_1.matrix_world * \ + curves_duplicate_1.data.splines[st_idx].bezier_points[bp_idx].co + + bp_2_co = curves_duplicate_2.matrix_world * \ + curves_duplicate_2.data.splines[st_idx].bezier_points[bp_idx].co if bp_idx == 0: shortest_dist = (bp_1_co - bp_2_co).length - nearest_points_coords[st_idx] = ("%.4f" % bp_2_co[0], "%.4f" % bp_2_co[1], "%.4f" % bp_2_co[2]) + nearest_points_coords[st_idx] = ("%.4f" % bp_2_co[0], + "%.4f" % bp_2_co[1], + "%.4f" % bp_2_co[2]) dist = (bp_1_co - bp_2_co).length if dist < shortest_dist: - nearest_points_coords[st_idx] = ("%.4f" % bp_2_co[0], "%.4f" % bp_2_co[1], "%.4f" % bp_2_co[2]) + nearest_points_coords[st_idx] = ("%.4f" % bp_2_co[0], + "%.4f" % bp_2_co[1], + "%.4f" % bp_2_co[2]) shortest_dist = dist - - - #### Get all coords of GP strokes points, for comparison. + # Get all coords of GP strokes points, for comparison GP_strokes_coords = [] for st_idx in range(len(GP_strokes_curve.data.splines)): - GP_strokes_coords.append([("%.4f" % x if "%.4f" % x != "-0.00" else "0.00", "%.4f" % y if "%.4f" % y != "-0.00" else "0.00", "%.4f" % z if "%.4f" % z != "-0.00" else "0.00") for x, y, z in [bp.co for bp in GP_strokes_curve.data.splines[st_idx].bezier_points]]) - - - #### Check the point of the GP strokes with the same coords as the nearest points of the curves (with shrinkwrap). - GP_connection_points = {} # Dictionary with GP stroke index as index, and a list as value. The list has as index the point index of the GP stroke nearest to the spline, and as value the spline index. + GP_strokes_coords.append( + [("%.4f" % x if "%.4f" % x != "-0.00" else "0.00", + "%.4f" % y if "%.4f" % y != "-0.00" else "0.00", + "%.4f" % z if "%.4f" % z != "-0.00" else "0.00") for + x, y, z in [bp.co for bp in GP_strokes_curve.data.splines[st_idx].bezier_points]] + ) + + # Check the point of the GP strokes with the same coords as + # the nearest points of the curves (with shrinkwrap) + + # Dictionary with GP stroke index as index, and a list as value. + # The list has as index the point index of the GP stroke + # nearest to the spline, and as value the spline index + GP_connection_points = {} for gp_st_idx in range(len(GP_strokes_coords)): GPvert_spline_relationship = {} for splines_st_idx in range(len(nearest_points_coords)): if nearest_points_coords[splines_st_idx] in GP_strokes_coords[gp_st_idx]: - GPvert_spline_relationship[GP_strokes_coords[gp_st_idx].index(nearest_points_coords[splines_st_idx])] = splines_st_idx - + GPvert_spline_relationship[ + GP_strokes_coords[gp_st_idx].index(nearest_points_coords[splines_st_idx]) + ] = splines_st_idx GP_connection_points[gp_st_idx] = GPvert_spline_relationship - - #### Get the splines new order. + # Get the splines new order splines_new_order = [] for i in GP_connection_points: - dict_keys = sorted(GP_connection_points[i].keys()) # Sort dictionaries by key + dict_keys = sorted(GP_connection_points[i].keys()) # Sort dictionaries by key for k in dict_keys: splines_new_order.append(GP_connection_points[i][k]) - - - #### Reorder. - + # Reorder curve_original_name = self.main_curve.name bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') @@ -3460,7 +3632,6 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - for sp_idx in range(len(self.main_curve.data.splines)): self.main_curve.data.splines[0].bezier_points[0].select_control_point = True @@ -3468,9 +3639,7 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): bpy.ops.curve.separate('EXEC_REGION_WIN') bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - - #### Get the names of the separated splines objects in the original order. + # Get the names of the separated splines objects in the original order splines_unordered = {} for o in bpy.data.objects: if o.name.find("SURFSKIO_CRV_ORD") != -1: @@ -3480,9 +3649,7 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): spline_order_index = int(spline_order_string) - 1 splines_unordered[spline_order_index] = o.name - - - #### Join all splines objects in final order. + # Join all splines objects in final order for order_idx in splines_new_order: bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[splines_unordered[order_idx]].select = True @@ -3491,12 +3658,10 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): bpy.ops.object.join('INVOKE_REGION_WIN') - - #### Go back to the original name of the curves object. + # Go back to the original name of the curves object. bpy.context.object.name = curve_original_name - - #### Delete all unused objects. + # Delete all unused objects for o in objects_to_delete: bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[o.name].select = True @@ -3504,7 +3669,6 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): bpy.ops.object.delete() - bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT') bpy.data.objects[curve_original_name].select = True bpy.context.scene.objects.active = bpy.data.objects[curve_original_name] @@ -3512,22 +3676,16 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') - bpy.ops.gpencil.active_frame_delete('INVOKE_REGION_WIN') - - return {"FINISHED"} - - - def invoke (self, context, event): + def invoke(self, context, event): self.main_curve = bpy.context.object - - there_are_GP_strokes = False + try: - #### Get the active grease pencil layer. + # Get the active grease pencil layer strokes_num = len(self.main_curve.grease_pencil.layers.active.active_frame.strokes) if strokes_num > 0: @@ -3535,41 +3693,35 @@ class CURVE_OT_SURFSK_reorder_splines(bpy.types.Operator): except: pass - if there_are_GP_strokes: self.execute(context) - self.report({'INFO'}, "Splines have been reordered.") + self.report({'INFO'}, "Splines have been reordered") else: - self.report({'WARNING'}, "Draw grease pencil strokes to connect splines.") + self.report({'WARNING'}, "Draw grease pencil strokes to connect splines") return {"FINISHED"} - - -class CURVE_OT_SURFSK_first_points(bpy.types.Operator): +class CURVE_OT_SURFSK_first_points(Operator): bl_idname = "curve.surfsk_first_points" bl_label = "Bsurfaces set first points" bl_description = "Set the selected points as the first point of each spline" bl_options = {'REGISTER', 'UNDO'} - - def execute(self, context): splines_to_invert = [] - #### Check non-cyclic splines to invert. + # Check non-cyclic splines to invert for i in range(len(self.main_curve.data.splines)): b_points = self.main_curve.data.splines[i].bezier_points - if not i in self.cyclic_splines: # Only for non-cyclic splines + if i not in self.cyclic_splines: # Only for non-cyclic splines if b_points[len(b_points) - 1].select_control_point: splines_to_invert.append(i) + # Reorder points of cyclic splines, and set all handles to "Automatic" - #### Reorder points of cyclic splines, and set all handles to "Automatic". - - # Check first selected point. + # Check first selected point cyclic_splines_new_first_pt = {} for i in self.cyclic_splines: sp = self.main_curve.data.splines[i] @@ -3578,9 +3730,9 @@ class CURVE_OT_SURFSK_first_points(bpy.types.Operator): bp = sp.bezier_points[t] if bp.select_control_point or bp.select_right_handle or bp.select_left_handle: cyclic_splines_new_first_pt[i] = t - break # To take only one if there are more. + break # To take only one if there are more - # Reorder. + # Reorder for spline_idx in cyclic_splines_new_first_pt: sp = self.main_curve.data.splines[spline_idx] @@ -3590,14 +3742,24 @@ class CURVE_OT_SURFSK_first_points(bpy.types.Operator): left_handle_type = str(bp_old.handle_left_type) left_handle_length = float(bp_old.handle_left.length) - left_handle_xyz = (float(bp_old.handle_left.x), float(bp_old.handle_left.y), float(bp_old.handle_left.z)) - + left_handle_xyz = ( + float(bp_old.handle_left.x), + float(bp_old.handle_left.y), + float(bp_old.handle_left.z) + ) right_handle_type = str(bp_old.handle_right_type) right_handle_length = float(bp_old.handle_right.length) - right_handle_xyz = (float(bp_old.handle_right.x), float(bp_old.handle_right.y), float(bp_old.handle_right.z)) - - spline_old_coords.append([coords, left_handle_type, right_handle_type, left_handle_length, right_handle_length, left_handle_xyz, right_handle_xyz]) - + right_handle_xyz = ( + float(bp_old.handle_right.x), + float(bp_old.handle_right.y), + float(bp_old.handle_right.z) + ) + spline_old_coords.append( + [coords, left_handle_type, + right_handle_type, left_handle_length, + right_handle_length, left_handle_xyz, + right_handle_xyz] + ) for t in range(len(sp.bezier_points)): bp = sp.bezier_points @@ -3607,7 +3769,7 @@ class CURVE_OT_SURFSK_first_points(bpy.types.Operator): else: new_index = t + cyclic_splines_new_first_pt[spline_idx] + 1 - len(bp) - bp[t].co = mathutils.Vector(spline_old_coords[new_index][0]) + bp[t].co = Vector(spline_old_coords[new_index][0]) bp[t].handle_left.length = spline_old_coords[new_index][3] bp[t].handle_right.length = spline_old_coords[new_index][4] @@ -3626,9 +3788,7 @@ class CURVE_OT_SURFSK_first_points(bpy.types.Operator): bp[t].handle_left_type = spline_old_coords[new_index][1] bp[t].handle_right_type = spline_old_coords[new_index][2] - - - #### Invert the non-cyclic splines designated above. + # Invert the non-cyclic splines designated above for i in range(len(splines_to_invert)): bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') @@ -3640,143 +3800,153 @@ class CURVE_OT_SURFSK_first_points(bpy.types.Operator): bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT') - - #### Keep selected the first vert of each spline. + # Keep selected the first vert of each spline bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') for i in range(len(self.main_curve.data.splines)): if not self.main_curve.data.splines[i].use_cyclic_u: bp = self.main_curve.data.splines[i].bezier_points[0] else: - bp = self.main_curve.data.splines[i].bezier_points[len(self.main_curve.data.splines[i].bezier_points) - 1] + bp = self.main_curve.data.splines[i].bezier_points[ + len(self.main_curve.data.splines[i].bezier_points) - 1 + ] bp.select_control_point = True bp.select_right_handle = True bp.select_left_handle = True - bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') - - + bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN') return {'FINISHED'} - - - def invoke (self, context, event): + def invoke(self, context, event): self.main_curve = bpy.context.object - # Check if all curves are Bezier, and detect which ones are cyclic. + # Check if all curves are Bezier, and detect which ones are cyclic self.cyclic_splines = [] for i in range(len(self.main_curve.data.splines)): if self.main_curve.data.splines[i].type != "BEZIER": - self.report({'WARNING'}, 'All splines must be Bezier type.') + self.report({'WARNING'}, "All splines must be Bezier type") return {'CANCELLED'} else: if self.main_curve.data.splines[i].use_cyclic_u: self.cyclic_splines.append(i) - - self.execute(context) - self.report({'INFO'}, "First points have been set.") + self.report({'INFO'}, "First points have been set") return {'FINISHED'} -## Addons Preferences Update Panel + +# Add-ons Preferences Update Panel + +# Define Panel classes for updating +panels = ( + VIEW3D_PT_tools_SURFSK_mesh, + VIEW3D_PT_tools_SURFSK_curve, + ) + + def update_panel(self, context): + message = "Bsurfaces GPL Edition: Updating Panel locations has failed" try: - bpy.utils.unregister_class(VIEW3D_PT_tools_SURFSK_mesh) - bpy.utils.unregister_class(VIEW3D_PT_tools_SURFSK_curve) - except: + for panel in panels: + if "bl_rna" in panel.__dict__: + bpy.utils.unregister_class(panel) + + for panel in panels: + panel.bl_category = context.user_preferences.addons[__name__].preferences.category + bpy.utils.register_class(panel) + + except Exception as e: + print("\n[{}]\n{}\n\nError:\n{}".format(__name__, message, e)) pass - VIEW3D_PT_tools_SURFSK_mesh.bl_category = context.user_preferences.addons[__name__].preferences.category - bpy.utils.register_class(VIEW3D_PT_tools_SURFSK_mesh) - VIEW3D_PT_tools_SURFSK_curve.bl_category = context.user_preferences.addons[__name__].preferences.category - bpy.utils.register_class(VIEW3D_PT_tools_SURFSK_curve) -class BsurfPreferences(bpy.types.AddonPreferences): + +class BsurfPreferences(AddonPreferences): # this must match the addon name, use '__package__' # when defining this in a submodule of a python package. bl_idname = __name__ - category = bpy.props.StringProperty( + category = StringProperty( name="Tab Category", description="Choose a name for the category of the panel", default="Tools", - update=update_panel) + update=update_panel + ) def draw(self, context): - layout = self.layout + row = layout.row() col = row.column() col.label(text="Tab Category:") col.prop(self, "category", text="") -def register(): - bpy.utils.register_class(VIEW3D_PT_tools_SURFSK_mesh) - bpy.utils.register_class(VIEW3D_PT_tools_SURFSK_curve) - bpy.utils.register_class(GPENCIL_OT_SURFSK_add_surface) - bpy.utils.register_class(GPENCIL_OT_SURFSK_edit_strokes) - bpy.utils.register_class(CURVE_OT_SURFSK_reorder_splines) - bpy.utils.register_class(CURVE_OT_SURFSK_first_points) - bpy.utils.register_class(BsurfPreferences) - update_panel(None, bpy.context) - - bpy.types.Scene.SURFSK_cyclic_cross = bpy.props.BoolProperty( - name="Cyclic Cross", - description="Make cyclic the face-loops crossing the strokes", - default=False) - - bpy.types.Scene.SURFSK_cyclic_follow = bpy.props.BoolProperty( - name="Cyclic Follow", - description="Make cyclic the face-loops following the strokes", - default=False) +# Properties +class BsurfacesProps(PropertyGroup): + SURFSK_cyclic_cross = BoolProperty( + name="Cyclic Cross", + description="Make cyclic the face-loops crossing the strokes", + default=False + ) + SURFSK_cyclic_follow = BoolProperty( + name="Cyclic Follow", + description="Make cyclic the face-loops following the strokes", + default=False + ) + SURFSK_keep_strokes = BoolProperty( + name="Keep strokes", + description="Keeps the sketched strokes or curves after adding the surface", + default=False + ) + SURFSK_automatic_join = BoolProperty( + name="Automatic join", + description="Join automatically vertices of either surfaces " + "generated by crosshatching, or from the borders of closed shapes", + default=True + ) + SURFSK_loops_on_strokes = BoolProperty( + name="Loops on strokes", + description="Make the loops match the paths of the strokes", + default=True + ) + SURFSK_precision = IntProperty( + name="Precision", + description="Precision level of the surface calculation", + default=2, + min=1, + max=100 + ) + + +classes = ( + VIEW3D_PT_tools_SURFSK_mesh, + VIEW3D_PT_tools_SURFSK_curve, + GPENCIL_OT_SURFSK_add_surface, + GPENCIL_OT_SURFSK_edit_strokes, + CURVE_OT_SURFSK_reorder_splines, + CURVE_OT_SURFSK_first_points, + BsurfPreferences, + BsurfacesProps, + ) - bpy.types.Scene.SURFSK_keep_strokes = bpy.props.BoolProperty( - name="Keep strokes", - description="Keeps the sketched strokes or curves after adding the surface", - default=False) - bpy.types.Scene.SURFSK_automatic_join = bpy.props.BoolProperty( - name="Automatic join", - description="Join automatically vertices of either surfaces generated by crosshatching, or from the borders of closed shapes", - default=True) - - bpy.types.Scene.SURFSK_loops_on_strokes = bpy.props.BoolProperty( - name="Loops on strokes", - description="Make the loops match the paths of the strokes", - default=True) +def register(): + for cls in classes: + bpy.utils.register_class(cls) - bpy.types.Scene.SURFSK_precision = bpy.props.IntProperty( - name="Precision", - description="Precision level of the surface calculation", - default=2, - min=1, - max=100) + bpy.types.Scene.bsurfaces = PointerProperty(type=BsurfacesProps) + update_panel(None, bpy.context) def unregister(): - bpy.utils.unregister_class(VIEW3D_PT_tools_SURFSK_mesh) - bpy.utils.unregister_class(VIEW3D_PT_tools_SURFSK_curve) - bpy.utils.unregister_class(GPENCIL_OT_SURFSK_add_surface) - bpy.utils.unregister_class(GPENCIL_OT_SURFSK_edit_strokes) - bpy.utils.unregister_class(CURVE_OT_SURFSK_reorder_splines) - bpy.utils.unregister_class(CURVE_OT_SURFSK_first_points) - bpy.utils.unregister_class(BsurfPreferences) - - del bpy.types.Scene.SURFSK_precision - del bpy.types.Scene.SURFSK_keep_strokes - del bpy.types.Scene.SURFSK_automatic_join - del bpy.types.Scene.SURFSK_cyclic_cross - del bpy.types.Scene.SURFSK_cyclic_follow - del bpy.types.Scene.SURFSK_loops_on_strokes + for cls in classes: + bpy.utils.unregister_class(cls) + del bpy.types.Scene.bsurfaces if __name__ == "__main__": register() - - - |