?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
glTF exporter: Reset pose bone between each action
[blender-addons.git] / mesh_bsurfaces.py
blobc980ed047d0060865e912b557e25708d774818ff
1 # SPDX-License-Identifier: GPL-2.0-or-later
2
3
4 bl_info = {
5 "name": "Bsurfaces GPL Edition",
6 "author": "Eclectiel, Vladimir Spivak (cwolf3d)",
7 "version": (1, 8, 1),
8 "blender": (2, 80, 0),
9 "location": "View3D EditMode > Sidebar > Edit Tab",
10 "description": "Modeling and retopology tool",
11 "doc_url": "{BLENDER_MANUAL_URL}/addons/mesh/bsurfaces.html",
12 "category": "Mesh",
13 }
14
15
16 import bpy
17 import bmesh
18 from bpy_extras import object_utils
19
20 import operator
21 from mathutils import Matrix, Vector
22 from mathutils.geometry import (
23 intersect_line_line,
24 intersect_point_line,
25 )
26 from math import (
27 degrees,
28 pi,
29 sqrt,
30 )
31 from bpy.props import (
32 BoolProperty,
33 FloatProperty,
34 IntProperty,
35 StringProperty,
36 PointerProperty,
37 EnumProperty,
38 FloatVectorProperty,
39 )
40 from bpy.types import (
41 Operator,
42 Panel,
43 PropertyGroup,
44 AddonPreferences,
45 )
46
47 # ----------------------------
48 # GLOBAL
49 global_shade_smooth = False
50 global_mesh_object = ""
51 global_gpencil_object = ""
52 global_curve_object = ""
53
54 # ----------------------------
55 # Panels
56 class VIEW3D_PT_tools_SURFSK_mesh(Panel):
57 bl_space_type = 'VIEW_3D'
58 bl_region_type = 'UI'
59 bl_category = 'Edit'
60 bl_label = "Bsurfaces"
61
62 def draw(self, context):
63 layout = self.layout
64 bs = context.scene.bsurfaces
65
66 col = layout.column(align=True)
67 row = layout.row()
68 row.separator()
69 col.operator("mesh.surfsk_init", text="Initialize (Add BSurface mesh)")
70 col.operator("mesh.surfsk_add_modifiers", text="Add Mirror and others modifiers")
71
72 col.label(text="Mesh of BSurface:")
73 col.prop(bs, "SURFSK_mesh", text="")
74 if bs.SURFSK_mesh != None:
75 try: mesh_object = bs.SURFSK_mesh
76 except: pass
77 try: col.prop(mesh_object.data.materials[0], "diffuse_color")
78 except: pass
79 try: col.prop(mesh_object.modifiers['Shrinkwrap'], "offset")
80 except: pass
81 try: col.prop(mesh_object, "show_in_front")
82 except: pass
83 try: col.prop(bs, "SURFSK_shade_smooth")
84 except: pass
85 try: col.prop(mesh_object, "show_wire")
86 except: pass
87
88 col.label(text="Guide strokes:")
89 col.row().prop(bs, "SURFSK_guide", expand=True)
90 if bs.SURFSK_guide == 'GPencil':
91 col.prop(bs, "SURFSK_gpencil", text="")
92 col.separator()
93 if bs.SURFSK_guide == 'Curve':
94 col.prop(bs, "SURFSK_curve", text="")
95 col.separator()
96
97 col.separator()
98 col.operator("mesh.surfsk_add_surface", text="Add Surface")
99 col.operator("mesh.surfsk_edit_surface", text="Edit Surface")
100
101 col.separator()
102 if bs.SURFSK_guide == 'GPencil':
103 col.operator("gpencil.surfsk_add_strokes", text="Add Strokes")
104 col.operator("gpencil.surfsk_edit_strokes", text="Edit Strokes")
105 col.separator()
106 col.operator("gpencil.surfsk_strokes_to_curves", text="Strokes to curves")
107
108 if bs.SURFSK_guide == 'Annotation':
109 col.operator("gpencil.surfsk_add_annotation", text="Add Annotation")
110 col.separator()
111 col.operator("gpencil.surfsk_annotations_to_curves", text="Annotation to curves")
112
113 if bs.SURFSK_guide == 'Curve':
114 col.operator("curve.surfsk_edit_curve", text="Edit curve")
115
116 col.separator()
117 col.label(text="Initial settings:")
118 col.prop(bs, "SURFSK_edges_U")
119 col.prop(bs, "SURFSK_edges_V")
120 col.prop(bs, "SURFSK_cyclic_cross")
121 col.prop(bs, "SURFSK_cyclic_follow")
122 col.prop(bs, "SURFSK_loops_on_strokes")
123 col.prop(bs, "SURFSK_automatic_join")
124 col.prop(bs, "SURFSK_keep_strokes")
125
126 class VIEW3D_PT_tools_SURFSK_curve(Panel):
127 bl_space_type = 'VIEW_3D'
128 bl_region_type = 'UI'
129 bl_context = "curve_edit"
130 bl_category = 'Edit'
131 bl_label = "Bsurfaces"
132
133 @classmethod
134 def poll(cls, context):
135 return context.active_object
136
137 def draw(self, context):
138 layout = self.layout
139
140 col = layout.column(align=True)
141 row = layout.row()
142 row.separator()
143 col.operator("curve.surfsk_first_points", text="Set First Points")
144 col.operator("curve.switch_direction", text="Switch Direction")
145 col.operator("curve.surfsk_reorder_splines", text="Reorder Splines")
146
147
148 # ----------------------------
149 # Returns the type of strokes used
150 def get_strokes_type(context):
151 strokes_type = "NO_STROKES"
152 strokes_num = 0
153
154 # Check if they are annotation
155 if context.scene.bsurfaces.SURFSK_guide == 'Annotation':
156 try:
157 strokes = bpy.context.annotation_data.layers.active.active_frame.strokes
158
159 strokes_num = len(strokes)
160
161 if strokes_num > 0:
162 strokes_type = "GP_ANNOTATION"
163 except:
164 strokes_type = "NO_STROKES"
165
166 # Check if they are grease pencil
167 if context.scene.bsurfaces.SURFSK_guide == 'GPencil':
168 try:
169 global global_gpencil_object
170 gpencil = bpy.data.objects[global_gpencil_object]
171 strokes = gpencil.data.layers.active.active_frame.strokes
172
173 strokes_num = len(strokes)
174
175 if strokes_num > 0:
176 strokes_type = "GP_STROKES"
177 except:
178 strokes_type = "NO_STROKES"
179
180 # Check if they are curves, if there aren't grease pencil strokes
181 if context.scene.bsurfaces.SURFSK_guide == 'Curve':
182 try:
183 global global_curve_object
184 ob = bpy.data.objects[global_curve_object]
185 if ob.type == "CURVE":
186 strokes_type = "EXTERNAL_CURVE"
187 strokes_num = len(ob.data.splines)
188
189 # Check if there is any non-bezier spline
190 for i in range(len(ob.data.splines)):
191 if ob.data.splines[i].type != "BEZIER":
192 strokes_type = "CURVE_WITH_NON_BEZIER_SPLINES"
193 break
194
195 else:
196 strokes_type = "EXTERNAL_NO_CURVE"
197 except:
198 strokes_type = "NO_STROKES"
199
200 # Check if they are mesh
201 try:
202 global global_mesh_object
203 self.main_object = bpy.data.objects[global_mesh_object]
204 total_vert_sel = len([v for v in self.main_object.data.vertices if v.select])
205
206 # Check if there is a single stroke without any selection in the object
207 if strokes_num == 1 and total_vert_sel == 0:
208 if strokes_type == "EXTERNAL_CURVE":
209 strokes_type = "SINGLE_CURVE_STROKE_NO_SELECTION"
210 elif strokes_type == "GP_STROKES":
211 strokes_type = "SINGLE_GP_STROKE_NO_SELECTION"
212
213 if strokes_num == 0 and total_vert_sel > 0:
214 strokes_type = "SELECTION_ALONE"
215 except:
216 pass
217
218 return strokes_type
219
220 # ----------------------------
221 # Surface generator operator
222 class MESH_OT_SURFSK_add_surface(Operator):
223 bl_idname = "mesh.surfsk_add_surface"
224 bl_label = "Bsurfaces add surface"
225 bl_description = "Generates surfaces from grease pencil strokes, bezier curves or loose edges"
226 bl_options = {'REGISTER', 'UNDO'}
227
228 is_crosshatch: BoolProperty(
229 default=False
230 )
231 is_fill_faces: BoolProperty(
232 default=False
233 )
234 selection_U_exists: BoolProperty(
235 default=False
236 )
237 selection_V_exists: BoolProperty(
238 default=False
239 )
240 selection_U2_exists: BoolProperty(
241 default=False
242 )
243 selection_V2_exists: BoolProperty(
244 default=False
245 )
246 selection_V_is_closed: BoolProperty(
247 default=False
248 )
249 selection_U_is_closed: BoolProperty(
250 default=False
251 )
252 selection_V2_is_closed: BoolProperty(
253 default=False
254 )
255 selection_U2_is_closed: BoolProperty(
256 default=False
257 )
258
259 edges_U: IntProperty(
260 name="Cross",
261 description="Number of face-loops crossing the strokes",
262 default=1,
263 min=1,
264 max=200
265 )
266 edges_V: IntProperty(
267 name="Follow",
268 description="Number of face-loops following the strokes",
269 default=1,
270 min=1,
271 max=200
272 )
273 cyclic_cross: BoolProperty(
274 name="Cyclic Cross",
275 description="Make cyclic the face-loops crossing the strokes",
276 default=False
277 )
278 cyclic_follow: BoolProperty(
279 name="Cyclic Follow",
280 description="Make cyclic the face-loops following the strokes",
281 default=False
282 )
283 loops_on_strokes: BoolProperty(
284 name="Loops on strokes",
285 description="Make the loops match the paths of the strokes",
286 default=False
287 )
288 automatic_join: BoolProperty(
289 name="Automatic join",
290 description="Join automatically vertices of either surfaces generated "
291 "by crosshatching, or from the borders of closed shapes",
292 default=False
293 )
294 join_stretch_factor: FloatProperty(
295 name="Stretch",
296 description="Amount of stretching or shrinking allowed for "
297 "edges when joining vertices automatically",
298 default=1,
299 min=0,
300 max=3,
301 subtype='FACTOR'
302 )
303 keep_strokes: BoolProperty(
304 name="Keep strokes",
305 description="Keeps the sketched strokes or curves after adding the surface",
306 default=False
307 )
308 strokes_type: StringProperty()
309 initial_global_undo_state: BoolProperty()
310
311
312 def draw(self, context):
313 layout = self.layout
314 col = layout.column(align=True)
315 row = layout.row()
316
317 if not self.is_fill_faces:
318 row.separator()
319 if not self.is_crosshatch:
320 if not self.selection_U_exists:
321 col.prop(self, "edges_U")
322 row.separator()
323
324 if not self.selection_V_exists:
325 col.prop(self, "edges_V")
326 row.separator()
327
328 row.separator()
329
330 if not self.selection_U_exists:
331 if not (
332 (self.selection_V_exists and not self.selection_V_is_closed) or
333 (self.selection_V2_exists and not self.selection_V2_is_closed)
334 ):
335 col.prop(self, "cyclic_cross")
336
337 if not self.selection_V_exists:
338 if not (
339 (self.selection_U_exists and not self.selection_U_is_closed) or
340 (self.selection_U2_exists and not self.selection_U2_is_closed)
341 ):
342 col.prop(self, "cyclic_follow")
343
344 col.prop(self, "loops_on_strokes")
345
346 col.prop(self, "automatic_join")
347
348 if self.automatic_join:
349 row.separator()
350 col.separator()
351 row.separator()
352 col.prop(self, "join_stretch_factor")
353
354 col.prop(self, "keep_strokes")
355
356 # Get an ordered list of a chain of vertices
357 def get_ordered_verts(self, ob, all_selected_edges_idx, all_selected_verts_idx,
358 first_vert_idx, middle_vertex_idx, closing_vert_idx):
359 # Order selected vertices.
360 verts_ordered = []
361 if closing_vert_idx is not None:
362 verts_ordered.append(ob.data.vertices[closing_vert_idx])
363
364 verts_ordered.append(ob.data.vertices[first_vert_idx])
365 prev_v = first_vert_idx
366 prev_ed = None
367 finish_while = False
368 while True:
369 edges_non_matched = 0
370 for i in all_selected_edges_idx:
371 if ob.data.edges[i] != prev_ed and ob.data.edges[i].vertices[0] == prev_v and \
372 ob.data.edges[i].vertices[1] in all_selected_verts_idx:
373
374 verts_ordered.append(ob.data.vertices[ob.data.edges[i].vertices[1]])
375 prev_v = ob.data.edges[i].vertices[1]
376 prev_ed = ob.data.edges[i]
377 elif ob.data.edges[i] != prev_ed and ob.data.edges[i].vertices[1] == prev_v and \
378 ob.data.edges[i].vertices[0] in all_selected_verts_idx:
379
380 verts_ordered.append(ob.data.vertices[ob.data.edges[i].vertices[0]])
381 prev_v = ob.data.edges[i].vertices[0]
382 prev_ed = ob.data.edges[i]
383 else:
384 edges_non_matched += 1
385
386 if edges_non_matched == len(all_selected_edges_idx):
387 finish_while = True
388
389 if finish_while:
390 break
391
392 if closing_vert_idx is not None:
393 verts_ordered.append(ob.data.vertices[closing_vert_idx])
394
395 if middle_vertex_idx is not None:
396 verts_ordered.append(ob.data.vertices[middle_vertex_idx])
397 verts_ordered.reverse()
398
399 return tuple(verts_ordered)
400
401 # Calculates length of a chain of points.
402 def get_chain_length(self, object, verts_ordered):
403 matrix = object.matrix_world
404
405 edges_lengths = []
406 edges_lengths_sum = 0
407 for i in range(0, len(verts_ordered)):
408 if i == 0:
409 prev_v_co = matrix @ verts_ordered[i].co
410 else:
411 v_co = matrix @ verts_ordered[i].co
412
413 v_difs = [prev_v_co[0] - v_co[0], prev_v_co[1] - v_co[1], prev_v_co[2] - v_co[2]]
414 edge_length = abs(sqrt(v_difs[0] * v_difs[0] + v_difs[1] * v_difs[1] + v_difs[2] * v_difs[2]))
415
416 edges_lengths.append(edge_length)
417 edges_lengths_sum += edge_length
418
419 prev_v_co = v_co
420
421 return edges_lengths, edges_lengths_sum
422
423 # Calculates the proportion of the edges of a chain of edges, relative to the full chain length.
424 def get_edges_proportions(self, edges_lengths, edges_lengths_sum, use_boundaries, fixed_edges_num):
425 edges_proportions = []
426 if use_boundaries:
427 verts_count = 1
428 for l in edges_lengths:
429 edges_proportions.append(l / edges_lengths_sum)
430 verts_count += 1
431 else:
432 verts_count = 1
433 for _n in range(0, fixed_edges_num):
434 edges_proportions.append(1 / fixed_edges_num)
435 verts_count += 1
436
437 return edges_proportions
438
439 # Calculates the angle between two pairs of points in space
440 def orientation_difference(self, points_A_co, points_B_co):
441 # each parameter should be a list with two elements,
442 # and each element should be a x,y,z coordinate
443 vec_A = points_A_co[0] - points_A_co[1]
444 vec_B = points_B_co[0] - points_B_co[1]
445
446 angle = vec_A.angle(vec_B)
447
448 if angle > 0.5 * pi:
449 angle = abs(angle - pi)
450
451 return angle
452
453 # Calculate the which vert of verts_idx list is the nearest one
454 # to the point_co coordinates, and the distance
455 def shortest_distance(self, object, point_co, verts_idx):
456 matrix = object.matrix_world
457
458 for i in range(0, len(verts_idx)):
459 dist = (point_co - matrix @ object.data.vertices[verts_idx[i]].co).length
460 if i == 0:
461 prev_dist = dist
462 nearest_vert_idx = verts_idx[i]
463 shortest_dist = dist
464
465 if dist < prev_dist:
466 prev_dist = dist
467 nearest_vert_idx = verts_idx[i]
468 shortest_dist = dist
469
470 return nearest_vert_idx, shortest_dist
471
472 # Returns the index of the opposite vert tip in a chain, given a vert tip index
473 # as parameter, and a multidimentional list with all pairs of tips
474 def opposite_tip(self, vert_tip_idx, all_chains_tips_idx):
475 opposite_vert_tip_idx = None
476 for i in range(0, len(all_chains_tips_idx)):
477 if vert_tip_idx == all_chains_tips_idx[i][0]:
478 opposite_vert_tip_idx = all_chains_tips_idx[i][1]
479 if vert_tip_idx == all_chains_tips_idx[i][1]:
480 opposite_vert_tip_idx = all_chains_tips_idx[i][0]
481
482 return opposite_vert_tip_idx
483
484 # Simplifies a spline and returns the new points coordinates
485 def simplify_spline(self, spline_coords, segments_num):
486 simplified_spline = []
487 points_between_segments = round(len(spline_coords) / segments_num)
488
489 simplified_spline.append(spline_coords[0])
490 for i in range(1, segments_num):
491 simplified_spline.append(spline_coords[i * points_between_segments])
492
493 simplified_spline.append(spline_coords[len(spline_coords) - 1])
494
495 return simplified_spline
496
497 # Returns a list with the coords of the points distributed over the splines
498 # passed to this method according to the proportions parameter
499 def distribute_pts(self, surface_splines, proportions):
500
501 # Calculate the length of each final surface spline
502 surface_splines_lengths = []
503 surface_splines_parsed = []
504
505 for sp_idx in range(0, len(surface_splines)):
506 # Calculate spline length
507 surface_splines_lengths.append(0)
508
509 for i in range(0, len(surface_splines[sp_idx].bezier_points)):
510 if i == 0:
511 prev_p = surface_splines[sp_idx].bezier_points[i]
512 else:
513 p = surface_splines[sp_idx].bezier_points[i]
514 edge_length = (prev_p.co - p.co).length
515 surface_splines_lengths[sp_idx] += edge_length
516
517 prev_p = p
518
519 # Calculate vertex positions with appropriate edge proportions, and ordered, for each spline
520 for sp_idx in range(0, len(surface_splines)):
521 surface_splines_parsed.append([])
522 surface_splines_parsed[sp_idx].append(surface_splines[sp_idx].bezier_points[0].co)
523
524 prev_p_co = surface_splines[sp_idx].bezier_points[0].co
525 p_idx = 0
526
527 for prop_idx in range(len(proportions) - 1):
528 target_length = surface_splines_lengths[sp_idx] * proportions[prop_idx]
529 partial_segment_length = 0
530 finish_while = False
531
532 while True:
533 # if not it'll pass the p_idx as an index below and crash
534 if p_idx < len(surface_splines[sp_idx].bezier_points):
535 p_co = surface_splines[sp_idx].bezier_points[p_idx].co
536 new_dist = (prev_p_co - p_co).length
537
538 # The new distance that could have the partial segment if
539 # it is still shorter than the target length
540 potential_segment_length = partial_segment_length + new_dist
541
542 # If the potential is still shorter, keep adding
543 if potential_segment_length < target_length:
544 partial_segment_length = potential_segment_length
545
546 p_idx += 1
547 prev_p_co = p_co
548
549 # If the potential is longer than the target, calculate the target
550 # (a point between the last two points), and assign
551 elif potential_segment_length > target_length:
552 remaining_dist = target_length - partial_segment_length
553 vec = p_co - prev_p_co
554 vec.normalize()
555 intermediate_co = prev_p_co + (vec * remaining_dist)
556
557 surface_splines_parsed[sp_idx].append(intermediate_co)
558
559 partial_segment_length += remaining_dist
560 prev_p_co = intermediate_co
561
562 finish_while = True
563
564 # If the potential is equal to the target, assign
565 elif potential_segment_length == target_length:
566 surface_splines_parsed[sp_idx].append(p_co)
567 prev_p_co = p_co
568
569 finish_while = True
570
571 if finish_while:
572 break
573
574 # last point of the spline
575 surface_splines_parsed[sp_idx].append(
576 surface_splines[sp_idx].bezier_points[len(surface_splines[sp_idx].bezier_points) - 1].co
577 )
578
579 return surface_splines_parsed
580
581 # Counts the number of faces that belong to each edge
582 def edge_face_count(self, ob):
583 ed_keys_count_dict = {}
584
585 for face in ob.data.polygons:
586 for ed_keys in face.edge_keys:
587 if ed_keys not in ed_keys_count_dict:
588 ed_keys_count_dict[ed_keys] = 1
589 else:
590 ed_keys_count_dict[ed_keys] += 1
591
592 edge_face_count = []
593 for i in range(len(ob.data.edges)):
594 edge_face_count.append(0)
595
596 for i in range(len(ob.data.edges)):
597 ed = ob.data.edges[i]
598
599 v1 = ed.vertices[0]
600 v2 = ed.vertices[1]
601
602 if (v1, v2) in ed_keys_count_dict:
603 edge_face_count[i] = ed_keys_count_dict[(v1, v2)]
604 elif (v2, v1) in ed_keys_count_dict:
605 edge_face_count[i] = ed_keys_count_dict[(v2, v1)]
606
607 return edge_face_count
608
609 # Fills with faces all the selected vertices which form empty triangles or quads
610 def fill_with_faces(self, object):
611 all_selected_verts_count = self.main_object_selected_verts_count
612
613 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
614
615 # Calculate average length of selected edges
616 all_selected_verts = []
617 original_sel_edges_count = 0
618 for ed in object.data.edges:
619 if object.data.vertices[ed.vertices[0]].select and object.data.vertices[ed.vertices[1]].select:
620 coords = []
621 coords.append(object.data.vertices[ed.vertices[0]].co)
622 coords.append(object.data.vertices[ed.vertices[1]].co)
623
624 original_sel_edges_count += 1
625
626 if not ed.vertices[0] in all_selected_verts:
627 all_selected_verts.append(ed.vertices[0])
628
629 if not ed.vertices[1] in all_selected_verts:
630 all_selected_verts.append(ed.vertices[1])
631
632 tuple(all_selected_verts)
633
634 # Check if there is any edge selected. If not, interrupt the script
635 if original_sel_edges_count == 0 and all_selected_verts_count > 0:
636 return 0
637
638 # Get all edges connected to selected verts
639 all_edges_around_sel_verts = []
640 edges_connected_to_sel_verts = {}
641 verts_connected_to_every_vert = {}
642 for ed_idx in range(len(object.data.edges)):
643 ed = object.data.edges[ed_idx]
644 include_edge = False
645
646 if ed.vertices[0] in all_selected_verts:
647 if not ed.vertices[0] in edges_connected_to_sel_verts:
648 edges_connected_to_sel_verts[ed.vertices[0]] = []
649
650 edges_connected_to_sel_verts[ed.vertices[0]].append(ed_idx)
651 include_edge = True
652
653 if ed.vertices[1] in all_selected_verts:
654 if not ed.vertices[1] in edges_connected_to_sel_verts:
655 edges_connected_to_sel_verts[ed.vertices[1]] = []
656
657 edges_connected_to_sel_verts[ed.vertices[1]].append(ed_idx)
658 include_edge = True
659
660 if include_edge is True:
661 all_edges_around_sel_verts.append(ed_idx)
662
663 # Get all connected verts to each vert
664 if not ed.vertices[0] in verts_connected_to_every_vert:
665 verts_connected_to_every_vert[ed.vertices[0]] = []
666
667 if not ed.vertices[1] in verts_connected_to_every_vert:
668 verts_connected_to_every_vert[ed.vertices[1]] = []
669
670 verts_connected_to_every_vert[ed.vertices[0]].append(ed.vertices[1])
671 verts_connected_to_every_vert[ed.vertices[1]].append(ed.vertices[0])
672
673 # Get all verts connected to faces
674 all_verts_part_of_faces = []
675 all_edges_faces_count = []
676 all_edges_faces_count += self.edge_face_count(object)
677
678 # Get only the selected edges that have faces attached.
679 count_faces_of_edges_around_sel_verts = {}
680 selected_verts_with_faces = []
681 for ed_idx in all_edges_around_sel_verts:
682 count_faces_of_edges_around_sel_verts[ed_idx] = all_edges_faces_count[ed_idx]
683
684 if all_edges_faces_count[ed_idx] > 0:
685 ed = object.data.edges[ed_idx]
686
687 if not ed.vertices[0] in selected_verts_with_faces:
688 selected_verts_with_faces.append(ed.vertices[0])
689
690 if not ed.vertices[1] in selected_verts_with_faces:
691 selected_verts_with_faces.append(ed.vertices[1])
692
693 all_verts_part_of_faces.append(ed.vertices[0])
694 all_verts_part_of_faces.append(ed.vertices[1])
695
696 tuple(selected_verts_with_faces)
697
698 # Discard unneeded verts from calculations
699 participating_verts = []
700 movable_verts = []
701 for v_idx in all_selected_verts:
702 vert_has_edges_with_one_face = False
703
704 # Check if the actual vert has at least one edge connected to only one face
705 for ed_idx in edges_connected_to_sel_verts[v_idx]:
706 if count_faces_of_edges_around_sel_verts[ed_idx] == 1:
707 vert_has_edges_with_one_face = True
708
709 # If the vert has two or less edges connected and the vert is not part of any face.
710 # Or the vert is part of any face and at least one of
711 # the connected edges has only one face attached to it.
712 if (len(edges_connected_to_sel_verts[v_idx]) == 2 and
713 v_idx not in all_verts_part_of_faces) or \
714 len(edges_connected_to_sel_verts[v_idx]) == 1 or \
715 (v_idx in all_verts_part_of_faces and
716 vert_has_edges_with_one_face):
717
718 participating_verts.append(v_idx)
719
720 if v_idx not in all_verts_part_of_faces:
721 movable_verts.append(v_idx)
722
723 # Remove from movable verts list those that are part of closed geometry (ie: triangles, quads)
724 for mv_idx in movable_verts:
725 freeze_vert = False
726 mv_connected_verts = verts_connected_to_every_vert[mv_idx]
727
728 for actual_v_idx in all_selected_verts:
729 count_shared_neighbors = 0
730 checked_verts = []
731
732 for mv_conn_v_idx in mv_connected_verts:
733 if mv_idx != actual_v_idx:
734 if mv_conn_v_idx in verts_connected_to_every_vert[actual_v_idx] and \
735 mv_conn_v_idx not in checked_verts:
736 count_shared_neighbors += 1
737 checked_verts.append(mv_conn_v_idx)
738
739 if actual_v_idx in mv_connected_verts:
740 freeze_vert = True
741 break
742
743 if count_shared_neighbors == 2:
744 freeze_vert = True
745 break
746
747 if freeze_vert:
748 break
749
750 if freeze_vert:
751 movable_verts.remove(mv_idx)
752
753 # Calculate merge distance for participating verts
754 shortest_edge_length = None
755 for ed in object.data.edges:
756 if ed.vertices[0] in movable_verts and ed.vertices[1] in movable_verts:
757 v1 = object.data.vertices[ed.vertices[0]]
758 v2 = object.data.vertices[ed.vertices[1]]
759
760 length = (v1.co - v2.co).length
761
762 if shortest_edge_length is None:
763 shortest_edge_length = length
764 else:
765 if length < shortest_edge_length:
766 shortest_edge_length = length
767
768 if shortest_edge_length is not None:
769 edges_merge_distance = shortest_edge_length * 0.5
770 else:
771 edges_merge_distance = 0
772
773 # Get together the verts near enough. They will be merged later
774 remaining_verts = []
775 remaining_verts += participating_verts
776 for v1_idx in participating_verts:
777 if v1_idx in remaining_verts and v1_idx in movable_verts:
778 verts_to_merge = []
779 coords_verts_to_merge = {}
780
781 verts_to_merge.append(v1_idx)
782
783 v1_co = object.data.vertices[v1_idx].co
784 coords_verts_to_merge[v1_idx] = (v1_co[0], v1_co[1], v1_co[2])
785
786 for v2_idx in remaining_verts:
787 if v1_idx != v2_idx:
788 v2_co = object.data.vertices[v2_idx].co
789
790 dist = (v1_co - v2_co).length
791
792 if dist <= edges_merge_distance: # Add the verts which are near enough
793 verts_to_merge.append(v2_idx)
794
795 coords_verts_to_merge[v2_idx] = (v2_co[0], v2_co[1], v2_co[2])
796
797 for vm_idx in verts_to_merge:
798 remaining_verts.remove(vm_idx)
799
800 if len(verts_to_merge) > 1:
801 # Calculate middle point of the verts to merge.
802 sum_x_co = 0
803 sum_y_co = 0
804 sum_z_co = 0
805 movable_verts_to_merge_count = 0
806 for i in range(len(verts_to_merge)):
807 if verts_to_merge[i] in movable_verts:
808 v_co = object.data.vertices[verts_to_merge[i]].co
809
810 sum_x_co += v_co[0]
811 sum_y_co += v_co[1]
812 sum_z_co += v_co[2]
813
814 movable_verts_to_merge_count += 1
815
816 middle_point_co = [
817 sum_x_co / movable_verts_to_merge_count,
818 sum_y_co / movable_verts_to_merge_count,
819 sum_z_co / movable_verts_to_merge_count
820 ]
821
822 # Check if any vert to be merged is not movable
823 shortest_dist = None
824 are_verts_not_movable = False
825 verts_not_movable = []
826 for v_merge_idx in verts_to_merge:
827 if v_merge_idx in participating_verts and v_merge_idx not in movable_verts:
828 are_verts_not_movable = True
829 verts_not_movable.append(v_merge_idx)
830
831 if are_verts_not_movable:
832 # Get the vert connected to faces, that is nearest to
833 # the middle point of the movable verts
834 shortest_dist = None
835 for vcf_idx in verts_not_movable:
836 dist = abs((object.data.vertices[vcf_idx].co -
837 Vector(middle_point_co)).length)
838
839 if shortest_dist is None:
840 shortest_dist = dist
841 nearest_vert_idx = vcf_idx
842 else:
843 if dist < shortest_dist:
844 shortest_dist = dist
845 nearest_vert_idx = vcf_idx
846
847 coords = object.data.vertices[nearest_vert_idx].co
848 target_point_co = [coords[0], coords[1], coords[2]]
849 else:
850 target_point_co = middle_point_co
851
852 # Move verts to merge to the middle position
853 for v_merge_idx in verts_to_merge:
854 if v_merge_idx in movable_verts: # Only move the verts that are not part of faces
855 object.data.vertices[v_merge_idx].co[0] = target_point_co[0]
856 object.data.vertices[v_merge_idx].co[1] = target_point_co[1]
857 object.data.vertices[v_merge_idx].co[2] = target_point_co[2]
858
859 # Perform "Remove Doubles" to weld all the disconnected verts
860 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT')
861 bpy.ops.mesh.remove_doubles(threshold=0.0001)
862
863 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
864
865 # Get all the definitive selected edges, after weldding
866 selected_edges = []
867 edges_per_vert = {} # Number of faces of each selected edge
868 for ed in object.data.edges:
869 if object.data.vertices[ed.vertices[0]].select and object.data.vertices[ed.vertices[1]].select:
870 selected_edges.append(ed.index)
871
872 # Save all the edges that belong to each vertex.
873 if not ed.vertices[0] in edges_per_vert:
874 edges_per_vert[ed.vertices[0]] = []
875
876 if not ed.vertices[1] in edges_per_vert:
877 edges_per_vert[ed.vertices[1]] = []
878
879 edges_per_vert[ed.vertices[0]].append(ed.index)
880 edges_per_vert[ed.vertices[1]].append(ed.index)
881
882 # Check if all the edges connected to each vert have two faces attached to them.
883 # To discard them later and make calculations faster
884 a = []
885 a += self.edge_face_count(object)
886 tuple(a)
887 verts_surrounded_by_faces = {}
888 for v_idx in edges_per_vert:
889 edges_with_two_faces_count = 0
890
891 for ed_idx in edges_per_vert[v_idx]:
892 if a[ed_idx] == 2:
893 edges_with_two_faces_count += 1
894
895 if edges_with_two_faces_count == len(edges_per_vert[v_idx]):
896 verts_surrounded_by_faces[v_idx] = True
897 else:
898 verts_surrounded_by_faces[v_idx] = False
899
900 # Get all the selected vertices
901 selected_verts_idx = []
902 for v in object.data.vertices:
903 if v.select:
904 selected_verts_idx.append(v.index)
905
906 # Get all the faces of the object
907 all_object_faces_verts_idx = []
908 for face in object.data.polygons:
909 face_verts = []
910 face_verts.append(face.vertices[0])
911 face_verts.append(face.vertices[1])
912 face_verts.append(face.vertices[2])
913
914 if len(face.vertices) == 4:
915 face_verts.append(face.vertices[3])
916
917 all_object_faces_verts_idx.append(face_verts)
918
919 # Deselect all vertices
920 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT')
921 bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='DESELECT')
922 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
923
924 # Make a dictionary with the verts related to each vert
925 related_key_verts = {}
926 for ed_idx in selected_edges:
927 ed = object.data.edges[ed_idx]
928
929 if not verts_surrounded_by_faces[ed.vertices[0]]:
930 if not ed.vertices[0] in related_key_verts:
931 related_key_verts[ed.vertices[0]] = []
932
933 if not ed.vertices[1] in related_key_verts[ed.vertices[0]]:
934 related_key_verts[ed.vertices[0]].append(ed.vertices[1])
935
936 if not verts_surrounded_by_faces[ed.vertices[1]]:
937 if not ed.vertices[1] in related_key_verts:
938 related_key_verts[ed.vertices[1]] = []
939
940 if not ed.vertices[0] in related_key_verts[ed.vertices[1]]:
941 related_key_verts[ed.vertices[1]].append(ed.vertices[0])
942
943 # Get groups of verts forming each face
944 faces_verts_idx = []
945 for v1 in related_key_verts: # verts-1 ....
946 for v2 in related_key_verts: # verts-2
947 if v1 != v2:
948 related_verts_in_common = []
949 v2_in_rel_v1 = False
950 v1_in_rel_v2 = False
951 for rel_v1 in related_key_verts[v1]:
952 # Check if related verts of verts-1 are related verts of verts-2
953 if rel_v1 in related_key_verts[v2]:
954 related_verts_in_common.append(rel_v1)
955
956 if v2 in related_key_verts[v1]:
957 v2_in_rel_v1 = True
958
959 if v1 in related_key_verts[v2]:
960 v1_in_rel_v2 = True
961
962 repeated_face = False
963 # If two verts have two related verts in common, they form a quad
964 if len(related_verts_in_common) == 2:
965 # Check if the face is already saved
966 all_faces_to_check_idx = faces_verts_idx + all_object_faces_verts_idx
967
968 for f_verts in all_faces_to_check_idx:
969 repeated_verts = 0
970
971 if len(f_verts) == 4:
972 if v1 in f_verts:
973 repeated_verts += 1
974 if v2 in f_verts:
975 repeated_verts += 1
976 if related_verts_in_common[0] in f_verts:
977 repeated_verts += 1
978 if related_verts_in_common[1] in f_verts:
979 repeated_verts += 1
980
981 if repeated_verts == len(f_verts):
982 repeated_face = True
983 break
984
985 if not repeated_face:
986 faces_verts_idx.append(
987 [v1, related_verts_in_common[0], v2, related_verts_in_common[1]]
988 )
989
990 # If Two verts have one related vert in common and
991 # they are related to each other, they form a triangle
992 elif v2_in_rel_v1 and v1_in_rel_v2 and len(related_verts_in_common) == 1:
993 # Check if the face is already saved.
994 all_faces_to_check_idx = faces_verts_idx + all_object_faces_verts_idx
995
996 for f_verts in all_faces_to_check_idx:
997 repeated_verts = 0
998
999 if len(f_verts) == 3:
1000 if v1 in f_verts:
1001 repeated_verts += 1
1002 if v2 in f_verts:
1003 repeated_verts += 1
1004 if related_verts_in_common[0] in f_verts:
1005 repeated_verts += 1
1006
1007 if repeated_verts == len(f_verts):
1008 repeated_face = True
1009 break
1010
1011 if not repeated_face:
1012 faces_verts_idx.append([v1, related_verts_in_common[0], v2])
1013
1014 # Keep only the faces that don't overlap by ignoring quads
1015 # that overlap with two adjacent triangles
1016 faces_to_not_include_idx = [] # Indices of faces_verts_idx to eliminate
1017 all_faces_to_check_idx = faces_verts_idx + all_object_faces_verts_idx
1018 for i in range(len(faces_verts_idx)):
1019 for t in range(len(all_faces_to_check_idx)):
1020 if i != t:
1021 verts_in_common = 0
1022
1023 if len(faces_verts_idx[i]) == 4 and len(all_faces_to_check_idx[t]) == 3:
1024 for v_idx in all_faces_to_check_idx[t]:
1025 if v_idx in faces_verts_idx[i]:
1026 verts_in_common += 1
1027 # If it doesn't have all it's vertices repeated in the other face
1028 if verts_in_common == 3:
1029 if i not in faces_to_not_include_idx:
1030 faces_to_not_include_idx.append(i)
1031
1032 # Build faces discarding the ones in faces_to_not_include
1033 me = object.data
1034 bm = bmesh.new()
1035 bm.from_mesh(me)
1036
1037 num_faces_created = 0
1038 for i in range(len(faces_verts_idx)):
1039 if i not in faces_to_not_include_idx:
1040 bm.faces.new([bm.verts[v] for v in faces_verts_idx[i]])
1041
1042 num_faces_created += 1
1043
1044 bm.to_mesh(me)
1045 bm.free()
1046
1047 for v_idx in selected_verts_idx:
1048 self.main_object.data.vertices[v_idx].select = True
1049
1050 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT')
1051 bpy.ops.mesh.normals_make_consistent(inside=False)
1052 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
1053
1054 self.update()
1055
1056 return num_faces_created
1057
1058 # Crosshatch skinning
1059 def crosshatch_surface_invoke(self, ob_original_splines):
1060 self.is_crosshatch = False
1061 self.crosshatch_merge_distance = 0
1062
1063 objects_to_delete = [] # duplicated strokes to be deleted.
1064
1065 # If the main object uses modifiers deactivate them temporarily until the surface is joined
1066 # (without this the surface verts merging with the main object doesn't work well)
1067 self.modifiers_prev_viewport_state = []
1068 if len(self.main_object.modifiers) > 0:
1069 for m_idx in range(len(self.main_object.modifiers)):
1070 self.modifiers_prev_viewport_state.append(
1071 self.main_object.modifiers[m_idx].show_viewport
1072 )
1073 self.main_object.modifiers[m_idx].show_viewport = False
1074
1075 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
1076 ob_original_splines.select_set(True)
1077 bpy.context.view_layer.objects.active = ob_original_splines
1078
1079 if len(ob_original_splines.data.splines) >= 2:
1080 bpy.ops.object.duplicate('INVOKE_REGION_WIN')
1081 ob_splines = bpy.context.object
1082 ob_splines.name = "SURFSKIO_NE_STR"
1083
1084 # Get estimative merge distance (sum up the distances from the first point to
1085 # all other points, then average them and then divide them)
1086 first_point_dist_sum = 0
1087 first_dist = 0
1088 second_dist = 0
1089 coords_first_pt = ob_splines.data.splines[0].bezier_points[0].co
1090 for i in range(len(ob_splines.data.splines)):
1091 sp = ob_splines.data.splines[i]
1092
1093 if coords_first_pt != sp.bezier_points[0].co:
1094 first_dist = (coords_first_pt - sp.bezier_points[0].co).length
1095
1096 if coords_first_pt != sp.bezier_points[len(sp.bezier_points) - 1].co:
1097 second_dist = (coords_first_pt - sp.bezier_points[len(sp.bezier_points) - 1].co).length
1098
1099 first_point_dist_sum += first_dist + second_dist
1100
1101 if i == 0:
1102 if first_dist != 0:
1103 shortest_dist = first_dist
1104 elif second_dist != 0:
1105 shortest_dist = second_dist
1106
1107 if shortest_dist > first_dist and first_dist != 0:
1108 shortest_dist = first_dist
1109
1110 if shortest_dist > second_dist and second_dist != 0:
1111 shortest_dist = second_dist
1112
1113 self.crosshatch_merge_distance = shortest_dist / 20
1114
1115 # Recalculation of merge distance
1116
1117 bpy.ops.object.duplicate('INVOKE_REGION_WIN')
1118
1119 ob_calc_merge_dist = bpy.context.object
1120 ob_calc_merge_dist.name = "SURFSKIO_CALC_TMP"
1121
1122 objects_to_delete.append(ob_calc_merge_dist)
1123
1124 # Smooth out strokes a little to improve crosshatch detection
1125 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1126 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='SELECT')
1127
1128 for i in range(4):
1129 bpy.ops.curve.smooth('INVOKE_REGION_WIN')
1130
1131 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
1132 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1133
1134 # Convert curves into mesh
1135 ob_calc_merge_dist.data.resolution_u = 12
1136 bpy.ops.object.convert(target='MESH', keep_original=False)
1137
1138 # Find "intersection-nodes"
1139 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1140 bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='SELECT')
1141 bpy.ops.mesh.remove_doubles('INVOKE_REGION_WIN',
1142 threshold=self.crosshatch_merge_distance)
1143 bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='DESELECT')
1144 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1145
1146 # Remove verts with less than three edges
1147 verts_edges_count = {}
1148 for ed in ob_calc_merge_dist.data.edges:
1149 v = ed.vertices
1150
1151 if v[0] not in verts_edges_count:
1152 verts_edges_count[v[0]] = 0
1153
1154 if v[1] not in verts_edges_count:
1155 verts_edges_count[v[1]] = 0
1156
1157 verts_edges_count[v[0]] += 1
1158 verts_edges_count[v[1]] += 1
1159
1160 nodes_verts_coords = []
1161 for v_idx in verts_edges_count:
1162 v = ob_calc_merge_dist.data.vertices[v_idx]
1163
1164 if verts_edges_count[v_idx] < 3:
1165 v.select = True
1166
1167 # Remove them
1168 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1169 bpy.ops.mesh.delete('INVOKE_REGION_WIN', type='VERT')
1170 bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='SELECT')
1171
1172 # Remove doubles to discard very near verts from calculations of distance
1173 bpy.ops.mesh.remove_doubles(
1174 'INVOKE_REGION_WIN',
1175 threshold=self.crosshatch_merge_distance * 4.0
1176 )
1177 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1178
1179 # Get all coords of the resulting nodes
1180 nodes_verts_coords = [(v.co[0], v.co[1], v.co[2]) for
1181 v in ob_calc_merge_dist.data.vertices]
1182
1183 # Check if the strokes are a crosshatch
1184 if len(nodes_verts_coords) >= 3:
1185 self.is_crosshatch = True
1186
1187 shortest_dist = None
1188 for co_1 in nodes_verts_coords:
1189 for co_2 in nodes_verts_coords:
1190 if co_1 != co_2:
1191 dist = (Vector(co_1) - Vector(co_2)).length
1192
1193 if shortest_dist is not None:
1194 if dist < shortest_dist:
1195 shortest_dist = dist
1196 else:
1197 shortest_dist = dist
1198
1199 self.crosshatch_merge_distance = shortest_dist / 3
1200
1201 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
1202 ob_splines.select_set(True)
1203 bpy.context.view_layer.objects.active = ob_splines
1204
1205 # Deselect all points
1206 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1207 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
1208 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1209
1210 # Smooth splines in a localized way, to eliminate "saw-teeth"
1211 # like shapes when there are many points
1212 for sp in ob_splines.data.splines:
1213 angle_sum = 0
1214
1215 angle_limit = 2 # Degrees
1216 for t in range(len(sp.bezier_points)):
1217 # Because on each iteration it checks the "next two points"
1218 # of the actual. This way it doesn't go out of range
1219 if t <= len(sp.bezier_points) - 3:
1220 p1 = sp.bezier_points[t]
1221 p2 = sp.bezier_points[t + 1]
1222 p3 = sp.bezier_points[t + 2]
1223
1224 vec_1 = p1.co - p2.co
1225 vec_2 = p2.co - p3.co
1226
1227 if p2.co != p1.co and p2.co != p3.co:
1228 angle = vec_1.angle(vec_2)
1229 angle_sum += degrees(angle)
1230
1231 if angle_sum >= angle_limit: # If sum of angles is grater than the limit
1232 if (p1.co - p2.co).length <= self.crosshatch_merge_distance:
1233 p1.select_control_point = True
1234 p1.select_left_handle = True
1235 p1.select_right_handle = True
1236
1237 p2.select_control_point = True
1238 p2.select_left_handle = True
1239 p2.select_right_handle = True
1240
1241 if (p1.co - p2.co).length <= self.crosshatch_merge_distance:
1242 p3.select_control_point = True
1243 p3.select_left_handle = True
1244 p3.select_right_handle = True
1245
1246 angle_sum = 0
1247
1248 sp.bezier_points[0].select_control_point = False
1249 sp.bezier_points[0].select_left_handle = False
1250 sp.bezier_points[0].select_right_handle = False
1251
1252 sp.bezier_points[len(sp.bezier_points) - 1].select_control_point = False
1253 sp.bezier_points[len(sp.bezier_points) - 1].select_left_handle = False
1254 sp.bezier_points[len(sp.bezier_points) - 1].select_right_handle = False
1255
1256 # Smooth out strokes a little to improve crosshatch detection
1257 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1258
1259 for i in range(15):
1260 bpy.ops.curve.smooth('INVOKE_REGION_WIN')
1261
1262 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
1263 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1264
1265 # Simplify the splines
1266 for sp in ob_splines.data.splines:
1267 angle_sum = 0
1268
1269 sp.bezier_points[0].select_control_point = True
1270 sp.bezier_points[0].select_left_handle = True
1271 sp.bezier_points[0].select_right_handle = True
1272
1273 sp.bezier_points[len(sp.bezier_points) - 1].select_control_point = True
1274 sp.bezier_points[len(sp.bezier_points) - 1].select_left_handle = True
1275 sp.bezier_points[len(sp.bezier_points) - 1].select_right_handle = True
1276
1277 angle_limit = 15 # Degrees
1278 for t in range(len(sp.bezier_points)):
1279 # Because on each iteration it checks the "next two points"
1280 # of the actual. This way it doesn't go out of range
1281 if t <= len(sp.bezier_points) - 3:
1282 p1 = sp.bezier_points[t]
1283 p2 = sp.bezier_points[t + 1]
1284 p3 = sp.bezier_points[t + 2]
1285
1286 vec_1 = p1.co - p2.co
1287 vec_2 = p2.co - p3.co
1288
1289 if p2.co != p1.co and p2.co != p3.co:
1290 angle = vec_1.angle(vec_2)
1291 angle_sum += degrees(angle)
1292 # If sum of angles is grater than the limit
1293 if angle_sum >= angle_limit:
1294 p1.select_control_point = True
1295 p1.select_left_handle = True
1296 p1.select_right_handle = True
1297
1298 p2.select_control_point = True
1299 p2.select_left_handle = True
1300 p2.select_right_handle = True
1301
1302 p3.select_control_point = True
1303 p3.select_left_handle = True
1304 p3.select_right_handle = True
1305
1306 angle_sum = 0
1307
1308 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1309 bpy.ops.curve.select_all(action='INVERT')
1310
1311 bpy.ops.curve.delete(type='VERT')
1312 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1313
1314 objects_to_delete.append(ob_splines)
1315
1316 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1317 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
1318 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1319
1320 # Check if the strokes are a crosshatch
1321 if self.is_crosshatch:
1322 all_points_coords = []
1323 for i in range(len(ob_splines.data.splines)):
1324 all_points_coords.append([])
1325
1326 all_points_coords[i] = [Vector((x, y, z)) for
1327 x, y, z in [bp.co for
1328 bp in ob_splines.data.splines[i].bezier_points]]
1329
1330 all_intersections = []
1331 checked_splines = []
1332 for i in range(len(all_points_coords)):
1333
1334 for t in range(len(all_points_coords[i]) - 1):
1335 bp1_co = all_points_coords[i][t]
1336 bp2_co = all_points_coords[i][t + 1]
1337
1338 for i2 in range(len(all_points_coords)):
1339 if i != i2 and i2 not in checked_splines:
1340 for t2 in range(len(all_points_coords[i2]) - 1):
1341 bp3_co = all_points_coords[i2][t2]
1342 bp4_co = all_points_coords[i2][t2 + 1]
1343
1344 intersec_coords = intersect_line_line(
1345 bp1_co, bp2_co, bp3_co, bp4_co
1346 )
1347 if intersec_coords is not None:
1348 dist = (intersec_coords[0] - intersec_coords[1]).length
1349
1350 if dist <= self.crosshatch_merge_distance * 1.5:
1351 _temp_co, percent1 = intersect_point_line(
1352 intersec_coords[0], bp1_co, bp2_co
1353 )
1354 if (percent1 >= -0.02 and percent1 <= 1.02):
1355 _temp_co, percent2 = intersect_point_line(
1356 intersec_coords[1], bp3_co, bp4_co
1357 )
1358 if (percent2 >= -0.02 and percent2 <= 1.02):
1359 # Format: spline index, first point index from
1360 # corresponding segment, percentage from first point of
1361 # actual segment, coords of intersection point
1362 all_intersections.append(
1363 (i, t, percent1,
1364 ob_splines.matrix_world @ intersec_coords[0])
1365 )
1366 all_intersections.append(
1367 (i2, t2, percent2,
1368 ob_splines.matrix_world @ intersec_coords[1])
1369 )
1370
1371 checked_splines.append(i)
1372 # Sort list by spline, then by corresponding first point index of segment,
1373 # and then by percentage from first point of segment: elements 0 and 1 respectively
1374 all_intersections.sort(key=operator.itemgetter(0, 1, 2))
1375
1376 self.crosshatch_strokes_coords = {}
1377 for i in range(len(all_intersections)):
1378 if not all_intersections[i][0] in self.crosshatch_strokes_coords:
1379 self.crosshatch_strokes_coords[all_intersections[i][0]] = []
1380
1381 self.crosshatch_strokes_coords[all_intersections[i][0]].append(
1382 all_intersections[i][3]
1383 ) # Save intersection coords
1384 else:
1385 self.is_crosshatch = False
1386
1387 # Delete all duplicates
1388 bpy.ops.object.delete({"selected_objects": objects_to_delete})
1389
1390 # If the main object has modifiers, turn their "viewport view status" to
1391 # what it was before the forced deactivation above
1392 if len(self.main_object.modifiers) > 0:
1393 for m_idx in range(len(self.main_object.modifiers)):
1394 self.main_object.modifiers[m_idx].show_viewport = self.modifiers_prev_viewport_state[m_idx]
1395
1396 self.update()
1397
1398 return
1399
1400 # Part of the Crosshatch process that is repeated when the operator is tweaked
1401 def crosshatch_surface_execute(self, context):
1402 # If the main object uses modifiers deactivate them temporarily until the surface is joined
1403 # (without this the surface verts merging with the main object doesn't work well)
1404 self.modifiers_prev_viewport_state = []
1405 if len(self.main_object.modifiers) > 0:
1406 for m_idx in range(len(self.main_object.modifiers)):
1407 self.modifiers_prev_viewport_state.append(self.main_object.modifiers[m_idx].show_viewport)
1408
1409 self.main_object.modifiers[m_idx].show_viewport = False
1410
1411 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1412
1413 me_name = "SURFSKIO_STK_TMP"
1414 me = bpy.data.meshes.new(me_name)
1415
1416 all_verts_coords = []
1417 all_edges = []
1418 for st_idx in self.crosshatch_strokes_coords:
1419 for co_idx in range(len(self.crosshatch_strokes_coords[st_idx])):
1420 coords = self.crosshatch_strokes_coords[st_idx][co_idx]
1421
1422 all_verts_coords.append(coords)
1423
1424 if co_idx > 0:
1425 all_edges.append((len(all_verts_coords) - 2, len(all_verts_coords) - 1))
1426
1427 me.from_pydata(all_verts_coords, all_edges, [])
1428 ob = object_utils.object_data_add(context, me)
1429 ob.location = (0.0, 0.0, 0.0)
1430 ob.rotation_euler = (0.0, 0.0, 0.0)
1431 ob.scale = (1.0, 1.0, 1.0)
1432
1433 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
1434 ob.select_set(True)
1435 bpy.context.view_layer.objects.active = ob
1436
1437 # Get together each vert and its nearest, to the middle position
1438 verts = ob.data.vertices
1439 checked_verts = []
1440 for i in range(len(verts)):
1441 shortest_dist = None
1442
1443 if i not in checked_verts:
1444 for t in range(len(verts)):
1445 if i != t and t not in checked_verts:
1446 dist = (verts[i].co - verts[t].co).length
1447
1448 if shortest_dist is not None:
1449 if dist < shortest_dist:
1450 shortest_dist = dist
1451 nearest_vert = t
1452 else:
1453 shortest_dist = dist
1454 nearest_vert = t
1455
1456 middle_location = (verts[i].co + verts[nearest_vert].co) / 2
1457
1458 verts[i].co = middle_location
1459 verts[nearest_vert].co = middle_location
1460
1461 checked_verts.append(i)
1462 checked_verts.append(nearest_vert)
1463
1464 # Calculate average length between all the generated edges
1465 ob = bpy.context.object
1466 lengths_sum = 0
1467 for ed in ob.data.edges:
1468 v1 = ob.data.vertices[ed.vertices[0]]
1469 v2 = ob.data.vertices[ed.vertices[1]]
1470
1471 lengths_sum += (v1.co - v2.co).length
1472
1473 edges_count = len(ob.data.edges)
1474 # possible division by zero here
1475 average_edge_length = lengths_sum / edges_count if edges_count != 0 else 0.0001
1476
1477 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1478 bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='SELECT')
1479 bpy.ops.mesh.remove_doubles('INVOKE_REGION_WIN',
1480 threshold=average_edge_length / 15.0)
1481 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1482
1483 final_points_ob = bpy.context.view_layer.objects.active
1484
1485 # Make a dictionary with the verts related to each vert
1486 related_key_verts = {}
1487 for ed in final_points_ob.data.edges:
1488 if not ed.vertices[0] in related_key_verts:
1489 related_key_verts[ed.vertices[0]] = []
1490
1491 if not ed.vertices[1] in related_key_verts:
1492 related_key_verts[ed.vertices[1]] = []
1493
1494 if not ed.vertices[1] in related_key_verts[ed.vertices[0]]:
1495 related_key_verts[ed.vertices[0]].append(ed.vertices[1])
1496
1497 if not ed.vertices[0] in related_key_verts[ed.vertices[1]]:
1498 related_key_verts[ed.vertices[1]].append(ed.vertices[0])
1499
1500 # Get groups of verts forming each face
1501 faces_verts_idx = []
1502 for v1 in related_key_verts: # verts-1 ....
1503 for v2 in related_key_verts: # verts-2
1504 if v1 != v2:
1505 related_verts_in_common = []
1506 v2_in_rel_v1 = False
1507 v1_in_rel_v2 = False
1508 for rel_v1 in related_key_verts[v1]:
1509 # Check if related verts of verts-1 are related verts of verts-2
1510 if rel_v1 in related_key_verts[v2]:
1511 related_verts_in_common.append(rel_v1)
1512
1513 if v2 in related_key_verts[v1]:
1514 v2_in_rel_v1 = True
1515
1516 if v1 in related_key_verts[v2]:
1517 v1_in_rel_v2 = True
1518
1519 repeated_face = False
1520 # If two verts have two related verts in common, they form a quad
1521 if len(related_verts_in_common) == 2:
1522 # Check if the face is already saved
1523 for f_verts in faces_verts_idx:
1524 repeated_verts = 0
1525
1526 if len(f_verts) == 4:
1527 if v1 in f_verts:
1528 repeated_verts += 1
1529 if v2 in f_verts:
1530 repeated_verts += 1
1531 if related_verts_in_common[0] in f_verts:
1532 repeated_verts += 1
1533 if related_verts_in_common[1] in f_verts:
1534 repeated_verts += 1
1535
1536 if repeated_verts == len(f_verts):
1537 repeated_face = True
1538 break
1539
1540 if not repeated_face:
1541 faces_verts_idx.append([v1, related_verts_in_common[0],
1542 v2, related_verts_in_common[1]])
1543
1544 # If Two verts have one related vert in common and they are
1545 # related to each other, they form a triangle
1546 elif v2_in_rel_v1 and v1_in_rel_v2 and len(related_verts_in_common) == 1:
1547 # Check if the face is already saved.
1548 for f_verts in faces_verts_idx:
1549 repeated_verts = 0
1550
1551 if len(f_verts) == 3:
1552 if v1 in f_verts:
1553 repeated_verts += 1
1554 if v2 in f_verts:
1555 repeated_verts += 1
1556 if related_verts_in_common[0] in f_verts:
1557 repeated_verts += 1
1558
1559 if repeated_verts == len(f_verts):
1560 repeated_face = True
1561 break
1562
1563 if not repeated_face:
1564 faces_verts_idx.append([v1, related_verts_in_common[0], v2])
1565
1566 # Keep only the faces that don't overlap by ignoring
1567 # quads that overlap with two adjacent triangles
1568 faces_to_not_include_idx = [] # Indices of faces_verts_idx to eliminate
1569 for i in range(len(faces_verts_idx)):
1570 for t in range(len(faces_verts_idx)):
1571 if i != t:
1572 verts_in_common = 0
1573
1574 if len(faces_verts_idx[i]) == 4 and len(faces_verts_idx[t]) == 3:
1575 for v_idx in faces_verts_idx[t]:
1576 if v_idx in faces_verts_idx[i]:
1577 verts_in_common += 1
1578 # If it doesn't have all it's vertices repeated in the other face
1579 if verts_in_common == 3:
1580 if i not in faces_to_not_include_idx:
1581 faces_to_not_include_idx.append(i)
1582
1583 # Build surface
1584 all_surface_verts_co = []
1585 for i in range(len(final_points_ob.data.vertices)):
1586 coords = final_points_ob.data.vertices[i].co
1587 all_surface_verts_co.append([coords[0], coords[1], coords[2]])
1588
1589 # Verts of each face.
1590 all_surface_faces = []
1591 for i in range(len(faces_verts_idx)):
1592 if i not in faces_to_not_include_idx:
1593 face = []
1594 for v_idx in faces_verts_idx[i]:
1595 face.append(v_idx)
1596
1597 all_surface_faces.append(face)
1598
1599 # Build the mesh
1600 surf_me_name = "SURFSKIO_surface"
1601 me_surf = bpy.data.meshes.new(surf_me_name)
1602 me_surf.from_pydata(all_surface_verts_co, [], all_surface_faces)
1603 ob_surface = object_utils.object_data_add(context, me_surf)
1604 ob_surface.location = (0.0, 0.0, 0.0)
1605 ob_surface.rotation_euler = (0.0, 0.0, 0.0)
1606 ob_surface.scale = (1.0, 1.0, 1.0)
1607
1608 # Delete final points temporal object
1609 bpy.ops.object.delete({"selected_objects": [final_points_ob]})
1610
1611 # Delete isolated verts if there are any
1612 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
1613 ob_surface.select_set(True)
1614 bpy.context.view_layer.objects.active = ob_surface
1615
1616 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1617 bpy.ops.mesh.select_all(action='DESELECT')
1618 bpy.ops.mesh.select_face_by_sides(type='NOTEQUAL')
1619 bpy.ops.mesh.delete()
1620 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1621
1622 # Join crosshatch results with original mesh
1623
1624 # Calculate a distance to merge the verts of the crosshatch surface to the main object
1625 edges_length_sum = 0
1626 for ed in ob_surface.data.edges:
1627 edges_length_sum += (
1628 ob_surface.data.vertices[ed.vertices[0]].co -
1629 ob_surface.data.vertices[ed.vertices[1]].co
1630 ).length
1631
1632 # Make dictionary with all the verts connected to each vert, on the new surface object.
1633 surface_connected_verts = {}
1634 for ed in ob_surface.data.edges:
1635 if not ed.vertices[0] in surface_connected_verts:
1636 surface_connected_verts[ed.vertices[0]] = []
1637
1638 surface_connected_verts[ed.vertices[0]].append(ed.vertices[1])
1639
1640 if ed.vertices[1] not in surface_connected_verts:
1641 surface_connected_verts[ed.vertices[1]] = []
1642
1643 surface_connected_verts[ed.vertices[1]].append(ed.vertices[0])
1644
1645 # Duplicate the new surface object, and use shrinkwrap to
1646 # calculate later the nearest verts to the main object
1647 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1648 bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='DESELECT')
1649 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1650
1651 bpy.ops.object.duplicate('INVOKE_REGION_WIN')
1652
1653 final_ob_duplicate = bpy.context.view_layer.objects.active
1654
1655 bpy.ops.object.modifier_add('INVOKE_REGION_WIN', type='SHRINKWRAP')
1656 shrinkwrap_modifier = final_ob_duplicate.modifiers[-1]
1657 shrinkwrap_modifier.wrap_method = "NEAREST_VERTEX"
1658 shrinkwrap_modifier.target = self.main_object
1659
1660 bpy.ops.object.modifier_apply('INVOKE_REGION_WIN', modifier=shrinkwrap_modifier.name)
1661
1662 # Make list with verts of original mesh as index and coords as value
1663 main_object_verts_coords = []
1664 for v in self.main_object.data.vertices:
1665 coords = self.main_object.matrix_world @ v.co
1666
1667 # To avoid problems when taking "-0.00" as a different value as "0.00"
1668 for c in range(len(coords)):
1669 if "%.3f" % coords[c] == "-0.00":
1670 coords[c] = 0
1671
1672 main_object_verts_coords.append(["%.3f" % coords[0], "%.3f" % coords[1], "%.3f" % coords[2]])
1673
1674 tuple(main_object_verts_coords)
1675
1676 # Determine which verts will be merged, snap them to the nearest verts
1677 # on the original verts, and get them selected
1678 crosshatch_verts_to_merge = []
1679 if self.automatic_join:
1680 for i in range(len(ob_surface.data.vertices)-1):
1681 # Calculate the distance from each of the connected verts to the actual vert,
1682 # and compare it with the distance they would have if joined.
1683 # If they don't change much, that vert can be joined
1684 merge_actual_vert = True
1685 try:
1686 if len(surface_connected_verts[i]) < 4:
1687 for c_v_idx in surface_connected_verts[i]:
1688 points_original = []
1689 points_original.append(ob_surface.data.vertices[c_v_idx].co)
1690 points_original.append(ob_surface.data.vertices[i].co)
1691
1692 points_target = []
1693 points_target.append(ob_surface.data.vertices[c_v_idx].co)
1694 points_target.append(final_ob_duplicate.data.vertices[i].co)
1695
1696 vec_A = points_original[0] - points_original[1]
1697 vec_B = points_target[0] - points_target[1]
1698
1699 dist_A = (points_original[0] - points_original[1]).length
1700 dist_B = (points_target[0] - points_target[1]).length
1701
1702 if not (
1703 points_original[0] == points_original[1] or
1704 points_target[0] == points_target[1]
1705 ): # If any vector's length is zero
1706
1707 angle = vec_A.angle(vec_B) / pi
1708 else:
1709 angle = 0
1710
1711 # Set a range of acceptable variation in the connected edges
1712 if dist_B > dist_A * 1.7 * self.join_stretch_factor or \
1713 dist_B < dist_A / 2 / self.join_stretch_factor or \
1714 angle >= 0.15 * self.join_stretch_factor:
1715
1716 merge_actual_vert = False
1717 break
1718 else:
1719 merge_actual_vert = False
1720 except:
1721 self.report({'WARNING'},
1722 "Crosshatch set incorrectly")
1723
1724 if merge_actual_vert:
1725 coords = final_ob_duplicate.data.vertices[i].co
1726 # To avoid problems when taking "-0.000" as a different value as "0.00"
1727 for c in range(len(coords)):
1728 if "%.3f" % coords[c] == "-0.00":
1729 coords[c] = 0
1730
1731 comparison_coords = ["%.3f" % coords[0], "%.3f" % coords[1], "%.3f" % coords[2]]
1732
1733 if comparison_coords in main_object_verts_coords:
1734 # Get the index of the vert with those coords in the main object
1735 main_object_related_vert_idx = main_object_verts_coords.index(comparison_coords)
1736
1737 if self.main_object.data.vertices[main_object_related_vert_idx].select is True or \
1738 self.main_object_selected_verts_count == 0:
1739
1740 ob_surface.data.vertices[i].co = final_ob_duplicate.data.vertices[i].co
1741 ob_surface.data.vertices[i].select = True
1742 crosshatch_verts_to_merge.append(i)
1743
1744 # Make sure the vert in the main object is selected,
1745 # in case it wasn't selected and the "join crosshatch" option is active
1746 self.main_object.data.vertices[main_object_related_vert_idx].select = True
1747
1748 # Delete duplicated object
1749 bpy.ops.object.delete({"selected_objects": [final_ob_duplicate]})
1750
1751 # Join crosshatched surface and main object
1752 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
1753 ob_surface.select_set(True)
1754 self.main_object.select_set(True)
1755 bpy.context.view_layer.objects.active = self.main_object
1756
1757 bpy.ops.object.join('INVOKE_REGION_WIN')
1758
1759 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1760 # Perform Remove doubles to merge verts
1761 if not (self.automatic_join is False and self.main_object_selected_verts_count == 0):
1762 bpy.ops.mesh.remove_doubles(threshold=0.0001)
1763
1764 bpy.ops.mesh.select_all(action='DESELECT')
1765
1766 # If the main object has modifiers, turn their "viewport view status"
1767 # to what it was before the forced deactivation above
1768 if len(self.main_object.modifiers) > 0:
1769 for m_idx in range(len(self.main_object.modifiers)):
1770 self.main_object.modifiers[m_idx].show_viewport = self.modifiers_prev_viewport_state[m_idx]
1771
1772 self.update()
1773
1774 return {'FINISHED'}
1775
1776 def rectangular_surface(self, context):
1777 # Selected edges
1778 all_selected_edges_idx = []
1779 all_selected_verts = []
1780 all_verts_idx = []
1781 for ed in self.main_object.data.edges:
1782 if ed.select:
1783 all_selected_edges_idx.append(ed.index)
1784
1785 # Selected vertices
1786 if not ed.vertices[0] in all_selected_verts:
1787 all_selected_verts.append(self.main_object.data.vertices[ed.vertices[0]])
1788 if not ed.vertices[1] in all_selected_verts:
1789 all_selected_verts.append(self.main_object.data.vertices[ed.vertices[1]])
1790
1791 # All verts (both from each edge) to determine later
1792 # which are at the tips (those not repeated twice)
1793 all_verts_idx.append(ed.vertices[0])
1794 all_verts_idx.append(ed.vertices[1])
1795
1796 # Identify the tips and "middle-vertex" that separates U from V, if there is one
1797 all_chains_tips_idx = []
1798 for v_idx in all_verts_idx:
1799 if all_verts_idx.count(v_idx) < 2:
1800 all_chains_tips_idx.append(v_idx)
1801
1802 edges_connected_to_tips = []
1803 for ed in self.main_object.data.edges:
1804 if (ed.vertices[0] in all_chains_tips_idx or ed.vertices[1] in all_chains_tips_idx) and \
1805 not (ed.vertices[0] in all_verts_idx and ed.vertices[1] in all_verts_idx):
1806
1807 edges_connected_to_tips.append(ed)
1808
1809 # Check closed selections
1810 # List with groups of three verts, where the first element of the pair is
1811 # the unselected vert of a closed selection and the other two elements are the
1812 # selected neighbor verts (it will be useful to determine which selection chain
1813 # the unselected vert belongs to, and determine the "middle-vertex")
1814 single_unselected_verts_and_neighbors = []
1815
1816 # To identify a "closed" selection (a selection that is a closed chain except
1817 # for one vertex) find the vertex in common that have the edges connected to tips.
1818 # If there is a vertex in common, that one is the unselected vert that closes
1819 # the selection or is a "middle-vertex"
1820 single_unselected_verts = []
1821 for ed in edges_connected_to_tips:
1822 for ed_b in edges_connected_to_tips:
1823 if ed != ed_b:
1824 if ed.vertices[0] == ed_b.vertices[0] and \
1825 not self.main_object.data.vertices[ed.vertices[0]].select and \
1826 ed.vertices[0] not in single_unselected_verts:
1827
1828 # The second element is one of the tips of the selected
1829 # vertices of the closed selection
1830 single_unselected_verts_and_neighbors.append(
1831 [ed.vertices[0], ed.vertices[1], ed_b.vertices[1]]
1832 )
1833 single_unselected_verts.append(ed.vertices[0])
1834 break
1835 elif ed.vertices[0] == ed_b.vertices[1] and \
1836 not self.main_object.data.vertices[ed.vertices[0]].select and \
1837 ed.vertices[0] not in single_unselected_verts:
1838
1839 single_unselected_verts_and_neighbors.append(
1840 [ed.vertices[0], ed.vertices[1], ed_b.vertices[0]]
1841 )
1842 single_unselected_verts.append(ed.vertices[0])
1843 break
1844 elif ed.vertices[1] == ed_b.vertices[0] and \
1845 not self.main_object.data.vertices[ed.vertices[1]].select and \
1846 ed.vertices[1] not in single_unselected_verts:
1847
1848 single_unselected_verts_and_neighbors.append(
1849 [ed.vertices[1], ed.vertices[0], ed_b.vertices[1]]
1850 )
1851 single_unselected_verts.append(ed.vertices[1])
1852 break
1853 elif ed.vertices[1] == ed_b.vertices[1] and \
1854 not self.main_object.data.vertices[ed.vertices[1]].select and \
1855 ed.vertices[1] not in single_unselected_verts:
1856
1857 single_unselected_verts_and_neighbors.append(
1858 [ed.vertices[1], ed.vertices[0], ed_b.vertices[0]]
1859 )
1860 single_unselected_verts.append(ed.vertices[1])
1861 break
1862
1863 middle_vertex_idx = None
1864 tips_to_discard_idx = []
1865
1866 # Check if there is a "middle-vertex", and get its index
1867 for i in range(0, len(single_unselected_verts_and_neighbors)):
1868 actual_chain_verts = self.get_ordered_verts(
1869 self.main_object, all_selected_edges_idx,
1870 all_verts_idx, single_unselected_verts_and_neighbors[i][1],
1871 None, None
1872 )
1873
1874 if single_unselected_verts_and_neighbors[i][2] != \
1875 actual_chain_verts[len(actual_chain_verts) - 1].index:
1876
1877 middle_vertex_idx = single_unselected_verts_and_neighbors[i][0]
1878 tips_to_discard_idx.append(single_unselected_verts_and_neighbors[i][1])
1879 tips_to_discard_idx.append(single_unselected_verts_and_neighbors[i][2])
1880
1881 # List with pairs of verts that belong to the tips of each selection chain (row)
1882 verts_tips_same_chain_idx = []
1883 if len(all_chains_tips_idx) >= 2:
1884 checked_v = []
1885 for i in range(0, len(all_chains_tips_idx)):
1886 if all_chains_tips_idx[i] not in checked_v:
1887 v_chain = self.get_ordered_verts(
1888 self.main_object, all_selected_edges_idx,
1889 all_verts_idx, all_chains_tips_idx[i],
1890 middle_vertex_idx, None
1891 )
1892
1893 verts_tips_same_chain_idx.append([v_chain[0].index, v_chain[len(v_chain) - 1].index])
1894
1895 checked_v.append(v_chain[0].index)
1896 checked_v.append(v_chain[len(v_chain) - 1].index)
1897
1898 # Selection tips (vertices).
1899 verts_tips_parsed_idx = []
1900 if len(all_chains_tips_idx) >= 2:
1901 for spec_v_idx in all_chains_tips_idx:
1902 if (spec_v_idx not in tips_to_discard_idx):
1903 verts_tips_parsed_idx.append(spec_v_idx)
1904
1905 # Identify the type of selection made by the user
1906 if middle_vertex_idx is not None:
1907 # If there are 4 tips (two selection chains), and
1908 # there is only one single unselected vert (the middle vert)
1909 if len(all_chains_tips_idx) == 4 and len(single_unselected_verts_and_neighbors) == 1:
1910 selection_type = "TWO_CONNECTED"
1911 else:
1912 # The type of the selection was not identified, the script stops.
1913 self.report({'WARNING'}, "The selection isn't valid.")
1914
1915 self.stopping_errors = True
1916
1917 return{'CANCELLED'}
1918 else:
1919 if len(all_chains_tips_idx) == 2: # If there are 2 tips
1920 selection_type = "SINGLE"
1921 elif len(all_chains_tips_idx) == 4: # If there are 4 tips
1922 selection_type = "TWO_NOT_CONNECTED"
1923 elif len(all_chains_tips_idx) == 0:
1924 if len(self.main_splines.data.splines) > 1:
1925 selection_type = "NO_SELECTION"
1926 else:
1927 # If the selection was not identified and there is only one stroke,
1928 # there's no possibility to build a surface, so the script is interrupted
1929 self.report({'WARNING'}, "The selection isn't valid.")
1930
1931 self.stopping_errors = True
1932
1933 return{'CANCELLED'}
1934 else:
1935 # The type of the selection was not identified, the script stops
1936 self.report({'WARNING'}, "The selection isn't valid.")
1937
1938 self.stopping_errors = True
1939
1940 return{'CANCELLED'}
1941
1942 # If the selection type is TWO_NOT_CONNECTED and there is only one stroke, stop the script
1943 if selection_type == "TWO_NOT_CONNECTED" and len(self.main_splines.data.splines) == 1:
1944 self.report({'WARNING'},
1945 "At least two strokes are needed when there are two not connected selections")
1946
1947 self.stopping_errors = True
1948
1949 return{'CANCELLED'}
1950
1951 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1952
1953 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
1954 self.main_splines.select_set(True)
1955 bpy.context.view_layer.objects.active = self.main_splines
1956
1957 # Enter editmode for the new curve (converted from grease pencil strokes), to smooth it out
1958 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1959 bpy.ops.curve.smooth('INVOKE_REGION_WIN')
1960 bpy.ops.curve.smooth('INVOKE_REGION_WIN')
1961 bpy.ops.curve.smooth('INVOKE_REGION_WIN')
1962 bpy.ops.curve.smooth('INVOKE_REGION_WIN')
1963 bpy.ops.curve.smooth('INVOKE_REGION_WIN')
1964 bpy.ops.curve.smooth('INVOKE_REGION_WIN')
1965 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
1966
1967 self.selection_U_exists = False
1968 self.selection_U2_exists = False
1969 self.selection_V_exists = False
1970 self.selection_V2_exists = False
1971
1972 self.selection_U_is_closed = False
1973 self.selection_U2_is_closed = False
1974 self.selection_V_is_closed = False
1975 self.selection_V2_is_closed = False
1976
1977 # Define what vertices are at the tips of each selection and are not the middle-vertex
1978 if selection_type == "TWO_CONNECTED":
1979 self.selection_U_exists = True
1980 self.selection_V_exists = True
1981
1982 closing_vert_U_idx = None
1983 closing_vert_V_idx = None
1984 closing_vert_U2_idx = None
1985 closing_vert_V2_idx = None
1986
1987 # Determine which selection is Selection-U and which is Selection-V
1988 points_A = []
1989 points_B = []
1990 points_first_stroke_tips = []
1991
1992 points_A.append(
1993 self.main_object.matrix_world @ self.main_object.data.vertices[verts_tips_parsed_idx[0]].co
1994 )
1995 points_A.append(
1996 self.main_object.matrix_world @ self.main_object.data.vertices[middle_vertex_idx].co
1997 )
1998 points_B.append(
1999 self.main_object.matrix_world @ self.main_object.data.vertices[verts_tips_parsed_idx[1]].co
2000 )
2001 points_B.append(
2002 self.main_object.matrix_world @ self.main_object.data.vertices[middle_vertex_idx].co
2003 )
2004 points_first_stroke_tips.append(
2005 self.main_splines.data.splines[0].bezier_points[0].co
2006 )
2007 points_first_stroke_tips.append(
2008 self.main_splines.data.splines[0].bezier_points[
2009 len(self.main_splines.data.splines[0].bezier_points) - 1
2010 ].co
2011 )
2012
2013 angle_A = self.orientation_difference(points_A, points_first_stroke_tips)
2014 angle_B = self.orientation_difference(points_B, points_first_stroke_tips)
2015
2016 if angle_A < angle_B:
2017 first_vert_U_idx = verts_tips_parsed_idx[0]
2018 first_vert_V_idx = verts_tips_parsed_idx[1]
2019 else:
2020 first_vert_U_idx = verts_tips_parsed_idx[1]
2021 first_vert_V_idx = verts_tips_parsed_idx[0]
2022
2023 elif selection_type == "SINGLE" or selection_type == "TWO_NOT_CONNECTED":
2024 first_sketched_point_first_stroke_co = self.main_splines.data.splines[0].bezier_points[0].co
2025 last_sketched_point_first_stroke_co = \
2026 self.main_splines.data.splines[0].bezier_points[
2027 len(self.main_splines.data.splines[0].bezier_points) - 1
2028 ].co
2029 first_sketched_point_last_stroke_co = \
2030 self.main_splines.data.splines[
2031 len(self.main_splines.data.splines) - 1
2032 ].bezier_points[0].co
2033 if len(self.main_splines.data.splines) > 1:
2034 first_sketched_point_second_stroke_co = self.main_splines.data.splines[1].bezier_points[0].co
2035 last_sketched_point_second_stroke_co = \
2036 self.main_splines.data.splines[1].bezier_points[
2037 len(self.main_splines.data.splines[1].bezier_points) - 1
2038 ].co
2039
2040 single_unselected_neighbors = [] # Only the neighbors of the single unselected verts
2041 for verts_neig_idx in single_unselected_verts_and_neighbors:
2042 single_unselected_neighbors.append(verts_neig_idx[1])
2043 single_unselected_neighbors.append(verts_neig_idx[2])
2044
2045 all_chains_tips_and_middle_vert = []
2046 for v_idx in all_chains_tips_idx:
2047 if v_idx not in single_unselected_neighbors:
2048 all_chains_tips_and_middle_vert.append(v_idx)
2049
2050 all_chains_tips_and_middle_vert += single_unselected_verts
2051
2052 all_participating_verts = all_chains_tips_and_middle_vert + all_verts_idx
2053
2054 # The tip of the selected vertices nearest to the first point of the first sketched stroke
2055 nearest_tip_to_first_st_first_pt_idx, shortest_distance_to_first_stroke = \
2056 self.shortest_distance(
2057 self.main_object,
2058 first_sketched_point_first_stroke_co,
2059 all_chains_tips_and_middle_vert
2060 )
2061 # If the nearest tip is not from a closed selection, get the opposite tip vertex index
2062 if nearest_tip_to_first_st_first_pt_idx not in single_unselected_verts or \
2063 nearest_tip_to_first_st_first_pt_idx == middle_vertex_idx:
2064
2065 nearest_tip_to_first_st_first_pt_opposite_idx = \
2066 self.opposite_tip(
2067 nearest_tip_to_first_st_first_pt_idx,
2068 verts_tips_same_chain_idx
2069 )
2070 # The tip of the selected vertices nearest to the last point of the first sketched stroke
2071 nearest_tip_to_first_st_last_pt_idx, _temp_dist = \
2072 self.shortest_distance(
2073 self.main_object,
2074 last_sketched_point_first_stroke_co,
2075 all_chains_tips_and_middle_vert
2076 )
2077 # The tip of the selected vertices nearest to the first point of the last sketched stroke
2078 nearest_tip_to_last_st_first_pt_idx, shortest_distance_to_last_stroke = \
2079 self.shortest_distance(
2080 self.main_object,
2081 first_sketched_point_last_stroke_co,
2082 all_chains_tips_and_middle_vert
2083 )
2084 if len(self.main_splines.data.splines) > 1:
2085 # The selected vertex nearest to the first point of the second sketched stroke
2086 # (This will be useful to determine the direction of the closed
2087 # selection V when extruding along strokes)
2088 nearest_vert_to_second_st_first_pt_idx, _temp_dist = \
2089 self.shortest_distance(
2090 self.main_object,
2091 first_sketched_point_second_stroke_co,
2092 all_verts_idx
2093 )
2094 # The selected vertex nearest to the first point of the second sketched stroke
2095 # (This will be useful to determine the direction of the closed
2096 # selection V2 when extruding along strokes)
2097 nearest_vert_to_second_st_last_pt_idx, _temp_dist = \
2098 self.shortest_distance(
2099 self.main_object,
2100 last_sketched_point_second_stroke_co,
2101 all_verts_idx
2102 )
2103 # Determine if the single selection will be treated as U or as V
2104 edges_sum = 0
2105 for i in all_selected_edges_idx:
2106 edges_sum += (
2107 (self.main_object.matrix_world @
2108 self.main_object.data.vertices[self.main_object.data.edges[i].vertices[0]].co) -
2109 (self.main_object.matrix_world @
2110 self.main_object.data.vertices[self.main_object.data.edges[i].vertices[1]].co)
2111 ).length
2112
2113 average_edge_length = edges_sum / len(all_selected_edges_idx)
2114
2115 # Get shortest distance from the first point of the last stroke to any participating vertex
2116 _temp_idx, shortest_distance_to_last_stroke = \
2117 self.shortest_distance(
2118 self.main_object,
2119 first_sketched_point_last_stroke_co,
2120 all_participating_verts
2121 )
2122 # If the beginning of the first stroke is near enough, and its orientation
2123 # difference with the first edge of the nearest selection chain is not too high,
2124 # interpret things as an "extrude along strokes" instead of "extrude through strokes"
2125 if shortest_distance_to_first_stroke < average_edge_length / 4 and \
2126 shortest_distance_to_last_stroke < average_edge_length and \
2127 len(self.main_splines.data.splines) > 1:
2128
2129 self.selection_U_exists = False
2130 self.selection_V_exists = True
2131 # If the first selection is not closed
2132 if nearest_tip_to_first_st_first_pt_idx not in single_unselected_verts or \
2133 nearest_tip_to_first_st_first_pt_idx == middle_vertex_idx:
2134 self.selection_V_is_closed = False
2135 closing_vert_U_idx = None
2136 closing_vert_U2_idx = None
2137 closing_vert_V_idx = None
2138 closing_vert_V2_idx = None
2139
2140 first_vert_V_idx = nearest_tip_to_first_st_first_pt_idx
2141
2142 if selection_type == "TWO_NOT_CONNECTED":
2143 self.selection_V2_exists = True
2144
2145 first_vert_V2_idx = nearest_tip_to_first_st_last_pt_idx
2146 else:
2147 self.selection_V_is_closed = True
2148 closing_vert_V_idx = nearest_tip_to_first_st_first_pt_idx
2149
2150 # Get the neighbors of the first (unselected) vert of the closed selection U.
2151 vert_neighbors = []
2152 for verts in single_unselected_verts_and_neighbors:
2153 if verts[0] == nearest_tip_to_first_st_first_pt_idx:
2154 vert_neighbors.append(verts[1])
2155 vert_neighbors.append(verts[2])
2156 break
2157
2158 verts_V = self.get_ordered_verts(
2159 self.main_object, all_selected_edges_idx,
2160 all_verts_idx, vert_neighbors[0], middle_vertex_idx, None
2161 )
2162
2163 for i in range(0, len(verts_V)):
2164 if verts_V[i].index == nearest_vert_to_second_st_first_pt_idx:
2165 # If the vertex nearest to the first point of the second stroke
2166 # is in the first half of the selected verts
2167 if i >= len(verts_V) / 2:
2168 first_vert_V_idx = vert_neighbors[1]
2169 break
2170 else:
2171 first_vert_V_idx = vert_neighbors[0]
2172 break
2173
2174 if selection_type == "TWO_NOT_CONNECTED":
2175 self.selection_V2_exists = True
2176 # If the second selection is not closed
2177 if nearest_tip_to_first_st_last_pt_idx not in single_unselected_verts or \
2178 nearest_tip_to_first_st_last_pt_idx == middle_vertex_idx:
2179
2180 self.selection_V2_is_closed = False
2181 closing_vert_V2_idx = None
2182 first_vert_V2_idx = nearest_tip_to_first_st_last_pt_idx
2183
2184 else:
2185 self.selection_V2_is_closed = True
2186 closing_vert_V2_idx = nearest_tip_to_first_st_last_pt_idx
2187
2188 # Get the neighbors of the first (unselected) vert of the closed selection U
2189 vert_neighbors = []
2190 for verts in single_unselected_verts_and_neighbors:
2191 if verts[0] == nearest_tip_to_first_st_last_pt_idx:
2192 vert_neighbors.append(verts[1])
2193 vert_neighbors.append(verts[2])
2194 break
2195
2196 verts_V2 = self.get_ordered_verts(
2197 self.main_object, all_selected_edges_idx,
2198 all_verts_idx, vert_neighbors[0], middle_vertex_idx, None
2199 )
2200
2201 for i in range(0, len(verts_V2)):
2202 if verts_V2[i].index == nearest_vert_to_second_st_last_pt_idx:
2203 # If the vertex nearest to the first point of the second stroke
2204 # is in the first half of the selected verts
2205 if i >= len(verts_V2) / 2:
2206 first_vert_V2_idx = vert_neighbors[1]
2207 break
2208 else:
2209 first_vert_V2_idx = vert_neighbors[0]
2210 break
2211 else:
2212 self.selection_V2_exists = False
2213
2214 else:
2215 self.selection_U_exists = True
2216 self.selection_V_exists = False
2217 # If the first selection is not closed
2218 if nearest_tip_to_first_st_first_pt_idx not in single_unselected_verts or \
2219 nearest_tip_to_first_st_first_pt_idx == middle_vertex_idx:
2220 self.selection_U_is_closed = False
2221 closing_vert_U_idx = None
2222
2223 points_tips = []
2224 points_tips.append(
2225 self.main_object.matrix_world @
2226 self.main_object.data.vertices[nearest_tip_to_first_st_first_pt_idx].co
2227 )
2228 points_tips.append(
2229 self.main_object.matrix_world @
2230 self.main_object.data.vertices[nearest_tip_to_first_st_first_pt_opposite_idx].co
2231 )
2232 points_first_stroke_tips = []
2233 points_first_stroke_tips.append(self.main_splines.data.splines[0].bezier_points[0].co)
2234 points_first_stroke_tips.append(
2235 self.main_splines.data.splines[0].bezier_points[
2236 len(self.main_splines.data.splines[0].bezier_points) - 1
2237 ].co
2238 )
2239 vec_A = points_tips[0] - points_tips[1]
2240 vec_B = points_first_stroke_tips[0] - points_first_stroke_tips[1]
2241
2242 # Compare the direction of the selection and the first
2243 # grease pencil stroke to determine which is the "first" vertex of the selection
2244 if vec_A.dot(vec_B) < 0:
2245 first_vert_U_idx = nearest_tip_to_first_st_first_pt_opposite_idx
2246 else:
2247 first_vert_U_idx = nearest_tip_to_first_st_first_pt_idx
2248
2249 else:
2250 self.selection_U_is_closed = True
2251 closing_vert_U_idx = nearest_tip_to_first_st_first_pt_idx
2252
2253 # Get the neighbors of the first (unselected) vert of the closed selection U
2254 vert_neighbors = []
2255 for verts in single_unselected_verts_and_neighbors:
2256 if verts[0] == nearest_tip_to_first_st_first_pt_idx:
2257 vert_neighbors.append(verts[1])
2258 vert_neighbors.append(verts[2])
2259 break
2260
2261 points_first_and_neighbor = []
2262 points_first_and_neighbor.append(
2263 self.main_object.matrix_world @
2264 self.main_object.data.vertices[nearest_tip_to_first_st_first_pt_idx].co
2265 )
2266 points_first_and_neighbor.append(
2267 self.main_object.matrix_world @
2268 self.main_object.data.vertices[vert_neighbors[0]].co
2269 )
2270 points_first_stroke_tips = []
2271 points_first_stroke_tips.append(self.main_splines.data.splines[0].bezier_points[0].co)
2272 points_first_stroke_tips.append(self.main_splines.data.splines[0].bezier_points[1].co)
2273
2274 vec_A = points_first_and_neighbor[0] - points_first_and_neighbor[1]
2275 vec_B = points_first_stroke_tips[0] - points_first_stroke_tips[1]
2276
2277 # Compare the direction of the selection and the first grease pencil stroke to
2278 # determine which is the vertex neighbor to the first vertex (unselected) of
2279 # the closed selection. This will determine the direction of the closed selection
2280 if vec_A.dot(vec_B) < 0:
2281 first_vert_U_idx = vert_neighbors[1]
2282 else:
2283 first_vert_U_idx = vert_neighbors[0]
2284
2285 if selection_type == "TWO_NOT_CONNECTED":
2286 self.selection_U2_exists = True
2287 # If the second selection is not closed
2288 if nearest_tip_to_last_st_first_pt_idx not in single_unselected_verts or \
2289 nearest_tip_to_last_st_first_pt_idx == middle_vertex_idx:
2290
2291 self.selection_U2_is_closed = False
2292 closing_vert_U2_idx = None
2293 first_vert_U2_idx = nearest_tip_to_last_st_first_pt_idx
2294 else:
2295 self.selection_U2_is_closed = True
2296 closing_vert_U2_idx = nearest_tip_to_last_st_first_pt_idx
2297
2298 # Get the neighbors of the first (unselected) vert of the closed selection U
2299 vert_neighbors = []
2300 for verts in single_unselected_verts_and_neighbors:
2301 if verts[0] == nearest_tip_to_last_st_first_pt_idx:
2302 vert_neighbors.append(verts[1])
2303 vert_neighbors.append(verts[2])
2304 break
2305
2306 points_first_and_neighbor = []
2307 points_first_and_neighbor.append(
2308 self.main_object.matrix_world @
2309 self.main_object.data.vertices[nearest_tip_to_last_st_first_pt_idx].co
2310 )
2311 points_first_and_neighbor.append(
2312 self.main_object.matrix_world @
2313 self.main_object.data.vertices[vert_neighbors[0]].co
2314 )
2315 points_last_stroke_tips = []
2316 points_last_stroke_tips.append(
2317 self.main_splines.data.splines[
2318 len(self.main_splines.data.splines) - 1
2319 ].bezier_points[0].co
2320 )
2321 points_last_stroke_tips.append(
2322 self.main_splines.data.splines[
2323 len(self.main_splines.data.splines) - 1
2324 ].bezier_points[1].co
2325 )
2326 vec_A = points_first_and_neighbor[0] - points_first_and_neighbor[1]
2327 vec_B = points_last_stroke_tips[0] - points_last_stroke_tips[1]
2328
2329 # Compare the direction of the selection and the last grease pencil stroke to
2330 # determine which is the vertex neighbor to the first vertex (unselected) of
2331 # the closed selection. This will determine the direction of the closed selection
2332 if vec_A.dot(vec_B) < 0:
2333 first_vert_U2_idx = vert_neighbors[1]
2334 else:
2335 first_vert_U2_idx = vert_neighbors[0]
2336 else:
2337 self.selection_U2_exists = False
2338
2339 elif selection_type == "NO_SELECTION":
2340 self.selection_U_exists = False
2341 self.selection_V_exists = False
2342
2343 # Get an ordered list of the vertices of Selection-U
2344 verts_ordered_U = []
2345 if self.selection_U_exists:
2346 verts_ordered_U = self.get_ordered_verts(
2347 self.main_object, all_selected_edges_idx,
2348 all_verts_idx, first_vert_U_idx,
2349 middle_vertex_idx, closing_vert_U_idx
2350 )
2351
2352 # Get an ordered list of the vertices of Selection-U2
2353 verts_ordered_U2 = []
2354 if self.selection_U2_exists:
2355 verts_ordered_U2 = self.get_ordered_verts(
2356 self.main_object, all_selected_edges_idx,
2357 all_verts_idx, first_vert_U2_idx,
2358 middle_vertex_idx, closing_vert_U2_idx
2359 )
2360
2361 # Get an ordered list of the vertices of Selection-V
2362 verts_ordered_V = []
2363 if self.selection_V_exists:
2364 verts_ordered_V = self.get_ordered_verts(
2365 self.main_object, all_selected_edges_idx,
2366 all_verts_idx, first_vert_V_idx,
2367 middle_vertex_idx, closing_vert_V_idx
2368 )
2369 verts_ordered_V_indices = [x.index for x in verts_ordered_V]
2370
2371 # Get an ordered list of the vertices of Selection-V2
2372 verts_ordered_V2 = []
2373 if self.selection_V2_exists:
2374 verts_ordered_V2 = self.get_ordered_verts(
2375 self.main_object, all_selected_edges_idx,
2376 all_verts_idx, first_vert_V2_idx,
2377 middle_vertex_idx, closing_vert_V2_idx
2378 )
2379
2380 # Check if when there are two-not-connected selections both have the same
2381 # number of verts. If not terminate the script
2382 if ((self.selection_U2_exists and len(verts_ordered_U) != len(verts_ordered_U2)) or
2383 (self.selection_V2_exists and len(verts_ordered_V) != len(verts_ordered_V2))):
2384 # Display a warning
2385 self.report({'WARNING'}, "Both selections must have the same number of edges")
2386
2387 self.stopping_errors = True
2388
2389 return{'CANCELLED'}
2390
2391 # Calculate edges U proportions
2392 # Sum selected edges U lengths
2393 edges_lengths_U = []
2394 edges_lengths_sum_U = 0
2395
2396 if self.selection_U_exists:
2397 edges_lengths_U, edges_lengths_sum_U = self.get_chain_length(
2398 self.main_object,
2399 verts_ordered_U
2400 )
2401 if self.selection_U2_exists:
2402 edges_lengths_U2, edges_lengths_sum_U2 = self.get_chain_length(
2403 self.main_object,
2404 verts_ordered_U2
2405 )
2406 # Sum selected edges V lengths
2407 edges_lengths_V = []
2408 edges_lengths_sum_V = 0
2409
2410 if self.selection_V_exists:
2411 edges_lengths_V, edges_lengths_sum_V = self.get_chain_length(
2412 self.main_object,
2413 verts_ordered_V
2414 )
2415 if self.selection_V2_exists:
2416 edges_lengths_V2, edges_lengths_sum_V2 = self.get_chain_length(
2417 self.main_object,
2418 verts_ordered_V2
2419 )
2420
2421 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2422 bpy.ops.curve.subdivide('INVOKE_REGION_WIN',
2423 number_cuts=bpy.context.scene.bsurfaces.SURFSK_precision)
2424 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2425
2426 # Proportions U
2427 edges_proportions_U = []
2428 edges_proportions_U = self.get_edges_proportions(
2429 edges_lengths_U, edges_lengths_sum_U,
2430 self.selection_U_exists, self.edges_U
2431 )
2432 verts_count_U = len(edges_proportions_U) + 1
2433
2434 if self.selection_U2_exists:
2435 edges_proportions_U2 = []
2436 edges_proportions_U2 = self.get_edges_proportions(
2437 edges_lengths_U2, edges_lengths_sum_U2,
2438 self.selection_U2_exists, self.edges_V
2439 )
2440
2441 # Proportions V
2442 edges_proportions_V = []
2443 edges_proportions_V = self.get_edges_proportions(
2444 edges_lengths_V, edges_lengths_sum_V,
2445 self.selection_V_exists, self.edges_V
2446 )
2447
2448 if self.selection_V2_exists:
2449 edges_proportions_V2 = []
2450 edges_proportions_V2 = self.get_edges_proportions(
2451 edges_lengths_V2, edges_lengths_sum_V2,
2452 self.selection_V2_exists, self.edges_V
2453 )
2454
2455 # Cyclic Follow: simplify sketched curves, make them Cyclic, and complete
2456 # the actual sketched curves with a "closing segment"
2457 if self.cyclic_follow and not self.selection_V_exists and not \
2458 ((self.selection_U_exists and not self.selection_U_is_closed) or
2459 (self.selection_U2_exists and not self.selection_U2_is_closed)):
2460
2461 simplified_spline_coords = []
2462 simplified_curve = []
2463 ob_simplified_curve = []
2464 splines_first_v_co = []
2465 for i in range(len(self.main_splines.data.splines)):
2466 # Create a curve object for the actual spline "cyclic extension"
2467 simplified_curve.append(bpy.data.curves.new('SURFSKIO_simpl_crv', 'CURVE'))
2468 ob_simplified_curve.append(bpy.data.objects.new('SURFSKIO_simpl_crv', simplified_curve[i]))
2469 bpy.context.collection.objects.link(ob_simplified_curve[i])
2470
2471 simplified_curve[i].dimensions = "3D"
2472
2473 spline_coords = []
2474 for bp in self.main_splines.data.splines[i].bezier_points:
2475 spline_coords.append(bp.co)
2476
2477 # Simplification
2478 simplified_spline_coords.append(self.simplify_spline(spline_coords, 5))
2479
2480 # Get the coordinates of the first vert of the actual spline
2481 splines_first_v_co.append(simplified_spline_coords[i][0])
2482
2483 # Generate the spline
2484 spline = simplified_curve[i].splines.new('BEZIER')
2485 # less one because one point is added when the spline is created
2486 spline.bezier_points.add(len(simplified_spline_coords[i]) - 1)
2487 for p in range(0, len(simplified_spline_coords[i])):
2488 spline.bezier_points[p].co = simplified_spline_coords[i][p]
2489
2490 spline.use_cyclic_u = True
2491
2492 spline_bp_count = len(spline.bezier_points)
2493
2494 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
2495 ob_simplified_curve[i].select_set(True)
2496 bpy.context.view_layer.objects.active = ob_simplified_curve[i]
2497
2498 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2499 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='SELECT')
2500 bpy.ops.curve.handle_type_set('INVOKE_REGION_WIN', type='AUTOMATIC')
2501 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
2502 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2503
2504 # Select the "closing segment", and subdivide it
2505 ob_simplified_curve[i].data.splines[0].bezier_points[0].select_control_point = True
2506 ob_simplified_curve[i].data.splines[0].bezier_points[0].select_left_handle = True
2507 ob_simplified_curve[i].data.splines[0].bezier_points[0].select_right_handle = True
2508
2509 ob_simplified_curve[i].data.splines[0].bezier_points[spline_bp_count - 1].select_control_point = True
2510 ob_simplified_curve[i].data.splines[0].bezier_points[spline_bp_count - 1].select_left_handle = True
2511 ob_simplified_curve[i].data.splines[0].bezier_points[spline_bp_count - 1].select_right_handle = True
2512
2513 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2514 segments = sqrt(
2515 (ob_simplified_curve[i].data.splines[0].bezier_points[0].co -
2516 ob_simplified_curve[i].data.splines[0].bezier_points[spline_bp_count - 1].co).length /
2517 self.average_gp_segment_length
2518 )
2519 for t in range(2):
2520 bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=int(segments))
2521
2522 # Delete the other vertices and make it non-cyclic to
2523 # keep only the needed verts of the "closing segment"
2524 bpy.ops.curve.select_all(action='INVERT')
2525 bpy.ops.curve.delete(type='VERT')
2526 ob_simplified_curve[i].data.splines[0].use_cyclic_u = False
2527 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2528
2529 # Add the points of the "closing segment" to the original curve from grease pencil stroke
2530 first_new_index = len(self.main_splines.data.splines[i].bezier_points)
2531 self.main_splines.data.splines[i].bezier_points.add(
2532 len(ob_simplified_curve[i].data.splines[0].bezier_points) - 1
2533 )
2534 for t in range(1, len(ob_simplified_curve[i].data.splines[0].bezier_points)):
2535 self.main_splines.data.splines[i].bezier_points[t - 1 + first_new_index].co = \
2536 ob_simplified_curve[i].data.splines[0].bezier_points[t].co
2537
2538 # Delete the temporal curve
2539 bpy.ops.object.delete({"selected_objects": [ob_simplified_curve[i]]})
2540
2541 # Get the coords of the points distributed along the sketched strokes,
2542 # with proportions-U of the first selection
2543 pts_on_strokes_with_proportions_U = self.distribute_pts(
2544 self.main_splines.data.splines,
2545 edges_proportions_U
2546 )
2547 sketched_splines_parsed = []
2548
2549 if self.selection_U2_exists:
2550 # Initialize the multidimensional list with the proportions of all the segments
2551 proportions_loops_crossing_strokes = []
2552 for i in range(len(pts_on_strokes_with_proportions_U)):
2553 proportions_loops_crossing_strokes.append([])
2554
2555 for t in range(len(pts_on_strokes_with_proportions_U[0])):
2556 proportions_loops_crossing_strokes[i].append(None)
2557
2558 # Calculate the proportions of each segment of the loops-U from pts_on_strokes_with_proportions_U
2559 for lp in range(len(pts_on_strokes_with_proportions_U[0])):
2560 loop_segments_lengths = []
2561
2562 for st in range(len(pts_on_strokes_with_proportions_U)):
2563 # When on the first stroke, add the segment from the selection to the dirst stroke
2564 if st == 0:
2565 loop_segments_lengths.append(
2566 ((self.main_object.matrix_world @ verts_ordered_U[lp].co) -
2567 pts_on_strokes_with_proportions_U[0][lp]).length
2568 )
2569 # For all strokes except for the last, calculate the distance
2570 # from the actual stroke to the next
2571 if st != len(pts_on_strokes_with_proportions_U) - 1:
2572 loop_segments_lengths.append(
2573 (pts_on_strokes_with_proportions_U[st][lp] -
2574 pts_on_strokes_with_proportions_U[st + 1][lp]).length
2575 )
2576 # When on the last stroke, add the segments
2577 # from the last stroke to the second selection
2578 if st == len(pts_on_strokes_with_proportions_U) - 1:
2579 loop_segments_lengths.append(
2580 (pts_on_strokes_with_proportions_U[st][lp] -
2581 (self.main_object.matrix_world @ verts_ordered_U2[lp].co)).length
2582 )
2583 # Calculate full loop length
2584 loop_seg_lengths_sum = 0
2585 for i in range(len(loop_segments_lengths)):
2586 loop_seg_lengths_sum += loop_segments_lengths[i]
2587
2588 # Fill the multidimensional list with the proportions of all the segments
2589 for st in range(len(pts_on_strokes_with_proportions_U)):
2590 proportions_loops_crossing_strokes[st][lp] = \
2591 loop_segments_lengths[st] / loop_seg_lengths_sum
2592
2593 # Calculate proportions for each stroke
2594 for st in range(len(pts_on_strokes_with_proportions_U)):
2595 actual_stroke_spline = []
2596 # Needs to be a list for the "distribute_pts" method
2597 actual_stroke_spline.append(self.main_splines.data.splines[st])
2598
2599 # Calculate the proportions for the actual stroke.
2600 actual_edges_proportions_U = []
2601 for i in range(len(edges_proportions_U)):
2602 proportions_sum = 0
2603
2604 # Sum the proportions of this loop up to the actual.
2605 for t in range(0, st + 1):
2606 proportions_sum += proportions_loops_crossing_strokes[t][i]
2607 # i + 1, because proportions_loops_crossing_strokes refers to loops,
2608 # and the proportions refer to edges, so we start at the element 1
2609 # of proportions_loops_crossing_strokes instead of element 0
2610 actual_edges_proportions_U.append(
2611 edges_proportions_U[i] -
2612 ((edges_proportions_U[i] - edges_proportions_U2[i]) * proportions_sum)
2613 )
2614 points_actual_spline = self.distribute_pts(actual_stroke_spline, actual_edges_proportions_U)
2615 sketched_splines_parsed.append(points_actual_spline[0])
2616 else:
2617 sketched_splines_parsed = pts_on_strokes_with_proportions_U
2618
2619 # If the selection type is "TWO_NOT_CONNECTED" replace the
2620 # points of the last spline with the points in the "target" selection
2621 if selection_type == "TWO_NOT_CONNECTED":
2622 if self.selection_U2_exists:
2623 for i in range(0, len(sketched_splines_parsed[len(sketched_splines_parsed) - 1])):
2624 sketched_splines_parsed[len(sketched_splines_parsed) - 1][i] = \
2625 self.main_object.matrix_world @ verts_ordered_U2[i].co
2626
2627 # Create temporary curves along the "control-points" found
2628 # on the sketched curves and the mesh selection
2629 mesh_ctrl_pts_name = "SURFSKIO_ctrl_pts"
2630 me = bpy.data.meshes.new(mesh_ctrl_pts_name)
2631 ob_ctrl_pts = bpy.data.objects.new(mesh_ctrl_pts_name, me)
2632 ob_ctrl_pts.data = me
2633 bpy.context.collection.objects.link(ob_ctrl_pts)
2634
2635 cyclic_loops_U = []
2636 first_verts = []
2637 second_verts = []
2638 last_verts = []
2639
2640 for i in range(0, verts_count_U):
2641 vert_num_in_spline = 1
2642
2643 if self.selection_U_exists:
2644 ob_ctrl_pts.data.vertices.add(1)
2645 last_v = ob_ctrl_pts.data.vertices[len(ob_ctrl_pts.data.vertices) - 1]
2646 last_v.co = self.main_object.matrix_world @ verts_ordered_U[i].co
2647
2648 vert_num_in_spline += 1
2649
2650 for t in range(0, len(sketched_splines_parsed)):
2651 ob_ctrl_pts.data.vertices.add(1)
2652 v = ob_ctrl_pts.data.vertices[len(ob_ctrl_pts.data.vertices) - 1]
2653 v.co = sketched_splines_parsed[t][i]
2654
2655 if vert_num_in_spline > 1:
2656 ob_ctrl_pts.data.edges.add(1)
2657 ob_ctrl_pts.data.edges[len(ob_ctrl_pts.data.edges) - 1].vertices[0] = \
2658 len(ob_ctrl_pts.data.vertices) - 2
2659 ob_ctrl_pts.data.edges[len(ob_ctrl_pts.data.edges) - 1].vertices[1] = \
2660 len(ob_ctrl_pts.data.vertices) - 1
2661
2662 if t == 0:
2663 first_verts.append(v.index)
2664
2665 if t == 1:
2666 second_verts.append(v.index)
2667
2668 if t == len(sketched_splines_parsed) - 1:
2669 last_verts.append(v.index)
2670
2671 last_v = v
2672 vert_num_in_spline += 1
2673
2674 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
2675 ob_ctrl_pts.select_set(True)
2676 bpy.context.view_layer.objects.active = ob_ctrl_pts
2677
2678 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2679 bpy.ops.mesh.select_all(action='DESELECT')
2680 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2681
2682 # Determine which loops-U will be "Cyclic"
2683 for i in range(0, len(first_verts)):
2684 # When there is Cyclic Cross there is no need of
2685 # Automatic Join, (and there are at least three strokes)
2686 if self.automatic_join and not self.cyclic_cross and \
2687 selection_type != "TWO_CONNECTED" and len(self.main_splines.data.splines) >= 3:
2688
2689 v = ob_ctrl_pts.data.vertices
2690 first_point_co = v[first_verts[i]].co
2691 second_point_co = v[second_verts[i]].co
2692 last_point_co = v[last_verts[i]].co
2693
2694 # Coordinates of the point in the center of both the first and last verts.
2695 verts_center_co = [
2696 (first_point_co[0] + last_point_co[0]) / 2,
2697 (first_point_co[1] + last_point_co[1]) / 2,
2698 (first_point_co[2] + last_point_co[2]) / 2
2699 ]
2700 vec_A = second_point_co - first_point_co
2701 vec_B = second_point_co - Vector(verts_center_co)
2702
2703 # Calculate the length of the first segment of the loop,
2704 # and the length it would have after moving the first vert
2705 # to the middle position between first and last
2706 length_original = (second_point_co - first_point_co).length
2707 length_target = (second_point_co - Vector(verts_center_co)).length
2708
2709 angle = vec_A.angle(vec_B) / pi
2710
2711 # If the target length doesn't stretch too much, and the
2712 # its angle doesn't change to much either
2713 if length_target <= length_original * 1.03 * self.join_stretch_factor and \
2714 angle <= 0.008 * self.join_stretch_factor and not self.selection_U_exists:
2715
2716 cyclic_loops_U.append(True)
2717 # Move the first vert to the center coordinates
2718 ob_ctrl_pts.data.vertices[first_verts[i]].co = verts_center_co
2719 # Select the last verts from Cyclic loops, for later deletion all at once
2720 v[last_verts[i]].select = True
2721 else:
2722 cyclic_loops_U.append(False)
2723 else:
2724 # If "Cyclic Cross" is active then "all" crossing curves become cyclic
2725 if self.cyclic_cross and not self.selection_U_exists and not \
2726 ((self.selection_V_exists and not self.selection_V_is_closed) or
2727 (self.selection_V2_exists and not self.selection_V2_is_closed)):
2728
2729 cyclic_loops_U.append(True)
2730 else:
2731 cyclic_loops_U.append(False)
2732
2733 # The cyclic_loops_U list needs to be reversed.
2734 cyclic_loops_U.reverse()
2735
2736 # Delete the previously selected (last_)verts.
2737 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2738 bpy.ops.mesh.delete('INVOKE_REGION_WIN', type='VERT')
2739 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2740
2741 # Create curves from control points.
2742 bpy.ops.object.convert('INVOKE_REGION_WIN', target='CURVE', keep_original=False)
2743 ob_curves_surf = bpy.context.view_layer.objects.active
2744 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2745 bpy.ops.curve.spline_type_set('INVOKE_REGION_WIN', type='BEZIER')
2746 bpy.ops.curve.handle_type_set('INVOKE_REGION_WIN', type='AUTOMATIC')
2747
2748 # Make Cyclic the splines designated as Cyclic.
2749 for i in range(0, len(cyclic_loops_U)):
2750 ob_curves_surf.data.splines[i].use_cyclic_u = cyclic_loops_U[i]
2751
2752 # Get the coords of all points on first loop-U, for later comparison with its
2753 # subdivided version, to know which points of the loops-U are crossed by the
2754 # original strokes. The indices will be the same for the other loops-U
2755 if self.loops_on_strokes:
2756 coords_loops_U_control_points = []
2757 for p in ob_ctrl_pts.data.splines[0].bezier_points:
2758 coords_loops_U_control_points.append(["%.4f" % p.co[0], "%.4f" % p.co[1], "%.4f" % p.co[2]])
2759
2760 tuple(coords_loops_U_control_points)
2761
2762 # Calculate number of edges-V in case option "Loops on strokes" is active or inactive
2763 if self.loops_on_strokes and not self.selection_V_exists:
2764 edges_V_count = len(self.main_splines.data.splines) * self.edges_V
2765 else:
2766 edges_V_count = len(edges_proportions_V)
2767
2768 # The Follow precision will vary depending on the number of Follow face-loops
2769 precision_multiplier = round(2 + (edges_V_count / 15))
2770 curve_cuts = bpy.context.scene.bsurfaces.SURFSK_precision * precision_multiplier
2771
2772 # Subdivide the curves
2773 bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=curve_cuts)
2774
2775 # The verts position shifting that happens with splines subdivision.
2776 # For later reorder splines points
2777 verts_position_shift = curve_cuts + 1
2778 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
2779
2780 # Reorder coordinates of the points of each spline to put the first point of
2781 # the spline starting at the position it was the first point before sudividing
2782 # the curve. And make a new curve object per spline (to handle memory better later)
2783 splines_U_objects = []
2784 for i in range(len(ob_curves_surf.data.splines)):
2785 spline_U_curve = bpy.data.curves.new('SURFSKIO_spline_U_' + str(i), 'CURVE')
2786 ob_spline_U = bpy.data.objects.new('SURFSKIO_spline_U_' + str(i), spline_U_curve)
2787 bpy.context.collection.objects.link(ob_spline_U)
2788
2789 spline_U_curve.dimensions = "3D"
2790
2791 # Add points to the spline in the new curve object
2792 ob_spline_U.data.splines.new('BEZIER')
2793 for t in range(len(ob_curves_surf.data.splines[i].bezier_points)):
2794 if cyclic_loops_U[i] is True and not self.selection_U_exists: # If the loop is cyclic
2795 if t + verts_position_shift <= len(ob_curves_surf.data.splines[i].bezier_points) - 1:
2796 point_index = t + verts_position_shift
2797 else:
2798 point_index = t + verts_position_shift - len(ob_curves_surf.data.splines[i].bezier_points)
2799 else:
2800 point_index = t
2801 # to avoid adding the first point since it's added when the spline is created
2802 if t > 0:
2803 ob_spline_U.data.splines[0].bezier_points.add(1)
2804 ob_spline_U.data.splines[0].bezier_points[t].co = \
2805 ob_curves_surf.data.splines[i].bezier_points[point_index].co
2806
2807 if cyclic_loops_U[i] is True and not self.selection_U_exists: # If the loop is cyclic
2808 # Add a last point at the same location as the first one
2809 ob_spline_U.data.splines[0].bezier_points.add(1)
2810 ob_spline_U.data.splines[0].bezier_points[len(ob_spline_U.data.splines[0].bezier_points) - 1].co = \
2811 ob_spline_U.data.splines[0].bezier_points[0].co
2812 else:
2813 ob_spline_U.data.splines[0].use_cyclic_u = False
2814
2815 splines_U_objects.append(ob_spline_U)
2816 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
2817 ob_spline_U.select_set(True)
2818 bpy.context.view_layer.objects.active = ob_spline_U
2819
2820 # When option "Loops on strokes" is active each "Cross" loop will have
2821 # its own proportions according to where the original strokes "touch" them
2822 if self.loops_on_strokes:
2823 # Get the indices of points where the original strokes "touch" loops-U
2824 points_U_crossed_by_strokes = []
2825 for i in range(len(splines_U_objects[0].data.splines[0].bezier_points)):
2826 bp = splines_U_objects[0].data.splines[0].bezier_points[i]
2827 if ["%.4f" % bp.co[0], "%.4f" % bp.co[1], "%.4f" % bp.co[2]] in coords_loops_U_control_points:
2828 points_U_crossed_by_strokes.append(i)
2829
2830 # Make a dictionary with the number of the edge, in the selected chain V, corresponding to each stroke
2831 edge_order_number_for_splines = {}
2832 if self.selection_V_exists:
2833 # For two-connected selections add a first hypothetic stroke at the beginning.
2834 if selection_type == "TWO_CONNECTED":
2835 edge_order_number_for_splines[0] = 0
2836
2837 for i in range(len(self.main_splines.data.splines)):
2838 sp = self.main_splines.data.splines[i]
2839 v_idx, _dist_temp = self.shortest_distance(
2840 self.main_object,
2841 sp.bezier_points[0].co,
2842 verts_ordered_V_indices
2843 )
2844 # Get the position (edges count) of the vert v_idx in the selected chain V
2845 edge_idx_in_chain = verts_ordered_V_indices.index(v_idx)
2846
2847 # For two-connected selections the strokes go after the
2848 # hypothetic stroke added before, so the index adds one per spline
2849 if selection_type == "TWO_CONNECTED":
2850 spline_number = i + 1
2851 else:
2852 spline_number = i
2853
2854 edge_order_number_for_splines[spline_number] = edge_idx_in_chain
2855
2856 # Get the first and last verts indices for later comparison
2857 if i == 0:
2858 first_v_idx = v_idx
2859 elif i == len(self.main_splines.data.splines) - 1:
2860 last_v_idx = v_idx
2861
2862 if self.selection_V_is_closed:
2863 # If there is no last stroke on the last vertex (same as first vertex),
2864 # add a hypothetic spline at last vert order
2865 if first_v_idx != last_v_idx:
2866 edge_order_number_for_splines[(len(self.main_splines.data.splines) - 1) + 1] = \
2867 len(verts_ordered_V_indices) - 1
2868 else:
2869 if self.cyclic_cross:
2870 edge_order_number_for_splines[len(self.main_splines.data.splines) - 1] = \
2871 len(verts_ordered_V_indices) - 2
2872 edge_order_number_for_splines[(len(self.main_splines.data.splines) - 1) + 1] = \
2873 len(verts_ordered_V_indices) - 1
2874 else:
2875 edge_order_number_for_splines[len(self.main_splines.data.splines) - 1] = \
2876 len(verts_ordered_V_indices) - 1
2877
2878 # Get the coords of the points distributed along the
2879 # "crossing curves", with appropriate proportions-V
2880 surface_splines_parsed = []
2881 for i in range(len(splines_U_objects)):
2882 sp_ob = splines_U_objects[i]
2883 # If "Loops on strokes" option is active, calculate the proportions for each loop-U
2884 if self.loops_on_strokes:
2885 # Segments distances from stroke to stroke
2886 dist = 0
2887 full_dist = 0
2888 segments_distances = []
2889 for t in range(len(sp_ob.data.splines[0].bezier_points)):
2890 bp = sp_ob.data.splines[0].bezier_points[t]
2891
2892 if t == 0:
2893 last_p = bp.co
2894 else:
2895 actual_p = bp.co
2896 dist += (last_p - actual_p).length
2897
2898 if t in points_U_crossed_by_strokes:
2899 segments_distances.append(dist)
2900 full_dist += dist
2901
2902 dist = 0
2903
2904 last_p = actual_p
2905
2906 # Calculate Proportions.
2907 used_edges_proportions_V = []
2908 for t in range(len(segments_distances)):
2909 if self.selection_V_exists:
2910 if t == 0:
2911 order_number_last_stroke = 0
2912
2913 segment_edges_length_V = 0
2914 segment_edges_length_V2 = 0
2915 for order in range(order_number_last_stroke, edge_order_number_for_splines[t + 1]):
2916 segment_edges_length_V += edges_lengths_V[order]
2917 if self.selection_V2_exists:
2918 segment_edges_length_V2 += edges_lengths_V2[order]
2919
2920 for order in range(order_number_last_stroke, edge_order_number_for_splines[t + 1]):
2921 # Calculate each "sub-segment" (the ones between each stroke) length
2922 if self.selection_V2_exists:
2923 proportion_sub_seg = (edges_lengths_V2[order] -
2924 ((edges_lengths_V2[order] - edges_lengths_V[order]) /
2925 len(splines_U_objects) * i)) / (segment_edges_length_V2 -
2926 (segment_edges_length_V2 - segment_edges_length_V) /
2927 len(splines_U_objects) * i)
2928
2929 sub_seg_dist = segments_distances[t] * proportion_sub_seg
2930 else:
2931 proportion_sub_seg = edges_lengths_V[order] / segment_edges_length_V
2932 sub_seg_dist = segments_distances[t] * proportion_sub_seg
2933
2934 used_edges_proportions_V.append(sub_seg_dist / full_dist)
2935
2936 order_number_last_stroke = edge_order_number_for_splines[t + 1]
2937
2938 else:
2939 for _c in range(self.edges_V):
2940 # Calculate each "sub-segment" (the ones between each stroke) length
2941 sub_seg_dist = segments_distances[t] / self.edges_V
2942 used_edges_proportions_V.append(sub_seg_dist / full_dist)
2943
2944 actual_spline = self.distribute_pts(sp_ob.data.splines, used_edges_proportions_V)
2945 surface_splines_parsed.append(actual_spline[0])
2946
2947 else:
2948 if self.selection_V2_exists:
2949 used_edges_proportions_V = []
2950 for p in range(len(edges_proportions_V)):
2951 used_edges_proportions_V.append(
2952 edges_proportions_V2[p] -
2953 ((edges_proportions_V2[p] -
2954 edges_proportions_V[p]) / len(splines_U_objects) * i)
2955 )
2956 else:
2957 used_edges_proportions_V = edges_proportions_V
2958
2959 actual_spline = self.distribute_pts(sp_ob.data.splines, used_edges_proportions_V)
2960 surface_splines_parsed.append(actual_spline[0])
2961
2962 # Set the verts of the first and last splines to the locations
2963 # of the respective verts in the selections
2964 if self.selection_V_exists:
2965 for i in range(0, len(surface_splines_parsed[0])):
2966 surface_splines_parsed[len(surface_splines_parsed) - 1][i] = \
2967 self.main_object.matrix_world @ verts_ordered_V[i].co
2968
2969 if selection_type == "TWO_NOT_CONNECTED":
2970 if self.selection_V2_exists:
2971 for i in range(0, len(surface_splines_parsed[0])):
2972 surface_splines_parsed[0][i] = self.main_object.matrix_world @ verts_ordered_V2[i].co
2973
2974 # When "Automatic join" option is active (and the selection type != "TWO_CONNECTED"),
2975 # merge the verts of the tips of the loops when they are "near enough"
2976 if self.automatic_join and selection_type != "TWO_CONNECTED":
2977 # Join the tips of "Follow" loops that are near enough and must be "closed"
2978 if not self.selection_V_exists and len(edges_proportions_U) >= 3:
2979 for i in range(len(surface_splines_parsed[0])):
2980 sp = surface_splines_parsed
2981 loop_segment_dist = (sp[0][i] - sp[1][i]).length
2982
2983 verts_middle_position_co = [
2984 (sp[0][i][0] + sp[len(sp) - 1][i][0]) / 2,
2985 (sp[0][i][1] + sp[len(sp) - 1][i][1]) / 2,
2986 (sp[0][i][2] + sp[len(sp) - 1][i][2]) / 2
2987 ]
2988 points_original = []
2989 points_original.append(sp[1][i])
2990 points_original.append(sp[0][i])
2991
2992 points_target = []
2993 points_target.append(sp[1][i])
2994 points_target.append(Vector(verts_middle_position_co))
2995
2996 vec_A = points_original[0] - points_original[1]
2997 vec_B = points_target[0] - points_target[1]
2998 # check for zero angles, not sure if it is a great fix
2999 if vec_A.length != 0 and vec_B.length != 0:
3000 angle = vec_A.angle(vec_B) / pi
3001 edge_new_length = (Vector(verts_middle_position_co) - sp[1][i]).length
3002 else:
3003 angle = 0
3004 edge_new_length = 0
3005
3006 # If after moving the verts to the middle point, the segment doesn't stretch too much
3007 if edge_new_length <= loop_segment_dist * 1.5 * \
3008 self.join_stretch_factor and angle < 0.25 * self.join_stretch_factor:
3009
3010 # Avoid joining when the actual loop must be merged with the original mesh
3011 if not (self.selection_U_exists and i == 0) and \
3012 not (self.selection_U2_exists and i == len(surface_splines_parsed[0]) - 1):
3013
3014 # Change the coords of both verts to the middle position
3015 surface_splines_parsed[0][i] = verts_middle_position_co
3016 surface_splines_parsed[len(surface_splines_parsed) - 1][i] = verts_middle_position_co
3017
3018 # Delete object with control points and object from grease pencil conversion
3019 bpy.ops.object.delete({"selected_objects": [ob_ctrl_pts]})
3020
3021 bpy.ops.object.delete({"selected_objects": splines_U_objects})
3022
3023 # Generate surface
3024
3025 # Get all verts coords
3026 all_surface_verts_co = []
3027 for i in range(0, len(surface_splines_parsed)):
3028 # Get coords of all verts and make a list with them
3029 for pt_co in surface_splines_parsed[i]:
3030 all_surface_verts_co.append(pt_co)
3031
3032 # Define verts for each face
3033 all_surface_faces = []
3034 for i in range(0, len(all_surface_verts_co) - len(surface_splines_parsed[0])):
3035 if ((i + 1) / len(surface_splines_parsed[0]) != int((i + 1) / len(surface_splines_parsed[0]))):
3036 all_surface_faces.append(
3037 [i + 1, i, i + len(surface_splines_parsed[0]),
3038 i + len(surface_splines_parsed[0]) + 1]
3039 )
3040 # Build the mesh
3041 surf_me_name = "SURFSKIO_surface"
3042 me_surf = bpy.data.meshes.new(surf_me_name)
3043 me_surf.from_pydata(all_surface_verts_co, [], all_surface_faces)
3044 ob_surface = object_utils.object_data_add(context, me_surf)
3045 ob_surface.location = (0.0, 0.0, 0.0)
3046 ob_surface.rotation_euler = (0.0, 0.0, 0.0)
3047 ob_surface.scale = (1.0, 1.0, 1.0)
3048
3049 # Select all the "unselected but participating" verts, from closed selection
3050 # or double selections with middle-vertex, for later join with remove doubles
3051 for v_idx in single_unselected_verts:
3052 self.main_object.data.vertices[v_idx].select = True
3053
3054 # Join the new mesh to the main object
3055 ob_surface.select_set(True)
3056 self.main_object.select_set(True)
3057 bpy.context.view_layer.objects.active = self.main_object
3058
3059 bpy.ops.object.join('INVOKE_REGION_WIN')
3060
3061 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3062
3063 bpy.ops.mesh.remove_doubles('INVOKE_REGION_WIN', threshold=0.0001)
3064 bpy.ops.mesh.normals_make_consistent('INVOKE_REGION_WIN', inside=False)
3065 bpy.ops.mesh.select_all('INVOKE_REGION_WIN', action='DESELECT')
3066
3067 self.update()
3068
3069 return{'FINISHED'}
3070
3071 def update(self):
3072 try:
3073 global global_shade_smooth
3074 if global_shade_smooth:
3075 bpy.ops.object.shade_smooth()
3076 else:
3077 bpy.ops.object.shade_flat()
3078 bpy.context.scene.bsurfaces.SURFSK_shade_smooth = global_shade_smooth
3079 except:
3080 pass
3081
3082 return{'FINISHED'}
3083
3084 def execute(self, context):
3085
3086 if bpy.ops.object.mode_set.poll():
3087 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3088
3089 try:
3090 global global_mesh_object
3091 global_mesh_object = bpy.context.scene.bsurfaces.SURFSK_mesh.name
3092 bpy.data.objects[global_mesh_object].select_set(True)
3093 self.main_object = bpy.data.objects[global_mesh_object]
3094 bpy.context.view_layer.objects.active = self.main_object
3095 bsurfaces_props = bpy.context.scene.bsurfaces
3096 except:
3097 self.report({'WARNING'}, "Specify the name of the object with retopology")
3098 return{"CANCELLED"}
3099 bpy.context.view_layer.objects.active = self.main_object
3100
3101 self.update()
3102
3103 if not self.is_fill_faces:
3104 bpy.ops.wm.context_set_value(data_path='tool_settings.mesh_select_mode',
3105 value='True, False, False')
3106
3107 # Build splines from the "last saved splines".
3108 last_saved_curve = bpy.data.curves.new('SURFSKIO_last_crv', 'CURVE')
3109 self.main_splines = bpy.data.objects.new('SURFSKIO_last_crv', last_saved_curve)
3110 bpy.context.collection.objects.link(self.main_splines)
3111
3112 last_saved_curve.dimensions = "3D"
3113
3114 for sp in self.last_strokes_splines_coords:
3115 spline = self.main_splines.data.splines.new('BEZIER')
3116 # less one because one point is added when the spline is created
3117 spline.bezier_points.add(len(sp) - 1)
3118 for p in range(0, len(sp)):
3119 spline.bezier_points[p].co = [sp[p][0], sp[p][1], sp[p][2]]
3120
3121 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3122
3123 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3124 self.main_splines.select_set(True)
3125 bpy.context.view_layer.objects.active = self.main_splines
3126
3127 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT')
3128
3129 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='SELECT')
3130 # Important to make it vector first and then automatic, otherwise the
3131 # tips handles get too big and distort the shrinkwrap results later
3132 bpy.ops.curve.handle_type_set(type='VECTOR')
3133 bpy.ops.curve.handle_type_set('INVOKE_REGION_WIN', type='AUTOMATIC')
3134 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
3135 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3136
3137 self.main_splines.name = "SURFSKIO_temp_strokes"
3138
3139 if self.is_crosshatch:
3140 strokes_for_crosshatch = True
3141 strokes_for_rectangular_surface = False
3142 else:
3143 strokes_for_rectangular_surface = True
3144 strokes_for_crosshatch = False
3145
3146 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3147
3148 if strokes_for_rectangular_surface:
3149 self.rectangular_surface(context)
3150 elif strokes_for_crosshatch:
3151 self.crosshatch_surface_execute(context)
3152
3153 #Set Shade smooth to new polygons
3154 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3155 global global_shade_smooth
3156 if global_shade_smooth:
3157 bpy.ops.object.shade_smooth()
3158 else:
3159 bpy.ops.object.shade_flat()
3160
3161 # Delete main splines
3162 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3163 if self.keep_strokes:
3164 self.main_splines.name = "keep_strokes"
3165 self.main_splines.data.bevel_depth = 0.001
3166 if "keep_strokes_material" in bpy.data.materials :
3167 self.main_splines.data.materials.append(bpy.data.materials["keep_strokes_material"])
3168 else:
3169 mat = bpy.data.materials.new("keep_strokes_material")
3170 mat.diffuse_color = (1, 0, 0, 0)
3171 mat.specular_color = (1, 0, 0)
3172 mat.specular_intensity = 0.0
3173 mat.roughness = 0.0
3174 self.main_splines.data.materials.append(mat)
3175 else:
3176 bpy.ops.object.delete({"selected_objects": [self.main_splines]})
3177
3178 # Delete grease pencil strokes
3179 if self.strokes_type == "GP_STROKES" and not self.stopping_errors:
3180 try:
3181 bpy.context.scene.bsurfaces.SURFSK_gpencil.data.layers.active.clear()
3182 except:
3183 pass
3184
3185 # Delete annotations
3186 if self.strokes_type == "GP_ANNOTATION" and not self.stopping_errors:
3187 try:
3188 bpy.context.annotation_data.layers.active.clear()
3189 except:
3190 pass
3191
3192 bsurfaces_props = bpy.context.scene.bsurfaces
3193 bsurfaces_props.SURFSK_edges_U = self.edges_U
3194 bsurfaces_props.SURFSK_edges_V = self.edges_V
3195 bsurfaces_props.SURFSK_cyclic_cross = self.cyclic_cross
3196 bsurfaces_props.SURFSK_cyclic_follow = self.cyclic_follow
3197 bsurfaces_props.SURFSK_automatic_join = self.automatic_join
3198 bsurfaces_props.SURFSK_loops_on_strokes = self.loops_on_strokes
3199 bsurfaces_props.SURFSK_keep_strokes = self.keep_strokes
3200
3201 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3202 self.main_object.select_set(True)
3203 bpy.context.view_layer.objects.active = self.main_object
3204
3205 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3206
3207 self.update()
3208
3209 return{'FINISHED'}
3210
3211 def invoke(self, context, event):
3212
3213 if bpy.ops.object.mode_set.poll():
3214 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3215
3216 bsurfaces_props = bpy.context.scene.bsurfaces
3217 self.cyclic_cross = bsurfaces_props.SURFSK_cyclic_cross
3218 self.cyclic_follow = bsurfaces_props.SURFSK_cyclic_follow
3219 self.automatic_join = bsurfaces_props.SURFSK_automatic_join
3220 self.loops_on_strokes = bsurfaces_props.SURFSK_loops_on_strokes
3221 self.keep_strokes = bsurfaces_props.SURFSK_keep_strokes
3222
3223 try:
3224 global global_mesh_object
3225 global_mesh_object = bpy.context.scene.bsurfaces.SURFSK_mesh.name
3226 bpy.data.objects[global_mesh_object].select_set(True)
3227 self.main_object = bpy.data.objects[global_mesh_object]
3228 bpy.context.view_layer.objects.active = self.main_object
3229 except:
3230 self.report({'WARNING'}, "Specify the name of the object with retopology")
3231 return{"CANCELLED"}
3232
3233 self.update()
3234
3235 self.main_object_selected_verts_count = len([v for v in self.main_object.data.vertices if v.select])
3236
3237 bpy.ops.wm.context_set_value(data_path='tool_settings.mesh_select_mode',
3238 value='True, False, False')
3239
3240 self.edges_U = bsurfaces_props.SURFSK_edges_U
3241 self.edges_V = bsurfaces_props.SURFSK_edges_V
3242
3243 self.is_fill_faces = False
3244 self.stopping_errors = False
3245 self.last_strokes_splines_coords = []
3246
3247 # Determine the type of the strokes
3248 self.strokes_type = get_strokes_type(context)
3249
3250 # Check if it will be used grease pencil strokes or curves
3251 # If there are strokes to be used
3252 if self.strokes_type == "GP_STROKES" or self.strokes_type == "EXTERNAL_CURVE" or self.strokes_type == "GP_ANNOTATION":
3253 if self.strokes_type == "GP_STROKES":
3254 # Convert grease pencil strokes to curve
3255 global global_gpencil_object
3256 gp = bpy.data.objects[global_gpencil_object]
3257 self.original_curve = conver_gpencil_to_curve(self, context, gp, 'GPensil')
3258 self.using_external_curves = False
3259
3260 elif self.strokes_type == "GP_ANNOTATION":
3261 # Convert grease pencil strokes to curve
3262 gp = bpy.context.annotation_data
3263 self.original_curve = conver_gpencil_to_curve(self, context, gp, 'Annotation')
3264 self.using_external_curves = False
3265
3266 elif self.strokes_type == "EXTERNAL_CURVE":
3267 global global_curve_object
3268 self.original_curve = bpy.data.objects[global_curve_object]
3269 self.using_external_curves = True
3270
3271 # Make sure there are no objects left from erroneous
3272 # executions of this operator, with the reserved names used here
3273 for o in bpy.data.objects:
3274 if o.name.find("SURFSKIO_") != -1:
3275 bpy.ops.object.delete({"selected_objects": [o]})
3276
3277 bpy.context.view_layer.objects.active = self.original_curve
3278
3279 bpy.ops.object.duplicate('INVOKE_REGION_WIN')
3280
3281 self.temporary_curve = bpy.context.view_layer.objects.active
3282
3283 # Deselect all points of the curve
3284 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3285 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
3286 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3287
3288 # Delete splines with only a single isolated point
3289 for i in range(len(self.temporary_curve.data.splines)):
3290 sp = self.temporary_curve.data.splines[i]
3291
3292 if len(sp.bezier_points) == 1:
3293 sp.bezier_points[0].select_control_point = True
3294
3295 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3296 bpy.ops.curve.delete(type='VERT')
3297 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3298
3299 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3300 self.temporary_curve.select_set(True)
3301 bpy.context.view_layer.objects.active = self.temporary_curve
3302
3303 # Set a minimum number of points for crosshatch
3304 minimum_points_num = 15
3305
3306 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3307 # Check if the number of points of each curve has at least the number of points
3308 # of minimum_points_num, which is a bit more than the face-loops limit.
3309 # If not, subdivide to reach at least that number of points
3310 for i in range(len(self.temporary_curve.data.splines)):
3311 sp = self.temporary_curve.data.splines[i]
3312
3313 if len(sp.bezier_points) < minimum_points_num:
3314 for bp in sp.bezier_points:
3315 bp.select_control_point = True
3316
3317 if (len(sp.bezier_points) - 1) != 0:
3318 # Formula to get the number of cuts that will make a curve
3319 # of N number of points have near to "minimum_points_num"
3320 # points, when subdividing with this number of cuts
3321 subdivide_cuts = int(
3322 (minimum_points_num - len(sp.bezier_points)) /
3323 (len(sp.bezier_points) - 1)
3324 ) + 1
3325 else:
3326 subdivide_cuts = 0
3327
3328 bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=subdivide_cuts)
3329 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
3330
3331 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3332
3333 # Detect if the strokes are a crosshatch and do it if it is
3334 self.crosshatch_surface_invoke(self.temporary_curve)
3335
3336 if not self.is_crosshatch:
3337 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3338 self.temporary_curve.select_set(True)
3339 bpy.context.view_layer.objects.active = self.temporary_curve
3340
3341 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3342
3343 # Set a minimum number of points for rectangular surfaces
3344 minimum_points_num = 60
3345
3346 # Check if the number of points of each curve has at least the number of points
3347 # of minimum_points_num, which is a bit more than the face-loops limit.
3348 # If not, subdivide to reach at least that number of points
3349 for i in range(len(self.temporary_curve.data.splines)):
3350 sp = self.temporary_curve.data.splines[i]
3351
3352 if len(sp.bezier_points) < minimum_points_num:
3353 for bp in sp.bezier_points:
3354 bp.select_control_point = True
3355
3356 if (len(sp.bezier_points) - 1) != 0:
3357 # Formula to get the number of cuts that will make a curve of
3358 # N number of points have near to "minimum_points_num" points,
3359 # when subdividing with this number of cuts
3360 subdivide_cuts = int(
3361 (minimum_points_num - len(sp.bezier_points)) /
3362 (len(sp.bezier_points) - 1)
3363 ) + 1
3364 else:
3365 subdivide_cuts = 0
3366
3367 bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=subdivide_cuts)
3368 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
3369
3370 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3371
3372 # Save coordinates of the actual strokes (as the "last saved splines")
3373 for sp_idx in range(len(self.temporary_curve.data.splines)):
3374 self.last_strokes_splines_coords.append([])
3375 for bp_idx in range(len(self.temporary_curve.data.splines[sp_idx].bezier_points)):
3376 coords = self.temporary_curve.matrix_world @ \
3377 self.temporary_curve.data.splines[sp_idx].bezier_points[bp_idx].co
3378 self.last_strokes_splines_coords[sp_idx].append([coords[0], coords[1], coords[2]])
3379
3380 # Check for cyclic splines, put the first and last points in the middle of their actual positions
3381 for sp_idx in range(len(self.temporary_curve.data.splines)):
3382 if self.temporary_curve.data.splines[sp_idx].use_cyclic_u is True:
3383 first_p_co = self.last_strokes_splines_coords[sp_idx][0]
3384 last_p_co = self.last_strokes_splines_coords[sp_idx][
3385 len(self.last_strokes_splines_coords[sp_idx]) - 1
3386 ]
3387 target_co = [
3388 (first_p_co[0] + last_p_co[0]) / 2,
3389 (first_p_co[1] + last_p_co[1]) / 2,
3390 (first_p_co[2] + last_p_co[2]) / 2
3391 ]
3392
3393 self.last_strokes_splines_coords[sp_idx][0] = target_co
3394 self.last_strokes_splines_coords[sp_idx][
3395 len(self.last_strokes_splines_coords[sp_idx]) - 1
3396 ] = target_co
3397 tuple(self.last_strokes_splines_coords)
3398
3399 # Estimation of the average length of the segments between
3400 # each point of the grease pencil strokes.
3401 # Will be useful to determine whether a curve should be made "Cyclic"
3402 segments_lengths_sum = 0
3403 segments_count = 0
3404 random_spline = self.temporary_curve.data.splines[0].bezier_points
3405 for i in range(0, len(random_spline)):
3406 if i != 0 and len(random_spline) - 1 >= i:
3407 segments_lengths_sum += (random_spline[i - 1].co - random_spline[i].co).length
3408 segments_count += 1
3409
3410 self.average_gp_segment_length = segments_lengths_sum / segments_count
3411
3412 # Delete temporary strokes curve object
3413 bpy.ops.object.delete({"selected_objects": [self.temporary_curve]})
3414
3415 # Set again since "execute()" will turn it again to its initial value
3416 self.execute(context)
3417
3418 if not self.stopping_errors:
3419 # Delete grease pencil strokes
3420 if self.strokes_type == "GP_STROKES":
3421 try:
3422 bpy.context.scene.bsurfaces.SURFSK_gpencil.data.layers.active.clear()
3423 except:
3424 pass
3425
3426 # Delete annotation strokes
3427 elif self.strokes_type == "GP_ANNOTATION":
3428 try:
3429 bpy.context.annotation_data.layers.active.clear()
3430 except:
3431 pass
3432
3433 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3434 bpy.ops.object.delete({"selected_objects": [self.original_curve]})
3435 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3436
3437 return {"FINISHED"}
3438 else:
3439 return{"CANCELLED"}
3440
3441 elif self.strokes_type == "SELECTION_ALONE":
3442 self.is_fill_faces = True
3443 created_faces_count = self.fill_with_faces(self.main_object)
3444
3445 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3446
3447 if created_faces_count == 0:
3448 self.report({'WARNING'}, "There aren't any strokes attached to the object")
3449 return {"CANCELLED"}
3450 else:
3451 return {"FINISHED"}
3452
3453 if self.strokes_type == "EXTERNAL_NO_CURVE":
3454 self.report({'WARNING'}, "The secondary object is not a Curve.")
3455 return{"CANCELLED"}
3456
3457 elif self.strokes_type == "MORE_THAN_ONE_EXTERNAL":
3458 self.report({'WARNING'}, "There shouldn't be more than one secondary object selected.")
3459 return{"CANCELLED"}
3460
3461 elif self.strokes_type == "SINGLE_GP_STROKE_NO_SELECTION" or \
3462 self.strokes_type == "SINGLE_CURVE_STROKE_NO_SELECTION":
3463
3464 self.report({'WARNING'}, "It's needed at least one stroke and one selection, or two strokes.")
3465 return{"CANCELLED"}
3466
3467 elif self.strokes_type == "NO_STROKES":
3468 self.report({'WARNING'}, "There aren't any strokes attached to the object")
3469 return{"CANCELLED"}
3470
3471 elif self.strokes_type == "CURVE_WITH_NON_BEZIER_SPLINES":
3472 self.report({'WARNING'}, "All splines must be Bezier.")
3473 return{"CANCELLED"}
3474
3475 else:
3476 return{"CANCELLED"}
3477
3478 # ----------------------------
3479 # Init operator
3480 class MESH_OT_SURFSK_init(Operator):
3481 bl_idname = "mesh.surfsk_init"
3482 bl_label = "Bsurfaces initialize"
3483 bl_description = "Add an empty mesh object with useful settings"
3484 bl_options = {'REGISTER', 'UNDO'}
3485
3486 def execute(self, context):
3487
3488 bs = bpy.context.scene.bsurfaces
3489
3490 if bpy.ops.object.mode_set.poll():
3491 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3492
3493 global global_shade_smooth
3494 global global_mesh_object
3495 global global_gpencil_object
3496
3497 if bs.SURFSK_mesh == None:
3498 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3499 mesh = bpy.data.meshes.new('BSurfaceMesh')
3500 mesh_object = object_utils.object_data_add(context, mesh)
3501 mesh_object.select_set(True)
3502 bpy.context.view_layer.objects.active = mesh_object
3503
3504 mesh_object.show_all_edges = True
3505 mesh_object.display_type = 'SOLID'
3506 mesh_object.show_wire = True
3507
3508 global_shade_smooth = bpy.context.scene.bsurfaces.SURFSK_shade_smooth
3509 if global_shade_smooth:
3510 bpy.ops.object.shade_smooth()
3511 else:
3512 bpy.ops.object.shade_flat()
3513
3514 color_red = [1.0, 0.0, 0.0, 0.3]
3515 material = makeMaterial("BSurfaceMesh", color_red)
3516 mesh_object.data.materials.append(material)
3517 bpy.ops.object.modifier_add(type='SHRINKWRAP')
3518 modifier = mesh_object.modifiers["Shrinkwrap"]
3519 if self.active_object is not None:
3520 modifier.target = self.active_object
3521 modifier.wrap_method = 'TARGET_PROJECT'
3522 modifier.wrap_mode = 'OUTSIDE_SURFACE'
3523 modifier.show_on_cage = True
3524
3525 global_mesh_object = mesh_object.name
3526 bpy.context.scene.bsurfaces.SURFSK_mesh = bpy.data.objects[global_mesh_object]
3527
3528 bpy.context.scene.tool_settings.snap_elements = {'FACE'}
3529 bpy.context.scene.tool_settings.use_snap = True
3530 bpy.context.scene.tool_settings.use_snap_self = False
3531 bpy.context.scene.tool_settings.use_snap_align_rotation = True
3532 bpy.context.scene.tool_settings.use_snap_project = True
3533 bpy.context.scene.tool_settings.use_snap_rotate = True
3534 bpy.context.scene.tool_settings.use_snap_scale = True
3535
3536 bpy.context.scene.tool_settings.use_mesh_automerge = True
3537 bpy.context.scene.tool_settings.double_threshold = 0.01
3538
3539 if context.scene.bsurfaces.SURFSK_guide == 'GPencil' and bs.SURFSK_gpencil == None:
3540 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3541 bpy.ops.object.gpencil_add(radius=1.0, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), type='EMPTY')
3542 bpy.context.scene.tool_settings.gpencil_stroke_placement_view3d = 'SURFACE'
3543 gpencil_object = bpy.context.scene.objects[bpy.context.scene.objects[-1].name]
3544 gpencil_object.select_set(True)
3545 bpy.context.view_layer.objects.active = gpencil_object
3546 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='PAINT_GPENCIL')
3547 global_gpencil_object = gpencil_object.name
3548 bpy.context.scene.bsurfaces.SURFSK_gpencil = bpy.data.objects[global_gpencil_object]
3549 gpencil_object.data.stroke_depth_order = '3D'
3550 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='PAINT_GPENCIL')
3551 bpy.ops.wm.tool_set_by_id(name="builtin_brush.Draw")
3552
3553 if context.scene.bsurfaces.SURFSK_guide == 'Annotation':
3554 bpy.ops.wm.tool_set_by_id(name="builtin.annotate")
3555 bpy.context.scene.tool_settings.annotation_stroke_placement_view3d = 'SURFACE'
3556
3557 def invoke(self, context, event):
3558 if bpy.context.active_object:
3559 self.active_object = bpy.context.active_object
3560 else:
3561 self.active_object = None
3562
3563 self.execute(context)
3564
3565 return {"FINISHED"}
3566
3567 # ----------------------------
3568 # Add modifiers operator
3569 class MESH_OT_SURFSK_add_modifiers(Operator):
3570 bl_idname = "mesh.surfsk_add_modifiers"
3571 bl_label = "Add Mirror and others modifiers"
3572 bl_description = "Add modifiers: Mirror, Shrinkwrap, Subdivision, Solidify"
3573 bl_options = {'REGISTER', 'UNDO'}
3574
3575 def execute(self, context):
3576
3577 bs = bpy.context.scene.bsurfaces
3578
3579 if bpy.ops.object.mode_set.poll():
3580 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3581
3582 if bs.SURFSK_mesh == None:
3583 self.report({'ERROR_INVALID_INPUT'}, "Please select Mesh of BSurface or click Initialize")
3584 else:
3585 mesh_object = bs.SURFSK_mesh
3586
3587 try:
3588 mesh_object.select_set(True)
3589 except:
3590 self.report({'ERROR_INVALID_INPUT'}, "Mesh of BSurface does not exist")
3591 return {"CANCEL"}
3592
3593 bpy.context.view_layer.objects.active = mesh_object
3594
3595 try:
3596 shrinkwrap = mesh_object.modifiers["Shrinkwrap"]
3597 if self.active_object is not None and self.active_object != mesh_object:
3598 shrinkwrap.target = self.active_object
3599 shrinkwrap.wrap_method = 'TARGET_PROJECT'
3600 shrinkwrap.wrap_mode = 'OUTSIDE_SURFACE'
3601 shrinkwrap.show_on_cage = True
3602 shrinkwrap.offset = bpy.context.scene.bsurfaces.SURFSK_Shrinkwrap_offset
3603 except:
3604 bpy.ops.object.modifier_add(type='SHRINKWRAP')
3605 shrinkwrap = mesh_object.modifiers["Shrinkwrap"]
3606 if self.active_object is not None and self.active_object != mesh_object:
3607 shrinkwrap.target = self.active_object
3608 shrinkwrap.wrap_method = 'TARGET_PROJECT'
3609 shrinkwrap.wrap_mode = 'OUTSIDE_SURFACE'
3610 shrinkwrap.show_on_cage = True
3611 shrinkwrap.offset = bpy.context.scene.bsurfaces.SURFSK_Shrinkwrap_offset
3612
3613 try:
3614 mirror = mesh_object.modifiers["Mirror"]
3615 mirror.use_clip = True
3616 except:
3617 bpy.ops.object.modifier_add(type='MIRROR')
3618 mirror = mesh_object.modifiers["Mirror"]
3619 mirror.use_clip = True
3620
3621 try:
3622 _subsurf = mesh_object.modifiers["Subdivision"]
3623 except:
3624 bpy.ops.object.modifier_add(type='SUBSURF')
3625 _subsurf = mesh_object.modifiers["Subdivision"]
3626
3627 try:
3628 solidify = mesh_object.modifiers["Solidify"]
3629 solidify.thickness = 0.01
3630 except:
3631 bpy.ops.object.modifier_add(type='SOLIDIFY')
3632 solidify = mesh_object.modifiers["Solidify"]
3633 solidify.thickness = 0.01
3634
3635 return {"FINISHED"}
3636
3637 def invoke(self, context, event):
3638 if bpy.context.active_object:
3639 self.active_object = bpy.context.active_object
3640 else:
3641 self.active_object = None
3642
3643 self.execute(context)
3644
3645 return {"FINISHED"}
3646
3647 # ----------------------------
3648 # Edit surface operator
3649 class MESH_OT_SURFSK_edit_surface(Operator):
3650 bl_idname = "mesh.surfsk_edit_surface"
3651 bl_label = "Bsurfaces edit surface"
3652 bl_description = "Edit surface mesh"
3653 bl_options = {'REGISTER', 'UNDO'}
3654
3655 def execute(self, context):
3656 if bpy.ops.object.mode_set.poll():
3657 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3658 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3659 bpy.context.scene.bsurfaces.SURFSK_mesh.select_set(True)
3660 bpy.context.view_layer.objects.active = bpy.context.scene.bsurfaces.SURFSK_mesh
3661 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT')
3662 bpy.ops.wm.tool_set_by_id(name="builtin.select")
3663
3664 def invoke(self, context, event):
3665 try:
3666 global_mesh_object = bpy.context.scene.bsurfaces.SURFSK_mesh.name
3667 bpy.data.objects[global_mesh_object].select_set(True)
3668 self.main_object = bpy.data.objects[global_mesh_object]
3669 bpy.context.view_layer.objects.active = self.main_object
3670 except:
3671 self.report({'WARNING'}, "Specify the name of the object with retopology")
3672 return{"CANCELLED"}
3673
3674 self.execute(context)
3675
3676 return {"FINISHED"}
3677
3678 # ----------------------------
3679 # Add strokes operator
3680 class GPENCIL_OT_SURFSK_add_strokes(Operator):
3681 bl_idname = "gpencil.surfsk_add_strokes"
3682 bl_label = "Bsurfaces add strokes"
3683 bl_description = "Add the grease pencil strokes"
3684 bl_options = {'REGISTER', 'UNDO'}
3685
3686 def execute(self, context):
3687 if bpy.ops.object.mode_set.poll():
3688 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3689 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3690
3691 bpy.context.scene.bsurfaces.SURFSK_gpencil.select_set(True)
3692 bpy.context.view_layer.objects.active = bpy.context.scene.bsurfaces.SURFSK_gpencil
3693 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='PAINT_GPENCIL')
3694 bpy.ops.wm.tool_set_by_id(name="builtin_brush.Draw")
3695
3696 return{"FINISHED"}
3697
3698 def invoke(self, context, event):
3699 try:
3700 bpy.context.scene.bsurfaces.SURFSK_gpencil.select_set(True)
3701 except:
3702 self.report({'WARNING'}, "Specify the name of the object with strokes")
3703 return{"CANCELLED"}
3704
3705 self.execute(context)
3706
3707 return {"FINISHED"}
3708
3709 # ----------------------------
3710 # Edit strokes operator
3711 class GPENCIL_OT_SURFSK_edit_strokes(Operator):
3712 bl_idname = "gpencil.surfsk_edit_strokes"
3713 bl_label = "Bsurfaces edit strokes"
3714 bl_description = "Edit the grease pencil strokes"
3715 bl_options = {'REGISTER', 'UNDO'}
3716
3717 def execute(self, context):
3718 if bpy.ops.object.mode_set.poll():
3719 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3720 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3721
3722 gpencil_object = bpy.context.scene.bsurfaces.SURFSK_gpencil
3723
3724 gpencil_object.select_set(True)
3725 bpy.context.view_layer.objects.active = gpencil_object
3726
3727 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT_GPENCIL')
3728 try:
3729 bpy.ops.gpencil.select_all(action='SELECT')
3730 except:
3731 pass
3732
3733 def invoke(self, context, event):
3734 try:
3735 bpy.context.scene.bsurfaces.SURFSK_gpencil.select_set(True)
3736 except:
3737 self.report({'WARNING'}, "Specify the name of the object with strokes")
3738 return{"CANCELLED"}
3739
3740 self.execute(context)
3741
3742 return {"FINISHED"}
3743
3744 # ----------------------------
3745 # Convert annotation to curves operator
3746 class GPENCIL_OT_SURFSK_annotation_to_curves(Operator):
3747 bl_idname = "gpencil.surfsk_annotations_to_curves"
3748 bl_label = "Convert annotation to curves"
3749 bl_description = "Convert annotation to curves for editing"
3750 bl_options = {'REGISTER', 'UNDO'}
3751
3752 def execute(self, context):
3753
3754 if bpy.ops.object.mode_set.poll():
3755 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3756
3757 # Convert annotation to curve
3758 curve = conver_gpencil_to_curve(self, context, None, 'Annotation')
3759
3760 if curve != None:
3761 # Delete annotation strokes
3762 try:
3763 bpy.context.annotation_data.layers.active.clear()
3764 except:
3765 pass
3766
3767 # Clean up curves
3768 curve.select_set(True)
3769 bpy.context.view_layer.objects.active = curve
3770
3771 bpy.ops.wm.tool_set_by_id(name="builtin.select_box")
3772
3773 return {"FINISHED"}
3774
3775 def invoke(self, context, event):
3776 try:
3777 strokes = bpy.context.annotation_data.layers.active.active_frame.strokes
3778
3779 _strokes_num = len(strokes)
3780 except:
3781 self.report({'WARNING'}, "Not active annotation")
3782 return{"CANCELLED"}
3783
3784 self.execute(context)
3785
3786 return {"FINISHED"}
3787
3788 # ----------------------------
3789 # Convert strokes to curves operator
3790 class GPENCIL_OT_SURFSK_strokes_to_curves(Operator):
3791 bl_idname = "gpencil.surfsk_strokes_to_curves"
3792 bl_label = "Convert strokes to curves"
3793 bl_description = "Convert grease pencil strokes to curves for editing"
3794 bl_options = {'REGISTER', 'UNDO'}
3795
3796 def execute(self, context):
3797
3798 if bpy.ops.object.mode_set.poll():
3799 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3800
3801 # Convert grease pencil strokes to curve
3802 gp = bpy.context.scene.bsurfaces.SURFSK_gpencil
3803 curve = conver_gpencil_to_curve(self, context, gp, 'GPensil')
3804
3805 if curve != None:
3806 # Delete grease pencil strokes
3807 try:
3808 bpy.context.scene.bsurfaces.SURFSK_gpencil.data.layers.active.clear()
3809 except:
3810 pass
3811
3812 # Clean up curves
3813
3814 curve.select_set(True)
3815 bpy.context.view_layer.objects.active = curve
3816
3817 bpy.ops.wm.tool_set_by_id(name="builtin.select_box")
3818
3819 return {"FINISHED"}
3820
3821 def invoke(self, context, event):
3822 try:
3823 bpy.context.scene.bsurfaces.SURFSK_gpencil.select_set(True)
3824 except:
3825 self.report({'WARNING'}, "Specify the name of the object with strokes")
3826 return{"CANCELLED"}
3827
3828 self.execute(context)
3829
3830 return {"FINISHED"}
3831
3832 # ----------------------------
3833 # Add annotation
3834 class GPENCIL_OT_SURFSK_add_annotation(Operator):
3835 bl_idname = "gpencil.surfsk_add_annotation"
3836 bl_label = "Bsurfaces add annotation"
3837 bl_description = "Add annotation"
3838 bl_options = {'REGISTER', 'UNDO'}
3839
3840 def execute(self, context):
3841 bpy.ops.wm.tool_set_by_id(name="builtin.annotate")
3842 bpy.context.scene.tool_settings.annotation_stroke_placement_view3d = 'SURFACE'
3843
3844 return{"FINISHED"}
3845
3846 def invoke(self, context, event):
3847
3848 self.execute(context)
3849
3850 return {"FINISHED"}
3851
3852
3853 # ----------------------------
3854 # Edit curve operator
3855 class CURVE_OT_SURFSK_edit_curve(Operator):
3856 bl_idname = "curve.surfsk_edit_curve"
3857 bl_label = "Bsurfaces edit curve"
3858 bl_description = "Edit curve"
3859 bl_options = {'REGISTER', 'UNDO'}
3860
3861 def execute(self, context):
3862 if bpy.ops.object.mode_set.poll():
3863 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
3864 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3865 bpy.context.scene.bsurfaces.SURFSK_curve.select_set(True)
3866 bpy.context.view_layer.objects.active = bpy.context.scene.bsurfaces.SURFSK_curve
3867 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='EDIT')
3868
3869 def invoke(self, context, event):
3870 try:
3871 bpy.context.scene.bsurfaces.SURFSK_curve.select_set(True)
3872 except:
3873 self.report({'WARNING'}, "Specify the name of the object with curve")
3874 return{"CANCELLED"}
3875
3876 self.execute(context)
3877
3878 return {"FINISHED"}
3879
3880 # ----------------------------
3881 # Reorder splines
3882 class CURVE_OT_SURFSK_reorder_splines(Operator):
3883 bl_idname = "curve.surfsk_reorder_splines"
3884 bl_label = "Bsurfaces reorder splines"
3885 bl_description = "Defines the order of the splines by using grease pencil strokes"
3886 bl_options = {'REGISTER', 'UNDO'}
3887
3888 def execute(self, context):
3889 objects_to_delete = []
3890 # Convert grease pencil strokes to curve.
3891 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3892 bpy.ops.gpencil.convert('INVOKE_REGION_WIN', type='CURVE', use_link_strokes=False)
3893 for ob in bpy.context.selected_objects:
3894 if ob != bpy.context.view_layer.objects.active and ob.name.startswith("GP_Layer"):
3895 GP_strokes_curve = ob
3896
3897 # GP_strokes_curve = bpy.context.object
3898 objects_to_delete.append(GP_strokes_curve)
3899
3900 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3901 GP_strokes_curve.select_set(True)
3902 bpy.context.view_layer.objects.active = GP_strokes_curve
3903
3904 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3905 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='SELECT')
3906 bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=100)
3907 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3908
3909 bpy.ops.object.duplicate('INVOKE_REGION_WIN')
3910 GP_strokes_mesh = bpy.context.object
3911 objects_to_delete.append(GP_strokes_mesh)
3912
3913 GP_strokes_mesh.data.resolution_u = 1
3914 bpy.ops.object.convert(target='MESH', keep_original=False)
3915
3916 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3917 self.main_curve.select_set(True)
3918 bpy.context.view_layer.objects.active = self.main_curve
3919
3920 bpy.ops.object.duplicate('INVOKE_REGION_WIN')
3921 curves_duplicate_1 = bpy.context.object
3922 objects_to_delete.append(curves_duplicate_1)
3923
3924 minimum_points_num = 500
3925
3926 # Some iterations since the subdivision operator
3927 # has a limit of 100 subdivisions per iteration
3928 for x in range(round(minimum_points_num / 100)):
3929 # Check if the number of points of each curve has at least the number of points
3930 # of minimum_points_num. If not, subdivide to reach at least that number of points
3931 for i in range(len(curves_duplicate_1.data.splines)):
3932 sp = curves_duplicate_1.data.splines[i]
3933
3934 if len(sp.bezier_points) < minimum_points_num:
3935 for bp in sp.bezier_points:
3936 bp.select_control_point = True
3937
3938 if (len(sp.bezier_points) - 1) != 0:
3939 # Formula to get the number of cuts that will make a curve of N
3940 # number of points have near to "minimum_points_num" points,
3941 # when subdividing with this number of cuts
3942 subdivide_cuts = int(
3943 (minimum_points_num - len(sp.bezier_points)) /
3944 (len(sp.bezier_points) - 1)
3945 ) + 1
3946 else:
3947 subdivide_cuts = 0
3948
3949 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3950 bpy.ops.curve.subdivide('INVOKE_REGION_WIN', number_cuts=subdivide_cuts)
3951 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
3952 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
3953
3954 bpy.ops.object.duplicate('INVOKE_REGION_WIN')
3955 curves_duplicate_2 = bpy.context.object
3956 objects_to_delete.append(curves_duplicate_2)
3957
3958 # Duplicate the duplicate and add Shrinkwrap to it, with the grease pencil strokes curve as target
3959 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
3960 curves_duplicate_2.select_set(True)
3961 bpy.context.view_layer.objects.active = curves_duplicate_2
3962
3963 bpy.ops.object.modifier_add('INVOKE_REGION_WIN', type='SHRINKWRAP')
3964 curves_duplicate_2.modifiers["Shrinkwrap"].wrap_method = "NEAREST_VERTEX"
3965 curves_duplicate_2.modifiers["Shrinkwrap"].target = GP_strokes_mesh
3966 bpy.ops.object.modifier_apply('INVOKE_REGION_WIN', modifier='Shrinkwrap')
3967
3968 # Get the distance of each vert from its original position to its position with Shrinkwrap
3969 nearest_points_coords = {}
3970 for st_idx in range(len(curves_duplicate_1.data.splines)):
3971 for bp_idx in range(len(curves_duplicate_1.data.splines[st_idx].bezier_points)):
3972 bp_1_co = curves_duplicate_1.matrix_world @ \
3973 curves_duplicate_1.data.splines[st_idx].bezier_points[bp_idx].co
3974
3975 bp_2_co = curves_duplicate_2.matrix_world @ \
3976 curves_duplicate_2.data.splines[st_idx].bezier_points[bp_idx].co
3977
3978 if bp_idx == 0:
3979 shortest_dist = (bp_1_co - bp_2_co).length
3980 nearest_points_coords[st_idx] = ("%.4f" % bp_2_co[0],
3981 "%.4f" % bp_2_co[1],
3982 "%.4f" % bp_2_co[2])
3983
3984 dist = (bp_1_co - bp_2_co).length
3985
3986 if dist < shortest_dist:
3987 nearest_points_coords[st_idx] = ("%.4f" % bp_2_co[0],
3988 "%.4f" % bp_2_co[1],
3989 "%.4f" % bp_2_co[2])
3990 shortest_dist = dist
3991
3992 # Get all coords of GP strokes points, for comparison
3993 GP_strokes_coords = []
3994 for st_idx in range(len(GP_strokes_curve.data.splines)):
3995 GP_strokes_coords.append(
3996 [("%.4f" % x if "%.4f" % x != "-0.00" else "0.00",
3997 "%.4f" % y if "%.4f" % y != "-0.00" else "0.00",
3998 "%.4f" % z if "%.4f" % z != "-0.00" else "0.00") for
3999 x, y, z in [bp.co for bp in GP_strokes_curve.data.splines[st_idx].bezier_points]]
4000 )
4001
4002 # Check the point of the GP strokes with the same coords as
4003 # the nearest points of the curves (with shrinkwrap)
4004
4005 # Dictionary with GP stroke index as index, and a list as value.
4006 # The list has as index the point index of the GP stroke
4007 # nearest to the spline, and as value the spline index
4008 GP_connection_points = {}
4009 for gp_st_idx in range(len(GP_strokes_coords)):
4010 GPvert_spline_relationship = {}
4011
4012 for splines_st_idx in range(len(nearest_points_coords)):
4013 if nearest_points_coords[splines_st_idx] in GP_strokes_coords[gp_st_idx]:
4014 GPvert_spline_relationship[
4015 GP_strokes_coords[gp_st_idx].index(nearest_points_coords[splines_st_idx])
4016 ] = splines_st_idx
4017
4018 GP_connection_points[gp_st_idx] = GPvert_spline_relationship
4019
4020 # Get the splines new order
4021 splines_new_order = []
4022 for i in GP_connection_points:
4023 dict_keys = sorted(GP_connection_points[i].keys()) # Sort dictionaries by key
4024
4025 for k in dict_keys:
4026 splines_new_order.append(GP_connection_points[i][k])
4027
4028 # Reorder
4029 curve_original_name = self.main_curve.name
4030
4031 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
4032 self.main_curve.select_set(True)
4033 bpy.context.view_layer.objects.active = self.main_curve
4034
4035 self.main_curve.name = "SURFSKIO_CRV_ORD"
4036
4037 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4038 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
4039 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4040
4041 for _sp_idx in range(len(self.main_curve.data.splines)):
4042 self.main_curve.data.splines[0].bezier_points[0].select_control_point = True
4043
4044 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4045 bpy.ops.curve.separate('EXEC_REGION_WIN')
4046 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4047
4048 # Get the names of the separated splines objects in the original order
4049 splines_unordered = {}
4050 for o in bpy.data.objects:
4051 if o.name.find("SURFSKIO_CRV_ORD") != -1:
4052 spline_order_string = o.name.partition(".")[2]
4053
4054 if spline_order_string != "" and int(spline_order_string) > 0:
4055 spline_order_index = int(spline_order_string) - 1
4056 splines_unordered[spline_order_index] = o.name
4057
4058 # Join all splines objects in final order
4059 for order_idx in splines_new_order:
4060 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
4061 bpy.data.objects[splines_unordered[order_idx]].select_set(True)
4062 bpy.data.objects["SURFSKIO_CRV_ORD"].select_set(True)
4063 bpy.context.view_layer.objects.active = bpy.data.objects["SURFSKIO_CRV_ORD"]
4064
4065 bpy.ops.object.join('INVOKE_REGION_WIN')
4066
4067 # Go back to the original name of the curves object.
4068 bpy.context.object.name = curve_original_name
4069
4070 # Delete all unused objects
4071 bpy.ops.object.delete({"selected_objects": objects_to_delete})
4072
4073 bpy.ops.object.select_all('INVOKE_REGION_WIN', action='DESELECT')
4074 bpy.data.objects[curve_original_name].select_set(True)
4075 bpy.context.view_layer.objects.active = bpy.data.objects[curve_original_name]
4076
4077 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4078 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
4079
4080 try:
4081 bpy.context.scene.bsurfaces.SURFSK_gpencil.data.layers.active.clear()
4082 except:
4083 pass
4084
4085
4086 return {"FINISHED"}
4087
4088 def invoke(self, context, event):
4089 self.main_curve = bpy.context.object
4090 there_are_GP_strokes = False
4091
4092 try:
4093 # Get the active grease pencil layer
4094 strokes_num = len(self.main_curve.grease_pencil.layers.active.active_frame.strokes)
4095
4096 if strokes_num > 0:
4097 there_are_GP_strokes = True
4098 except:
4099 pass
4100
4101 if there_are_GP_strokes:
4102 self.execute(context)
4103 self.report({'INFO'}, "Splines have been reordered")
4104 else:
4105 self.report({'WARNING'}, "Draw grease pencil strokes to connect splines")
4106
4107 return {"FINISHED"}
4108
4109 # ----------------------------
4110 # Set first points operator
4111 class CURVE_OT_SURFSK_first_points(Operator):
4112 bl_idname = "curve.surfsk_first_points"
4113 bl_label = "Bsurfaces set first points"
4114 bl_description = "Set the selected points as the first point of each spline"
4115 bl_options = {'REGISTER', 'UNDO'}
4116
4117 def execute(self, context):
4118 splines_to_invert = []
4119
4120 # Check non-cyclic splines to invert
4121 for i in range(len(self.main_curve.data.splines)):
4122 b_points = self.main_curve.data.splines[i].bezier_points
4123
4124 if i not in self.cyclic_splines: # Only for non-cyclic splines
4125 if b_points[len(b_points) - 1].select_control_point:
4126 splines_to_invert.append(i)
4127
4128 # Reorder points of cyclic splines, and set all handles to "Automatic"
4129
4130 # Check first selected point
4131 cyclic_splines_new_first_pt = {}
4132 for i in self.cyclic_splines:
4133 sp = self.main_curve.data.splines[i]
4134
4135 for t in range(len(sp.bezier_points)):
4136 bp = sp.bezier_points[t]
4137 if bp.select_control_point or bp.select_right_handle or bp.select_left_handle:
4138 cyclic_splines_new_first_pt[i] = t
4139 break # To take only one if there are more
4140
4141 # Reorder
4142 for spline_idx in cyclic_splines_new_first_pt:
4143 sp = self.main_curve.data.splines[spline_idx]
4144
4145 spline_old_coords = []
4146 for bp_old in sp.bezier_points:
4147 coords = (bp_old.co[0], bp_old.co[1], bp_old.co[2])
4148
4149 left_handle_type = str(bp_old.handle_left_type)
4150 left_handle_length = float(bp_old.handle_left.length)
4151 left_handle_xyz = (
4152 float(bp_old.handle_left.x),
4153 float(bp_old.handle_left.y),
4154 float(bp_old.handle_left.z)
4155 )
4156 right_handle_type = str(bp_old.handle_right_type)
4157 right_handle_length = float(bp_old.handle_right.length)
4158 right_handle_xyz = (
4159 float(bp_old.handle_right.x),
4160 float(bp_old.handle_right.y),
4161 float(bp_old.handle_right.z)
4162 )
4163 spline_old_coords.append(
4164 [coords, left_handle_type,
4165 right_handle_type, left_handle_length,
4166 right_handle_length, left_handle_xyz,
4167 right_handle_xyz]
4168 )
4169
4170 for t in range(len(sp.bezier_points)):
4171 bp = sp.bezier_points
4172
4173 if t + cyclic_splines_new_first_pt[spline_idx] + 1 <= len(bp) - 1:
4174 new_index = t + cyclic_splines_new_first_pt[spline_idx] + 1
4175 else:
4176 new_index = t + cyclic_splines_new_first_pt[spline_idx] + 1 - len(bp)
4177
4178 bp[t].co = Vector(spline_old_coords[new_index][0])
4179
4180 bp[t].handle_left.length = spline_old_coords[new_index][3]
4181 bp[t].handle_right.length = spline_old_coords[new_index][4]
4182
4183 bp[t].handle_left_type = "FREE"
4184 bp[t].handle_right_type = "FREE"
4185
4186 bp[t].handle_left.x = spline_old_coords[new_index][5][0]
4187 bp[t].handle_left.y = spline_old_coords[new_index][5][1]
4188 bp[t].handle_left.z = spline_old_coords[new_index][5][2]
4189
4190 bp[t].handle_right.x = spline_old_coords[new_index][6][0]
4191 bp[t].handle_right.y = spline_old_coords[new_index][6][1]
4192 bp[t].handle_right.z = spline_old_coords[new_index][6][2]
4193
4194 bp[t].handle_left_type = spline_old_coords[new_index][1]
4195 bp[t].handle_right_type = spline_old_coords[new_index][2]
4196
4197 # Invert the non-cyclic splines designated above
4198 for i in range(len(splines_to_invert)):
4199 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
4200
4201 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4202 self.main_curve.data.splines[splines_to_invert[i]].bezier_points[0].select_control_point = True
4203 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4204
4205 bpy.ops.curve.switch_direction()
4206
4207 bpy.ops.curve.select_all('INVOKE_REGION_WIN', action='DESELECT')
4208
4209 # Keep selected the first vert of each spline
4210 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4211 for i in range(len(self.main_curve.data.splines)):
4212 if not self.main_curve.data.splines[i].use_cyclic_u:
4213 bp = self.main_curve.data.splines[i].bezier_points[0]
4214 else:
4215 bp = self.main_curve.data.splines[i].bezier_points[
4216 len(self.main_curve.data.splines[i].bezier_points) - 1
4217 ]
4218
4219 bp.select_control_point = True
4220 bp.select_right_handle = True
4221 bp.select_left_handle = True
4222
4223 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4224
4225 return {'FINISHED'}
4226
4227 def invoke(self, context, event):
4228 self.main_curve = bpy.context.object
4229
4230 # Check if all curves are Bezier, and detect which ones are cyclic
4231 self.cyclic_splines = []
4232 for i in range(len(self.main_curve.data.splines)):
4233 if self.main_curve.data.splines[i].type != "BEZIER":
4234 self.report({'WARNING'}, "All splines must be Bezier type")
4235
4236 return {'CANCELLED'}
4237 else:
4238 if self.main_curve.data.splines[i].use_cyclic_u:
4239 self.cyclic_splines.append(i)
4240
4241 self.execute(context)
4242 self.report({'INFO'}, "First points have been set")
4243
4244 return {'FINISHED'}
4245
4246
4247 # Add-ons Preferences Update Panel
4248
4249 # Define Panel classes for updating
4250 panels = (
4251 VIEW3D_PT_tools_SURFSK_mesh,
4252 VIEW3D_PT_tools_SURFSK_curve
4253 )
4254
4255
4256 def conver_gpencil_to_curve(self, context, pencil, type):
4257 newCurve = bpy.data.curves.new(type + '_curve', type='CURVE')
4258 newCurve.dimensions = '3D'
4259 CurveObject = object_utils.object_data_add(context, newCurve)
4260 error = False
4261
4262 if type == 'GPensil':
4263 try:
4264 strokes = pencil.data.layers.active.active_frame.strokes
4265 except:
4266 error = True
4267 CurveObject.location = pencil.location
4268 CurveObject.rotation_euler = pencil.rotation_euler
4269 CurveObject.scale = pencil.scale
4270 elif type == 'Annotation':
4271 try:
4272 strokes = bpy.context.annotation_data.layers.active.active_frame.strokes
4273 except:
4274 error = True
4275 CurveObject.location = (0.0, 0.0, 0.0)
4276 CurveObject.rotation_euler = (0.0, 0.0, 0.0)
4277 CurveObject.scale = (1.0, 1.0, 1.0)
4278
4279 if not error:
4280 for i, _stroke in enumerate(strokes):
4281 stroke_points = strokes[i].points
4282 data_list = [ (point.co.x, point.co.y, point.co.z)
4283 for point in stroke_points ]
4284 points_to_add = len(data_list)-1
4285
4286 flat_list = []
4287 for point in data_list:
4288 flat_list.extend(point)
4289
4290 spline = newCurve.splines.new(type='BEZIER')
4291 spline.bezier_points.add(points_to_add)
4292 spline.bezier_points.foreach_set("co", flat_list)
4293
4294 for point in spline.bezier_points:
4295 point.handle_left_type="AUTO"
4296 point.handle_right_type="AUTO"
4297
4298 return CurveObject
4299 else:
4300 return None
4301
4302
4303 def update_panel(self, context):
4304 message = "Bsurfaces GPL Edition: Updating Panel locations has failed"
4305 try:
4306 for panel in panels:
4307 if "bl_rna" in panel.__dict__:
4308 bpy.utils.unregister_class(panel)
4309
4310 for panel in panels:
4311 category = context.preferences.addons[__name__].preferences.category
4312 if category != 'Tool':
4313 panel.bl_category = context.preferences.addons[__name__].preferences.category
4314 else:
4315 context.preferences.addons[__name__].preferences.category = 'Edit'
4316 panel.bl_category = 'Edit'
4317 raise ValueError("You can not install add-ons in the Tool panel")
4318 bpy.utils.register_class(panel)
4319
4320 except Exception as e:
4321 print("\n[{}]\n{}\n\nError:\n{}".format(__name__, message, e))
4322 pass
4323
4324 def makeMaterial(name, diffuse):
4325
4326 if name in bpy.data.materials:
4327 material = bpy.data.materials[name]
4328 material.diffuse_color = diffuse
4329 else:
4330 material = bpy.data.materials.new(name)
4331 material.diffuse_color = diffuse
4332
4333 return material
4334
4335 def update_mesh(self, context):
4336 try:
4337 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
4338 bpy.ops.object.select_all(action='DESELECT')
4339 bpy.context.view_layer.update()
4340 global global_mesh_object
4341 global_mesh_object = bpy.context.scene.bsurfaces.SURFSK_mesh.name
4342 bpy.data.objects[global_mesh_object].select_set(True)
4343 bpy.context.view_layer.objects.active = bpy.data.objects[global_mesh_object]
4344 except:
4345 print("Select mesh object")
4346
4347 def update_gpencil(self, context):
4348 try:
4349 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
4350 bpy.ops.object.select_all(action='DESELECT')
4351 bpy.context.view_layer.update()
4352 global global_gpencil_object
4353 global_gpencil_object = bpy.context.scene.bsurfaces.SURFSK_gpencil.name
4354 bpy.data.objects[global_gpencil_object].select_set(True)
4355 bpy.context.view_layer.objects.active = bpy.data.objects[global_gpencil_object]
4356 except:
4357 print("Select gpencil object")
4358
4359 def update_curve(self, context):
4360 try:
4361 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
4362 bpy.ops.object.select_all(action='DESELECT')
4363 bpy.context.view_layer.update()
4364 global global_curve_object
4365 global_curve_object = bpy.context.scene.bsurfaces.SURFSK_curve.name
4366 bpy.data.objects[global_curve_object].select_set(True)
4367 bpy.context.view_layer.objects.active = bpy.data.objects[global_curve_object]
4368 except:
4369 print("Select curve object")
4370
4371 def update_shade_smooth(self, context):
4372 try:
4373 global global_shade_smooth
4374 global_shade_smooth = bpy.context.scene.bsurfaces.SURFSK_shade_smooth
4375
4376 contex_mode = bpy.context.mode
4377
4378 if bpy.ops.object.mode_set.poll():
4379 bpy.ops.object.mode_set('INVOKE_REGION_WIN', mode='OBJECT')
4380
4381 bpy.ops.object.select_all(action='DESELECT')
4382 global global_mesh_object
4383 global_mesh_object = bpy.context.scene.bsurfaces.SURFSK_mesh.name
4384 bpy.data.objects[global_mesh_object].select_set(True)
4385
4386 if global_shade_smooth:
4387 bpy.ops.object.shade_smooth()
4388 else:
4389 bpy.ops.object.shade_flat()
4390
4391 if contex_mode == "EDIT_MESH":
4392 bpy.ops.object.editmode_toggle('INVOKE_REGION_WIN')
4393
4394 except:
4395 print("Select mesh object")
4396
4397
4398 class BsurfPreferences(AddonPreferences):
4399 # this must match the addon name, use '__package__'
4400 # when defining this in a submodule of a python package.
4401 bl_idname = __name__
4402
4403 category: StringProperty(
4404 name="Tab Category",
4405 description="Choose a name for the category of the panel",
4406 default="Edit",
4407 update=update_panel
4408 )
4409
4410 def draw(self, context):
4411 layout = self.layout
4412
4413 row = layout.row()
4414 col = row.column()
4415 col.label(text="Tab Category:")
4416 col.prop(self, "category", text="")
4417
4418 # Properties
4419 class BsurfacesProps(PropertyGroup):
4420 SURFSK_guide: EnumProperty(
4421 name="Guide:",
4422 items=[
4423 ('Annotation', 'Annotation', 'Annotation'),
4424 ('GPencil', 'GPencil', 'GPencil'),
4425 ('Curve', 'Curve', 'Curve')
4426 ],
4427 default="Annotation"
4428 )
4429 SURFSK_edges_U: IntProperty(
4430 name="Cross",
4431 description="Number of face-loops crossing the strokes",
4432 default=5,
4433 min=1,
4434 max=200
4435 )
4436 SURFSK_edges_V: IntProperty(
4437 name="Follow",
4438 description="Number of face-loops following the strokes",
4439 default=1,
4440 min=1,
4441 max=200
4442 )
4443 SURFSK_cyclic_cross: BoolProperty(
4444 name="Cyclic Cross",
4445 description="Make cyclic the face-loops crossing the strokes",
4446 default=False
4447 )
4448 SURFSK_cyclic_follow: BoolProperty(
4449 name="Cyclic Follow",
4450 description="Make cyclic the face-loops following the strokes",
4451 default=False
4452 )
4453 SURFSK_keep_strokes: BoolProperty(
4454 name="Keep strokes",
4455 description="Keeps the sketched strokes or curves after adding the surface",
4456 default=False
4457 )
4458 SURFSK_automatic_join: BoolProperty(
4459 name="Automatic join",
4460 description="Join automatically vertices of either surfaces "
4461 "generated by crosshatching, or from the borders of closed shapes",
4462 default=True
4463 )
4464 SURFSK_loops_on_strokes: BoolProperty(
4465 name="Loops on strokes",
4466 description="Make the loops match the paths of the strokes",
4467 default=True
4468 )
4469 SURFSK_precision: IntProperty(
4470 name="Precision",
4471 description="Precision level of the surface calculation",
4472 default=2,
4473 min=1,
4474 max=100
4475 )
4476 SURFSK_mesh: PointerProperty(
4477 name="Mesh of BSurface",
4478 type=bpy.types.Object,
4479 description="Mesh of BSurface",
4480 update=update_mesh,
4481 )
4482 SURFSK_gpencil: PointerProperty(
4483 name="GreasePencil object",
4484 type=bpy.types.Object,
4485 description="GreasePencil object",
4486 update=update_gpencil,
4487 )
4488 SURFSK_curve: PointerProperty(
4489 name="Curve object",
4490 type=bpy.types.Object,
4491 description="Curve object",
4492 update=update_curve,
4493 )
4494 SURFSK_shade_smooth: BoolProperty(
4495 name="Shade smooth",
4496 description="Render and display faces smooth, using interpolated Vertex Normals",
4497 default=False,
4498 update=update_shade_smooth,
4499 )
4500
4501 classes = (
4502 MESH_OT_SURFSK_init,
4503 MESH_OT_SURFSK_add_modifiers,
4504 MESH_OT_SURFSK_add_surface,
4505 MESH_OT_SURFSK_edit_surface,
4506 GPENCIL_OT_SURFSK_add_strokes,
4507 GPENCIL_OT_SURFSK_edit_strokes,
4508 GPENCIL_OT_SURFSK_strokes_to_curves,
4509 GPENCIL_OT_SURFSK_annotation_to_curves,
4510 GPENCIL_OT_SURFSK_add_annotation,
4511 CURVE_OT_SURFSK_edit_curve,
4512 CURVE_OT_SURFSK_reorder_splines,
4513 CURVE_OT_SURFSK_first_points,
4514 BsurfPreferences,
4515 BsurfacesProps
4516 )
4517
4518 def register():
4519 for cls in classes:
4520 bpy.utils.register_class(cls)
4521
4522 for panel in panels:
4523 bpy.utils.register_class(panel)
4524
4525 bpy.types.Scene.bsurfaces = PointerProperty(type=BsurfacesProps)
4526 update_panel(None, bpy.context)
4527
4528 def unregister():
4529 for panel in panels:
4530 bpy.utils.unregister_class(panel)
4531
4532 for cls in classes:
4533 bpy.utils.unregister_class(cls)
4534
4535 del bpy.types.Scene.bsurfaces
4536
4537 if __name__ == "__main__":
4538 register()
Central repository of Blender addons