def makeEngraves(m, obj):
tool_id = m.group(1)
operation = m.group(2)
z_pos = m.group(3)
#restore view cplane
p1 = rs.WorldXYPlane()
rs.ViewCPlane(None, p1)
subtracts = []
if operation == 'Engrave':
# return sweepVolume(obj, tool_id, z_pos)
subcurves = rs.ExplodeCurves(obj, True)
if subcurves:
for crv in subcurves:
vol = sweepVolume(crv, tool_id, z_pos)
if vol:
subtracts += vol
result = rs.BooleanUnion(subtracts)
return result
def create_pipe(self, point_n, point_p):
outer_point_n = self.create_scaled_point(point_n, self.PIPE_SCALAR)
outer_point_p = self.create_scaled_point(point_p, self.PIPE_SCALAR)
inner_point_n = self.create_scaled_point(point_n,
self.INNER_PIPE_SCALAR)
inner_point_p = self.create_scaled_point(point_p,
self.INNER_PIPE_SCALAR)
opl = rs.AddPolyline([outer_point_p, self.middle_point, outer_point_n])
ipl = rs.AddPolyline([inner_point_p, self.middle_point, inner_point_n])
o_pipe = rs.AddPipe(opl, 0, self.CIRCLE_WIDTH, 1, 1)
i_pipe = rs.AddPipe(ipl, 0, self.CIRCLE_INNER_WIDTH, 1, 1)
return rs.BooleanUnion([o_pipe, i_pipe])
def main():
to_delete = []
rs.ProjectOsnaps(False)
positive_object = rs.GetObject("select positive object", 16)
negative_object = rs.GetObject("select negative object", 16)
rs.HideObject(negative_object)
polysurface, face = GetSubSurface("select tenon surface")
to_delete.append(face)
normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5)))
plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal)
rs.ViewCPlane(plane=plane)
rs.ProjectOsnaps(True)
tenon_rects = rs.GetObjects(message="select tenon curves", filter=4)
tenon_faces = []
for rect in tenon_rects:
tenon_faces.append(rs.AddPlanarSrf(rect)[0])
rs.ShowObject(negative_object)
rs.ProjectOsnaps(False)
height_pt = rs.GetPoint("enter height point")
# compule a vector normal to plane of the desired height
extrude_vec_a = rs.EvaluateSurface(face, 0.5, 0.5)
dist = rs.DistanceToPlane(plane, height_pt)
extrude_vec_b = [dist * el for el in normal]
extrude_vec_b = rs.VectorAdd(extrude_vec_a, extrude_vec_b)
extrude_curve = rs.AddCurve((extrude_vec_a, extrude_vec_b))
to_delete.append(extrude_curve)
tenons = []
for tenon_face in tenon_faces:
tenon = rs.ExtrudeSurface(tenon_face, extrude_curve)
tenons.append(tenon)
rs.BooleanUnion([positive_object] + tenons, delete_input=False)
rs.BooleanDifference([negative_object], tenons, delete_input=False)
to_delete.append(positive_object)
to_delete.append(negative_object)
rs.DeleteObjects(to_delete)
rs.DeleteObjects(tenon_faces)
rs.DeleteObjects(tenons)
def makeFireStair(rect, landingLevels):
#HARD VARIABLES
minStairWidth = 1.118
minHeadroom = 2.032
maxRunRise = 3.658
minNumRisers = 3
minGapSize = .2
minTread = .280
maxTread = .400
minRiser = .100
maxRiser = .180
thickness = .25
maxRisersInRun = 16
maxWidth = 2.4
scissorStair = False
hdrlHeight = .900
#hdrlTopExtension = .305
#hdrlBtmExtension = 1*treadDepth
#hdrlMaxProjection = .114
#(1)Determine Run Direction
rs.SimplifyCurve(rect)
rectSegments = rs.ExplodeCurves(rect)
edge1 = rectSegments[0]
edge3 = rectSegments[1]
if rs.CurveLength(edge1) > rs.CurveLength(edge3):
longEdge = edge1
shortEdge = edge3
else:
longEdge = edge3
shortEdge = edge1
longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge),
rs.CurveEndPoint(longEdge))
longVecRev = rs.VectorReverse(longVec)
shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge),
rs.CurveEndPoint(shortEdge))
shortVecRev = rs.VectorReverse(shortVec)
#(2)Stair Width
stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2
if stairWidth < .6:
print "ERROR: Stair is ridiculously too narrow."
return
#(3)Run Length
runLength = rs.CurveLength(longEdge) - (stairWidth * 2)
if runLength < 1:
print "ERROR: Stair is ridiculously too short."
return
#LandingRect
landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge),
shortVecRev, longVecRev)
landing1 = rs.AddRectangle(landing1Plane, rs.CurveLength(shortEdge),
stairWidth)
landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge), shortVec,
longVec)
landing2 = rs.AddRectangle(landing2Plane, rs.CurveLength(shortEdge),
stairWidth)
#RunRects
run1Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev)
run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength)
run2Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing2)[3], shortVec, longVec)
run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength)
#(4)Num Flights between Landings
numLevels = len(landingLevels)
deltaLevels = []
runsPerLevel = []
mostRisersInRun = math.floor(runLength / minTread)
if mostRisersInRun > maxRisersInRun:
mostRisersInRun = maxRisersInRun
numRuns = 0
for i in range(0, numLevels - 1):
deltaLevels.append(landingLevels[i + 1] - landingLevels[i])
minNumRisers = math.ceil(deltaLevels[i] / maxRiser)
runsPerLevel.append(math.ceil(minNumRisers / mostRisersInRun))
numRuns = numRuns + int(runsPerLevel[i])
#(5) Which flights
listOfRuns = []
for i in range(0, numRuns):
if i % 2: #if even
listOfRuns.append(rs.CopyObject(run1Rect))
else:
listOfRuns.append(rs.CopyObject(run2Rect))
#(6) Num Treads per run
runsDeltaHeight = []
for i in range(0, numLevels - 1):
for j in range(0, int(runsPerLevel[i])):
runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i])
numRisersPerRun = []
for i in range(0, numRuns):
numRisersPerRun.append(math.ceil(runsDeltaHeight[i] / maxRiser))
#(7) Move Runs
elevation = 0
landings = []
for i in range(0, numRuns):
elevation = elevation + runsDeltaHeight[i]
translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0])
rs.MoveObject(listOfRuns[i], translation)
if i % 2:
landings.append(rs.MoveObject(rs.CopyObject(landing2),
translation))
else:
landings.append(rs.MoveObject(rs.CopyObject(landing1),
translation))
#(8) Make Landings
stairGeo = []
for i in range(0, numRuns):
dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]])
#rs.MoveObject(landings[i], dir)
path = rs.AddLine([0, 0, 0], [0, 0, -thickness])
geo = rs.ExtrudeCurve(landings[i], path)
rs.CapPlanarHoles(geo)
stairGeo.append(geo)
rs.DeleteObject(path)
rs.DeleteObjects(landings)
#(9) Draw Stairs
runs = []
for i in range(0, numRuns):
runs.append(
Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i],
thickness, i, maxTread))
stairGeo.append(runs[i].make())
runs[i].makeHandrail(hdrlHeight, minGapSize)
runs[i].printStats()
runs[i].cleanup()
finalGeo = rs.BooleanUnion(stairGeo, delete_input=True)
#(10) Scissor Stairs
if scissorStair:
pt0 = rs.CurveMidPoint(rectSegments[0])
pt1 = rs.CurveMidPoint(rectSegments[1])
pt2 = rs.CurveMidPoint(rectSegments[2])
pt3 = rs.CurveMidPoint(rectSegments[3])
mir1 = rs.MirrorObject(finalGeo, pt0, pt2, copy=True)
mirroredStair = rs.MirrorObject(mir1, pt1, pt3, copy=False)
#(11)Label
rs.SetUserText(finalGeo, "Brew", "Hot Coffee")
if scissorStair:
rs.SetUserText(mirroredStair, "Brew", "Hot Coffee")
#Cleanup
rs.DeleteObjects(listOfRuns)
rs.DeleteObjects(rectSegments)
rs.DeleteObject(landing1)
rs.DeleteObject(landing2)
rs.DeleteObject(run1Rect)
rs.DeleteObject(run2Rect)
print "done"
return None
def __init__(self, current_point, next_point_up, next_point_down,
prev_point_up, prev_point_down):
self.middle_point = current_point
extrusion_nu = self.create_pipe(next_point_up, prev_point_down)
extrusion_nd = self.create_pipe(next_point_down, prev_point_up)
self.brep = rs.BooleanUnion([extrusion_nu, extrusion_nd])
def makeFireStair(rect, landingLevels):
#HARD VARIABLES
minGapSize = .2
minTread = .260
maxRiser = .180
thickness = .15
#(1)Determine Run Direction
rs.SimplifyCurve(rect)
rectSegments = rs.ExplodeCurves(rect)
edge1 = rectSegments[0]
edge3 = rectSegments[1]
rs.DeleteObject(rectSegments[2])
rs.DeleteObject(rectSegments[3])
if rs.CurveLength(edge1) > rs.CurveLength(edge3):
longEdge = edge1
shortEdge = edge3
else:
longEdge = edge3
shortEdge = edge1
longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge),
rs.CurveEndPoint(longEdge))
longVecRev = rs.VectorReverse(longVec)
shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge),
rs.CurveEndPoint(shortEdge))
shortVecRev = rs.VectorReverse(shortVec)
rs.CurveArrows(longEdge, 2)
rs.CurveArrows(shortEdge, 2)
#(2)Stair Width
stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2
#LandingRect
landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge),
shortVecRev, longVecRev)
landing1 = rs.AddRectangle(landing1Plane,
rs.CurveLength(shortEdge), stairWidth)
landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge),
shortVec, longVec)
landing2 = rs.AddRectangle(landing2Plane,
rs.CurveLength(shortEdge), stairWidth)
#(3)Run Length
runLength = rs.CurveLength(longEdge) - (stairWidth * 2)
#RunRects
run1Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev)
run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength)
run2Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing2)[3], shortVec, longVec)
run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength)
#(4)Num Flights between Landings
numLevels = len(landingLevels)
deltaLevels = []
runsPerLevel = []
maxRisersPerRun = math.floor(runLength / minTread)
numRuns = 0
for i in range(0, numLevels - 1):
deltaLevels.append(landingLevels[i + 1] - landingLevels[i])
minNumRisers = math.ceil(deltaLevels[i] / maxRiser)
runsPerLevel.append(math.ceil(minNumRisers / maxRisersPerRun))
numRuns = numRuns + int(runsPerLevel[i])
#(5) Which flights
listOfRuns = []
for i in range(0, numRuns):
if i % 2: #if even
listOfRuns.append(rs.CopyObject(run1Rect))
else:
listOfRuns.append(rs.CopyObject(run2Rect))
#(6) Num Treads per run
runsDeltaHeight = []
for i in range(0, numLevels - 1):
for j in range(0, int(runsPerLevel[i])):
runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i])
numRisersPerRun = []
for i in range(0, numRuns):
numRisersPerRun.append(math.ceil(runsDeltaHeight[i] /
maxRiser))
#(7) Move Runs
elevation = 0
landings = []
for i in range(0, numRuns):
elevation = elevation + runsDeltaHeight[i]
translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0])
rs.MoveObject(listOfRuns[i], translation)
if i % 2:
landings.append(
rs.MoveObject(rs.CopyObject(landing2), translation))
else:
landings.append(
rs.MoveObject(rs.CopyObject(landing1), translation))
#(8) Make Landings
stairGeo = []
for i in range(0, numRuns):
dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]])
#rs.MoveObject(landings[i], dir)
path = rs.AddLine([0, 0, 0], [0, 0, -thickness])
geo = rs.ExtrudeCurve(landings[i], path)
rs.CapPlanarHoles(geo)
stairGeo.append(geo)
rs.DeleteObject(path)
rs.DeleteObjects(landings)
#(9) Draw Stairs
runs = []
for i in range(0, numRuns):
runs.append(
Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i]))
stairGeo.append(runs[i].make())
finalGeo = rs.BooleanUnion(stairGeo, delete_input=True)
#Cleanup
rs.DeleteObjects(listOfRuns)
rs.DeleteObjects(rectSegments)
rs.DeleteObject(landing1)
rs.DeleteObject(landing2)
rs.DeleteObject(run1Rect)
rs.DeleteObject(run2Rect)
print "done"
return finalGeo
def Generation():
#SETTING UP THE FILE ACCESS TO READ ALL THERE IS TO BE READ
#THE SCRIPT FROM NOW ON LOOKS for FILE AND if IT CANNOT FIND ONE IT WILL HAVE TO MAKE ONE
#SOOO WE START BY LOOKING for AND READING THE FILE if WE FIND IT
##
########################################################################
#READ INFO IN THE FILE
########################################################################
#ReadFile returns an array of [isAlive,startPoint,jointNos]
content = History.ReadPolies(folder, file)
rhUnitInches = 8
rs.UnitSystem(rhUnitInches, False, True)
zero = [0, 0, 0]
zaxis = [0, 0, 1]
vrt = []
#Decimal display and decimal places
#rs.UnitDistanceDisplayMode(0)
#rs.UnitDistanceDisplayPrecision(7)
#sth to control that we have an [0,0,0] to check
endcheck = 1
size = 1
living = []
startpts = []
sequences = []
#if we read nothing we should save 1 starting point - namely [0,0,0]
if content is None:
living = [1]
startpts = [[0, 0, 0]]
sequences = [[0]]
npolies = 0
content = [[living[0], startpts[0], sequences[0]]]
endcheck = 0
else:
for rib in content:
living.append(rib[0])
startpts.append(rib[1])
sequences.append(rib[2])
#checking if new rib has actualy been started
#[0,0,0] will always be there to be grown
if rs.Distance(content[-1][1], [0, 0, 0]) < tiny:
endcheck = 0
# if not and we have less than 4 legs start a new leg at [0,0,0]
if (endcheck != 0 and len(content) < 4):
ribs = content
ribs.append([1, [0, 0, 0], [0]])
content = ribs
endcheck = 0
living.append(1)
startpts.append([0, 0, 0])
sequences.append([0])
npolies = len(content)
narm = []
setforbool = []
content2 = []
crack = []
numb = 0
# P R O C E S S I N G
#CASE 1. NOTHING HAS BEEN MADE. WE HAVE ONE EXISTING RIB. IT IS BUDDING (IT THINKS IT STARTS AT [0,0,0])
#NO CHECKS, NO INTERSECTIONS, THE B A S I C STUFF
if npolies == 1:
for i in range(noribs):
rs.Command(
"_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER")
rs.Command("_SelAll")
rs.Command("_Join")
rs.Command("_SelNone")
rs.Command("_SelAll")
defject = rs.SelectedObjects(False, False)
box2 = rs.AddPolyline([[-5.25, -5.25, 0], [5.25, -5.25, 0],
[5.25, 5.25, 0], [-5.25, 5.25, 0],
[-5.25, -5.25, 0]])
rs.MoveObject(box2, move_it)
line1 = [1, 0, 0]
line1 = rs.VectorRotate(line1, i * 360 / (noribs), zaxis)
sequence = [1, line1, [0]]
polypoints = JointAccess.Outline(sequence[1], sequence[1],
sequence[2])
verte = rs.AddPolyline(polypoints)
intersection = rs.CurveCurveIntersection(verte, box2)
if not intersection is None:
sequence[0] = 0
rs.DeleteObject(verte)
setforbool = []
setforbool.append(defject)
setforbool.append(
JointAccess.Arm(sequence[1], sequence[1], sequence[2], fc))
container = rs.BooleanUnion(setforbool)
if not container is None:
defject = container(0)
SaveNClean(defject, polypoints, numb, content2)
numb = numb + 1
#CASE 2 ONE RIB HAS STARTED GROWING AND ONE RIB IS BUDDING (THINKS THE ENDPOINT IS (0,0,0))
#THE EXISTING RIB NEEDS TO CHECK FOR INTERECTIONS WITH ITSELF ALONE [MAYBE WITH THE BASE AS WELL????]
#THE NEW RIB MUST MAKE SURE IT IS STARTING FROM A DIFFERENT POINT A N D THAT IT DOES NOT INTERSECT WITH EXISTING RIB
elif npolies == 2 and rs.Distance(startpts[-1], [0, 0, 0]) <= tiny:
#ADDING TO THE EXISTING RIB
#THE LOOP BELOW IS INFRASTRUCTURE FOR CASE 3. RIGHT NOW IT ONLY HAS ONE ITERATION
for i in range(npolies - 1):
insequence = content[i]
#do sth only if this particular rib is NOT DEAD
if insequence[0] != 0:
for i in range(noribs)[1:]:
#i is going through 1 to 15 for different endings
#in [s,e,q,u,e,n,c,e,0] we will get [s,e,q,u,e,n,c,e,i,0]
rs.Command(
"_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER"
)
rs.Command("_SelAll")
rs.Command("_Join")
rs.Command("_SelNone")
rs.Command("_SelAll")
defject = rs.SelectedObjects(False, False)
box2 = rs.AddPolyline([[-5.25, -5.25, 0], [5.25, -5.25, 0],
[5.25, 5.25, 0], [-5.25, 5.25, 0],
[-5.25, -5.25, 0]])
rs.MoveObject(box2, move_it)
joints = insequence[2][:-1]
joints.append(i)
joints.append(0)
sequence = [1, insequence[1], joints]
polypoints = JointAccess.Outline(sequence[1], sequence[1],
sequence[2])
verte = rs.AddPolyline(polypoints)
#CHECKING FOR SELF INTERSECTION
#continue continues with the loop without reading the stuff below
int = rs.CurveCurveIntersection(verte, None, 0.000001)
if len(int) != 0:
everything = rs.AllObjects()
rs.DeleteObjects(everything)
continue
intersection = rs.CurveCurveIntersection(verte, box2)
#NEED A SELF INTERSECTIOn CHECK
if not intersection is None:
sequence[0] = 0
rs.DeleteObject(verte)
setforbool = []
setforbool.append(defject)
setforbool.append(
JointAccess.Arm(sequence[1], sequence[1], sequence[2],
fc))
container = rs.BooleanUnion(setforbool)
if not container is None:
defject = container(0)
else:
#print error message
message = str(datetime.datetime.now()
) + "\n" + "BOOLEAN UNION FAIL"
History.WriteFile(
"C:\R3\OffCenter\Walk\ErrorMessage.dat", message)
SaveNClean(defject, polypoints, numb, content2)
numb = numb + 1
#MAKING OF THE NEW RIB
other_ribs = []
for i in range(len(content) - 1):
other_ribs.append(content[i])
for i in range(noribs):
rs.Command(
"_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER")
rs.Command("_SelAll")
rs.Command("_Join")
rs.Command("_SelNone")
rs.Command("_SelAll")
defject = rs.SelectedObjects(False, False)
box2 = rs.AddPolyline([[-5.25, -5.25, 0], [5.25, -5.25, 0],
[5.25, 5.25, 0], [-5.25, 5.25, 0],
[-5.25, -5.25, 0]])
rs.MoveObject(box2, move_it)
line1 = [1, 0, 0]
line1 = rs.VectorRotate(line1, i * 360 / (noribs), zaxis)
sequence = [1, line1, [0]]
polypoints = JointAccess.Outline(sequence[1], sequence[1],
sequence[2])
verte = rs.AddPolyline(polypoints)
#CHECKING FOR INTERSECTION with any of the already existent ribs
#continue continues with the loop without reading the stuff below
chck = False
for i in range(len(content) - 1):
chckpts = JointAccess.Outline(content[i][1], content[i][1],
content[i][2])
chckcrv = rs.AddPolyline(chckpts)
int = rs.CurveCurveIntersection(verte, chckcrv, 0.000001)
if len(int) != 0:
chck = True
if chck:
everything = rs.AllObjects()
rs.DeleteObjects(everything)
continue
intersection = rs.CurveCurveIntersection(verte, box2)
if not intersection is None:
sequence[0] = 0
rs.DeleteObject(verte)
setforbool = []
setforbool.append(defject)
setforbool.append(
JointAccess.Arm(sequence[1], sequence[1], sequence[2], fc))
for i in range(len(content) - 1):
setforbool.append(
JointAccess.Arm(content[i][1], content[i][1],
content[i][2], fc))
container = rs.BooleanUnion(setforbool)
if not container is None:
defject = container(0)
else:
#print error message
message = str(
datetime.datetime.now()) + "\n" + "BOOLEAN UNION FAIL"
History.WriteFile("C:\R3\OffCenter\Walk\ErrorMessage.dat",
message)
SaveNClean(defject, polypoints, numb, content2)
numb = numb + 1
elif npolies > 2 and rs.Distance(startpts[-1], [0, 0, 0]) <= tiny:
print "case npolies>2 and one budding not coded yet"
else:
print "case npolies>2 and none budding"
#THE OUTERMOST POINT ROTATES THROUGH THE END POINTS - whatever that means:P
"""
for k in range(len(content)):
#OOOOOOO
#OOOOOOO
#OOOOOOO
#OOOOOOO
#G O I N G T H R O U G H L I V I N G R I B S
#if RIB IS ALIVE THEN DO WHAT FOLLOWS OTHERWISE THERE IS NOTHING TO LOOK AT
#WHAT if ALL DIES??? I WILL WORRY ABOUT IT LATER
for i in range(len(noribs)):
rs.Command("_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER")
rs.Command("_SelAll")
rs.Command("_Join")
rs.Command("_SelNone")
rs.Command("_SelAll")
defject = rs.SelectedObjects(False,False)
box2 = rs.AddPolyline([[-5.25,-5.25,0],[5.25,-5.25,0],[5.25,5.25,0],[-5.25,5.25,0],[-5.25,-5.25,0]])
rs.MoveObject(box2, move_it)
pas = 1
con2 = -1
if rs.Distance(endpts[k],[0,0,0]) < tiny:
#If we are working with a new rib then we need to set a new beginning.
line1 = [1,0,0]
line1 = rs.VectorRotate(line1,i*360/(noribs),zaxis)
sequence = [1,line1,[0]]
#TEST1 - CHECK for LEAVING OFF IN THE SAME DIRECTION
pas = 1
for pt in startpts:
if rs.Distance(pt,line1)<tiny:
pas = 0
#TEST2 - CHECK for OVERLAP WITH OTHER CURVES
if pas = 1:
for j = 0 To npolies
#CAN#T DO INTERSECTION WITH CURVE THAT HASN#T GROWN YET - OUTLINE PRODUCTION
if rs.Distance(content(0](j](1],[0,0,0]] > tiny And j<>k Then
carrier = content(0](j]
con2 = con2 + 1
ReDim Preserve content2(con2]
content2(con2] = Outline(carrier(1],carrier(1],carrier(2]]
ReDim Preserve vrt(con2]
vrt(con2] = rs.PolylineVertices(content2(j]]
elif rs.Distance(content(0](j](1],[0,0,0]] < tiny And j=k Then
carrier = sequence
con2 = con2 + 1
ReDim Preserve content2(con2]
content2(con2] = Outline(carrier(1],carrier(1],carrier(2]]
ReDim Preserve vrt(con2]
vrt(con2] = rs.PolylineVertices(content2(j]]
verte = content2
#TEST3 - CHECK for OVERLAP WITH THE BORDER - OVERLAP = KILL
intersection = rs.CurveCurveIntersection(verte(k],box2]
if intersection not is None:
sequence(0] = 0
for j = 0 To npolies
if j <> k Then
intersection = rs.CurveCurveIntersection(verte(k],verte(j]]
if Not isNull(intersection] Then
rs.DeleteObjects(verte]
pass = 0
Exit for
rs.DeleteObjects(verte]
#STEP 4 - PRINT THE ARMS AND BOOLEAN THE HELL OUT OF THEM SAVE THEM ETC
if pass = 1 Then
for j = 0 To npolies
if j <> k Then
content2(j] = content(0](j]
Else
content2(k] = sequence
End if
Next
ReDim setforbool(npolies+1]
setforbool(0] = defject
for j = 0 To npolies
setforbool(j+1] = Arm(content2(j](1],content2(j](1],content2(j](2]]
Next
#BOOLEAN THINGS UP
container = rs.BooleanUnion(setforbool]
if Not IsNull(container] Then
defject = container(0]
End if
SaveNClean(defject,vrt,numb,k,content2]
numb = numb + 1
Else
objects = rs.AllObjects(]
rs.DeleteObjects(objects]
End if
Else
if i <> 0 Then
#STEP0 - MAKE A NEW RIB
line1 = i
size2 = UBound(content(0](k](2]]
ReDim crack(size2+1]
for j = 0 To size2-1
crack(j] = content(0](k](2](j]
Next
crack(size2] = line1
crack(size2+1] = 0
sequence = [content(0](k](0],content(0](k](1],crack]
#TEST1 - CHECK for LEAVING OFF IN THE SAME DIRECTION
#DROPPED
if pass = 1 Then
for j = 0 To npolies
#CAN#T DO INTERSECTION WITH CURVE THAT HASN#T GROWN YET - OUTLINE PRODUCTION
if rs.Distance(content(0](j](1],[0,0,0]] > tiny Then
carrier = sequence
con2 = con2 + 1
ReDim Preserve content2(con2]
content2(con2] = Outline(carrier(1],carrier(1],carrier(2]]
ReDim Preserve vrt(con2]
vrt(con2] = rs.PolylineVertices(content2(j]]
End if
Next
verte = content2
#TEST3 - CHECK for OVERLAP WITH THE BORDER - OVERLAP = KILL
intersection = rs.CurveCurveIntersection(verte(k],box2]
if Not isNull(intersection] Then
sequence(0] = 0
End if
#TEST2 - CHECK for OVERLAP WITH OTHER CURVES
for j = 0 To con2
if j <> k Then
intersection = rs.CurveCurveIntersection(verte(k],verte(j]]
if Not isNull(intersection] Then
pas = 0
Exit for
End if
End if
Next
rs.DeleteObjects(verte]
End if
#STEP 4 - PRINT THE ARMS AND BOOLEAN THE HELL OUT OF THEM SAVE THEM ETC
if pass = 1 Then
for j = 0 To con2 #[0,0,0] can only happen in the last poly
if j <> k Then
content2(j] = content(0](j]
Else
content2(k] = sequence
End if
Next
ReDim setforbool(con2+1]
setforbool[0] = defject
for j = 0 To con2
setforbool[j+1] = Arm(content2[j][1],content2[j][1],content2[j][2])
container = rs.BooleanUnion(setforbool)
if container not is None:
defject = container(0)
SaveNClean(defject,vrt,numb,k,content2)
numb = numb + 1
else:
objects = rs.AllObjects(]
rs.DeleteObjects(objects]
"""
##
########################################################################
#making a text file that will be read by python to decide how many iterations to run on testing
########################################################################
History.WriteFile(tempfolder, str(numb))
########################################################################
##
#DONE
History.WriteFile(tempfolder + "OutputNo.txt", str(numb))
#SET UP A CLEAN EXIT
rs.Command("-saveas C:\\R3\OffCenter\Walk\Temp\rubbish.3dm")
def make_hinge(num_knuckles, knuckle_height, knuckle_radius, thickness,
leaf_length, gap, add_vents):
origin = [0, 0, 0]
hinge_height = num_knuckles * knuckle_height
######################################################################
# Make pin with caps
cap_radius = knuckle_radius - 0.5 * thickness - gap
cap_height = thickness
cap_bottom = rs.AddCylinder(origin, cap_height, cap_radius)
cap_top = rs.AddCylinder([0, 0, hinge_height - cap_height], cap_height,
cap_radius)
pin_radius = knuckle_radius - (gap + thickness)
pin = rs.AddCylinder(origin, hinge_height, pin_radius)
pin = rs.BooleanUnion([pin, cap_bottom, cap_top])
######################################################################
# Make knuckle and holes
right_knuckle = rs.AddCylinder(origin, hinge_height, knuckle_radius)
knuckle_pin_hole = rs.AddCylinder(origin, hinge_height,
knuckle_radius - thickness)
knuckle_bottom_hole = rs.AddCylinder(origin, cap_height + gap,
cap_radius + gap)
knuckle_top_hole = rs.AddCylinder([0, 0, hinge_height - cap_height - gap],
cap_height + gap, cap_radius + gap)
######################################################################
# Make leaves
right_p0 = (0, knuckle_radius, 0)
right_p1 = (leaf_length, knuckle_radius - thickness, hinge_height)
right_leaf = rs.AddBox(mz.box_verts_from_corners(right_p0, right_p1))
right_leaf = rs.BooleanUnion([right_knuckle, right_leaf])
right_leaf, = rs.BooleanDifference(
[right_leaf],
[knuckle_pin_hole, knuckle_bottom_hole, knuckle_top_hole])
mirror_leaf = rs.XformMirror(origin, (1, 0, 0))
left_leaf = rs.TransformObject(right_leaf, mirror_leaf, True)
######################################################################
# Cut out alternating knuckles
z0 = 0
sz = knuckle_radius + gap
left_boxes = []
right_boxes = []
vent_height = knuckle_height - 4 * thickness
for stage in range(num_knuckles):
z1 = z0 + knuckle_height
if stage == 0:
cur_z0 = z0
else:
cur_z0 = z0 - 0.5 * gap
if stage == num_knuckles - 1:
cur_z1 = z1
else:
cur_z1 = z1 + 0.5 * gap
knuckle_box = rs.AddBox(
mz.box_verts_from_corners((-sz, -sz, cur_z0), (sz, sz, cur_z1)))
if stage % 2 == 0:
left_boxes.append(knuckle_box)
else:
right_boxes.append(knuckle_box)
if add_vents:
zmid = z0 + 0.5 * knuckle_height
za = zmid - 0.5 * vent_height
zb = zmid + 0.5 * vent_height
mid_box = rs.AddBox(
mz.box_verts_from_corners((-sz, -pin_radius - gap, za),
(sz, pin_radius + gap, zb)))
if stage % 2 == 0:
right_boxes.append(mid_box)
else:
left_boxes.append(mid_box)
z0 += knuckle_height
left_leaf, = rs.BooleanDifference([left_leaf], left_boxes)
right_leaf, = rs.BooleanDifference([right_leaf], right_boxes)
rs.SelectObjects([left_leaf, right_leaf, pin])
rs.Command('MergeAllFaces')
def main():
rectangle = rs.GetObject("Select rectangle to create mortise and tenon from", rs.filter.curve, True, True)
errorCheck = curveErrorCheck(rectangle)
if errorCheck == True:
return
lines = rs.ExplodeCurves(rectangle)
errorCheck = lineErrorCheck(lines)
if errorCheck == True:
return
face = rs.GetObject("Select tenon surface", rs.filter.surface, False, True, None, True)
length = rs.GetReal("Enter tenon length", number=None)
if length and length != 0:
x = 0
else:
print "Failed....No length was entered"
return
depth = rs.GetReal("Enter mortise depth", number=length+0.05)
if depth and depth != 0:
x = 0
else:
print "Failed....No depth was entered"
return
fit = rs.GetReal("Enter mortise fit", number=0.01)
line1 = rs.AddLine(rs.CurveStartPoint(lines[0]),rs.CurveEndPoint(lines[0]))
line2 = rs.AddLine(rs.CurveStartPoint(lines[1]),rs.CurveEndPoint(lines[1]))
line3 = rs.AddLine(rs.CurveStartPoint(lines[2]),rs.CurveEndPoint(lines[2]))
line4 = rs.AddLine(rs.CurveStartPoint(lines[3]),rs.CurveEndPoint(lines[3]))
rs.DeleteObjects(lines)
lines = line1, line2, line3, line4
if rs.CurveLength(lines[0]) > rs.CurveLength(lines[1]):
smallside = rs.CurveLength(lines[1])
longside1 = lines[0]
longside2 = lines[2]
else:
smallside = rs.CurveLength(lines[0])
longside1 = lines[1]
longside2 = lines[3]
filletRadius = smallside/2
fillet1 = rs.CurveFilletPoints (lines[0], lines[1])
fillet2 = rs.CurveFilletPoints (lines[1], lines[2])
fillet3 = rs.CurveFilletPoints (lines[2], lines[3])
fillet4 = rs.CurveFilletPoints (lines[3], lines[0])
arc1 = rs.AddFilletCurve(lines[0],lines[1], radius = filletRadius)
arc2 = rs.AddFilletCurve(lines[1],lines[2], radius = filletRadius)
arc3 = rs.AddFilletCurve(lines[2],lines[3], radius = filletRadius)
arc4 = rs.AddFilletCurve(lines[3],lines[0], radius = filletRadius)
arcs = arc1, arc2, arc3, arc4
arcs = rs.JoinCurves(arcs)
arcEnd1 = rs.CurveEndPoint(arcs[0])
arcStart1 = rs.CurveStartPoint(arcs[0])
arcEnd2 = rs.CurveEndPoint(arcs[1])
arcStart2 = rs.CurveStartPoint(arcs[1])
if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1,arcStart2):
temp = arcEnd2
arcEnd2 = arcStart2
arcStart2 = temp
line1 = rs.AddLine(arcEnd1, arcEnd2)
line2 = rs.AddLine(arcStart1, arcStart2)
curves = line1, arcs[0], arcs[1], line2
tenonOut = rs.JoinCurves(curves)
tenonSurf = rs.AddPlanarSrf(tenonOut)
point = rs.SurfacePoints(face)
param = rs.SurfaceClosestPoint(face, point[0])
normal = rs.SurfaceNormal(face, param)
normal = normal * length
vect = rs.AddLine( arcEnd1, arcEnd1 + normal )
tenon = rs.ExtrudeSurface(tenonSurf, vect, cap=True)
rs.DeleteObjects(curves)
arcs = arc1, arc2, arc3, arc4
rs.DeleteObjects(arcs)
rs.DeleteObject(rectangle)
rs.ExtendCurveLength(longside1, 0, 0, fit)
rs.ExtendCurveLength(longside1, 0, 1, fit)
rs.ExtendCurveLength(longside2, 0, 0, fit)
rs.ExtendCurveLength(longside2, 0, 1, fit)
if rs.Distance(rs.CurveEndPoint(longside1), rs.CurveEndPoint(longside2)) < rs.Distance(rs.CurveStartPoint(longside1), rs.CurveEndPoint(longside2)):
line1Start = rs.CurveEndPoint(longside1)
line1End = rs.CurveEndPoint(longside2)
line2Start = rs.CurveStartPoint(longside1)
line2End = rs.CurveStartPoint(longside2)
else:
line1Start = rs.CurveStartPoint(longside1)
line1End = rs.CurveEndPoint(longside2)
line2Start = rs.CurveEndPoint(longside1)
line2End = rs.CurveStartPoint(longside2)
shortside1 = rs.AddLine(line1Start, line1End)
shortside2 = rs.AddLine(line2Start, line2End)
arc1 = rs.AddFilletCurve(longside1, shortside1, radius = filletRadius)
arc2 = rs.AddFilletCurve(shortside1, longside2, radius = filletRadius)
arc3 = rs.AddFilletCurve(longside2, shortside2, radius = filletRadius)
arc4 = rs.AddFilletCurve(shortside2, longside1, radius = filletRadius)
arcs = arc1, arc2, arc3, arc4
arcs = rs.JoinCurves(arcs)
arcEnd1 = rs.CurveEndPoint(arcs[0])
arcStart1 = rs.CurveStartPoint(arcs[0])
arcEnd2 = rs.CurveEndPoint(arcs[1])
arcStart2 = rs.CurveStartPoint(arcs[1])
if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1,arcStart2):
temp = arcEnd2
arcEnd2 = arcStart2
arcStart2 = temp
line1 = rs.AddLine(arcEnd1, arcEnd2)
line2 = rs.AddLine(arcStart1, arcStart2)
curves = line1, arcs[0], arcs[1], line2
mortiseOut = rs.JoinCurves(curves)
mortiseSurf = rs.AddPlanarSrf(mortiseOut)
param = rs.SurfaceClosestPoint(face, point[0])
normal = rs.SurfaceNormal(face, param)
normal = normal * depth
vect = rs.AddLine( arcEnd1, arcEnd1 + normal )
mortise = rs.ExtrudeSurface(mortiseSurf, vect, cap=True)
rs.DeleteObject(shortside1)
rs.DeleteObject(shortside2)
rs.DeleteObject(mortiseOut)
rs.DeleteObject(mortiseSurf)
rs.DeleteObjects(curves)
rs.DeleteObjects(lines)
arcs = arc1, arc2, arc3, arc4
rs.DeleteObjects(arcs)
rs.DeleteObject(rectangle)
rs.DeleteObject(tenonOut)
rs.DeleteObject(tenonSurf)
mortiseSide = rs.GetObject("Select part to mortise", rs.filter.polysurface, False, False)
tenonSide = rs.GetObject("Select part to tenon", rs.filter.polysurface, False, False)
tenonUnion = tenonSide, tenon
rs.BooleanDifference(mortiseSide, mortise, delete_input = True)
rs.BooleanUnion(tenonUnion, delete_input = True)
return
# Part 0: Base
if BUILD_TARGET == 'all' or 'base' in BUILD_TARGET:
base_btm_origin = (BEAM_HALF_LENGTH, BEAM_HALF_LENGTH, 0)
base_btm_pts = quad_rotate_point(base_btm_origin)
base_top_pts = quad_rotate_point(rss.PointAdd(
base_btm_origin,
(-BEAM_HEIGHT * tan(pi/3), -BEAM_HEIGHT * tan(pi/3), BEAM_HEIGHT))
)
base = rss.BooleanUnion((
rss.JoinSurfaces(
[rss.AddSrfPt(base_btm_pts), rss.AddSrfPt(base_top_pts)]
+ quad_rotate_object(rss.AddSrfPt((
base_btm_pts[0],
base_btm_pts[1],
base_top_pts[0],
base_top_pts[1]
))),
delete_input=True
),
rss.AddCylinder((0, 0, 0), 107.5, CORE_RADIUS)
))
# Part 1: Layer 1
# PLANE_HEIGHT: Height where the layer is placed
PLANE_HEIGHT = 62.5
if BUILD_TARGET == 'all' or 'layer1' in BUILD_TARGET:
beam_origin = (BEAM_HALF_LENGTH, CORE_RADIUS, PLANE_HEIGHT)
def handle_GENBLOCK_bt_view_srf(self, sender, e):
self.suspendInteraction()
rs.EnableRedraw(False)
try:
layername = get_layer_name('MASSING')
tolerance = 0.0001
self.isolateLayer(layername)
sel = rs.ObjectsByLayer(layername)
print('sel from MASSING layer:', sel)
self.deleteObjectsByGuid(sel)
rs.CurrentLayer(layername)
#blocks=rs.ObjectsByLayer(get_layer_name('BLOCK'))
cons = [('phase', 'BLOCK')]
obj_blocks = self.data.find_all(cons)
print('flag_1')
rhi_blocks = self.data.find_all_guids(cons)
print('flag_2', rhi_blocks)
cblocks = rs.CopyObjects(rhi_blocks)
ublocks = rs.BooleanUnion(cblocks, True)
splitedSrfs = []
horzSrfs = []
vertSrfs = []
#找出union block里的横竖面
print('Sparate horz and vert srfs')
for b in ublocks:
os = rs.ExplodePolysurfaces(b, True)
print('os', os)
#先把水平面分走
horzSrfs = []
vertSrfs = []
for s in os:
print('line 740')
if s is None:
continue
if not rs.IsObject(s):
continue
isHor, direct = isHorizonalSrf(s, True)
if isHorizonalSrf(s):
if direct < 0:
rs.ObjectColor(s, (255, 0, 0))
else:
rs.ObjectColor(s, COLOR_SET_01[5])
horzSrfs.append(s)
else:
vertSrfs.append(s)
blockedSrf = []
parentDic = {}
wheel = 0
print('assign parent objects')
#Union block的横竖面找parent
for po in obj_blocks:
srfs = rs.ExplodePolysurfaces(po.guid, False)
for vsrf in vertSrfs:
pts2 = rs.SurfaceEditPoints(vsrf)
for s in srfs:
pts1 = rs.SurfaceEditPoints(s)
if listsEqual(pts1, pts2):
parentDic[vsrf] = po
rs.DeleteObjects(srfs)
print(parentDic)
print('split irregular polygons')
for s in vertSrfs:
parent = parentDic[s]
if parent is None:
print('parent is None')
rs.SelectObject(s)
continue
#rs.EnableRedraw(True)
phaseIndex = 'MASSING'
typeIndex = parent.typeIndices[0]
boundary = rs.DuplicateSurfaceBorder(s)
pts = rs.CurveEditPoints(boundary)
if len(pts) > 5:
#print('splitting polygon')
#rs.EnableRedraw(False)
srfs = splitIrregularPolygon(s)
#print('splitIregPoly srfs=',srfs)
if srfs is None:
continue
splitedSrfs += srfs
for ss in srfs:
#print(shortGuid(parent.guid))
o = self.addObject(ss, phaseIndex, typeIndex, parent)
if o is None: continue
self.setObjectType(o, typeIndex)
#rs.EnableRedraw(True)
else:
splitedSrfs.append(s)
o = None
try:
o = self.addObject(s, phaseIndex, typeIndex, parent)
except Exception as e:
print(e, s, phaseIndex, typeIndex, parent)
if o is None: continue
#print('o=',o)
self.setObjectType(o, typeIndex)
#self.logDataTree()
rs.DeleteObject(boundary)
except Exception as e:
print('exception:', e)
#PrintException()
rs.EnableRedraw(True)
self.resumeInteraction()
rs.EnableRedraw(True)
