
last update. time to do other stuff.

def selectLayer(layernum):
bools = []
for i in range(20):
if layernum == i:
bools.append(True)
else:
bools.append(False)
return tuple(bools) #does a typecast from list to tuple
# because selectLayer returns a tuple
print(selectLayer(4))
# you can stick that into the ridiculously long line like
bpy.ops.curve.primitive_nurbs_path_add( view_align=False,
enter_editmode=False, location=(0, 0, 0),
rotation=(0, 0, 0),
layers=(True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# write instead, if you really need to select a layer
bpy.ops.curve.primitive_nurbs_path_add(layers=selectLayer(0))
bpy.ops.curve.primitive_nurbs_path_add(layers=((True,)+(False,)*19)))
def selectLayer(layer_nr):
return tuple(i == layer_nr for i in range(0, 20))
>>> print(selectLayer(2))
>>>
(False, False, True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False)
# written by Dealga McArdle
# parts based on Keith (Wahooney) Boshoff, cursor to intersection script and
# Paul Bourke's Shortest Line Between 2 lines
# PKHG from blenderartists.org suggested a few refinements in the Vector code,
# making the code a bit easier to read.
# ***** BEGIN GPL LICENSE BLOCK *****
#
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# ***** END GPL LICENCE BLOCK *****
import bpy
import sys
from mathutils import Vector
__author__ = ['zeffii']
__version__ = '0.1'
__bpydoc__ = """
"""
bl_addon_info = {
'name': 'Mesh: Slice Intersect',
'author': 'zeffii',
'version': '0.1',
'blender': (2, 5, 4),
'location': 'View3D > EditMode > Specials',
'wiki_url': '',
'category': 'Mesh'}
##function lifted from 3dview_spacebar_menu
def LineLineIntersect (p1, p2, p3, p4):
# based on Paul Bourke's Shortest Line Between 2 lines
min = 0.0000001
v1 = p1 - p3 #Vector((p1.x - p3.x, p1.y - p3.y, p1.z - p3.z))
v2 = p4 - p3 #Vector((p4.x - p3.x, p4.y - p3.y, p4.z - p3.z))
if abs(v2.x) < min and abs(v2.y) < min and abs(v2.z) < min:
return None
v3 = p2 - p1
if abs(v3.x) < min and abs(v3.y) < min and abs(v3.z) < min:
return None
d1 = v1.dot(v2)
d2 = v2.dot(v3)
d3 = v1.dot(v3)
d4 = v2.dot(v2)
d5 = v3.dot(v3)
d = d5 * d4 - d2 * d2
if abs(d) < min:
return None
n = d1 * d2 - d3 * d4
mua = n / d
mub = (d1 + d2 * (mua)) / d4
#modified for clarity, and to use some neat Vector functionality.
return [p1 + mua * v3 , p3 + mub * v2]
##function partially lifted from 3dview_spacebar_menu
def checkEdges(Edge, obj):
p1 = Vector((Edge[0][0]))
p2 = Vector((Edge[0][1]))
p3 = Vector((Edge[1][0]))
p4 = Vector((Edge[1][1]))
line = LineLineIntersect(p1, p2, p3, p4)
if line == None: return None
tm = obj.matrix_world.copy()
point = ((line[0] + line[1]) / 2)
point = tm * point
return point
def makeGeometry(point,outer_points):
# print("start cutting")
# print("intersection point: " + str(point))
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.delete(type='EDGE') # removes edges + verts
(vert_count, edge_count) = getVertEdgeCount()
vert_count = len(vert_count)
edge_count = len(edge_count)
'''
print("vert count is now: " + str(vert_count))
print("Edge count is now: " + str(edge_count))
print(outer_points[0][0])
print(outer_points[0][1])
print(outer_points[1][0])
print(outer_points[1][1])
'''
bpy.ops.object.mode_set(mode='OBJECT') # to be sure.
o = bpy.context.active_object
va = Vector((outer_points[0][0]))
vb = point
vc = Vector((outer_points[0][1]))
vd = Vector((outer_points[1][0]))
ve = Vector((outer_points[1][1]))
o.data.vertices.add(5)
o.data.vertices[vert_count].co = va
o.data.vertices[vert_count+1].co = vb
o.data.vertices[vert_count+2].co = vc
o.data.vertices[vert_count+3].co = vd
o.data.vertices[vert_count+4].co = ve
oe = o.data.edges
oe.add(4)
oe[edge_count].vertices = [vert_count,vert_count+1]
oe[edge_count+1].vertices = [vert_count+2,vert_count+1]
oe[edge_count+2].vertices = [vert_count+3,vert_count+1]
oe[edge_count+3].vertices = [vert_count+4,vert_count+1]
def runCleanUp():
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='TOGGLE')
bpy.ops.mesh.select_all(action='TOGGLE')
bpy.ops.mesh.remove_doubles(limit=0.0001)
#unselect all
bpy.ops.mesh.select_all(action='TOGGLE')
def getMeshMatrix(obj):
is_editmode = (obj.mode == 'EDIT')
if is_editmode:
bpy.ops.object.mode_set(mode='OBJECT')
edges = []
mesh = obj.data
verts = mesh.vertices
for e in mesh.edges:
if e.select:
edges.append(e)
meshMatrix = []
edgenum = 0
for edge_to_test in edges:
p1 = verts[edge_to_test.vertices[0]].co
p2 = verts[edge_to_test.vertices[1]].co
meshMatrix.append([(p1.x,p1.y,p1.z),(p2.x,p2.y,p2.z)])
edgenum += 1
return meshMatrix
def getVertEdgeCount():
bpy.ops.object.mode_set(mode='OBJECT')
vert_count = bpy.context.active_object.data.vertices
edge_count = bpy.context.active_object.data.edges
return (vert_count, edge_count)
def selectNewGeometry():
# potentially this is where i maybe go back to edit mode and select
# the newly added edges.
return
def initScript(context, self):
obj = bpy.context.active_object
meshMatrix = getMeshMatrix(obj)
(vert_count, edge_count) = getVertEdgeCount()
## force edit mode
bpy.ops.object.mode_set(mode='EDIT')
vSel = bpy.context.active_object.data.total_vert_sel
xv = len(vert_count)
xe = len(edge_count)
if len(meshMatrix) != 2:
print(str(len(meshMatrix)) +" select, make sure (only) 2 are selected")
else:
''' debug prints
print("begin--------------------")
print("the object has " + str(xv) + " verts")
print("currently " + str(vSel) + " verts are selected")
print("the object has " + str(xe) + " edges")
print("currently " + str(len(meshMatrix)) + " edges are selected")
print("--------------------end")
'''
if checkEdges(meshMatrix, obj) == None:
print("lines dont intersect")
else:
makeGeometry(checkEdges(meshMatrix, obj),meshMatrix)
runCleanUp()
# selectNewGeometry()
class SliceIntersectingEdges(bpy.types.Operator):
'''Finds visible intersection, existing or projected through extrapolation, creates new edges'''
bl_idname = "Slice at Intersection"
bl_label = "Slice Intersect"
@classmethod
def poll(self, context):
obj = context.active_object
return obj != None and obj.type == 'MESH'
def execute(self, context):
initScript(context, self)
return {'FINISHED'}
menu_func = (lambda self,
context: self.layout.operator(SliceIntersectingEdges.bl_idname,
text="Slice at Edge Intersection"))
def register():
bpy.types.VIEW3D_MT_edit_mesh_specials.append(menu_func)
def unregister():
bpy.types.VIEW3D_MT_edit_mesh_specials.remove(menu_func)
if __name__ == "__main__":
register()
import bpy
import sys
from mathutils import Vector
##function lifted from 3dview_spacebar_menu
def LineLineIntersect (p1, p2, p3, p4):
# based on Paul Bourke's Shortest Line Between 2 lines
min = 0.0000001
v1 = p1 - p3 #Vector((p1.x - p3.x, p1.y - p3.y, p1.z - p3.z))
v2 = p4 - p3 #Vector((p4.x - p3.x, p4.y - p3.y, p4.z - p3.z))
if abs(v2.x) < min and abs(v2.y) < min and abs(v2.z) < min:
return None
v3 = p2 - p1
if abs(v3.x) < min and abs(v3.y) < min and abs(v3.z) < min:
return None
d1 = v1.dot(v2)
d2 = v2.dot(v3)
d3 = v1.dot(v3)
d4 = v2.dot(v2)
d5 = v3.dot(v3)
d = d5 * d4 - d2 * d2
if abs(d) < min:
return None
n = d1 * d2 - d3 * d4
mua = n / d
mub = (d1 + d2 * (mua)) / d4
#modified for clarity, and to use some neat Vector functionality.
return [p1 + mua * v3 , p3 + mub * v2]
##function partially lifted from 3dview_spacebar_menu
def checkEdges(Edge, obj):
p1 = Vector((Edge[0][0]))
p2 = Vector((Edge[0][1]))
p3 = Vector((Edge[1][0]))
p4 = Vector((Edge[1][1]))
line = LineLineIntersect(p1, p2, p3, p4)
if line == None: return None
tm = obj.matrix_world.copy()
point = ((line[0] + line[1]) / 2)
point = tm * point
return point
def makeGeometry(point,outer_points):
# print("start cutting")
# print("intersection point: " + str(point))
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.delete(type='EDGE') # removes edges + verts
(vert_count, edge_count) = getVertEdgeCount()
vert_count = len(vert_count)
edge_count = len(edge_count)
'''
print("vert count is now: " + str(vert_count))
print("Edge count is now: " + str(edge_count))
print(outer_points[0][0])
print(outer_points[0][1])
print(outer_points[1][0])
print(outer_points[1][1])
'''
bpy.ops.object.mode_set(mode='OBJECT') # to be sure.
o = bpy.context.active_object
va = Vector((outer_points[0][0]))
vb = point
vc = Vector((outer_points[0][1]))
vd = Vector((outer_points[1][0]))
ve = Vector((outer_points[1][1]))
o.data.vertices.add(5)
o.data.vertices[vert_count].co = va
o.data.vertices[vert_count+1].co = vb
o.data.vertices[vert_count+2].co = vc
o.data.vertices[vert_count+3].co = vd
o.data.vertices[vert_count+4].co = ve
oe = o.data.edges
oe.add(4)
oe[edge_count].vertices = [vert_count,vert_count+1]
oe[edge_count+1].vertices = [vert_count+2,vert_count+1]
oe[edge_count+2].vertices = [vert_count+3,vert_count+1]
oe[edge_count+3].vertices = [vert_count+4,vert_count+1]
def runCleanUp():
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='TOGGLE')
bpy.ops.mesh.select_all(action='TOGGLE')
bpy.ops.mesh.remove_doubles(limit=0.0001)
def getMeshMatrix(obj):
is_editmode = (obj.mode == 'EDIT')
if is_editmode:
bpy.ops.object.mode_set(mode='OBJECT')
edges = []
mesh = obj.data
verts = mesh.vertices
for e in mesh.edges:
if e.select:
edges.append(e)
meshMatrix = []
edgenum = 0
for edge_to_test in edges:
p1 = verts[edge_to_test.vertices[0]].co
p2 = verts[edge_to_test.vertices[1]].co
meshMatrix.append([(p1.x,p1.y,p1.z),(p2.x,p2.y,p2.z)])
edgenum += 1
return meshMatrix
def getVertEdgeCount():
bpy.ops.object.mode_set(mode='OBJECT')
vert_count = bpy.context.active_object.data.vertices
edge_count = bpy.context.active_object.data.edges
return (vert_count, edge_count)
def selectNewGeometry():
# potentially this is where i maybe go back to edit mode and select
# the newly added edges.
return
def initScript():
obj = bpy.context.active_object
meshMatrix = getMeshMatrix(obj)
(vert_count, edge_count) = getVertEdgeCount()
## force edit mode
bpy.ops.object.mode_set(mode='EDIT')
vSel = bpy.context.active_object.data.total_vert_sel
xv = len(vert_count)
xe = len(edge_count)
if len(meshMatrix) != 2:
print(str(len(meshMatrix)) +" select, make sure (only) 2 are selected")
else:
''' debug prints
print("begin--------------------")
print("the object has " + str(xv) + " verts")
print("currently " + str(vSel) + " verts are selected")
print("the object has " + str(xe) + " edges")
print("currently " + str(len(meshMatrix)) + " edges are selected")
print("--------------------end")
'''
if checkEdges(meshMatrix, obj) == None:
print("lines dont intersect")
else:
makeGeometry(checkEdges(meshMatrix, obj),meshMatrix)
runCleanUp()
# selectNewGeometry()
# runs the joint
initScript()

import sys
obj = bpy.context.active_object
edges = []
mesh = obj.data
verts = mesh.vertices
# this for loop is from the 3dview_spacebar_menu
for e in mesh.edges:
if e.select:
edges.append(e)
meshMatrix = []
edgenum = 0
for edge_to_test in edges:
p1 = verts[edge_to_test.vertices[0]].co
p2 = verts[edge_to_test.vertices[1]].co
meshMatrix.append([(p1.x,p1.y,p1.z),(p2.x,p2.y,p2.z)])
edgenum += 1
for edge_ in meshMatrix:
edge_
[(0.0, 1.0, 1.0), (5.211963127749186e-08, 0.0, 1.0)]
[(5.211963127749186e-08, 0.0, 1.0), (5.211963127749186e-08, 0.0, 2.0)]
[(0.6621248126029968, 0.0, 2.0), (0.6621248126029968, 0.0, 1.0)]
[(0.6621248126029968, 0.0, 1.0), (0.6621248126029968, 1.637786626815796, 1.0)]
[(0.6621248126029968, 1.637786626815796, -0.04176926612854004), (0.6621248126029968, 1.637786626815796, 1.0)]
[(2.0378873348236084, 1.637786626815796, 1.0), (2.0378873348236084, 1.637786626815796, -0.04176926612854004)]
[(2.0378873348236084, 1.637786626815796, 1.0), (2.0378873348236084, 0.0, 1.0)]
# test
import sys
import math
preStantonList = [
[(0.0, 1.0, 1.0), (5.211963127749186e-08, 0.0, 1.0)],
[(5.211963127749186e-08, 0.0, 1.0), (5.211963127749186e-08, 0.0, 2.0)],
[(0.6621248126029968, 0.0, 2.0), (0.6621248126029968, 0.0, 1.0)],
[(0.6621248126029968, 0.0, 1.0), (0.6621248126029968, 1.637786626815796, 1.0)],
[(0.6621248126029968, 1.637786626815796, -0.04176926612854004), (0.6621248126029968, 1.637786626815796, 1.0)],
[(2.0378873348236084, 1.637786626815796, 1.0), (2.0378873348236084, 1.637786626815796, -0.04176926612854004)],
[(2.0378873348236084, 1.637786626815796, 1.0), (2.0378873348236084, 0.0, 1.0)]
]
def calcDifference(val1, val2):
if val1 > val2: return val1-val2
if val2 > val1: return val2-val1
if val1 == val2: return 0.0
def isListHomogenous(vertList):
'''
function returns True if no anomalies are found, False if one vert exceeds epsilon
'''
def average(vertList):
sum = 0.0
for i in vertList:
sum += i
avsum = sum / len(vertList)
return avsum
def isEpsilon(val1, val2):
min = 0.0000001
if calcDifference(val1, val2) == 0.0: return True
if calcDifference(val1, val2) < min: return True
return False
def checkList(vertList):
print average(vertList)
for i in vertList:
if not isEpsilon(i, average(vertList)): return False
# reaches this stage, means the variation is probably minimal
return True
#my Boolean
GOODTOGO = False
GOODTOGO = checkList(vertList)
return GOODTOGO
def printEdgeList(eList):
(p1x, p1y, p1z) = (0.0, 0.0, 0.0)
(p2x, p2y, p2z) = (0.0, 0.0, 0.0)
planarX = 0.0
planarY = 0.0
planarZ = 0.0
edgenum = 0
vertXList = []
vertYList = []
vertZList = []
xPlaneVerts = []
yPlaneVerts = []
zPlaneVerts = []
def sumList(coordinate_list):
summing = 0.0
for i in coordinate_list:
summing += i
return summing
def VertsDeltaInPlane(axis, value1, value2):
min = 0.0000001
difference = calcDifference(value1, value2)
# gets dirty for larger numbers, but we aren't doing intergalatic travel.
if difference < min: difference = 0.0
print "difference in axis " + axis + " component of this edge is " + str(difference)
return difference
def printCoordinate(val_x,val_y,val_z):
print "| x = " + str(val_x),
print "| y = " + str(val_y),
print "| z = " + str(val_z)
for item in eList:
print "=========="
print "edge [" + str(edgenum) + "] .....(" + str(edgenum+1) + ")"
print "vertex 0",
p1x = item[0][0]
p1y = item[0][1]
p1z = item[0][2]
printCoordinate(p1x,p1y,p1z)
print "vertex 1",
p2x = item[1][0]
p2y = item[1][1]
p2z = item[1][2]
printCoordinate(p2x,p2y,p2z)
planarX = VertsDeltaInPlane("x", p1x, p2x)
planarY = VertsDeltaInPlane("y", p1y, p2y)
planarZ = VertsDeltaInPlane("z", p1z, p2z)
# collects all vertices
xComp = [p1x,p2x]
yComp = [p1y,p2y]
zComp = [p1z,p2z]
xPlaneVerts.extend(xComp)
yPlaneVerts.extend(yComp)
zPlaneVerts.extend(zComp)
vertXList.append(planarX)
vertYList.append(planarY)
vertZList.append(planarZ)
edgenum += 1
def myRound(value):
return ".7f" % value
print "-------conclusion---------"
# this statement checks if the the verts on each edge or on the same plane
# check here if the selection is usable or not.
if sumList(vertXList) == 0.0:
print "x", xPlaneVerts
if isListHomogenous(xPlaneVerts):
print "GOOD TO GO!",
print "the plane is X at " + str(round(p1x,6))
else:
print "same plane but not same elevation"
elif sumList(vertYList) == 0.0:
print "y", yPlaneVerts
if isListHomogenous(yPlaneVerts):
print "GOOD TO GO!",
print "the plane is Y at " + str(round(p1y,6))
else:
print "same plane but not same elevation"
elif sumList(vertZList) == 0.0:
print "z", zPlaneVerts
if isListHomogenous(zPlaneVerts):
print "GOOD TO GO!",
print "the plane is Z at " + str(round(p1z,6))
else:
print "same plane but not same elevation"
else:
print "not on the same plane, the script will not proceed"
printEdgeList(preStantonList)