def Rectify_AngleFirst(obj, angleMultiple, lengthMultiple):
"""
Rebuilds a polyline with exact angles and lengths. Angles have priority
input:
obj (polyline)
angleMultiple (float): Multiple to round to
lengthMultiple (float): Length to round to (0 == no rounding)
returns:
polyline (guid)
"""
angles = GetCornerAngles(obj)
if angleMultiple != 0:
fixedAngles = ForceToMultipleOf(angles, angleMultiple)
else:
fixedAngles = angles
if rs.IsLine(obj):
lengths = [rs.CurveLength(obj)]
fixedAngles = 0
else:
lengths = GetSegmentLengths(obj)
if lengthMultiple != 0:
fixedLengths = ForceToMultipleOf(lengths, lengthMultiple)
else:
fixedLengths = lengths
if rs.IsLine(obj):
line = ChangeLineLength(obj, fixedLengths)
id = sc.doc.Objects.AddLine(line)
else:
newPline = ChangeVertexAngles(obj, fixedAngles, fixedLengths)
id = sc.doc.Objects.AddPolyline(newPline)
sc.doc.Views.Redraw()
return id
def _are_line_guids(self, guids):
value = True
for guid in guids:
if not rs.IsLine(guid):
value = False
break
return value
def Intersect(self, other):
"""
function to check if a fracture intersects another
Parameter
-------
other: guid
guid of the second fracture
"""
# inputs are frcature instances in fracture list
curveA = self.fracture_GUID
# check for intersection
intersection = rs.IntersectBreps(curveA, other.fracture_GUID)
# if no intersection
if intersection is None:
print('The fractures do not intersect')
else:
# go through the list of intersection
for x in intersection:
# check it's a line!
if rs.IsLine(intersection[0]):
# get intersection length
length = rs.CurveLength(intersection[0])
# print a statement
print(
'Fracture intersect, the length of intersection\
is:', length)
def shape_from_ref(r):
with parameter(immediate_mode, False):
obj = _geometry_from_id(r)
ref = native_ref(r)
if isinstance(obj, geo.Point):
return point.new_ref(ref, fromPt(obj.Location))
elif isinstance(obj, geo.Curve):
if rh.IsLine(r) or rh.IsPolyline(r):
if rh.IsCurveClosed(r):
return polygon.new_ref(
ref, [fromPt(p) for p in rh.CurvePoints(r)[:-1]])
else:
return line.new_ref(ref,
[fromPt(p) for p in rh.CurvePoints(r)])
elif obj.IsCircle(Rhino.RhinoMath.ZeroTolerance):
return circle.new_ref(ref, fromPt(rh.CircleCenterPoint(r)),
rh.CircleRadius(r))
elif rh.IsCurveClosed(r):
return closed_spline.new_ref(
ref, [fromPt(p) for p in rh.CurvePoints(r)])
else:
return spline.new_ref(ref,
[fromPt(p) for p in rh.CurvePoints(r)])
elif rh.IsObject(r) and rh.IsObjectSolid(r):
return solid(native_ref(r))
elif rh.IsSurface(r) or rh.IsPolysurface(r):
return surface(native_ref(r))
else:
raise RuntimeError("{0}: Unknown Rhino object {1}".format(
'shape_from_ref', r))
def TotalLengthOfFractures(self, fracture_guid_list, cut_plane):
"""
Function to intersect fractures and return the total length of
fractures in the cut plane
Parameters
----------
fracture_guid_list: list
list containing domain fractures' guids
cut_plane: guid
guid of the cut plane
"""
# initialise length as 0
length = 0
# convert plane to a surface
plane_surf = rs.AddPlanarSrf(cut_plane)
# loop through the fractures' GUIDs
for i in range(len(fracture_guid_list)):
# perform intersection test
intersection = rs.IntersectBreps(fracture_guid_list[i], plane_surf)
# if there is intersection
if intersection is not None:
# go through the list
for x in intersection:
# check it's a line!
if rs.IsLine(intersection[0]):
# add the GUID to class attribute
# 'intersecting_fractures'
self.intersecting_fractures.append(intersection[0])
# increment the length of intersecting fractures
length += rs.CurveLength(intersection[0])
# delete the plane surface we added to Rhino interface
rs.DeleteObject(plane_surf)
# return the lotal lengths of intersection
return length
def _objects_are_all_lines(objects):
value = True
for object_i in objects:
if not rs.IsLine(object_i):
value = False
break
return value
def RunCommand(is_interactive):
global params
pitch_line = rs.GetObject(message="Select pitch line",
filter=rs.filter.curve,
preselect=True)
if pitch_line is None:
return 1 # Cancel
if not rs.IsLine(pitch_line):
print "Selected curve is not a line!"
return 1 # Cancel
rs.SelectObjects(pitch_line)
m = rs.GetReal(message="Rack module", number=params["m"])
pa = rs.GetReal(message="Pressure angle",
number=params["pa"],
minimum=0,
maximum=45)
if m is None or pa is None:
return 1 # Cancel
params["m"] = m
params["pa"] = pa
pitch_line_center = rs.CurveMidPoint(pitch_line)
pitch_line_start = rs.CurveStartPoint(pitch_line)
pitch_line_end = rs.CurveEndPoint(pitch_line)
angle, reflex_angle = rs.Angle2(line1=((0, 0, 0), (1, 0, 0)),
line2=(pitch_line_start, pitch_line_end))
x_vector = rs.VectorCreate(pitch_line_end, pitch_line_start)
y_vector = rs.VectorRotate(x_vector, 90.0, [0, 0, 1])
cplane = rs.PlaneFromFrame(origin=pitch_line_center,
x_axis=x_vector,
y_axis=y_vector)
xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane())
rs.EnableRedraw(False)
old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane())
rack = draw_rack(length=rs.CurveLength(pitch_line),
module=params["m"],
pressure_angle=params["pa"])
rs.ViewCPlane(plane=old_plane)
rs.TransformObjects(rack, xform)
rs.EnableRedraw(True)
rs.UnselectAllObjects()
rs.SelectObjects(rack)
return 0 # Success
def get_preview_geometry(arr_curves): """duplicate the geometry for extension""" arr_exploded = [] arr_lines = [] for x in arr_curves: if rs.IsLine(x): arr_exploded.append(x) for i in xrange(len(arr_curves)): if rs.IsLine(arr_curves[i]): arr_lines.append(arr_curves[i]) arr_preview_exploded = rs.ExplodeCurves(arr_curves,False) arr_preview_lines = rs.CopyObjects(arr_lines) #Get locked objects return arr_preview_exploded + arr_preview_lines
def ExportLighthouseSensorsToJSON(filename):
print "Writing", filename
#objectIds = rs.GetObjects("Select Sensors",rs.filter.curves,True,True)
#if( objectIds==None ): return3
# Find all circle and all lines in scene
circles = []
lines = []
for obj in rs.AllObjects():
# Skip hidden objects, and invisible layers
# TODO: Recuse up layet hierarchy?
if rs.IsObjectHidden(obj):
continue
layer = rs.ObjectLayer(obj)
if layer and not rs.IsLayerVisible(layer):
continue
if rs.IsCurve(obj):
if rs.IsCircle(obj):
circles.append((obj, rs.CircleCenterPoint(obj)))
elif rs.IsLine(obj):
verts = rs.PolylineVertices(obj)
if len(verts) == 2:
lines.append((obj, verts))
print 'found', len(circles), 'sensor candidates (circles) in scene'
print 'found', len(lines), 'sensor candidates (normals) in scene'
modelJSON = {'modelNormals': [], 'modelPoints': []}
# TODO: Better sort order? Perhaps based on winding around origin?
for circleObj, circleCenter in reversed(circles):
for line, lineVerts in lines:
pos, normal = GetSensorPosAndNormal(circleCenter, lineVerts)
if pos is None:
continue
else:
modelJSON['modelNormals'].append([float(x) for x in normal])
modelJSON['modelPoints'].append(
[float(x) / 1000.0 for x in pos])
break
modelJSON['channelMap'] = range(len(modelJSON['modelNormals']))
print "Extracted", len(modelJSON['channelMap']), "sensors"
if len(modelJSON['modelNormals']) > 0:
outputFile = file(filename, 'w')
jsonText = json.dumps(modelJSON, indent=4, sort_keys=True)
outputFile.write(jsonText)
outputFile.close()
print "Wrote", filename
else:
print "Error: No sensors found in scene"
def Func(crvID):
if rs.IsLine(crvID): plane = rs.ViewCPlane()
else: plane = rs.CurvePlane(crvID)
crv = sc.doc.Objects.Find(crvID).Geometry
# if t_style==1: trans=Rhino.Geometry.CurveOffsetCornerStyle.Sharp
# elif t_style==2: trans=Rhino.Geometry.CurveOffsetCornerStyle.Round
# elif t_style==3: trans=Rhino.Geometry.CurveOffsetCornerStyle.Smooth
# elif t_style==4: trans=Rhino.Geometry.CurveOffsetCornerStyle.Chamfer
offset1 = crv.Offset(plane, dist, tol, trans)
offset1ID = sc.doc.Objects.AddCurve(offset1[0])
def is_curve_line(guid):
"""Verify that a curve is a line.
Parameters
----------
guid : System.Guid
The identifier of the curve.
Returns
-------
bool
True if the curve is a line.
False otherwise.
"""
return rs.IsCurve(guid) and rs.IsLine(guid) and rs.CurveDegree(guid) == 1 and len(rs.CurvePoints(guid)) == 2
def is_line(self):
"""Determine if the curve is a line.
Returns
-------
bool
Tue if the curve is a line.
False otherwise.
Notes
-----
A curve is a line if it is a linear segment between two points.
"""
return (rs.IsLine(self.guid) and rs.CurveDegree(self.guid) == 1
and len(rs.CurvePoints(self.guid)) == 2)
def line2wall(layer):
go = Rhino.Input.Custom.GetOption()
go.AcceptNothing(True)
go.SetCommandPrompt("set wall width")
# set up the options
widthOption = Rhino.Input.Custom.OptionDouble(
config.DOUBLELINEWIDTH, config.DOUBLELINEWIDTHLIMIT[0],
config.DOUBLELINEWIDTHLIMIT[1])
go.AddOptionDouble("Width", widthOption)
while True:
get_rc = go.Get()
if go.CommandResult() != Rhino.Commands.Result.Success:
print go.CommandResult()
break
if get_rc == Rhino.Input.GetResult.Option:
continue
break
if go.CommandResult() != Rhino.Commands.Result.Cancel:
config.DOUBLELINEWIDTH = widthOption.CurrentValue
if not rs.IsLayer("Axis"):
util.initCaadLayer("Axis")
if not rs.IsLayer(layer):
util.initCaadLayer(layer)
go = Rhino.Input.Custom.GetObject()
go.SetCommandPrompt("Select lines")
go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve
go.GetMultiple(1, 0)
if go.CommandResult() != Rhino.Commands.Result.Success:
return go.CommandResult()
oldLayer = rs.CurrentLayer(layer)
for lineCurveId in go.Objects():
if rs.IsLine(lineCurveId):
# make axis
rs.ObjectLayer(lineCurveId, "Axis")
# make wall
point0 = rs.CurveStartPoint(lineCurveId)
point1 = rs.CurveEndPoint(lineCurveId)
doubleLine = DoubleLine.MakeDoubleLine(config.DOUBLELINEWIDTH,
point0, point1)
doubleLine.draw()
rs.CurrentLayer(oldLayer)
def OffsetCurve2Sides(crvID, dist, t_style, conn, tol):
if rs.IsLine(crvID): plane = rs.ViewCPlane()
else: plane = rs.CurvePlane(crvID)
crv = sc.doc.Objects.Find(crvID).Geometry
if t_style == 1: trans = Rhino.Geometry.CurveOffsetCornerStyle.Sharp
elif t_style == 2: trans = Rhino.Geometry.CurveOffsetCornerStyle.Round
elif t_style == 3: trans = Rhino.Geometry.CurveOffsetCornerStyle.Smooth
elif t_style == 4: trans = Rhino.Geometry.CurveOffsetCornerStyle.Chamfer
offset1 = crv.Offset(plane, dist, tol, trans)
if offset1:
offset2 = crv.Offset(plane, -dist, tol, trans)
if offset2:
if len(offset1) == 1 and len(offset2) == 1:
offset1ID = sc.doc.Objects.AddCurve(offset1[0])
offset2ID = sc.doc.Objects.AddCurve(offset2[0])
if conn >= 0 and not rs.IsCurveClosed(crvID):
AddEndsToOffset(offset1ID, offset2ID, conn, dist)
#don't care if ends get made or not, exit afterward
return True
def unfilletCurve(curve):
rs.EnableRedraw(False)
curLay = rs.CurrentLayer()
childrenLay = rs.LayerChildren(curLay)
cutCrvs = []
contours = []
finalLines = []
finalLineSegs = []
tempCrv = curve
if tempCrv is not None:
cutCrvs.append(tempCrv)
for crv in cutCrvs:
contours.append(ghcomp.Explode(crv, True)[0])
for contour in contours:
for i in range(0, len(contour)):
if rs.IsLine(contour[i]):
finalLines.append(sc.doc.Objects.AddCurve(contour[i]))
finalPts = []
for line in finalLines:
rs.ExtendCurveLength(line, 0, 2, 300)
for i in range(0, len(finalLines) - 1):
tempPt = rs.CurveCurveIntersection(finalLines[i], finalLines[i + 1])
finalPts.append(rs.AddPoint(rs.coerce3dpoint(tempPt[0][1])))
tempPt = rs.CurveCurveIntersection(finalLines[-1], finalLines[0])
finalPts.append(rs.AddPoint(rs.coerce3dpoint(tempPt[0][1])))
for i in range(0, len(finalPts) - 1):
finalLineSegs.append(rs.AddLine(finalPts[i], finalPts[i + 1]))
finalLineSegs.append(rs.AddLine(finalPts[-1], finalPts[0]))
lastCrv = rs.JoinCurves(finalLineSegs, True)
sc.doc.Views.Redraw()
rs.DeleteObjects(finalPts)
rs.DeleteObjects(finalLines)
rs.DeleteObject(tempCrv)
rs.DeleteObjects(cutCrvs)
rs.EnableRedraw(True)
rs.SelectObject(lastCrv)
def lineErrorCheck(curves):
count = 0
error = False
for curve in curves:
count = count + 1
if rs.IsLine(curve):
None
else:
error = True
if error == True:
print "Failed...Curve must be rectangular"
if count != 4:
print "Failed....To many line segments, redraw rectangle"
error = True
return error
def LengthOfIntersection(self, fracture_guid_list):
"""
returns the sum of all length of intersections and helps to track
the number of fracture intersections.
Parameters
----------
fracture_guid_list: list
a list of fractures' guids in the network
"""
# initialise length as 0
length = 0
# loop through all the fractures in the list
for i in range(len(fracture_guid_list)):
# fracture to test intersection against
curveA = fracture_guid_list[i]
# loop through all other fractures
for j in range(len(fracture_guid_list)):
# except the fractures we are testing against
if j != i:
# test for intersection
intersection = rs.IntersectBreps(curveA,
fracture_guid_list[j])
# if there is intersection
if intersection is not None:
for x in intersection:
# check it's a line!
if rs.IsLine(intersection[0]):
# increase no of fracture intersections
self.no_of_fracture_intersections += 1
# find the length of intersection
self.lengths_of_intersection_lines.append(
rs.CurveLength(intersection[0]))
# increment the length
length += rs.CurveLength(intersection[0])
# continue if i == j
else:
continue
return length
def writeG(selection, par):
# get filename frm dialog
filename = SaveFileName("Save", "Toolpath Files (*.nc)|*.nc||")
# retrun function if no filename was specified
if not filename: return
global file
file = open(filename, 'w')
writeHeader(file, par)
writeSpindleEnable()
for curve in selection:
#move to start of the curve at height 0+offset
writeFastMoveToCurveStart(curve)
writePlungeToCurveStart(curve)
# detect type of curve for different G-codes
if (rs.IsPolyline(curve)) or rs.IsLine(curve):
writePolyline(curve)
# elif rs.IsArc(curve):
# writeArc(curve)
else:
writeCurve(curve)
# return to offset at end of the curve
writePlungeRetract(curve)
# return to homing position and turn of the spindle
writeReturnToHomingPos()
writeSpindleDisable()
file.close()
def EncodeCurve(obj):
def SaveCurveVertices(curve):
vertices = []
if rs.IsArc(curve):
midPt = rs.ArcMidPoint(curve)
stPt = rs.CurveStartPoint(curve)
endPt = rs.CurveEndPoint(curve)
pts = [stPt, midPt, endPt]
else:
pts = rs.CurveEditPoints(curve)
for pt in pts:
vertices.append([pt.X, pt.Y, pt.Z])
return vertices
try:
fullList = []
segments = rs.ExplodeCurves(obj)
if len(segments) < 1:
segments = [rs.CopyObject(obj)]
for eachSeg in segments:
vertices = []
if rs.IsLine(eachSeg):
fullList.append(["line", SaveCurveVertices(eachSeg)])
elif rs.IsArc(eachSeg):
fullList.append(["arc", SaveCurveVertices(eachSeg)])
elif rs.IsCurve(eachSeg):
fullList.append(["curve", SaveCurveVertices(eachSeg)])
else:
fullList.append(["error"])
rs.DeleteObjects(segments)
return fullList
except:
print "Error"
return None
def dimensionPline(pline, offsetDist):
try:
if rs.IsCurvePlanar(pline):
pass
else:
print "Curve must be planar"
return
segments = []
dimGroup = rs.AddGroup("Pline Dims")
dir = rs.ClosedCurveOrientation(pline)
if dir == -1:
rs.ReverseCurve(pline)
normal = rs.CurvePlane(pline).ZAxis
segments = rs.ExplodeCurves(pline)
if len(segments)<1:
segments = [rs.CopyObject(pline)]
for seg in segments:
if rs.IsLine(seg):
endPt = rs.CurveEndPoint(seg)
stPt = rs.CurveStartPoint(seg)
tanVec = rs.VectorCreate(stPt, endPt)
offsetVec = rs.VectorRotate(tanVec, 90, normal)
offsetVec = rs.VectorUnitize(offsetVec)
offsetVec = rs.VectorScale(offsetVec, offsetDist)
offsetPt = rs.VectorAdd(stPt, offsetVec)
dim = rs.AddAlignedDimension(stPt, endPt, rs.coerce3dpoint(offsetPt), 'PCPA_12')
rs.AddObjectToGroup(dim, dimGroup)
rs.DeleteObjects(segments)
result = True
except:
result = False
return [dimGroup, result]
def stairHeight(route, width=48, height=120):
"""
Makes a stair to specified height.
input: route(pline), width (num), height(num)
returns: Geo
"""
try:
rs.EnableRedraw(False)
rs.SimplifyCurve(route)
if route is None:
print("ERROR: No path selected")
return
if (rs.UnitSystem() == 2): #if mm
maxRiserHeight = 180
thickness = 200
if (rs.UnitSystem() == 4): #if m
maxRiserHeight = .180
thickness = .200
if (rs.UnitSystem() == 8): #if in"
maxRiserHeight = 7
thickness = 9
negativeBoo = False
if (height < 0):
#if the stair
negativeBoo = True
landingEdges = []
landings = []
segments = rs.ExplodeCurves(route)
if len(segments) < 1:
segments = [rs.CopyObject(route)]
landingHeight = []
geometry = []
#Check that all segments are lines
for i in range(0, len(segments)):
if not (rs.IsLine(segments[i])):
print(
"ERROR: This function only accepts lines. No arcs or nurb curves."
)
rs.DeleteObjects(segments)
return
#first landing edge
norm = rs.VectorRotate(rs.CurveTangent(segments[0], 0), 90, [0, 0, 1])
norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2)
side1Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), norm)
side2Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), -norm)
landingEdges.append(rs.AddLine(side1Pt, side2Pt))
#middle landing edges
for i in range(0, len(segments) - 1):
edgeList, landing = rampIntersection(segments[i], segments[i + 1],
width)
landingEdges.append(edgeList[0])
landingEdges.append(edgeList[1])
landings.append(landing)
#last landing edge
norm = rs.VectorRotate(
rs.CurveTangent(segments[-1], rs.CurveParameter(segments[-1], 1)),
90, [0, 0, 1])
norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2)
side1Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), norm)
side2Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), -norm)
landingEdges.append(rs.AddLine(side1Pt, side2Pt))
#Add risers
riserCrvs = []
treadVecs = []
numRisersPerRun = []
numRisers = abs(int(math.ceil(height / maxRiserHeight)))
risersSoFar = 0
totalRun = getTotalRun(landingEdges)
optTreadDepth = totalRun / (numRisers - 1)
#2R+T = 635
riserHeight = height / numRisers
if (negativeBoo):
curRiserHeight = 0
else:
curRiserHeight = riserHeight
for i in range(0, len(landingEdges), 2): #find numRisers in each run
a = rs.CurveMidPoint(landingEdges[i])
b = rs.CurveMidPoint(landingEdges[i + 1])
runDist = rs.Distance(a, b)
numRisersThisRun = int(round((runDist / optTreadDepth), 0))
if (numRisersThisRun == 0):
numRisersThisRun = 1
if (i == len(landingEdges) -
2): #if last run, add the rest of the risers
numRisersThisRun = numRisers - risersSoFar
else:
risersSoFar = risersSoFar + numRisersThisRun
numRisersPerRun.append(numRisersThisRun)
#Create Risers on Plan
for i in range(0, len(landingEdges), 2):
run = []
a = rs.CurveMidPoint(landingEdges[i])
b = rs.CurveMidPoint(landingEdges[i + 1])
centerStringer = rs.AddLine(a, b)
runDist = rs.Distance(a, b)
numRisersThisRun = numRisersPerRun[int(i / 2)] #risers in this run
tarPts = rs.DivideCurve(centerStringer,
numRisersThisRun,
create_points=False)
rs.DeleteObject(centerStringer)
for j in range(0, numRisersThisRun + 1):
if (j == 0):
treadVecs.append(rs.VectorCreate(tarPts[0], tarPts[1]))
transVec = rs.VectorCreate(tarPts[0], tarPts[j])
run.append(rs.CopyObject(landingEdges[i], -transVec))
riserCrvs.append(run)
print('Flight {0} has {1} risers: {3}" tall, Treads: {2}" deep'.
format(
int(i / 2) + 1, numRisersThisRun,
rs.VectorLength(treadVecs[int(i / 2)]), riserHeight))
#Move riser edges vertically
for i in range(0, len(riserCrvs)):
triangles = []
if (negativeBoo):
for j in range(0, len(riserCrvs[i]) - 1):
#if stairs descending
rs.MoveObject(
riserCrvs[i][j],
rs.VectorAdd([0, 0, curRiserHeight], -treadVecs[i]))
riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j],
[0, 0, 0],
[0, 0, riserHeight])
treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j],
[0, 0, 0], treadVecs[i])
stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j]))
pt1 = rs.CopyObject(
stPt, [0, 0, riserHeight]) #first riser in run
pt2 = rs.CopyObject(stPt, treadVecs[i]) #last riser in run
triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt])
triangles.append(rs.AddPlanarSrf(triCrv))
geometry.append(riserGeo) #riser
geometry.append(treadGeo) #tread
curRiserHeight = curRiserHeight + riserHeight
rs.MoveObject(riserCrvs[i][j], treadVecs[i])
#cleanup
rs.DeleteObject(triCrv)
rs.DeleteObject(stPt)
rs.DeleteObject(pt1)
rs.DeleteObject(pt2)
else:
for j in range(0, len(riserCrvs[i]) - 1):
#if stairs ascend
rs.MoveObject(riserCrvs[i][j], [0, 0, curRiserHeight])
stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j]))
pt1 = rs.CopyObject(
stPt, [0, 0, -riserHeight]) #first riser in run
pt2 = rs.CopyObject(stPt,
-treadVecs[i]) #last riser in run
triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt])
triangles.append(rs.AddPlanarSrf(triCrv))
riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j],
[0, 0, 0],
[0, 0, -riserHeight])
treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j],
[0, 0, 0],
-treadVecs[i])
geometry.append(riserGeo) #riser
geometry.append(treadGeo) #tread
curRiserHeight = curRiserHeight + riserHeight
#cleanup
rs.DeleteObject(triCrv)
rs.DeleteObject(stPt)
rs.DeleteObject(pt1)
rs.DeleteObject(pt2)
#Make Stringer
if (negativeBoo):
firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0]))
lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2]))
#rs.MoveObject(firstStartPt, [0,0,riserHeight]) #first riser in run
rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run
rs.MoveObject(lastStartPt,
[0, 0, riserHeight]) #last riser in run
else:
firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0]))
lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2]))
rs.MoveObject(firstStartPt,
[0, 0, -riserHeight]) #first riser in run
rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run
stringerCrv = rs.AddLine(firstStartPt, lastStartPt)
stringerSrf = rs.ExtrudeCurveStraight(stringerCrv, [0, 0, 0],
[0, 0, -thickness])
triangles.append(stringerSrf)
stringer = makeFace(triangles)
stringerVec = rs.VectorCreate(rs.CurveEndPoint(riserCrvs[i][0]),
rs.CurveStartPoint(riserCrvs[i][0]))
underside = rs.ExtrudeCurveStraight(
stringerCrv, rs.CurveStartPoint(riserCrvs[i][0]),
rs.CurveEndPoint(riserCrvs[i][0]))
geometry.append(rs.MoveObject(underside, [0, 0, -thickness]))
geometry.append(rs.CopyObject(stringer, stringerVec))
geometry.append(stringer)
#cleanup
rs.DeleteObject(firstStartPt)
rs.DeleteObject(lastStartPt)
rs.DeleteObject(stringerCrv)
rs.DeleteObject(stringerSrf)
#Move Landings
lastLandingHeight = 0
for i in range(0, len(segments) - 1):
landingHeight = lastLandingHeight + numRisersPerRun[i] * riserHeight
rs.MoveObject(landings[i], [0, 0, landingHeight])
landingTopSrf = rs.AddPlanarSrf(landings[i])
landingBtmSrf = rs.CopyObject(landingTopSrf, [0, 0, -thickness])
geometry.append(landingTopSrf)
geometry.append(landingBtmSrf)
lastLandingHeight = landingHeight
landingEdgesToEx = rs.ExplodeCurves(landings[i])
geometry.append(
rs.ExtrudeCurveStraight(landingEdgesToEx[1], [0, 0, 0],
[0, 0, -thickness]))
geometry.append(
rs.ExtrudeCurveStraight(landingEdgesToEx[2], [0, 0, 0],
[0, 0, -thickness]))
rs.DeleteObjects(landingEdgesToEx)
#Create final geometry
joinedGeo = rs.JoinSurfaces(geometry, True)
holes = rs.DuplicateSurfaceBorder(joinedGeo)
cap = rs.AddPlanarSrf(holes)
newGeo = rs.ExplodePolysurfaces(joinedGeo, True)
for i in cap:
newGeo.append(i)
FinalGeo = rs.JoinSurfaces(newGeo, True)
#cleanup
try:
rs.DeleteObjects(segments)
except:
rs.DeleteObject(segments)
rs.DeleteObjects(holes)
rs.DeleteObjects(landings)
rs.DeleteObjects(landingEdges)
for i in riserCrvs:
rs.DeleteObjects(i)
rs.EnableRedraw(True)
return FinalGeo
except:
print "Error"
return None
def is_curve_line(guid):
return rs.IsCurve(guid) and rs.IsLine(guid) and rs.CurveDegree(guid) == 1 and len(rs.CurvePoints(guid)) == 2
def write_G(path, par):
#
# G code output
#
# get variables
sfeed = par['feedrate_cut']
efeed = par['feedrate_engrave']
sspindle = par['intensity_cut']
e_intensity = par['intensity_engrave']
tolerance = par['curve_tolerance']
a_tolerance = par['curve_angle_tolerance']
filename = rs.SaveFileName("Save", "Toolpath Files (*.nc)|*.nc||",
"/users/timcastelijn/documents")
if not filename: return
file = open(filename, 'w')
# write header
file.write("G90\n") # absolute positioning
file.write("F" + str(sfeed) + "\n") # feed rate
file.write("S" + str(sspindle) + "\n") # spindle speed
file.write("M08\n") # coolant on
for curve in path:
# fast move to path start
pt = rs.CurveStartPoint(curve)
file.write("G00 X%0.4f" % pt.X + " Y%0.4f" % pt.Y + "\n")
file.write("M03\n") # spindle on clockwise
# change feedrate for engraving
if (rs.ObjectLayer(curve) == "engrave"):
file.write("F%0.1f" % efeed + "\n")
file.write("S%0.1f" % e_intensity + "\n")
else:
file.write("F%0.1f" % sfeed + "\n")
file.write("S%0.1f" % sspindle + "\n")
# detect type of curve for different G-codes
if (rs.IsPolyline(curve)) or rs.IsLine(curve):
points = rs.CurvePoints(curve)
for pt in points:
file.write("G01 X%0.4f" % pt.X + " Y%0.4f" % pt.Y + "\n")
elif rs.IsArc(curve):
normal = rs.CurveTangent(curve, 0)
# get curvepoints
startpt = rs.CurveStartPoint(curve)
endpt = rs.CurveEndPoint(curve)
midpt = rs.ArcCenterPoint(curve)
# calc G2/G3 parameters
x = endpt.X
y = endpt.Y
i = -startpt.X + midpt.X
j = -startpt.Y + midpt.Y
# make a distinction between positive and negative direction
if ((normal[1] > 0) and
(startpt.X > midpt.X)) or ((normal[1] < 0) and
(startpt.X < midpt.X) or
(normal[1] == 0 and
(normal[0] == 1 or normal[0] == -1)
and startpt.X == midpt.X)):
# file.write(";positive ARC ccw \n")
file.write("G03 X%0.4f" % x + " Y%0.4f" % y + " I%0.4f" % i +
" J%0.4f" % j + "\n")
else:
# file.write(";negative ARC cw \n")
file.write("G02 X%0.4f" % x + " Y%0.4f" % y + " I%0.4f" % i +
" J%0.4f" % j + "\n")
else:
print "curve detected, subdiv needed"
#rs.ConvertCurveToPolyline(segment,angle_tolerance=5.0, tolerance=0.01, delete_input=False)
polyLine = rs.ConvertCurveToPolyline(curve, a_tolerance, tolerance)
points = rs.CurvePoints(polyLine)
# insert division points as line
for pt in points:
file.write("G01 X%0.4f" % pt.X + " Y%0.4f" % pt.Y + "\n")
# remove objects after use
rs.DeleteObjects(polyLine)
file.write("M05\n") # spindle stop
file.write("G00 X0.0000 Y0.0000 F1000\n")
# file.write("M09\n") # coolant off
# file.write("M30\n") # program end and reset
file.close()
rs.MessageBox("file succesfully saved to: " + filename +
", with the following parameters:\n" +
"cut feedrate: %0.1f" % sfeed + "\n" +
"cut intensity: %0.1f" % sspindle + "\n" +
"engrave feedrate: %0.1f" % efeed + "\n" +
"engrave intensity: %0.1f" % e_intensity + "\n")
def is_line(self):
return (rs.IsLine(self.guid) and rs.CurveDegree(self.guid) == 1
and len(rs.CurvePoints(self.guid)) == 2)
#draw run
v_hori = [v_ver[3], v_ver[2], outer_pts[i + 1]]
rs.AddSrfPt(v_hori)
#draw sides
s1 = rs.AddLine(outer_pts[i], rs.PointAdd(outer_pts[i], rise))
s2 = rs.AddLine(rs.PointAdd(outer_pts[i], rise), outer_pts[i + 1])
s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, outer_pts[i]),
rs.CurveClosestPoint(curve, outer_pts[i + 1]))
rs.AddEdgeSrf([s1, s2, s3])
rs.DeleteObjects([s1, s2, s3])
if plinth_lst[0]:
curvy_plinth(curve, None, stair_width, plinth_lst)
if bannister_lst[0]:
curvy_bannister(curve, None, stair_width, bannister_lst)
if rs.IsLine(curve):
straight_stairs(start_pt, end_pt, stair_width, steps, plinth_lst,
bannister_lst)
else:
if not spiral:
curvy_stairs(curve, start_pt, end_pt, stair_width, steps, plinth_lst,
bannister_lst)
else:
spiral_stairs(curve, center, start_pt, end_pt, stair_width, steps,
plinth_lst, bannister_lst)
def get_g_code(self, crv_list):
gcode = []
if not rs.IsPoint(self.nurbs_curve):
feed_plunge = self.input_data['feed_plunge']
feed_rapid = self.general_input["feed_rapid"]
feed_cut = self.input_data["feed_cut"]
else:
feed_plunge = self.input_data['feed']
feed_rapid = self.input_data["feed"]
feed_cut = self.input_data["feed"]
#Crea el G0Hello y el primer punto de corte y extrae la primer curva de corte
hello_pt = self.round_point(rs.CurveStartPoint(crv_list[0]))
gcode.append("G0X%sY%sZ%sF%s" %
(hello_pt[0], hello_pt[1], hello_pt[2], int(feed_rapid)))
start_cut__pt = self.round_point(rs.CurveEndPoint(crv_list[0]))
gcode.append("G1Z%sF%s" % (start_cut__pt[2], int(feed_plunge)))
crv_list = crv_list[1:]
#revisa cada bloque de curvas
last_state = "plunge"
for crv in crv_list:
crv_rgb = (rs.ColorRedValue(rs.ObjectColor(crv)),
rs.ColorGreenValue(rs.ObjectColor(crv)),
rs.ColorBlueValue(rs.ObjectColor(crv)))
new_state = "cut" if crv_rgb == color_palette["cut"] else "plunge"
add_feed = True if new_state != last_state else False
last_state = new_state
curve_segments = rs.ExplodeCurves(crv, delete_input=False)
if not curve_segments: curve_segments = [rs.CopyObject(crv)]
#revisa cada segmento en la curva para ver si es arco o linea etc y asigna codigo por punto
for crv in curve_segments:
crv_gcode = []
if rs.IsLine(crv) or rs.CurveLength(crv) < POINT_TOL:
crv_endpt = self.round_point(rs.CurveEndPoint(crv))
if curve_segments.index(
crv
) == 0 and add_feed: #si hay cambio de estado entre plunge y cut y es primera linea añade la variable de feed
actual_feed = feed_cut if new_state == "cut" else feed_plunge
crv_gcode.append("X%sY%sZ%sF%s" %
(crv_endpt[0], crv_endpt[1],
crv_endpt[2], int(actual_feed)))
else:
crv_gcode.append(
"X%sY%sZ%s" %
(crv_endpt[0], crv_endpt[1], crv_endpt[2]))
else:
no_points = int(rs.CurveLength(crv) / POINT_TOL)
pts = rs.DivideCurve(crv,
no_points,
create_points=False,
return_points=True)[1:]
for pt in pts:
if curve_segments.index(crv) == 0 and pts.index(
pt
) == 0 and add_feed: #si hay cambio de estado entre plunge y cut y es primera linea añade la variable de feed
pt = self.round_point(pt)
actual_feed = feed_cut if new_state == "cut" else feed_plunge
crv_gcode.append(
"X%sY%sZ%sF%s" %
(pt[0], pt[1], pt[2], int(actual_feed)))
else:
pt = self.round_point(pt)
crv_gcode.append("X%sY%sZ%s" %
(pt[0], pt[1], pt[2]))
gcode += crv_gcode
rs.DeleteObject(crv)
return gcode
def Main():
rectangle = rs.GetObject(
"Select rectangle to create mortise and tenon from", rs.filter.curve,
True, True)
if rs.IsCurveClosed(rectangle):
x = 0
else:
print "Failed....Curve must be closed and rectangular"
return
if rs.IsCurvePlanar(rectangle):
x = 0
else:
print "Failed....Curve must be planar"
return
lines = rs.ExplodeCurves(rectangle)
count = 0
for line in lines:
count = count + 1
if count != 4:
print "Failed....To many line segments, redraw rectangle"
return
if rs.IsLine(lines[0]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
if rs.IsLine(lines[1]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
if rs.IsLine(lines[2]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
if rs.IsLine(lines[3]):
x = 0
else:
print "Failed....Curve must be rectangular"
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)
return
def select_line(rhino_object, geo, geo_index):
cv = rs.coercecurve(geo)
return rs.IsLine(cv) and rs.CurveLength(cv) > 40
def _extract_lines(objects):
lines = []
for object_i in objects:
if rs.IsLine(object_i):
lines.append(object_i)
return lines
def _test_line(name, guid):
if rs.IsLine(guid):
value = 'is'
else:
value = 'is not'
print("%s %s a line" % (name, value))
