# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright 2012 Paul Marshall.
# The Blender Edgetools is to bring CAD tools to Blender.
bl_info = {
"name": "EdgeTools",
"author": "Paul Marshall",
"version": (0, 9, 2),
"blender": (2, 80, 0),
"location": "View3D > Toolbar and View3D > Specials (W-key)",
"warning": "",
"description": "CAD style edge manipulation tools",
"doc_url": "https://wiki.blender.org/index.php/Extensions:2.6/Py/"
"Scripts/Modeling/EdgeTools",
"category": "Mesh",
}
import bpy
import bmesh
from bpy.types import (
Operator,
Menu,
)
from math import acos, pi, radians, sqrt
from mathutils import Matrix, Vector
from mathutils.geometry import (
distance_point_to_plane,
interpolate_bezier,
intersect_point_line,
intersect_line_line,
intersect_line_plane,
)
from bpy.props import (
BoolProperty,
IntProperty,
FloatProperty,
EnumProperty,
)
"""
Blender EdgeTools
This is a toolkit for edge manipulation based on mesh manipulation
abilities of several CAD/CAE packages, notably CATIA's Geometric Workbench
from which most of these tools have a functional basis.
The GUI and Blender add-on structure shamelessly coded in imitation of the
LoopTools addon.
Examples:
- "Ortho" inspired from CATIA's line creation tool which creates a line of a
user specified length at a user specified angle to a curve at a chosen
point. The user then selects the plane the line is to be created in.
- "Shaft" is inspired from CATIA's tool of the same name. However, instead
of a curve around an axis, this will instead shaft a line, a point, or
a fixed radius about the selected axis.
- "Slice" is from CATIA's ability to split a curve on a plane. When
completed this be a Python equivalent with all the same basic
functionality, though it will sadly be a little clumsier to use due
to Blender's selection limitations.
Notes:
- Fillet operator and related functions removed as they didn't work
- Buggy parts have been hidden behind ENABLE_DEBUG global (set it to True)
Example: Shaft with more than two edges selected
Paul "BrikBot" Marshall
Created: January 28, 2012
Last Modified: October 6, 2012
Coded in IDLE, tested in Blender 2.6.
Search for "@todo" to quickly find sections that need work
Note: lijenstina - modified this script in preparation for merging
fixed the needless jumping to object mode for bmesh creation
causing the crash with the Slice > Rip operator
Removed the test operator since version 0.9.2
added general error handling
"""
# Enable debug
# Set to True to have the debug prints available
ENABLE_DEBUG = False
# Quick an dirty method for getting the sign of a number:
def sign(number):
return (number > 0) - (number < 0)
# is_parallel
# Checks to see if two lines are parallel
def is_parallel(v1, v2, v3, v4):
result = intersect_line_line(v1, v2, v3, v4)
return result is None
# Handle error notifications
def error_handlers(self, op_name, error, reports="ERROR", func=False):
if self and reports:
self.report({'WARNING'}, reports + " (See Console for more info)")
is_func = "Function" if func else "Operator"
print("\n[Mesh EdgeTools]\n{}: {}\nError: {}\n".format(is_func, op_name, error))
def flip_edit_mode():
bpy.ops.object.editmode_toggle()
bpy.ops.object.editmode_toggle()
# check the appropriate selection condition
# to prevent crashes with the index out of range errors
# pass the bEdges and bVerts based selection tables here
# types: Edge, Vertex, All
def is_selected_enough(self, bEdges, bVerts, edges_n=1, verts_n=0, types="Edge"):
check = False
try:
if bEdges and types == "Edge":
check = (len(bEdges) >= edges_n)
elif bVerts and types == "Vertex":
check = (len(bVerts) >= verts_n)
elif bEdges and bVerts and types == "All":
check = (len(bEdges) >= edges_n and len(bVerts) >= verts_n)
if check is False:
strings = "%s Vertices and / or " % verts_n if verts_n != 0 else ""
self.report({'WARNING'},
"Needs at least " + strings + "%s Edge(s) selected. "
"Operation Cancelled" % edges_n)
flip_edit_mode()
return check
except Exception as e:
error_handlers(self, "is_selected_enough", e,
"No appropriate selection. Operation Cancelled", func=True)
return False
return False
# is_axial
# This is for the special case where the edge is parallel to an axis.
# The projection onto the XY plane will fail so it will have to be handled differently
def is_axial(v1, v2, error=0.000002):
vector = v2 - v1
# Don't need to store, but is easier to read:
vec0 = vector[0] > -error and vector[0] < error
vec1 = vector[1] > -error and vector[1] < error
vec2 = vector[2] > -error and vector[2] < error
if (vec0 or vec1) and vec2:
return 'Z'
elif vec0 and vec1:
return 'Y'
return None
# is_same_co
# For some reason "Vector = Vector" does not seem to look at the actual coordinates
def is_same_co(v1, v2):
if len(v1) != len(v2):
return False
else:
for co1, co2 in zip(v1, v2):
if co1 != co2:
return False
return True
def is_face_planar(face, error=0.0005):
for v in face.verts:
d = distance_point_to_plane(v.co, face.verts[0].co, face.normal)
if ENABLE_DEBUG:
print("Distance: " + str(d))
if d < -error or d > error:
return False
return True
# other_joined_edges
# Starts with an edge. Then scans for linked, selected edges and builds a
# list with them in "order", starting at one end and moving towards the other
def order_joined_edges(edge, edges=[], direction=1):
if len(edges) == 0:
edges.append(edge)
edges[0] = edge
if ENABLE_DEBUG:
print(edge, end=", ")
print(edges, end=", ")
print(direction, end="; ")
# Robustness check: direction cannot be zero
if direction == 0:
direction = 1
newList = []
for e in edge.verts[0].link_edges:
if e.select and edges.count(e) == 0:
if direction > 0:
edges.insert(0, e)
newList.extend(order_joined_edges(e, edges, direction + 1))
newList.extend(edges)
else:
edges.append(e)
newList.extend(edges)
newList.extend(order_joined_edges(e, edges, direction - 1))
# This will only matter at the first level:
direction = direction * -1
for e in edge.verts[1].link_edges:
if e.select and edges.count(e) == 0:
if direction > 0:
edges.insert(0, e)
newList.extend(order_joined_edges(e, edges, direction + 2))
newList.extend(edges)
else:
edges.append(e)
newList.extend(edges)
newList.extend(order_joined_edges(e, edges, direction))
if ENABLE_DEBUG:
print(newList, end=", ")
print(direction)
return newList
# --------------- GEOMETRY CALCULATION METHODS --------------
# distance_point_line
# I don't know why the mathutils.geometry API does not already have this, but
# it is trivial to code using the structures already in place. Instead of
# returning a float, I also want to know the direction vector defining the
# distance. Distance can be found with "Vector.length"
def distance_point_line(pt, line_p1, line_p2):
int_co = intersect_point_line(pt, line_p1, line_p2)
distance_vector = int_co[0] - pt
return distance_vector
# interpolate_line_line
# This is an experiment into a cubic Hermite spline (c-spline) for connecting
# two edges with edges that obey the general equation.
# This will return a set of point coordinates (Vectors)
#
# A good, easy to read background on the mathematics can be found at:
# http://cubic.org/docs/hermite.htm
#
# Right now this is . . . less than functional :P
# @todo
# - C-Spline and Bezier curves do not end on p2_co as they are supposed to.
# - B-Spline just fails. Epically.
# - Add more methods as I come across them. Who said flexibility was bad?
def interpolate_line_line(p1_co, p1_dir, p2_co, p2_dir, segments, tension=1,
typ='BEZIER', include_ends=False):
pieces = []
fraction = 1 / segments
# Form: p1, tangent 1, p2, tangent 2
if typ == 'HERMITE':
poly = [[2, -3, 0, 1], [1, -2, 1, 0],
[-2, 3, 0, 0], [1, -1, 0, 0]]
elif typ == 'BEZIER':
poly = [[-1, 3, -3, 1], [3, -6, 3, 0],
[1, 0, 0, 0], [-3, 3, 0, 0]]
p1_dir = p1_dir + p1_co
p2_dir = -p2_dir + p2_co
elif typ == 'BSPLINE':
# Supposed poly matrix for a cubic b-spline:
# poly = [[-1, 3, -3, 1], [3, -6, 3, 0],
# [-3, 0, 3, 0], [1, 4, 1, 0]]
# My own invention to try to get something that somewhat acts right
# This is semi-quadratic rather than fully cubic:
poly = [[0, -1, 0, 1], [1, -2, 1, 0],
[0, -1, 2, 0], [1, -1, 0, 0]]
if include_ends:
pieces.append(p1_co)
# Generate each point:
for i in range(segments - 1):
t = fraction * (i + 1)
if ENABLE_DEBUG:
print(t)
s = [t ** 3, t ** 2, t, 1]
h00 = (poly[0][0] * s[0]) + (poly[0][1] * s[1]) + (poly[0][2] * s[2]) + (poly[0][3] * s[3])
h01 = (poly[1][0] * s[0]) + (poly[1][1] * s[1]) + (poly[1][2] * s[2]) + (poly[1][3] * s[3])
h10 = (poly[2][0] * s[0]) + (poly[2][1] * s[1]) + (poly[2][2] * s[2]) + (poly[2][3] * s[3])
h11 = (poly[3][0] * s[0]) + (poly[3][1] * s[1]) + (poly[3][2] * s[2]) + (poly[3][3] * s[3])
pieces.append((h00 * p1_co) + (h01 * p1_dir) + (h10 * p2_co) + (h11 * p2_dir))
if include_ends:
pieces.append(p2_co)
# Return:
if len(pieces) == 0:
return None
else:
if ENABLE_DEBUG:
print(pieces)
return pieces
# intersect_line_face
# Calculates the coordinate of intersection of a line with a face. It returns
# the coordinate if one exists, otherwise None. It can only deal with tris or
# quads for a face. A quad does NOT have to be planar
"""
Quad math and theory:
A quad may not be planar. Therefore the treated definition of the surface is
that the surface is composed of all lines bridging two other lines defined by
the given four points. The lines do not "cross"
The two lines in 3-space can defined as:
┌ ┐ ┌ ┐ ┌ ┐ ┌ ┐ ┌ ┐ ┌ ┐
│x1│ │a11│ │b11│ │x2│ │a21│ │b21│
│y1│ = (1-t1)│a12│ + t1│b12│, │y2│ = (1-t2)│a22│ + t2│b22│
│z1│ │a13│ │b13│ │z2│ │a23│ │b23│
└ ┘ └ ┘ └ ┘ └ ┘ └ ┘ └ ┘
Therefore, the surface is the lines defined by every point alone the two
lines with a same "t" value (t1 = t2). This is basically R = V1 + tQ, where
Q = V2 - V1 therefore R = V1 + t(V2 - V1) -> R = (1 - t)V1 + tV2:
┌ ┐ ┌ ┐ ┌ ┐
│x12│ │(1-t)a11 + t * b11│ │(1-t)a21 + t * b21│
│y12│ = (1 - t12)│(1-t)a12 + t * b12│ + t12│(1-t)a22 + t * b22│
│z12│ │(1-t)a13 + t * b13│ │(1-t)a23 + t * b23│
└ ┘ └ ┘ └ ┘
Now, the equation of our line can be likewise defined:
┌ ┐ ┌ ┐ ┌ ┐
│x3│ │a31│ │b31│
│y3│ = │a32│ + t3│b32│
│z3│ │a33│ │b33│
└ ┘ └ ┘ └ ┘
Now we just have to find a valid solution for the two equations. This should
be our point of intersection. Therefore, x12 = x3 -> x, y12 = y3 -> y,
z12 = z3 -> z. Thus, to find that point we set the equation defining the
surface as equal to the equation for the line:
┌ ┐ ┌ ┐ ┌ ┐ ┌ ┐
│(1-t)a11 + t * b11│ │(1-t)a21 + t * b21│ │a31│ │b31│
(1 - t12)│(1-t)a12 + t * b12│ + t12│(1-t)a22 + t * b22│ = │a32│ + t3│b32│
│(1-t)a13 + t * b13│ │(1-t)a23 + t * b23│ │a33│ │b33│
└ ┘ └ ┘ └ ┘ └ ┘
This leaves us with three equations, three unknowns. Solving the system by
hand is practically impossible, but using Mathematica we are given an insane
series of three equations (not reproduced here for the sake of space: see
http://www.mediafire.com/file/cc6m6ba3sz2b96m/intersect_line_surface.nb and
http://www.mediafire.com/file/0egbr5ahg14talm/intersect_line_surface2.nb for
Mathematica computation).
Additionally, the resulting series of equations may result in a div by zero
exception if the line in question if parallel to one of the axis or if the
quad is planar and parallel to either the XY, XZ, or YZ planes. However, the
system is still solvable but must be dealt with a little differently to avaid
these special cases. Because the resulting equations are a little different,
we have to code them differently. 00Hence the special cases.
Tri math and theory:
A triangle must be planar (three points define a plane). So we just
have to make sure that the line intersects inside the triangle.
If the point is within the triangle, then the angle between the lines that
connect the point to the each individual point of the triangle will be
equal to 2 * PI. Otherwise, if the point is outside the triangle, then the
sum of the angles will be less.
"""
# @todo
# - Figure out how to deal with n-gons
# How the heck is a face with 8 verts defined mathematically?
# How do I then find the intersection point of a line with said vert?
# How do I know if that point is "inside" all the verts?
# I have no clue, and haven't been able to find anything on it so far
# Maybe if someone (actually reads this and) who knows could note?
def intersect_line_face(edge, face, is_infinite=False, error=0.000002):
int_co = None
# If we are dealing with a non-planar quad:
if len(face.verts) == 4 and not is_face_planar(face):
edgeA = face.edges[0]
edgeB = None
flipB = False
for i in range(len(face.edges)):
if face.edges[i].verts[0] not in edgeA.verts and \
face.edges[i].verts[1] not in edgeA.verts:
edgeB = face.edges[i]
break
# I haven't figured out a way to mix this in with the above. Doing so might remove a
# few extra instructions from having to be executed saving a few clock cycles:
for i in range(len(face.edges)):
if face.edges[i] == edgeA or face.edges[i] == edgeB:
continue
if ((edgeA.verts[0] in face.edges[i].verts and
edgeB.verts[1] in face.edges[i].verts) or
(edgeA.verts[1] in face.edges[i].verts and edgeB.verts[0] in face.edges[i].verts)):
flipB = True
break
# Define calculation coefficient constants:
# "xx1" is the x coordinate, "xx2" is the y coordinate, and "xx3" is the z coordinate
a11, a12, a13 = edgeA.verts[0].co[0], edgeA.verts[0].co[1], edgeA.verts[0].co[2]
b11, b12, b13 = edgeA.verts[1].co[0], edgeA.verts[1].co[1], edgeA.verts[1].co[2]
if flipB:
a21, a22, a23 = edgeB.verts[1].co[0], edgeB.verts[1].co[1], edgeB.verts[1].co[2]
b21, b22, b23 = edgeB.verts[0].co[0], edgeB.verts[0].co[1], edgeB.verts[0].co[2]
else:
a21, a22, a23 = edgeB.verts[0].co[0], edgeB.verts[0].co[1], edgeB.verts[0].co[2]
b21, b22, b23 = edgeB.verts[1].co[0], edgeB.verts[1].co[1], edgeB.verts[1].co[2]
a31, a32, a33 = edge.verts[0].co[0], edge.verts[0].co[1], edge.verts[0].co[2]
b31, b32, b33 = edge.verts[1].co[0], edge.verts[1].co[1], edge.verts[1].co[2]
# There are a bunch of duplicate "sub-calculations" inside the resulting
# equations for t, t12, and t3. Calculate them once and store them to
# reduce computational time:
m01 = a13 * a22 * a31
m02 = a12 * a23 * a31
m03 = a13 * a21 * a32
m04 = a11 * a23 * a32
m05 = a12 * a21 * a33
m06 = a11 * a22 * a33
m07 = a23 * a32 * b11
m08 = a22 * a33 * b11
m09 = a23 * a31 * b12
m10 = a21 * a33 * b12
m11 = a22 * a31 * b13
m12 = a21 * a32 * b13
m13 = a13 * a32 * b21
m14 = a12 * a33 * b21
m15 = a13 * a31 * b22
m16 = a11 * a33 * b22
m17 = a12 * a31 * b23
m18 = a11 * a32 * b23
m19 = a13 * a22 * b31
m20 = a12 * a23 * b31
m21 = a13 * a32 * b31
m22 = a23 * a32 * b31
m23 = a12 * a33 * b31
m24 = a22 * a33 * b31
m25 = a23 * b12 * b31
m26 = a33 * b12 * b31
m27 = a22 * b13 * b31
m28 = a32 * b13 * b31
m29 = a13 * b22 * b31
m30 = a33 * b22 * b31
m31 = a12 * b23 * b31
m32 = a32 * b23 * b31
m33 = a13 * a21 * b32
m34 = a11 * a23 * b32
m35 = a13 * a31 * b32
m36 = a23 * a31 * b32
m37 = a11 * a33 * b32
m38 = a21 * a33 * b32
m39 = a23 * b11 * b32
m40 = a33 * b11 * b32
m41 = a21 * b13 * b32
m42 = a31 * b13 * b32
m43 = a13 * b21 * b32
m44 = a33 * b21 * b32
m45 = a11 * b23 * b32
m46 = a31 * b23 * b32
m47 = a12 * a21 * b33
m48 = a11 * a22 * b33
m49 = a12 * a31 * b33
m50 = a22 * a31 * b33
m51 = a11 * a32 * b33
m52 = a21 * a32 * b33
m53 = a22 * b11 * b33
m54 = a32 * b11 * b33
m55 = a21 * b12 * b33
m56 = a31 * b12 * b33
m57 = a12 * b21 * b33
m58 = a32 * b21 * b33
m59 = a11 * b22 * b33
m60 = a31 * b22 * b33
m61 = a33 * b12 * b21
m62 = a32 * b13 * b21
m63 = a33 * b11 * b22
m64 = a31 * b13 * b22
m65 = a32 * b11 * b23
m66 = a31 * b12 * b23
m67 = b13 * b22 * b31
m68 = b12 * b23 * b31
m69 = b13 * b21 * b32
m70 = b11 * b23 * b32
m71 = b12 * b21 * b33
m72 = b11 * b22 * b33
n01 = m01 - m02 - m03 + m04 + m05 - m06
n02 = -m07 + m08 + m09 - m10 - m11 + m12 + m13 - m14 - m15 + m16 + m17 - m18 - \
m25 + m27 + m29 - m31 + m39 - m41 - m43 + m45 - m53 + m55 + m57 - m59
n03 = -m19 + m20 + m33 - m34 - m47 + m48
n04 = m21 - m22 - m23 + m24 - m35 + m36 + m37 - m38 + m49 - m50 - m51 + m52
n05 = m26 - m28 - m30 + m32 - m40 + m42 + m44 - m46 + m54 - m56 - m58 + m60
n06 = m61 - m62 - m63 + m64 + m65 - m66 - m67 + m68 + m69 - m70 - m71 + m72
n07 = 2 * n01 + n02 + 2 * n03 + n04 + n05
n08 = n01 + n02 + n03 + n06
# Calculate t, t12, and t3:
t = (n07 - sqrt(pow(-n07, 2) - 4 * (n01 + n03 + n04) * n08)) / (2 * n08)
# t12 can be greatly simplified by defining it with t in it:
# If block used to help prevent any div by zero error.
t12 = 0
if a31 == b31:
# The line is parallel to the z-axis:
if a32 == b32:
t12 = ((a11 - a31) + (b11 - a11) * t) / ((a21 - a11) + (a11 - a21 - b11 + b21) * t)
# The line is parallel to the y-axis:
elif a33 == b33:
t12 = ((a11 - a31) + (b11 - a11) * t) / ((a21 - a11) + (a11 - a21 - b11 + b21) * t)
# The line is along the y/z-axis but is not parallel to either:
else:
t12 = -(-(a33 - b33) * (-a32 + a12 * (1 - t) + b12 * t) + (a32 - b32) *
(-a33 + a13 * (1 - t) + b13 * t)) / (-(a33 - b33) *
((a22 - a12) * (1 - t) + (b22 - b12) * t) + (a32 - b32) *
((a23 - a13) * (1 - t) + (b23 - b13) * t))
elif a32 == b32:
# The line is parallel to the x-axis:
if a33 == b33:
t12 = ((a12 - a32) + (b12 - a12) * t) / ((a22 - a12) + (a12 - a22 - b12 + b22) * t)
# The line is along the x/z-axis but is not parallel to either:
else:
t12 = -(-(a33 - b33) * (-a31 + a11 * (1 - t) + b11 * t) + (a31 - b31) * (-a33 + a13 *
(1 - t) + b13 * t)) / (-(a33 - b33) * ((a21 - a11) * (1 - t) + (b21 - b11) * t) +
(a31 - b31) * ((a23 - a13) * (1 - t) + (b23 - b13) * t))
# The line is along the x/y-axis but is not parallel to either:
else:
t12 = -(-(a32 - b32) * (-a31 + a11 * (1 - t) + b11 * t) + (a31 - b31) * (-a32 + a12 *
(1 - t) + b12 * t)) / (-(a32 - b32) * ((a21 - a11) * (1 - t) + (b21 - b11) * t) +
(a31 - b31) * ((a22 - a21) * (1 - t) + (b22 - b12) * t))
# Likewise, t3 is greatly simplified by defining it in terms of t and t12:
# If block used to prevent a div by zero error.
t3 = 0
if a31 != b31:
t3 = (-a11 + a31 + (a11 - b11) * t + (a11 - a21) *
t12 + (a21 - a11 + b11 - b21) * t * t12) / (a31 - b31)
elif a32 != b32:
t3 = (-a12 + a32 + (a12 - b12) * t + (a12 - a22) *
t12 + (a22 - a12 + b12 - b22) * t * t12) / (a32 - b32)
elif a33 != b33:
t3 = (-a13 + a33 + (a13 - b13) * t + (a13 - a23) *
t12 + (a23 - a13 + b13 - b23) * t * t12) / (a33 - b33)
else:
if ENABLE_DEBUG:
print("The second edge is a zero-length edge")
return None
# Calculate the point of intersection:
x = (1 - t3) * a31 + t3 * b31
y = (1 - t3) * a32 + t3 * b32
z = (1 - t3) * a33 + t3 * b33
int_co = Vector((x, y, z))
if ENABLE_DEBUG:
print(int_co)
# If the line does not intersect the quad, we return "None":
if (t < -1 or t > 1 or t12 < -1 or t12 > 1) and not is_infinite:
int_co = None
elif len(face.verts) == 3:
p1, p2, p3 = face.verts[0].co, face.verts[1].co, face.verts[2].co
int_co = intersect_line_plane(edge.verts[0].co, edge.verts[1].co, p1, face.normal)
# Only check if the triangle is not being treated as an infinite plane:
# Math based from http://paulbourke.net/geometry/linefacet/
if int_co is not None and not is_infinite:
pA = p1 - int_co
pB = p2 - int_co
pC = p3 - int_co
# These must be unit vectors, else we risk a domain error:
pA.length = 1
pB.length = 1
pC.length = 1
aAB = acos(pA.dot(pB))
aBC = acos(pB.dot(pC))
aCA = acos(pC.dot(pA))
sumA = aAB + aBC + aCA
# If the point is outside the triangle:
if (sumA > (pi + error) and sumA < (pi - error)):
int_co = None
# This is the default case where we either have a planar quad or an n-gon
else:
int_co = intersect_line_plane(edge.verts[0].co, edge.verts[1].co,
face.verts[0].co, face.normal)
return int_co
# project_point_plane
# Projects a point onto a plane. Returns a tuple of the projection vector
# and the projected coordinate
def project_point_plane(pt, plane_co, plane_no):
if ENABLE_DEBUG:
print("project_point_plane was called")
proj_co = intersect_line_plane(pt, pt + plane_no, plane_co, plane_no)
proj_ve = proj_co - pt
if ENABLE_DEBUG:
print("project_point_plane: proj_co is {}\nproj_ve is {}".format(proj_co, proj_ve))
return (proj_ve, proj_co)
# ------------ CHAMPHER HELPER METHODS -------------
def is_planar_edge(edge, error=0.000002):
angle = edge.calc_face_angle()
return ((angle < error and angle > -error) or
(angle < (180 + error) and angle > (180 - error)))
# ------------- EDGE TOOL METHODS -------------------
# Extends an "edge" in two directions:
# - Requires two vertices to be selected. They do not have to form an edge
# - Extends "length" in both directions
class Extend(Operator):
bl_idname = "mesh.edgetools_extend"
bl_label = "Extend"
bl_description = "Extend the selected edges of vertex pairs"
bl_options = {'REGISTER', 'UNDO'}
di1: BoolProperty(
name="Forwards",
description="Extend the edge forwards",
default=True
)
di2: BoolProperty(
name="Backwards",
description="Extend the edge backwards",
default=False
)
length: FloatProperty(
name="Length",
description="Length to extend the edge",
min=0.0, max=1024.0,
default=1.0
)
def draw(self, context):
layout = self.layout
row = layout.row(align=True)
row.prop(self, "di1", toggle=True)
row.prop(self, "di2", toggle=True)
layout.prop(self, "length")
@classmethod
def poll(cls, context):
ob = context.active_object
return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
def invoke(self, context, event):
return self.execute(context)
def execute(self, context):
try:
me = context.object.data
bm = bmesh.from_edit_mesh(me)
bm.normal_update()
bEdges = bm.edges
bVerts = bm.verts
edges = [e for e in bEdges if e.select]
verts = [v for v in bVerts if v.select]
if not is_selected_enough(self, edges, 0, edges_n=1, verts_n=0, types="Edge"):
return {'CANCELLED'}
if len(edges) > 0:
for e in edges:
vector = e.verts[0].co - e.verts[1].co
vector.length = self.length
if self.di1:
v = bVerts.new()
if (vector[0] + vector[1] + vector[2]) < 0:
v.co = e.verts[1].co - vector
newE = bEdges.new((e.verts[1], v))
bEdges.ensure_lookup_table()
else:
v.co = e.verts[0].co + vector
newE = bEdges.new((e.verts[0], v))
bEdges.ensure_lookup_table()
if self.di2:
v = bVerts.new()
if (vector[0] + vector[1] + vector[2]) < 0:
v.co = e.verts[0].co + vector
newE = bEdges.new((e.verts[0], v))
bEdges.ensure_lookup_table()
else:
v.co = e.verts[1].co - vector
newE = bEdges.new((e.verts[1], v))
bEdges.ensure_lookup_table()
else:
vector = verts[0].co - verts[1].co
vector.length = self.length
if self.di1:
v = bVerts.new()
if (vector[0] + vector[1] + vector[2]) < 0:
v.co = verts[1].co - vector
e = bEdges.new((verts[1], v))
bEdges.ensure_lookup_table()
else:
v.co = verts[0].co + vector
e = bEdges.new((verts[0], v))
bEdges.ensure_lookup_table()
if self.di2:
v = bVerts.new()
if (vector[0] + vector[1] + vector[2]) < 0:
v.co = verts[0].co + vector
e = bEdges.new((verts[0], v))
bEdges.ensure_lookup_table()
else:
v.co = verts[1].co - vector
e = bEdges.new((verts[1], v))
bEdges.ensure_lookup_table()
bmesh.update_edit_mesh(me)
except Exception as e:
error_handlers(self, "mesh.edgetools_extend", e,
reports="Extend Operator failed", func=False)
return {'CANCELLED'}
return {'FINISHED'}
# Creates a series of edges between two edges using spline interpolation.
# This basically just exposes existing functionality in addition to some
# other common methods: Hermite (c-spline), Bezier, and b-spline. These
# alternates I coded myself after some extensive research into spline theory
#
# @todo Figure out what's wrong with the Blender bezier interpolation
class Spline(Operator):
bl_idname = "mesh.edgetools_spline"
bl_label = "Spline"
bl_description = "Create a spline interplopation between two edges"
bl_options = {'REGISTER', 'UNDO'}
alg: EnumProperty(
name="Spline Algorithm",
items=[('Blender', "Blender", "Interpolation provided through mathutils.geometry"),
('Hermite', "C-Spline", "C-spline interpolation"),
('Bezier', "Bezier", "Bezier interpolation"),
('B-Spline', "B-Spline", "B-Spline interpolation")],
default='Bezier'
)
segments: IntProperty(
name="Segments",
description="Number of segments to use in the interpolation",
min=2, max=4096,
soft_max=1024,
default=32
)
flip1: BoolProperty(
name="Flip Edge",
description="Flip the direction of the spline on Edge 1",
default=False
)
flip2: BoolProperty(
name="Flip Edge",
description="Flip the direction of the spline on Edge 2",
default=False
)
ten1: FloatProperty(
name="Tension",
description="Tension on Edge 1",
min=-4096.0, max=4096.0,
soft_min=-8.0, soft_max=8.0,
default=1.0
)
ten2: FloatProperty(
name="Tension",
description="Tension on Edge 2",
min=-4096.0, max=4096.0,
soft_min=-8.0, soft_max=8.0,
default=1.0
)
def draw(self, context):
layout = self.layout
layout.prop(self, "alg")
layout.prop(self, "segments")
layout.label(text="Edge 1:")
split = layout.split(factor=0.8, align=True)
split.prop(self, "ten1")
split.prop(self, "flip1", text="Flip1", toggle=True)
layout.label(text="Edge 2:")
split = layout.split(factor=0.8, align=True)
split.prop(self, "ten2")
split.prop(self, "flip2", text="Flip2", toggle=True)
@classmethod
def poll(cls, context):
ob = context.active_object
return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
def invoke(self, context, event):
return self.execute(context)
def execute(self, context):
try:
me = context.object.data
bm = bmesh.from_edit_mesh(me)
bm.normal_update()
bEdges = bm.edges
bVerts = bm.verts
seg = self.segments
edges = [e for e in bEdges if e.select]
if not is_selected_enough(self, edges, 0, edges_n=2, verts_n=0, types="Edge"):
return {'CANCELLED'}
verts = [edges[v // 2].verts[v % 2] for v in range(4)]
if self.flip1:
v1 = verts[1]
p1_co = verts[1].co
p1_dir = verts[1].co - verts[0].co
else:
v1 = verts[0]
p1_co = verts[0].co
p1_dir = verts[0].co - verts[1].co
if self.ten1 < 0:
p1_dir = -1 * p1_dir
p1_dir.length = -self.ten1
else:
p1_dir.length = self.ten1
if self.flip2:
v2 = verts[3]
p2_co = verts[3].co
p2_dir = verts[2].co - verts[3].co
else:
v2 = verts[2]
p2_co = verts[2].co
p2_dir = verts[3].co - verts[2].co
if self.ten2 < 0:
p2_dir = -1 * p2_dir
p2_dir.length = -self.ten2
else:
p2_dir.length = self.ten2
# Get the interploted coordinates:
if self.alg == 'Blender':
pieces = interpolate_bezier(
p1_co, p1_dir, p2_dir, p2_co, self.segments
)
elif self.alg == 'Hermite':
pieces = interpolate_line_line(
p1_co, p1_dir, p2_co, p2_dir, self.segments, 1, 'HERMITE'
)
elif self.alg == 'Bezier':
pieces = interpolate_line_line(
p1_co, p1_dir, p2_co, p2_dir, self.segments, 1, 'BEZIER'
)
elif self.alg == 'B-Spline':
pieces = interpolate_line_line(
p1_co, p1_dir, p2_co, p2_dir, self.segments, 1, 'BSPLINE'
)
verts = []
verts.append(v1)
# Add vertices and set the points:
for i in range(seg - 1):
v = bVerts.new()
v.co = pieces[i]
bVerts.ensure_lookup_table()
verts.append(v)
verts.append(v2)
# Connect vertices:
for i in range(seg):
e = bEdges.new((verts[i], verts[i + 1]))
bEdges.ensure_lookup_table()
bmesh.update_edit_mesh(me)
except Exception as e:
error_handlers(self, "mesh.edgetools_spline", e,
reports="Spline Operator failed", func=False)
return {'CANCELLED'}
return {'FINISHED'}
# Creates edges normal to planes defined between each of two edges and the
# normal or the plane defined by those two edges.
# - Select two edges. The must form a plane.
# - On running the script, eight edges will be created. Delete the
# extras that you don't need.
# - The length of those edges is defined by the variable "length"
#
# @todo Change method from a cross product to a rotation matrix to make the
# angle part work.
# --- todo completed 2/4/2012, but still needs work ---
# @todo Figure out a way to make +/- predictable
# - Maybe use angle between edges and vector direction definition?
# --- TODO COMPLETED ON 2/9/2012 ---
class Ortho(Operator):
bl_idname = "mesh.edgetools_ortho"
bl_label = "Angle Off Edge"
bl_description = "Creates new edges within an angle from vertices of selected edges"
bl_options = {'REGISTER', 'UNDO'}
vert1: BoolProperty(
name="Vertice 1",
description="Enable edge creation for Vertice 1",
default=True
)
vert2: BoolProperty(
name="Vertice 2",
description="Enable edge creation for Vertice 2",
default=True
)
vert3: BoolProperty(
name="Vertice 3",
description="Enable edge creation for Vertice 3",
default=True
)
vert4: BoolProperty(
name="Vertice 4",
description="Enable edge creation for Vertice 4",
default=True
)
pos: BoolProperty(
name="Positive",
description="Enable creation of positive direction edges",
default=True
)
neg: BoolProperty(
name="Negative",
description="Enable creation of negative direction edges",
default=True
)
angle: FloatProperty(
name="Angle",
description="Define the angle off of the originating edge",
min=0.0, max=180.0,
default=90.0
)
length: FloatProperty(
name="Length",
description="Length of created edges",
min=0.0, max=1024.0,
default=1.0
)
# For when only one edge is selected (Possible feature to be testd):
plane: EnumProperty(
name="Plane",
items=[("XY", "X-Y Plane", "Use the X-Y plane as the plane of creation"),
("XZ", "X-Z Plane", "Use the X-Z plane as the plane of creation"),
("YZ", "Y-Z Plane", "Use the Y-Z plane as the plane of creation")],
default="XY"
)
def draw(self, context):
layout = self.layout
layout.label(text="Creation:")
split = layout.split()
col = split.column()
col.prop(self, "vert1", toggle=True)
col.prop(self, "vert2", toggle=True)
col = split.column()
col.prop(self, "vert3", toggle=True)
col.prop(self, "vert4", toggle=True)
layout.label(text="Direction:")
row = layout.row(align=False)
row.alignment = 'EXPAND'
row.prop(self, "pos")
row.prop(self, "neg")
layout.separator()
col = layout.column(align=True)
col.prop(self, "angle")
col.prop(self, "length")
@classmethod
def poll(cls, context):
ob = context.active_object
return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
def invoke(self, context, event):
return self.execute(context)
def execute(self, context):
try:
me = context.object.data
bm = bmesh.from_edit_mesh(me)
bm.normal_update()
bVerts = bm.verts
bEdges = bm.edges
edges = [e for e in bEdges if e.select]
vectors = []
if not is_selected_enough(self, edges, 0, edges_n=2, verts_n=0, types="Edge"):
return {'CANCELLED'}
verts = [edges[0].verts[0],
edges[0].verts[1],
edges[1].verts[0],
edges[1].verts[1]]
cos = intersect_line_line(verts[0].co, verts[1].co, verts[2].co, verts[3].co)
# If the two edges are parallel:
if cos is None:
self.report({'WARNING'},
"Selected lines are parallel: results may be unpredictable")
vectors.append(verts[0].co - verts[1].co)
vectors.append(verts[0].co - verts[2].co)
vectors.append(vectors[0].cross(vectors[1]))
vectors.append(vectors[2].cross(vectors[0]))
vectors.append(-vectors[3])
else:
# Warn the user if they have not chosen two planar edges:
if not is_same_co(cos[0], cos[1]):
self.report({'WARNING'},
"Selected lines are not planar: results may be unpredictable")
# This makes the +/- behavior predictable:
if (verts[0].co - cos[0]).length < (verts[1].co - cos[0]).length:
verts[0], verts[1] = verts[1], verts[0]
if (verts[2].co - cos[0]).length < (verts[3].co - cos[0]).length:
verts[2], verts[3] = verts[3], verts[2]
vectors.append(verts[0].co - verts[1].co)
vectors.append(verts[2].co - verts[3].co)
# Normal of the plane formed by vector1 and vector2:
vectors.append(vectors[0].cross(vectors[1]))
# Possible directions:
vectors.append(vectors[2].cross(vectors[0]))
vectors.append(vectors[1].cross(vectors[2]))
# Set the length:
vectors[3].length = self.length
vectors[4].length = self.length
# Perform any additional rotations:
matrix = Matrix.Rotation(radians(90 + self.angle), 3, vectors[2])
vectors.append(matrix @ -vectors[3]) # vectors[5]
matrix = Matrix.Rotation(radians(90 - self.angle), 3, vectors[2])
vectors.append(matrix @ vectors[4]) # vectors[6]
vectors.append(matrix @ vectors[3]) # vectors[7]
matrix = Matrix.Rotation(radians(90 + self.angle), 3, vectors[2])
vectors.append(matrix @ -vectors[4]) # vectors[8]
# Perform extrusions and displacements:
# There will be a total of 8 extrusions. One for each vert of each edge.
# It looks like an extrusion will add the new vert to the end of the verts
# list and leave the rest in the same location.
# -- EDIT --
# It looks like I might be able to do this within "bpy.data" with the ".add" function
for v in range(len(verts)):
vert = verts[v]
if ((v == 0 and self.vert1) or (v == 1 and self.vert2) or
(v == 2 and self.vert3) or (v == 3 and self.vert4)):
if self.pos:
new = bVerts.new()
new.co = vert.co - vectors[5 + (v // 2) + ((v % 2) * 2)]
bVerts.ensure_lookup_table()
bEdges.new((vert, new))
bEdges.ensure_lookup_table()
if self.neg:
new = bVerts.new()
new.co = vert.co + vectors[5 + (v // 2) + ((v % 2) * 2)]
bVerts.ensure_lookup_table()
bEdges.new((vert, new))
bEdges.ensure_lookup_table()
bmesh.update_edit_mesh(me)
except Exception as e:
error_handlers(self, "mesh.edgetools_ortho", e,
reports="Angle Off Edge Operator failed", func=False)
return {'CANCELLED'}
return {'FINISHED'}
# Usage:
# Select an edge and a point or an edge and specify the radius (default is 1 BU)
# You can select two edges but it might be unpredictable which edge it revolves
# around so you might have to play with the switch
class Shaft(Operator):
bl_idname = "mesh.edgetools_shaft"
bl_label = "Shaft"
bl_description = "Create a shaft mesh around an axis"
bl_options = {'REGISTER', 'UNDO'}
# Selection defaults:
shaftType = 0
# For tracking if the user has changed selection:
last_edge: IntProperty(
name="Last Edge",
description="Tracks if user has changed selected edges",
min=0, max=1,
default=0
)
last_flip = False
edge: IntProperty(
name="Edge",
description="Edge to shaft around",
min=0, max=1,
default=0
)
flip: BoolProperty(
name="Flip Second Edge",
description="Flip the perceived direction of the second edge",
default=False
)
radius: FloatProperty(
name="Radius",
description="Shaft Radius",
min=0.0, max=1024.0,
default=1.0
)
start: FloatProperty(
name="Starting Angle",
description="Angle to start the shaft at",
min=-360.0, max=360.0,
default=0.0
)
finish: FloatProperty(
name="Ending Angle",
description="Angle to end the shaft at",
min=-360.0, max=360.0,
default=360.0
)
segments: IntProperty(
name="Shaft Segments",
description="Number of segments to use in the shaft",
min=1, max=4096,
soft_max=512,
default=32
)
def draw(self, context):
layout = self.layout
if self.shaftType == 0:
layout.prop(self, "edge")
layout.prop(self, "flip")
elif self.shaftType == 3:
layout.prop(self, "radius")
layout.prop(self, "segments")
layout.prop(self, "start")
layout.prop(self, "finish")
@classmethod
def poll(cls, context):
ob = context.active_object
return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
def invoke(self, context, event):
# Make sure these get reset each time we run:
self.last_edge = 0
self.edge = 0
return self.execute(context)
def execute(self, context):
try:
me = context.object.data
bm = bmesh.from_edit_mesh(me)
bm.normal_update()
bFaces = bm.faces
bEdges = bm.edges
bVerts = bm.verts
active = None
edges, verts = [], []
# Pre-caclulated values:
rotRange = [radians(self.start), radians(self.finish)]
rads = radians((self.finish - self.start) / self.segments)
numV = self.segments + 1
numE = self.segments
edges = [e for e in bEdges if e.select]
# Robustness check: there should at least be one edge selected
if not is_selected_enough(self, edges, 0, edges_n=1, verts_n=0, types="Edge"):
return {'CANCELLED'}
# If two edges are selected:
if len(edges) == 2:
# default:
edge = [0, 1]
vert = [0, 1]
# By default, we want to shaft around the last selected edge (it
# will be the active edge). We know we are using the default if
# the user has not changed which edge is being shafted around (as
# is tracked by self.last_edge). When they are not the same, then
# the user has changed selection.
# We then need to make sure that the active object really is an edge
# (robustness check)
# Finally, if the active edge is not the initial one, we flip them
# and have the GUI reflect that
if self.last_edge == self.edge:
if isinstance(bm.select_history.active, bmesh.types.BMEdge):
if bm.select_history.active != edges[edge[0]]:
self.last_edge, self.edge = edge[1], edge[1]
edge = [edge[1], edge[0]]
else:
flip_edit_mode()
self.report({'WARNING'},
"Active geometry is not an edge. Operation Cancelled")
return {'CANCELLED'}
elif self.edge == 1:
edge = [1, 0]
verts.append(edges[edge[0]].verts[0])
verts.append(edges[edge[0]].verts[1])
if self.flip:
verts = [1, 0]
verts.append(edges[edge[1]].verts[vert[0]])
verts.append(edges[edge[1]].verts[vert[1]])
self.shaftType = 0
# If there is more than one edge selected:
# There are some issues with it ATM, so don't expose is it to normal users
# @todo Fix edge connection ordering issue
elif ENABLE_DEBUG and len(edges) > 2:
if isinstance(bm.select_history.active, bmesh.types.BMEdge):
active = bm.select_history.active
edges.remove(active)
# Get all the verts:
# edges = order_joined_edges(edges[0])
verts = []
for e in edges:
if verts.count(e.verts[0]) == 0:
verts.append(e.verts[0])
if verts.count(e.verts[1]) == 0:
verts.append(e.verts[1])
else:
flip_edit_mode()
self.report({'WARNING'},
"Active geometry is not an edge. Operation Cancelled")
return {'CANCELLED'}
self.shaftType = 1
else:
verts.append(edges[0].verts[0])
verts.append(edges[0].verts[1])
for v in bVerts:
if v.select and verts.count(v) == 0:
verts.append(v)
v.select = False
if len(verts) == 2:
self.shaftType = 3
else:
self.shaftType = 2
# The vector denoting the axis of rotation:
if self.shaftType == 1:
axis = active.verts[1].co - active.verts[0].co
else:
axis = verts[1].co - verts[0].co
# We will need a series of rotation matrices. We could use one which
# would be faster but also might cause propagation of error
# matrices = []
# for i in range(numV):
# matrices.append(Matrix.Rotation((rads * i) + rotRange[0], 3, axis))
matrices = [Matrix.Rotation((rads * i) + rotRange[0], 3, axis) for i in range(numV)]
# New vertice coordinates:
verts_out = []
# If two edges were selected:
# - If the lines are not parallel, then it will create a cone-like shaft
if self.shaftType == 0:
for i in range(len(verts) - 2):
init_vec = distance_point_line(verts[i + 2].co, verts[0].co, verts[1].co)
co = init_vec + verts[i + 2].co
# These will be rotated about the origin so will need to be shifted:
for j in range(numV):
verts_out.append(co - (matrices[j] @ init_vec))
elif self.shaftType == 1:
for i in verts:
init_vec = distance_point_line(i.co, active.verts[0].co, active.verts[1].co)
co = init_vec + i.co
# These will be rotated about the origin so will need to be shifted:
for j in range(numV):
verts_out.append(co - (matrices[j] @ init_vec))
# Else if a line and a point was selected:
elif self.shaftType == 2:
init_vec = distance_point_line(verts[2].co, verts[0].co, verts[1].co)
# These will be rotated about the origin so will need to be shifted:
verts_out = [
(verts[i].co - (matrices[j] @ init_vec)) for i in range(2) for j in range(numV)
]
else:
# Else the above are not possible, so we will just use the edge:
# - The vector defined by the edge is the normal of the plane for the shaft
# - The shaft will have radius "radius"
if is_axial(verts[0].co, verts[1].co) is None:
proj = (verts[1].co - verts[0].co)
proj[2] = 0
norm = proj.cross(verts[1].co - verts[0].co)
vec = norm.cross(verts[1].co - verts[0].co)
vec.length = self.radius
elif is_axial(verts[0].co, verts[1].co) == 'Z':
vec = verts[0].co + Vector((0, 0, self.radius))
else:
vec = verts[0].co + Vector((0, self.radius, 0))
init_vec = distance_point_line(vec, verts[0].co, verts[1].co)
# These will be rotated about the origin so will need to be shifted:
verts_out = [
(verts[i].co - (matrices[j] @ init_vec)) for i in range(2) for j in range(numV)
]
# We should have the coordinates for a bunch of new verts
# Now add the verts and build the edges and then the faces
newVerts = []
if self.shaftType == 1:
# Vertices:
for i in range(numV * len(verts)):
new = bVerts.new()
new.co = verts_out[i]
bVerts.ensure_lookup_table()
new.select = True
newVerts.append(new)
# Edges:
for i in range(numE):
for j in range(len(verts)):
e = bEdges.new((newVerts[i + (numV * j)], newVerts[i + (numV * j) + 1]))
bEdges.ensure_lookup_table()
e.select = True
for i in range(numV):
for j in range(len(verts) - 1):
e = bEdges.new((newVerts[i + (numV * j)], newVerts[i + (numV * (j + 1))]))
bEdges.ensure_lookup_table()
e.select = True
# Faces: There is a problem with this right now
"""
for i in range(len(edges)):
for j in range(numE):
f = bFaces.new((newVerts[i], newVerts[i + 1],
newVerts[i + (numV * j) + 1], newVerts[i + (numV * j)]))
f.normal_update()
"""
else:
# Vertices:
for i in range(numV * 2):
new = bVerts.new()
new.co = verts_out[i]
new.select = True
bVerts.ensure_lookup_table()
newVerts.append(new)
# Edges:
for i in range(numE):
e = bEdges.new((newVerts[i], newVerts[i + 1]))
e.select = True
bEdges.ensure_lookup_table()
e = bEdges.new((newVerts[i + numV], newVerts[i + numV + 1]))
e.select = True
bEdges.ensure_lookup_table()
for i in range(numV):
e = bEdges.new((newVerts[i], newVerts[i + numV]))
e.select = True
bEdges.ensure_lookup_table()
# Faces:
for i in range(numE):
f = bFaces.new((newVerts[i], newVerts[i + 1],
newVerts[i + numV + 1], newVerts[i + numV]))
bFaces.ensure_lookup_table()
f.normal_update()
bmesh.update_edit_mesh(me)
except Exception as e:
error_handlers(self, "mesh.edgetools_shaft", e,
reports="Shaft Operator failed", func=False)
return {'CANCELLED'}
return {'FINISHED'}
# "Slices" edges crossing a plane defined by a face
class Slice(Operator):
bl_idname = "mesh.edgetools_slice"
bl_label = "Slice"
bl_description = "Cut edges at the plane defined by a selected face"
bl_options = {'REGISTER', 'UNDO'}
make_copy: BoolProperty(
name="Make Copy",
description="Make new vertices at intersection points instead of splitting the edge",
default=False
)
rip: BoolProperty(
name="Rip",
description="Split into two edges that DO NOT share an intersection vertex",
default=True
)
pos: BoolProperty(
name="Positive",
description="Remove the portion on the side of the face normal",
default=False
)
neg: BoolProperty(
name="Negative",
description="Remove the portion on the side opposite of the face normal",
default=False
)
def draw(self, context):
layout = self.layout
layout.prop(self, "make_copy")
if not self.make_copy:
layout.prop(self, "rip")
layout.label(text="Remove Side:")
layout.prop(self, "pos")
layout.prop(self, "neg")
@classmethod
def poll(cls, context):
ob = context.active_object
return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
def invoke(self, context, event):
return self.execute(context)
def execute(self, context):
try:
me = context.object.data
bm = bmesh.from_edit_mesh(me)
bm.normal_update()
bVerts = bm.verts
bEdges = bm.edges
bFaces = bm.faces
face, normal = None, None
# Find the selected face. This will provide the plane to project onto:
# - First check to use the active face. Allows users to just
# select a bunch of faces with the last being the cutting plane
# - If that fails, then use the first found selected face in the BMesh face list
if isinstance(bm.select_history.active, bmesh.types.BMFace):
face = bm.select_history.active
normal = bm.select_history.active.normal
bm.select_history.active.select = False
else:
for f in bFaces:
if f.select:
face = f
normal = f.normal
f.select = False
break
# If we don't find a selected face exit:
if face is None:
flip_edit_mode()
self.report({'WARNING'},
"Please select a face as the cutting plane. Operation Cancelled")
return {'CANCELLED'}
# Warn the user if they are using an n-gon might lead to some odd results
elif len(face.verts) > 4 and not is_face_planar(face):
self.report({'WARNING'},
"Selected face is an N-gon. Results may be unpredictable")
if ENABLE_DEBUG:
dbg = 0
print("Number of Edges: ", len(bEdges))
for e in bEdges:
if ENABLE_DEBUG:
print("Looping through Edges - ", dbg)
dbg = dbg + 1
# Get the end verts on the edge:
v1 = e.verts[0]
v2 = e.verts[1]
# Make sure that verts are not a part of the cutting plane:
if e.select and (v1 not in face.verts and v2 not in face.verts):
if len(face.verts) < 5: # Not an n-gon
intersection = intersect_line_face(e, face, True)
else:
intersection = intersect_line_plane(v1.co, v2.co, face.verts[0].co, normal)
if ENABLE_DEBUG:
print("Intersection: ", intersection)
# If an intersection exists find the distance of each of the end
# points from the plane, with "positive" being in the direction
# of the cutting plane's normal. If the points are on opposite
# side of the plane, then it intersects and we need to cut it
if intersection is not None:
bVerts.ensure_lookup_table()
bEdges.ensure_lookup_table()
bFaces.ensure_lookup_table()
d1 = distance_point_to_plane(v1.co, face.verts[0].co, normal)
d2 = distance_point_to_plane(v2.co, face.verts[0].co, normal)
# If they have different signs, then the edge crosses the cutting plane:
if abs(d1 + d2) < abs(d1 - d2):
# Make the first vertex the positive one:
if d1 < d2:
v2, v1 = v1, v2
if self.make_copy:
new = bVerts.new()
new.co = intersection
new.select = True
bVerts.ensure_lookup_table()
elif self.rip:
if ENABLE_DEBUG:
print("Branch rip engaged")
newV1 = bVerts.new()
newV1.co = intersection
bVerts.ensure_lookup_table()
if ENABLE_DEBUG:
print("newV1 created", end='; ')
newV2 = bVerts.new()
newV2.co = intersection
bVerts.ensure_lookup_table()
if ENABLE_DEBUG:
print("newV2 created", end='; ')
newE1 = bEdges.new((v1, newV1))
newE2 = bEdges.new((v2, newV2))
bEdges.ensure_lookup_table()
if ENABLE_DEBUG:
print("new edges created", end='; ')
if e.is_valid:
bEdges.remove(e)
bEdges.ensure_lookup_table()
if ENABLE_DEBUG:
print("Old edge removed.\nWe're done with this edge")
else:
new = list(bmesh.utils.edge_split(e, v1, 0.5))
bEdges.ensure_lookup_table()
new[1].co = intersection
e.select = False
new[0].select = False
if self.pos:
bEdges.remove(new[0])
if self.neg:
bEdges.remove(e)
bEdges.ensure_lookup_table()
if ENABLE_DEBUG:
print("The Edge Loop has exited. Now to update the bmesh")
dbg = 0
bmesh.update_edit_mesh(me)
except Exception as e:
error_handlers(self, "mesh.edgetools_slice", e,
reports="Slice Operator failed", func=False)
return {'CANCELLED'}
return {'FINISHED'}
# This projects the selected edges onto the selected plane
# and/or both points on the selected edge
class Project(Operator):
bl_idname = "mesh.edgetools_project"
bl_label = "Project"
bl_description = ("Projects the selected Vertices/Edges onto a selected plane\n"
"(Active is projected onto the rest)")
bl_options = {'REGISTER', 'UNDO'}
make_copy: BoolProperty(
name="Make Copy",
description="Make duplicates of the vertices instead of altering them",
default=False
)
def draw(self, context):
layout = self.layout
layout.prop(self, "make_copy")
@classmethod
def poll(cls, context):
ob = context.active_object
return (ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
def invoke(self, context, event):
return self.execute(context)
def execute(self, context):
try:
me = context.object.data
bm = bmesh.from_edit_mesh(me)
bm.normal_update()
bFaces = bm.faces
bVerts = bm.verts
fVerts = []
# Find the selected face. This will provide the plane to project onto:
# @todo Check first for an active face
for f in bFaces:
if f.select:
for v in f.verts:
fVerts.append(v)
normal = f.normal
f.select = False
break
for v in bVerts:
if v.select:
if v in fVerts:
v.select = False
continue
d = distance_point_to_plane(v.co, fVerts[0].co, normal)
if self.make_copy:
temp = v
v = bVerts.new()
v.co = temp.co
bVerts.ensure_lookup_table()
vector = normal
vector.length = abs(d)
v.co = v.co - (vector * sign(d))
v.select = False
bmesh.update_edit_mesh(me)
except Exception as e:
error_handlers(self, "mesh.edgetools_project", e,
reports="Project Operator failed", func=False)
return {'CANCELLED'}
return {'FINISHED'}
# Project_End is for projecting/extending an edge to meet a plane
# This is used be selecting a face to define the plane then all the edges
# Then move the vertices in the edge that is closest to the
# plane to the coordinates of the intersection of the edge and the plane
class Project_End(Operator):
bl_idname = "mesh.edgetools_project_end"
bl_label = "Project (End Point)"
bl_description = ("Projects the vertices of the selected\n"
"edges closest to a plane onto that plane")
bl_options = {'REGISTER', 'UNDO'}
make_copy: BoolProperty(
name="Make Copy",
description="Make a duplicate of the vertice instead of moving it",
default=False
)
keep_length: BoolProperty(
name="Keep Edge Length",
description="Maintain edge lengths",
default=False
)
use_force: BoolProperty(
name="Use opposite vertices",
description="Force the usage of the vertices at the other end of the edge",
default=False
)
use_normal: BoolProperty(
name="Project along normal",
description="Use the plane's normal as the projection direction",
default=False
)
def draw(self, context):
layout = self.layout
if not self.keep_length:
layout.prop(self, "use_normal")
layout.prop(self, "make_copy")
layout.prop(self, "use_force")
@classmethod
def poll(cls, context):
ob = context.active_object
return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
def invoke(self, context, event):
return self.execute(context)
def execute(self, context):
try:
me = context.object.data
bm = bmesh.from_edit_mesh(me)
bm.normal_update()
bFaces = bm.faces
bEdges = bm.edges
bVerts = bm.verts
fVerts = []
# Find the selected face. This will provide the plane to project onto:
for f in bFaces:
if f.select:
for v in f.verts:
fVerts.append(v)
normal = f.normal
f.select = False
break
for e in bEdges:
if e.select:
v1 = e.verts[0]
v2 = e.verts[1]
if v1 in fVerts or v2 in fVerts:
e.select = False
continue
intersection = intersect_line_plane(v1.co, v2.co, fVerts[0].co, normal)
if intersection is not None:
# Use abs because we don't care what side of plane we're on:
d1 = distance_point_to_plane(v1.co, fVerts[0].co, normal)
d2 = distance_point_to_plane(v2.co, fVerts[0].co, normal)
# If d1 is closer than we use v1 as our vertice:
# "xor" with 'use_force':
if (abs(d1) < abs(d2)) is not self.use_force:
if self.make_copy:
v1 = bVerts.new()
v1.co = e.verts[0].co
bVerts.ensure_lookup_table()
bEdges.ensure_lookup_table()
if self.keep_length:
v1.co = intersection
elif self.use_normal:
vector = normal
vector.length = abs(d1)
v1.co = v1.co - (vector * sign(d1))
else:
v1.co = intersection
else:
if self.make_copy:
v2 = bVerts.new()
v2.co = e.verts[1].co
bVerts.ensure_lookup_table()
bEdges.ensure_lookup_table()
if self.keep_length:
v2.co = intersection
elif self.use_normal:
vector = normal
vector.length = abs(d2)
v2.co = v2.co - (vector * sign(d2))
else:
v2.co = intersection
e.select = False
bmesh.update_edit_mesh(me)
except Exception as e:
error_handlers(self, "mesh.edgetools_project_end", e,
reports="Project (End Point) Operator failed", func=False)
return {'CANCELLED'}
return {'FINISHED'}
class VIEW3D_MT_edit_mesh_edgetools(Menu):
bl_label = "Edge Tools"
bl_description = "Various tools for manipulating edges"
def draw(self, context):
layout = self.layout
layout.operator("mesh.edgetools_extend")
layout.operator("mesh.edgetools_spline")
layout.operator("mesh.edgetools_ortho")
layout.operator("mesh.edgetools_shaft")
layout.operator("mesh.edgetools_slice")
layout.separator()
layout.operator("mesh.edgetools_project")
layout.operator("mesh.edgetools_project_end")
def menu_func(self, context):
self.layout.menu("VIEW3D_MT_edit_mesh_edgetools")
# define classes for registration
classes = (
VIEW3D_MT_edit_mesh_edgetools,
Extend,
Spline,
Ortho,
Shaft,
Slice,
Project,
Project_End,
)
# registering and menu integration
def register():
for cls in classes:
bpy.utils.register_class(cls)
bpy.types.VIEW3D_MT_edit_mesh_context_menu.prepend(menu_func)
# unregistering and removing menus
def unregister():
for cls in classes:
bpy.utils.unregister_class(cls)
bpy.types.VIEW3D_MT_edit_mesh_context_menu.remove(menu_func)
if __name__ == "__main__":
register()