'name': 'Dynamic Edge Fillet',

'author': 'Dealga McArdle (zeffii) <digitalaphasia.com>',

'version': (0, 2, 1),

'blender': (2, 5, 8),

'location': '3d view > Tool properties > Dynamic Edge Fillet',

'description': 'select a vertex, connected to two edges, it will fillet the edge.',

'wiki_url': '',

'tracker_url': '',

selected_verts = [i.index for i in obj.data.vertices if i.select]

# prevent script from operating if currently >1 vertex is selected.

verts_selected = len(selected_verts)

if verts_selected != 1:

return None

else:

edges = obj.data.edges

connecting_edges = [i for i in edges if found_index in i.vertices[:]]

if len(connecting_edges) != 2:

return None

else:

connected_verts = []

for edge in connecting_edges:

cvert = set(edge.vertices[:])

cvert.remove(found_index)

connected_verts.append(cvert.pop())

# this function should only be called when it will return the correct

# and expected result. it's ugly, but OK for now.

f_index = find_index_of_selected_vertex(obj)

edge_lengths = []

for vert in connected_verts:

co1 = obj.data.vertices[vert].co

co2 = obj.data.vertices[found_index].co

edge_lengths.append([vert, (co1-co2).length])

def get_first_cut(outer_point, focal, distance_from_f):

co1 = obj.data.vertices[focal].co

co2 = obj.data.vertices[outer_point].co

real_length = (co1-co2).length

ratio = distance_from_f / real_length

# must use new variable, cannot do co1 += obj_center, changes in place.

new_co1 = co1 + obj_centre

new_co2 = co2 + obj_centre

return new_co1.lerp(new_co2, ratio)

obj_centre = obj.location

distance_from_f = max_rad * bpy.context.scene.MyMove

# make imaginary line between outerpoints

outer_points = []

for point in c_index:

outer_points.append(get_first_cut(point, f_index, distance_from_f))

# make imaginary line from focal point to halfway between outer_points

focal_coordinate = obj.data.vertices[f_index].co + obj_centre

center_of_outer_points = (outer_points[0] + outer_points[1]) / 2

# find radial center, by lerping ab -> ad

BC = (center_of_outer_points-outer_points[1]).length

AB = (focal_coordinate-center_of_outer_points).length

BD = (BC/AB)*BC

AD = AB + BD

ratio = AD / AB

radial_center = focal_coordinate.lerp(center_of_outer_points, ratio)

guide_line = [focal_coordinate, radial_center]

obj_centre = context.object.location

axis = mathutils.geometry.normal(arc_centre, arc_end, arc_start)

NUM_VERTS = context.scene.NumVerts

point1 = arc_start - arc_centre

point2 = arc_end - arc_centre

main_angle = point1.angle(point2)

main_angle_degrees = math.degrees(main_angle)

div_angle = main_angle / (NUM_VERTS - 1)

if DEBUG:

print("arc_centre =", arc_centre)

print("arc_start =", arc_start)

print("arc_end =", arc_end)

print("NUM_VERTS =", NUM_VERTS)

print("NormalAxis1 =", axis)

print("Main Angle (Rad)", main_angle, " > degrees", main_angle_degrees)

print("Division Angle (Radians)", div_angle)

print("AXIS:", axis)

trig_arc_verts = []

# means more code, but meh.

if BUILD_REV >= CHANGE_REV:

for i in range(NUM_VERTS):

rotation_matrix = mathutils.Matrix.Rotation(i*-div_angle, 3, axis)

trig_point = rotation_matrix * (arc_start - obj_centre - arc_centre)

trig_point += obj_centre + arc_centre

trig_arc_verts.append(trig_point)

else:

for i in range(NUM_VERTS):

rotation_matrix = mathutils.Matrix.Rotation(i*-div_angle, 3, axis)

trig_point = (arc_start - obj_centre - arc_centre) * rotation_matrix

trig_point += obj_centre + arc_centre

trig_arc_verts.append(trig_point)

NUM_VERTS = context.scene.NumVerts

MODE_SIGN = context.scene.FilletSign

mode = context.scene.FilletMode

# get control points and knots.

h_control = guide_verts[0]

knot1, knot2 = points[0], points[1]

# draw fillet ( 2 modes )

if mode == 'KAPPA':

kappa_ctrl_1 = knot1.lerp(h_control, context.scene.CurveHandle1)

kappa_ctrl_2 = knot2.lerp(h_control, context.scene.CurveHandle2)

arc_verts = bezlerp(knot1, kappa_ctrl_1, kappa_ctrl_2, knot2, NUM_VERTS)

if mode == 'TRIG':

if MODE_SIGN == 'POS':

arc_centre = guide_verts[1]

arc_verts = get_correct_verts(arc_centre, knot1, knot2, context)

if MODE_SIGN == 'NEG':

arc_centre = guide_verts[0]

arc_verts = get_correct_verts(arc_centre, knot2, knot1, context)

obj = context.object

# update the mesh before proceeding.

obj.data.update()

bpy.ops.object.mode_set(mode='EDIT')

# unselect all, perform vertex selection in object mode

bpy.ops.mesh.select_all(action='TOGGLE')

bpy.ops.object.mode_set(mode='OBJECT')

bpy.context.active_object.data.vertices[removable_vert].select = True

# back into edit mode, delete the removable_vert

bpy.ops.object.mode_set(mode='EDIT')

bpy.ops.mesh.delete()

# this cleans up the doubles generated by a fillet size that is

# equal to one of the edge lengths. i should be shot for this.

if context.scene.MyMove == 1.0:

bpy.ops.mesh.select_all(action='TOGGLE')

bpy.ops.mesh.remove_doubles()

bpy.ops.mesh.select_all(action='TOGGLE')

NUM_VERTS = context.scene.NumVerts

MODE_SIGN = context.scene.FilletSign

points, guide_verts = init_functions(self, context)

# changing mesh 3dview mode, requires object mode.

bpy.ops.object.mode_set(mode='OBJECT')

# we need a little bit of info from the obj

obj = context.object

removable_vert = find_index_of_selected_vertex(obj)

idx1, idx2 = return_connected_from_object(obj)

# whatever the mode is and user settings are, this returns the arc points.

arc_verts = get_arc_from_state(points, guide_verts, context)

# make vertices

obj.data.vertices.add(NUM_VERTS)

vertex_counter = NUM_VERTS

for vert in range(len(arc_verts)):

obj.data.vertices[-vertex_counter].co = arc_verts[vert]

vertex_counter -= 1

# build edges, find a prettier way to do this. it's ridiculous.

NUM_EDGES = (NUM_VERTS - 1)

obj.data.edges.add(NUM_EDGES)

# must count current verts first

current_vert_count = len(bpy.context.object.data.vertices)

edge_counter = -NUM_EDGES

vertex_ID = current_vert_count - NUM_VERTS

for edge in range(NUM_VERTS-1):

a = vertex_ID

b = vertex_ID+1

obj.data.edges[edge_counter].vertices = [a, b]

edge_counter += 1

vertex_ID += 1

# connect first and last new edge with the 2 existing 'found indices'

obj.data.edges.add(2)

last_new_vert = current_vert_count-1

first_new_vert = current_vert_count-NUM_VERTS

if context.scene.FilletMode == 'KAPPA':

MODE_SIGN = 'POS'

if MODE_SIGN == 'POS':

obj.data.edges[-2].vertices = [idx1, first_new_vert]

obj.data.edges[-1].vertices = [idx2, last_new_vert]

if MODE_SIGN == 'NEG':

obj.data.edges[-2].vertices = [idx2, first_new_vert]

obj.data.edges[-1].vertices = [idx1, last_new_vert]

# removes geometry, the first selected vertex. deals with doubles.

perform_tidyup(context, removable_vert)

obj = context.object

# Finding vertex.

found_index = find_index_of_selected_vertex(obj)

if found_index != None:

if DEBUG:

print("you selected vertex with index", found_index)

connected_verts = find_connected_verts(obj, found_index)

else:

if DEBUG:

print("select one vertex, no more, no less")

return None

# Find connected vertices.

if connected_verts == None:

if DEBUG:

print("vertex connected to only 1 other vert, or none at all")

print("remove doubles, the script operates on vertices with 2 edges")

return None

else:

if DEBUG:

print(connected_verts)

# reaching this stage means the vertex has 2 connected vertices. good.

# Find distances and maximum radius.

distances = find_distances(obj, connected_verts, found_index)

if DEBUG:

for d in distances:

print("from", found_index, "to", d[0], "=", d[1])

max_rad = min(distances[0][1],distances[1][1])

if DEBUG:

print("max radius", max_rad)

region = context.region

rv3d = context.space_data.region_3d

bgl.glColor4f(1.0, 1.0, 1.0, 1.0)

if LINE_TYPE == "GL_LINE_STIPPLE":

bgl.glLineStipple(4, 0x5555)

bgl.glEnable(bgl.GL_LINE_STIPPLE)

bgl.glColor4f(0.3, 0.3, 0.3, 1.0)

bgl.glBegin(bgl.GL_LINE_STRIP)

for coord in points:

vector3d = (coord.x, coord.y, coord.z)

vector2d = loc3d2d(region, rv3d, vector3d)

bgl.glVertex2f(*vector2d)

bgl.glEnd()

if LINE_TYPE == "GL_LINE_STIPPLE":

bgl.glDisable(bgl.GL_LINE_STIPPLE)

bgl.glEnable(bgl.GL_BLEND) # back to uninterupted lines

region = context.region

rv3d = context.space_data.region_3d

# needed for adjusting the size of gl_points

bgl.glEnable(bgl.GL_POINT_SMOOTH)

bgl.glPointSize(size)

bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)

bgl.glBegin(bgl.GL_POINTS)

bgl.glColor4f(*gl_col)

for coord in points:

vector3d = (coord.x, coord.y, coord.z)

vector2d = loc3d2d(region, rv3d, vector3d)

bgl.glVertex2f(*vector2d)

bgl.glEnd()

bgl.glDisable(bgl.GL_POINT_SMOOTH)

bgl.glDisable(bgl.GL_POINTS)

bgl.glColor4f(1.0, 1.0, 1.0, 0.8)

xpos, ypos = location

font_id = 0

blf.size(font_id, 12, 72) #fine tune

blf.position(font_id, location[0], location[1], 0)

num_edges = str(NUM_VERTS - 1)

if num_edges == str(1):

postfix = " edge"

else:

postfix = " edges"

display_text = str(NUM_VERTS)+" vert fillet, " + num_edges + postfix

blf.draw(font_id, display_text)

if init_functions(self, context) == None:

return

region = context.region

rv3d = context.space_data.region_3d

points, guide_verts = init_functions(self, context)

arc_verts = get_arc_from_state(points, guide_verts, context)

# draw bevel, followed by symmetry line, then fillet edge loop

draw_polyline_from_coordinates(context, points, "GL_LINE_STIPPLE")

draw_polyline_from_coordinates(context, guide_verts, "GL_LINE_STIPPLE")

draw_polyline_from_coordinates(context, arc_verts, "GL_BLEND")

# draw arc verts, then radial centre

if DRAW_POINTS:

draw_points(context, arc_verts, 4.2, gl_col1)

draw_points(context, [guide_verts[1]], 5.2, gl_col2)

# draw bottom left, above object name the number of vertices in the fillet

draw_text(context, (65, 30), context.scene.NumVerts)

# restore opengl defaults

bgl.glLineWidth(1)

bgl.glDisable(bgl.GL_BLEND)

bgl.glColor4f(0.0, 0.0, 0.0, 1.0)

bl_label = "Dynamic Edge Fillet"

bl_space_type = "VIEW_3D"

bl_region_type = "TOOL_PROPS"

scn = bpy.types.Scene

# object = bpy.context.object

scn.MeshVertexIndex = bpy.props.IntProperty(min=0, default=0)

scn.FilletMode = bpy.props.EnumProperty( items =(

('TRIG', 'TRIG', ''),

('KAPPA', 'KAPPA', '')),

name = 'filletmodes',

default = 'TRIG' )

scn.MyMove = bpy.props.FloatProperty(min=0.00001, max=1.0,

default=0.5, precision=5,

name="ratio of shortest edge")

scn.NumVerts = bpy.props.IntProperty(min=2, max=64, default=12,

name="number of verts")

scn.CurveHandle1 = bpy.props.FloatProperty( min=0.0, max=4.0,

default = KAPPA,

name="handle1")

scn.CurveHandle2 = bpy.props.FloatProperty( min=0.0, max=4.0,

default = KAPPA,

name="handle2")

scn.FilletSign = bpy.props.EnumProperty( items =(

('POS', '+', ''),

('NEG', '-', '')),

name = 'filletdirection',

default = 'POS' )

@classmethod

def poll(self, context):

obj = context.object

found_index = find_index_of_selected_vertex(obj)

if found_index != None:

connected_verts = find_connected_verts(obj, found_index)

if connected_verts != None:

if context.object.mode == 'EDIT':

return True

def draw(self, context):

layout = self.layout

ob = context.object

scn = context.scene

row1 = layout.row(align=True)

row1.prop(scn, "FilletMode", expand = True)

row2 = layout.row(align=True)

row2.operator("dynamic.fillet")

row3 = layout.row(align=True)

row3.prop(scn, "MyMove", slider=True)

if scn.FilletMode == 'KAPPA':

row4 = layout.row(align=True)

row4.prop(scn, "CurveHandle1", slider=True)

row4.prop(scn, "CurveHandle2", slider=True)

row5 = layout.row(align=True)

row5.operator("reset.handles")

if scn.FilletMode == 'TRIG':

row6 = layout.row(align=True)

bl_idname = "reset.handles"

bl_label = "Reset Handles"

bl_description = "Resets both handles, a convenience"

bl_options = {'REGISTER', 'UNDO'}

def execute(self, context):

KAPPA = 4 * (( math.sqrt(2) - 1) / 3 )

context.scene.CurveHandle1 = KAPPA

context.scene.CurveHandle2 = KAPPA

bl_idname = "dynamic.fillet"

bl_label = "Check Vertex"

bl_description = "Allows the user to dynamically fillet a vert/edge"

bl_options = {'REGISTER', 'UNDO'}

# i understand that a lot of these ifs are redundant, scheduled for

# deletion. is 'RELEASE' redundant for keys?

def modal(self, context, event):

context.area.tag_redraw()

if event.type == 'ESC':

if event.value == 'RELEASE':

# print("discontinue drawing")

context.area.tag_redraw()

context.region.callback_remove(self._handle)

return {'CANCELLED'}

if event.type == 'RIGHTMOUSE':

if event.value == 'RELEASE':

# update on alternate vertex selection.

bpy.ops.object.editmode_toggle()

bpy.ops.object.editmode_toggle()

return {'PASS_THROUGH'}

if event.type == 'LEFTMOUSE':

if event.value in ('PRESS', 'RELEASE'):

context.area.tag_redraw()

# HALF_RAD = context.scene.MyMove

# context.region.callback_remove(self._handle)

return {'PASS_THROUGH'}

if event.shift:

# take control of numpad plus / minus

if event.type == 'NUMPAD_PLUS' and event.value == 'RELEASE':

if context.scene.NumVerts <= 64:

context.scene.NumVerts += 1

return {'PASS_THROUGH'}

if event.type == 'NUMPAD_MINUS' and event.value == 'RELEASE':

if context.scene.NumVerts >=3:

context.scene.NumVerts -= 1

return {'PASS_THROUGH'}

# allows you to rotate around.

if event.type == 'MIDDLEMOUSE':

# context.area.tag_redraw()

# print(event.value)

if event.value == 'PRESS':

# print("Allow to rotate")

context.area.tag_redraw()

return {'PASS_THROUGH'}

if event.value == 'RELEASE':

context.area.tag_redraw()

# print("allow to interact with ui")

return {'PASS_THROUGH'}

# allows you to zoom.

if event.type in ('WHEELUPMOUSE', 'WHEELDOWNMOUSE'):

context.area.tag_redraw()

return {'PASS_THROUGH'}

# make real

if event.type in ('RET','NUMPAD_ENTER') and event.value == 'RELEASE':

# before calling the function, let's check if the state is right.

if init_functions(self, context) != None:

generate_geometry_already(self, context)

context.region.callback_remove(self._handle)

# user has unselected it.

if find_index_of_selected_vertex(context.object) == None:

report_string = "Atleast one vertex must be selected"

self.report({'INFO'}, report_string)

return {'CANCELLED'}

# context.area.tag_redraw()

return {'PASS_THROUGH'}

def invoke(self, context, event):

# let's make sure we have the right vertex. UGLY!

bpy.ops.object.editmode_toggle()

bpy.ops.object.editmode_toggle()

if context.area.type == 'VIEW_3D':

context.area.tag_redraw()

context.window_manager.modal_handler_add(self)

# Add the region OpenGL drawing callback

# draw in view space with 'POST_VIEW' and 'PRE_VIEW'

self._handle = context.region.callback_add(

draw_callback_px,

(self, context),

'POST_PIXEL')

return {'RUNNING_MODAL'}

else:

self.report({'WARNING'},

"View3D not found, cannot run operator")

context.area.tag_redraw()