[Bf-extensions-cvs] SVN commit: /data/svn/bf-extensions [1996] contrib/py/scripts/addons/ mesh_inset_extrude.py:
Jon Sandström
jon.oasan at gmail.com
Thu Jun 2 14:37:40 CEST 2011
Revision: 1996
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-extensions&revision=1996
Author: jos
Date: 2011-06-02 12:37:40 +0000 (Thu, 02 Jun 2011)
Log Message:
-----------
Added Paths:
-----------
contrib/py/scripts/addons/mesh_inset_extrude.py
Added: contrib/py/scripts/addons/mesh_inset_extrude.py
===================================================================
--- contrib/py/scripts/addons/mesh_inset_extrude.py (rev 0)
+++ contrib/py/scripts/addons/mesh_inset_extrude.py 2011-06-02 12:37:40 UTC (rev 1996)
@@ -0,0 +1,593 @@
+bl_info = {
+ 'name': "Inset Extrude",
+ 'description': "Inset and Extrude selected polygons, useful modeling tool",
+ 'author': "Jon Sandstrom",
+ 'version': (0, 5),
+ 'blender': (2, 5, 7),
+ 'api': 36147,
+ 'location': 'Search for Inset Extrude, or map a key to the operator "mesh.inset_extrude"',
+ 'warning': "",
+ 'category': 'Mesh',
+ 'wiki_url': 'http://wiki.blender.org/index.php/Extensions:2.5/Py/Scripts/Modeling/Inset-Extrude'}
+
+import bpy
+import bgl
+import blf
+from math import *
+from mathutils import Vector
+from bpy.props import FloatProperty
+
+def find_sel_faces(mesh):
+ selected_faces = []
+ for face in mesh.faces:
+ if face.select and not face.hide: selected_faces.append(face.index)
+ selected_islands = []
+ while len(selected_faces) != 0:
+ face = selected_faces[0]
+ selected_faces.remove(face)
+ active_island = [face]
+ active_faces = [face]
+
+ while len(active_faces) > 0:
+ connected_faces = island_extend(mesh, active_faces, selected_faces)
+ active_island.extend(connected_faces)
+ active_faces = connected_faces
+ selected_islands.append(active_island)
+
+ sel_f = []
+ for island in selected_islands:
+ sel_f.extend(island)
+
+ bpy.ops.object.mode_set(mode = 'EDIT')
+ bpy.ops.mesh.select_less()
+ bpy.ops.object.vertex_group_assign(new=True)
+ bpy.ops.object.mode_set(mode = 'OBJECT')
+
+ return (selected_islands)
+
+def island_extend(mesh, active_faces, selected_faces):
+ connected_faces = []
+ for face in active_faces:
+ cf = []
+ for f in selected_faces:
+ for edge in mesh.faces[face].edge_keys:
+ if edge in mesh.faces[f].edge_keys and f not in connected_faces:
+ connected_faces.append(f)
+ cf.append(f)
+ break
+
+ for f in cf: selected_faces.remove(f)
+ return(connected_faces)
+
+def find_outer_edge(mesh, island):
+ edges = []
+ for face in island:
+ for edge in mesh.faces[face].edge_keys: edges.append(edge)
+ outer_edges = []
+ for edge in edges:
+ if edges.count(edge) == 1:
+ outer_edges.append(edge)
+ return (outer_edges)
+
+def extend_vert_dict(mesh, edges, edge_vertices):
+ for edge in edges:
+ for vert in edge:
+ if vert not in edge_vertices:
+ edge_vertices[vert] = edge_vertex(vert)
+ edge_vertices[vert].edges.append(edge)
+ else:
+ edge_vertices[vert].edges.append(edge)
+
+
+class edge_vertex:
+ def __init__(self, index):
+ self.index = index
+ self.faces = []
+ self.edges = []
+
+def find_norm_vectors(mesh, vert_dict):
+ vertices = list(vert_dict.keys())
+ for vert in vertices:
+ edge_vectors = []
+ for edge in vert_dict[vert].edges:
+ if vert == edge[0]:
+ vec = mesh.vertices[edge[0]].co.copy() - mesh.vertices[edge[1]].co.copy()
+ else:
+ vec = mesh.vertices[edge[1]].co.copy() - mesh.vertices[edge[0]].co.copy()
+ edge_vectors.append(vec/vec.length)
+ vec1 = Vector.cross(edge_vectors[0], edge_vectors[1])
+ edges_vec = edge_vectors[1] + edge_vectors[0]
+ norm_vec = Vector.cross(vec1, edges_vec)
+ if norm_vec.length < 1e-12: #hackish fix for flat surfaces and straight edges
+ norm_vec = edge_vectors[0]
+
+ vert_dict[vert].new_index = len(mesh.vertices) + vertices.index(vert)
+ vert_dict[vert].norm_vec = norm_vec
+ vert_dict[vert].edge_vec = edge_vectors[0]
+
+
+def find_edge_faces(mesh, sel_faces, vert_dict):
+ edge_faces = []
+ for island in sel_faces:
+ for face in island:
+ for vert in mesh.faces[face].vertices:
+ if vert in vert_dict:
+ vert_dict[vert].faces.append(mesh.faces[face].index)
+ vert_dict[vert].island = sel_faces.index(island)
+ if face not in edge_faces: edge_faces.append(mesh.faces[face].index)
+ return edge_faces
+
+def find_offset_vec(mesh, vert_dict):
+ for vert in list(vert_dict.keys()):
+ for face in vert_dict[vert].faces:
+ rel_vec = [] # vertex vectors relative to active vertex
+ a = 0 # nr of verts on side 'a' of plane
+ b = 0 # on side b
+ for v in mesh.faces[face].vertices:
+ if v == vert: continue
+ rel_co = mesh.vertices[vert].co.copy() - mesh.vertices[v].co.copy()
+ rel_vec = rel_co/rel_co.length
+
+ case1 = rel_co - vert_dict[vert].norm_vec
+ case2 = rel_co + vert_dict[vert].norm_vec
+
+ if case1.length < case2.length:
+ a += 1
+ else:
+ b += 1
+ if a > 0 and b > 0:
+ middle_face = face
+ break
+
+ # find offset_vector
+ offset_vec_raw= Vector.cross(mesh.faces[middle_face].normal, vert_dict[vert].norm_vec)
+ offset_vec_norm = offset_vec_raw / offset_vec_raw.length
+ angle = acos(offset_vec_norm * vert_dict[vert].edge_vec)
+ if sin(angle) == 0:
+ angle = pi/2
+ offset_vec = offset_vec_norm / sin(angle)
+
+ if len(vert_dict[vert].faces) == 1:
+ face_center = Vector([0, 0, 0])
+ for v in mesh.faces[middle_face].vertices:
+ face_center += mesh.vertices[v].co.copy()
+ face_center /= len(mesh.faces[middle_face].vertices)
+
+ case1 = (face_center - mesh.vertices[vert].co.copy()) + offset_vec
+ case2 = (face_center - mesh.vertices[vert].co.copy()) - offset_vec
+ if case1.length < case2.length:
+ offset_vec.negate()
+
+ else:
+ for edge in mesh.faces[middle_face].edge_keys:
+ test = False
+ for face in vert_dict[vert].faces:
+ if face == middle_face: continue
+ if edge in mesh.faces[face].edge_keys:
+ test = True
+ break
+ if test:
+ if edge[0] == vert:
+ edge_vec = mesh.vertices[edge[1]].co - mesh.vertices[edge[0]].co
+ else:
+ edge_vec = mesh.vertices[edge[0]].co - mesh.vertices[edge[1]].co
+ continue
+ case1 = edge_vec + offset_vec
+ case2 = edge_vec - offset_vec
+ if case1.length < case2.length:
+ offset_vec.negate()
+
+ vert_dict[vert].offset_vec = offset_vec
+
+def new_faces(mesh, vert_dict, edge_faces, outer_edges):
+
+ faces_new = []
+ for face in edge_faces:
+ f_verts = []
+ for vert in mesh.faces[face].vertices:
+ if vert in vert_dict:
+ f_verts.append(vert_dict[vert].new_index)
+ else:
+ f_verts.append(vert)
+ if len(f_verts) == 3:
+ f_verts.append(f_verts[-1])
+ faces_new.append(f_verts)
+ not_selected = 0
+ for edge_island in outer_edges:
+ for edge in edge_island:
+ f_verts = [edge[0], edge[1], vert_dict[edge[1]].new_index, vert_dict[edge[0]].new_index]
+ faces_new.append(f_verts)
+ not_selected += 1
+
+
+
+ n_faces_old = len(mesh.faces)
+ rim_select = range(n_faces_old - len(edge_faces), (n_faces_old+len(faces_new)) - not_selected - len(edge_faces))
+ rim_noSelect = range((n_faces_old - len(edge_faces)) + (len(faces_new) - not_selected), n_faces_old - len(edge_faces) + len(faces_new))
+ mesh.faces.add(len(faces_new))
+ for i in range(len(faces_new)):
+ mesh.faces[n_faces_old + i].vertices_raw = faces_new[i]
+ mesh.update(calc_edges = True)
+
+ bpy.ops.object.mode_set(mode = 'EDIT')
+ bpy.ops.mesh.select_all(action='DESELECT')
+ bpy.ops.object.mode_set(mode = 'OBJECT')
+ for face in edge_faces:
+ mesh.faces[face].select = True
+ bpy.ops.object.mode_set(mode = 'EDIT')
+ bpy.ops.mesh.delete(type='FACE')
+ bpy.ops.object.mode_set(mode = 'OBJECT')
+ return (rim_select, rim_noSelect, n_faces_old) # return number of old faces to determine the first new face and compare normals to it
+
+
+def find_shortest_edge(mesh, edge_faces, vert_dict, outer_edges):
+ # finds the shortest edge that is connected to the outer rim
+ # will be used for scaling the sensitivity of the interface
+ shortest_edge = -1
+ for face in edge_faces:
+ for edge in mesh.faces[face].edge_keys:
+ if (edge not in outer_edges) and (edge[0] in vert_dict or edge[1] in vert_dict):
+ edgeco = mesh.vertices[edge[0]].co - mesh.vertices[edge[1]].co
+ if shortest_edge < 0 or edgeco.length < shortest_edge:
+ shortest_edge = edgeco.length
+ return(shortest_edge)
+
+def find_displace_vecs(mesh, sel_faces, vert_dict):
+ area = 0
+ inside_verts = {}
+ for island in sel_faces:
+ for face in island:
+ for vert in mesh.faces[face].vertices:
+ if vert in inside_verts:
+ inside_verts[vert].append(mesh.faces[face].normal)
+ else:
+ inside_verts[vert] = [mesh.faces[face].normal]
+ area += mesh.faces[face].area
+ displace_vecs = {}
+ for vert in list(inside_verts.keys()):
+ vec_norm = Vector([0,0,0])
+ for normal in inside_verts[vert]:
+ vec_norm += normal
+ vec_norm /= len(inside_verts[vert])
+ dot = vec_norm * inside_verts[vert][0]
+ if dot > 1: dot = 1
+ angle = acos(dot)
+ vec = vec_norm / sin(pi/2 - angle)
+ if vert in vert_dict:
+ displace_vecs[vert] = vec
+ else:
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-extensions-cvs
mailing list