release/scripts/startup/bl_operators/mesh.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 2
   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, write to the Free Software Foundation,
  15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16 #
  17 # ##### END GPL LICENSE BLOCK #####
  18
  19 # <pep8-80 compliant>
  20
  21 import bpy
  22 from bpy.types import Operator
  23
  24 from bpy.props import EnumProperty
  25
  26
  27 class MeshSelectInteriorFaces(Operator):
  28     '''Select faces where all edges have more than 2 face users'''
  29
  30     bl_idname = "mesh.faces_select_interior"
  31     bl_label = "Select Interior Faces"
  32     bl_options = {'REGISTER', 'UNDO'}
  33
  34     @classmethod
  35     def poll(cls, context):
  36         ob = context.active_object
  37         return (ob and ob.type == 'MESH')
  38
  39     def execute(self, context):
  40         from bpy_extras import mesh_utils
  41         ob = context.active_object
  42         context.tool_settings.mesh_select_mode = False, False, True
  43         is_editmode = (ob.mode == 'EDIT')
  44         if is_editmode:
  45             bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
  46
  47         mesh = ob.data
  48
  49         face_list = mesh.faces[:]
  50         face_edge_keys = [face.edge_keys for face in face_list]
  51
  52         edge_face_count = mesh_utils.edge_face_count_dict(mesh)
  53
  54         def test_interior(index):
  55             for key in face_edge_keys[index]:
  56                 if edge_face_count[key] < 3:
  57                     return False
  58             return True
  59
  60         for index, face in enumerate(face_list):
  61             if(test_interior(index)):
  62                 face.select = True
  63             else:
  64                 face.select = False
  65
  66         if is_editmode:
  67             bpy.ops.object.mode_set(mode='EDIT', toggle=False)
  68         return {'FINISHED'}
  69
  70
  71 class MeshMirrorUV(Operator):
  72     '''Copy mirror UV coordinates on the X axis based on a mirrored mesh'''
  73     bl_idname = "mesh.faces_mirror_uv"
  74     bl_label = "Copy Mirrored UV coords"
  75     bl_options = {'REGISTER', 'UNDO'}
  76
  77     direction = EnumProperty(
  78             name="Axis Direction",
  79             items=(('POSITIVE', "Positive", ""),
  80                    ('NEGATIVE', "Negative", "")),
  81             )
  82
  83     @classmethod
  84     def poll(cls, context):
  85         obj = context.active_object
  86         return (obj and obj.type == 'MESH' and obj.data.uv_textures.active)
  87
  88     def execute(self, context):
  89         DIR = (self.direction == 'NEGATIVE')
  90
  91         ob = context.active_object
  92         is_editmode = (ob.mode == 'EDIT')
  93         if is_editmode:
  94             bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
  95
  96         mesh = ob.data
  97
  98         # mirror lookups
  99         mirror_gt = {}
 100         mirror_lt = {}
 101
 102         vcos = [v.co.to_tuple(5) for v in mesh.vertices]
 103
 104         for i, co in enumerate(vcos):
 105             if co[0] > 0.0:
 106                 mirror_gt[co] = i
 107             elif co[0] < 0.0:
 108                 mirror_lt[co] = i
 109             else:
 110                 mirror_gt[co] = i
 111                 mirror_lt[co] = i
 112
 113         #for i, v in enumerate(mesh.vertices):
 114         vmap = {}
 115         for mirror_a, mirror_b in ((mirror_gt, mirror_lt),
 116                                    (mirror_lt, mirror_gt)):
 117             for co, i in mirror_a.items():
 118                 nco = (-co[0], co[1], co[2])
 119                 j = mirror_b.get(nco)
 120                 if j is not None:
 121                     vmap[i] = j
 122
 123         active_uv_layer = mesh.uv_textures.active.data
 124         fuvs = [(uv.uv1, uv.uv2, uv.uv3, uv.uv4) for uv in active_uv_layer]
 125         fuvs_cpy = [(uv[0].copy(), uv[1].copy(), uv[2].copy(), uv[3].copy())
 126                     for uv in fuvs]
 127
 128         # as a list
 129         faces = mesh.faces[:]
 130
 131         fuvsel = [(False not in uv.select_uv) for uv in active_uv_layer]
 132         fcents = [f.center for f in faces]
 133
 134         # find mirror faces
 135         mirror_fm = {}
 136         for i, f in enumerate(faces):
 137             verts = list(f.vertices)
 138             verts.sort()
 139             verts = tuple(verts)
 140             mirror_fm[verts] = i
 141
 142         fmap = {}
 143         for i, f in enumerate(faces):
 144             verts = [vmap.get(j) for j in f.vertices]
 145             if None not in verts:
 146                 verts.sort()
 147                 j = mirror_fm.get(tuple(verts))
 148                 if j is not None:
 149                     fmap[i] = j
 150
 151         for i, j in fmap.items():
 152
 153             if not fuvsel[i] or not fuvsel[j]:
 154                 continue
 155             elif DIR == 0 and fcents[i][0] < 0.0:
 156                 continue
 157             elif DIR == 1 and fcents[i][0] > 0.0:
 158                 continue
 159
 160             # copy UVs
 161             uv1 = fuvs[i]
 162             uv2 = fuvs_cpy[j]
 163
 164             # get the correct rotation
 165             v1 = faces[j].vertices[:]
 166             v2 = [vmap[k] for k in faces[i].vertices[:]]
 167
 168             if len(v1) == len(v2):
 169                 for k in range(len(v1)):
 170                     k_map = v1.index(v2[k])
 171                     uv1[k].xy = - (uv2[k_map].x - 0.5) + 0.5, uv2[k_map].y
 172
 173         if is_editmode:
 174             bpy.ops.object.mode_set(mode='EDIT', toggle=False)
 175
 176         return {'FINISHED'}