mesh_tools/mesh_extrude_and_reshape.py

   1 # ##### BEGIN GPL LICENSE BLOCK #####
   2 #
   3 #  This program is free software; you can redistribute it and/or
   4 #  modify it under the terms of the GNU General Public License
   5 #  as published by the Free Software Foundation; either version 3
   6 #  of the License, or (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15 #
  16 # ##### END GPL LICENSE BLOCK #####
  17
  18 # Contact for more information about the Addon:
  19 # Email:    germano.costa@ig.com.br
  20 # Twitter:  wii_mano @mano_wii
  21
  22 bl_info = {
  23     "name": "Extrude and Reshape",
  24     "author": "Germano Cavalcante",
  25     "version": (0, 8, 1),
  26     "blender": (2, 80, 0),
  27     "location": "View3D > UI > Tools > Mesh Tools > Add: > Extrude Menu (Alt + E)",
  28     "description": "Extrude face and merge edge intersections "
  29                    "between the mesh and the new edges",
  30     "wiki_url": "http://blenderartists.org/forum/"
  31                 "showthread.php?376618-Addon-Push-Pull-Face",
  32     "category": "Mesh"}
  33
  34 import bpy
  35 import bmesh
  36 from mathutils.geometry import intersect_line_line
  37 from bpy.types import Operator
  38
  39
  40 class BVHco():
  41     i = 0
  42     c1x = 0.0
  43     c1y = 0.0
  44     c1z = 0.0
  45     c2x = 0.0
  46     c2y = 0.0
  47     c2z = 0.0
  48
  49
  50 def edges_BVH_overlap(bm, edges, epsilon=0.0001):
  51     bco = set()
  52     for e in edges:
  53         bvh = BVHco()
  54         bvh.i = e.index
  55         b1 = e.verts[0]
  56         b2 = e.verts[1]
  57         co1 = b1.co.x
  58         co2 = b2.co.x
  59         if co1 <= co2:
  60             bvh.c1x = co1 - epsilon
  61             bvh.c2x = co2 + epsilon
  62         else:
  63             bvh.c1x = co2 - epsilon
  64             bvh.c2x = co1 + epsilon
  65         co1 = b1.co.y
  66         co2 = b2.co.y
  67         if co1 <= co2:
  68             bvh.c1y = co1 - epsilon
  69             bvh.c2y = co2 + epsilon
  70         else:
  71             bvh.c1y = co2 - epsilon
  72             bvh.c2y = co1 + epsilon
  73         co1 = b1.co.z
  74         co2 = b2.co.z
  75         if co1 <= co2:
  76             bvh.c1z = co1 - epsilon
  77             bvh.c2z = co2 + epsilon
  78         else:
  79             bvh.c1z = co2 - epsilon
  80             bvh.c2z = co1 + epsilon
  81         bco.add(bvh)
  82     del edges
  83     overlap = {}
  84     oget = overlap.get
  85     for e1 in bm.edges:
  86         by = bz = True
  87         a1 = e1.verts[0]
  88         a2 = e1.verts[1]
  89         c1x = a1.co.x
  90         c2x = a2.co.x
  91         if c1x > c2x:
  92             tm = c1x
  93             c1x = c2x
  94             c2x = tm
  95         for bvh in bco:
  96             if c1x <= bvh.c2x and c2x >= bvh.c1x:
  97                 if by:
  98                     by = False
  99                     c1y = a1.co.y
 100                     c2y = a2.co.y
 101                     if c1y > c2y:
 102                         tm = c1y
 103                         c1y = c2y
 104                         c2y = tm
 105                 if c1y <= bvh.c2y and c2y >= bvh.c1y:
 106                     if bz:
 107                         bz = False
 108                         c1z = a1.co.z
 109                         c2z = a2.co.z
 110                         if c1z > c2z:
 111                             tm = c1z
 112                             c1z = c2z
 113                             c2z = tm
 114                     if c1z <= bvh.c2z and c2z >= bvh.c1z:
 115                         e2 = bm.edges[bvh.i]
 116                         if e1 != e2:
 117                             overlap[e1] = oget(e1, set()).union({e2})
 118     return overlap
 119
 120
 121 def intersect_edges_edges(overlap, precision=4):
 122     epsilon = .1**precision
 123     fpre_min = -epsilon
 124     fpre_max = 1 + epsilon
 125     splits = {}
 126     sp_get = splits.get
 127     new_edges1 = set()
 128     new_edges2 = set()
 129     targetmap = {}
 130     for edg1 in overlap:
 131         # print("***", ed1.index, "***")
 132         for edg2 in overlap[edg1]:
 133             a1 = edg1.verts[0]
 134             a2 = edg1.verts[1]
 135             b1 = edg2.verts[0]
 136             b2 = edg2.verts[1]
 137
 138             # test if are linked
 139             if a1 in {b1, b2} or a2 in {b1, b2}:
 140                 # print('linked')
 141                 continue
 142
 143             aco1, aco2 = a1.co, a2.co
 144             bco1, bco2 = b1.co, b2.co
 145             tp = intersect_line_line(aco1, aco2, bco1, bco2)
 146             if tp:
 147                 p1, p2 = tp
 148                 if (p1 - p2).to_tuple(precision) == (0, 0, 0):
 149                     v = aco2 - aco1
 150                     f = p1 - aco1
 151                     x, y, z = abs(v.x), abs(v.y), abs(v.z)
 152                     max1 = 0 if x >= y and x >= z else\
 153                            1 if y >= x and y >= z else 2
 154                     fac1 = f[max1] / v[max1]
 155
 156                     v = bco2 - bco1
 157                     f = p2 - bco1
 158                     x, y, z = abs(v.x), abs(v.y), abs(v.z)
 159                     max2 = 0 if x >= y and x >= z else\
 160                            1 if y >= x and y >= z else 2
 161                     fac2 = f[max2] / v[max2]
 162
 163                     if fpre_min <= fac1 <= fpre_max:
 164                         # print(edg1.index, 'can intersect', edg2.index)
 165                         ed1 = edg1
 166
 167                     elif edg1 in splits:
 168                         for ed1 in splits[edg1]:
 169                             a1 = ed1.verts[0]
 170                             a2 = ed1.verts[1]
 171
 172                             vco1 = a1.co
 173                             vco2 = a2.co
 174
 175                             v = vco2 - vco1
 176                             f = p1 - vco1
 177                             fac1 = f[max1] / v[max1]
 178                             if fpre_min <= fac1 <= fpre_max:
 179                                 # print(e.index, 'can intersect', edg2.index)
 180                                 break
 181                         else:
 182                             # print(edg1.index, 'really does not intersect', edg2.index)
 183                             continue
 184                     else:
 185                         # print(edg1.index, 'not intersect', edg2.index)
 186                         continue
 187
 188                     if fpre_min <= fac2 <= fpre_max:
 189                         # print(ed1.index, 'actually intersect', edg2.index)
 190                         ed2 = edg2
 191
 192                     elif edg2 in splits:
 193                         for ed2 in splits[edg2]:
 194                             b1 = ed2.verts[0]
 195                             b2 = ed2.verts[1]
 196
 197                             vco1 = b1.co
 198                             vco2 = b2.co
 199
 200                             v = vco2 - vco1
 201                             f = p2 - vco1
 202                             fac2 = f[max2] / v[max2]
 203                             if fpre_min <= fac2 <= fpre_max:
 204                                 # print(ed1.index, 'actually intersect', e.index)
 205                                 break
 206                         else:
 207                             # print(ed1.index, 'really does not intersect', ed2.index)
 208                             continue
 209                     else:
 210                         # print(ed1.index, 'not intersect', edg2.index)
 211                         continue
 212
 213                     new_edges1.add(ed1)
 214                     new_edges2.add(ed2)
 215
 216                     if abs(fac1) <= epsilon:
 217                         nv1 = a1
 218                     elif fac1 + epsilon >= 1:
 219                         nv1 = a2
 220                     else:
 221                         ne1, nv1 = bmesh.utils.edge_split(ed1, a1, fac1)
 222                         new_edges1.add(ne1)
 223                         splits[edg1] = sp_get(edg1, set()).union({ne1})
 224
 225                     if abs(fac2) <= epsilon:
 226                         nv2 = b1
 227                     elif fac2 + epsilon >= 1:
 228                         nv2 = b2
 229                     else:
 230                         ne2, nv2 = bmesh.utils.edge_split(ed2, b1, fac2)
 231                         new_edges2.add(ne2)
 232                         splits[edg2] = sp_get(edg2, set()).union({ne2})
 233
 234                     if nv1 != nv2:  # necessary?
 235                         targetmap[nv1] = nv2
 236
 237     return new_edges1, new_edges2, targetmap
 238
 239
 240 class ER_OT_Extrude_and_Reshape(Operator):
 241     bl_idname = "mesh.extrude_reshape"
 242     bl_label = "Extrude and Reshape"
 243     bl_description = "Push and pull face entities to sculpt 3d models"
 244     bl_options = {'REGISTER', 'GRAB_CURSOR', 'BLOCKING'}
 245
 246     @classmethod
 247     def poll(cls, context):
 248         if context.mode=='EDIT_MESH':
 249             return True
 250
 251     def modal(self, context, event):
 252         if self.confirm:
 253             sface = self.bm.faces.active
 254             if not sface:
 255                 for face in self.bm.faces:
 256                     if face.select is True:
 257                         sface = face
 258                         break
 259                 else:
 260                     return {'FINISHED'}
 261             # edges to intersect
 262             edges = set()
 263             [[edges.add(ed) for ed in v.link_edges] for v in sface.verts]
 264
 265             overlap = edges_BVH_overlap(self.bm, edges, epsilon=0.0001)
 266             overlap = {k: v for k, v in overlap.items() if k not in edges}  # remove repetition
 267             """
 268             print([e.index for e in edges])
 269             for a, b in overlap.items():
 270                 print(a.index, [e.index for e in b])
 271             """
 272             new_edges1, new_edges2, targetmap = intersect_edges_edges(overlap)
 273             pos_weld = set()
 274             for e in new_edges1:
 275                 v1, v2 = e.verts
 276                 if v1 in targetmap and v2 in targetmap:
 277                     pos_weld.add((targetmap[v1], targetmap[v2]))
 278             if targetmap:
 279                 bmesh.ops.weld_verts(self.bm, targetmap=targetmap)
 280             """
 281             print([e.is_valid for e in new_edges1])
 282             print([e.is_valid for e in new_edges2])
 283             sp_faces1 = set()
 284             """
 285             for e in pos_weld:
 286                 v1, v2 = e
 287                 lf1 = set(v1.link_faces)
 288                 lf2 = set(v2.link_faces)
 289                 rlfe = lf1.intersection(lf2)
 290                 for f in rlfe:
 291                     try:
 292                         nf = bmesh.utils.face_split(f, v1, v2)
 293                         # sp_faces1.update({f, nf[0]})
 294                     except:
 295                         pass
 296
 297             # sp_faces2 = set()
 298             for e in new_edges2:
 299                 lfe = set(e.link_faces)
 300                 v1, v2 = e.verts
 301                 lf1 = set(v1.link_faces)
 302                 lf2 = set(v2.link_faces)
 303                 rlfe = lf1.intersection(lf2)
 304                 for f in rlfe.difference(lfe):
 305                     nf = bmesh.utils.face_split(f, v1, v2)
 306                     # sp_faces2.update({f, nf[0]})
 307
 308             bmesh.update_edit_mesh(self.mesh, loop_triangles=True, destructive=True)
 309             return {'FINISHED'}
 310         if self.cancel:
 311             return {'FINISHED'}
 312         self.cancel = event.type in {'ESC', 'NDOF_BUTTON_ESC'}
 313         self.confirm = event.type in {'LEFTMOUSE', 'RET', 'NUMPAD_ENTER'}
 314         return {'PASS_THROUGH'}
 315
 316     def execute(self, context):
 317         self.mesh = context.object.data
 318         self.bm = bmesh.from_edit_mesh(self.mesh)
 319         try:
 320             selection = self.bm.select_history[-1]
 321         except:
 322             for face in self.bm.faces:
 323                 if face.select is True:
 324                     selection = face
 325                     break
 326             else:
 327                 return {'FINISHED'}
 328         if not isinstance(selection, bmesh.types.BMFace):
 329             bpy.ops.mesh.extrude_region_move('INVOKE_DEFAULT')
 330             return {'FINISHED'}
 331         else:
 332             face = selection
 333             # face.select = False
 334             bpy.ops.mesh.select_all(action='DESELECT')
 335             geom = []
 336             for edge in face.edges:
 337                 if abs(edge.calc_face_angle(0) - 1.5707963267948966) < 0.01:  # self.angle_tolerance:
 338                     geom.append(edge)
 339
 340             ret_dict = bmesh.ops.extrude_discrete_faces(self.bm, faces=[face])
 341
 342             for face in ret_dict['faces']:
 343                 self.bm.faces.active = face
 344                 face.select = True
 345                 sface = face
 346             dfaces = bmesh.ops.dissolve_edges(
 347                         self.bm, edges=geom, use_verts=True, use_face_split=False
 348                         )
 349             bmesh.update_edit_mesh(self.mesh, loop_triangles=True, destructive=True)
 350             bpy.ops.transform.translate(
 351                         'INVOKE_DEFAULT', constraint_axis=(False, False, True),
 352                         orient_type='NORMAL', release_confirm=True
 353                         )
 354
 355         context.window_manager.modal_handler_add(self)
 356
 357         self.cancel = False
 358         self.confirm = False
 359         return {'RUNNING_MODAL'}
 360
 361
 362 def operator_draw(self, context):
 363     layout = self.layout
 364     col = layout.column(align=True)
 365     col.operator("mesh.extrude_reshape")
 366
 367
 368 def register():
 369     bpy.utils.register_class(ER_OT_Extrude_and_Reshape)
 370
 371
 372 def unregister():
 373     bpy.utils.unregister_class(ER_OT_Extrude_and_Reshape)
 374
 375
 376 if __name__ == "__main__":
 377     register()