[Bf-extensions-cvs] SVN commit: /data/svn/bf-extensions [3317] removing inset extrude from contrib
Brendon Murphy
meta.androcto1 at gmail.com
Fri Apr 27 14:58:39 CEST 2012
Revision: 3317
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-extensions&revision=3317
Author: meta-androcto
Date: 2012-04-27 12:58:38 +0000 (Fri, 27 Apr 2012)
Log Message:
-----------
removing inset extrude from contrib
adding to branches/broken_stuff/mesh_inset_extrude.py to archive the addon.
updated warning from previous commit, mesh_select_vertex_groups.py is indeed buggy.
Modified Paths:
--------------
contrib/py/scripts/addons/mesh_select_vertex_groups.py
Added Paths:
-----------
branches/broken_stuff/mesh_inset_extrude.py
Removed Paths:
-------------
contrib/py/scripts/addons/mesh_inset_extrude.py
Added: branches/broken_stuff/mesh_inset_extrude.py
===================================================================
--- branches/broken_stuff/mesh_inset_extrude.py (rev 0)
+++ branches/broken_stuff/mesh_inset_extrude.py 2012-04-27 12:58:38 UTC (rev 3317)
@@ -0,0 +1,637 @@
+bl_info = {
+ 'name': "Inset Extrude",
+ 'description': "Inset and Extrude selected polygons, useful modeling tool",
+ 'author': "Jon Sandstrom",
+ 'version': (0, 6),
+ 'blender': (2, 5, 9),
+ 'location': 'Search for Inset Extrude, map a key to the operator "mesh.inset_extrude", or use the default "I-key"',
+ 'warning': "Broken",
+ 'category': 'Mesh',
+ 'wiki_url': 'http://wiki.blender.org/index.php/Extensions:2.5/Py/Scripts/Modeling/Inset-Extrude'}
+
+import bpy, bmesh
+import bgl
+import blf
+from math import *
+from mathutils import Vector
+from bpy.props import FloatProperty, BoolProperty
+
+def find_sel_faces(mesh, individual_faces):
+ selected_faces = []
+ selected_islands = []
+ if individual_faces:
+ for face in mesh.polygons:
+ if face.select and not face.hide:
+ selected_islands.append([face.index])
+ return(selected_islands)
+
+ for face in mesh.polygons:
+ 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.polygons[face].edge_keys:
+ if edge in mesh.polygons[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.polygons[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, vert_dict):
+ for edge in edges:
+ for vert in edge:
+ if vert not in vert_dict:
+ vert_dict[vert] = edge_vertex(vert)
+ vert_dict[vert].edges.append(edge)
+ else:
+ vert_dict[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 face in sel_faces:
+ for vert in mesh.polygons[face].vertices:
+ if vert in vert_dict:
+ vert_dict[vert].faces.append(mesh.polygons[face].index)
+ if face not in edge_faces: edge_faces.append(mesh.polygons[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.polygons[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.polygons[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.polygons[middle_face].vertices:
+ face_center += mesh.vertices[v].co.copy()
+ face_center /= len(mesh.polygons[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.polygons[middle_face].edge_keys:
+ test = False
+ for face in vert_dict[vert].faces:
+ if face == middle_face: continue
+ if edge in mesh.polygons[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, island_dicts, edge_faces, outer_edges):
+
+ faces_new = []
+ for island in edge_faces:
+ vert_dict = island_dicts[edge_faces.index(island)]
+ for face in island:
+ f_verts = []
+ for vert in mesh.polygons[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:
+ vert_dict = island_dicts[outer_edges.index(edge_island)]
+ 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
+
+
+ ef_size = 0
+ for i in edge_faces: ef_size += len(i)
+ n_faces_old = len(mesh.polygons)
+ rim_select = range(n_faces_old - ef_size, (n_faces_old+len(faces_new)) - not_selected - ef_size)
+ rim_noSelect = range((n_faces_old - ef_size) + (len(faces_new) - not_selected), n_faces_old - ef_size + len(faces_new))
+ mesh.polygons.add(len(faces_new))
+ for i in range(len(faces_new)):
+ mesh.polygons[n_faces_old + i].vertices = 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 island in edge_faces:
+ for face in island:
+ mesh.polygons[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
+ if len(edge_faces) == 1:
+ for edge in mesh.polygons[edge_faces[0]].edge_keys:
+ edgeco = mesh.vertices[edge[0]].co - mesh.vertices[edge[1]].co
+ if shortest_edge < 0 or edgeco.length < shortest_edge:
+ shortest_edge = edgeco.length
+ for face in edge_faces:
+ for edge in mesh.polygons[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 face in sel_faces:
+ for vert in mesh.polygons[face].vertices:
+ if vert in inside_verts:
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-extensions-cvs
mailing list