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 update(self):
print('update')
#delete last generated objects
try:
rs.DeleteObjects(self.generatedObjs)
self.generatedObjs = []
except:
print('exception in delete generated object')
divWidth = 600
crv = self.baseCrv
if not rs.IsObject(crv):
print('crv is not an object')
return
if not rs.IsPolyline(crv):
pts = rs.DivideCurveEquidistant(crv, divWidth)
rail = rs.AddPolyline(pts)
else:
rail = rs.CopyObject(crv)
pts = rs.CurveEditPoints(rail)
if len(pts) < 3:
print('too little points')
return
#find vectors to move and orient the profile
vect = pts[1] - pts[0]
vect = rs.VectorUnitize(vect)
a = rs.VectorAngle(vect, (0, 1, 0)) - 90
#load the component
path = self.loadPath
component = None
try:
component = importComponent(path)
except:
print('exception on importing module')
if component is None:
print('component is None')
return None
#rs.MoveObjects(component.breps,pts[0])
#rs.RotateObjects(component.breps,pts[0],a)
for b in component.breps:
self.generatedObjs.append(b)
oriented = orientObjAlongPolyPts(b, pts)
print('pts count:', len(pts), ' num gen:', len(oriented))
rs.MoveObjects(component.polys, pts[0])
rs.RotateObjects(component.polys, pts[0], a)
for c in component.polys:
self.generatedObjs.append(c)
mesh = meshSwipPolyAlongPoly(c, rail)
self.generatedObjs.append(mesh)
rs.DeleteObject(rail)
print('generated obj count:', len(self.generatedObjs))
rs.AddGroup('gen')
rs.AddObjectsToGroup(self.generatedObjs, 'gen')
def test_is_polyline(options):
layer_name = options['layer']
objs = get_geometry_by_layer(layer_name)
for x in objs:
if not rs.IsPolyline(x.Id):
return False, None
return True, None
def CrvSegmentMidPt(crv, n):
if rs.IsPolyline(crv):
verts = rs.PolylineVertices(crv)
midPt = (verts[n] + verts[n + 1]) / 2
elif rs.IsPolyCurve(crv):
midPt = rs.CurveMidPoint(crv, n)
else:
midPt = rs.CurveMidPoint(crv)
return midPt
def test_is_polyline(options):
layer_name = options['layer']
# log('Test: objects on layer {} should be polyline'.format(layer_name))
objs = get_geometry_by_layer(layer_name)
for x in objs:
if not rs.IsPolyline(x.Id):
return False
return True
def is_polyline(self):
"""Determine if the curve is a polyline.
Returns
-------
bool
Tue if the curve is a polyline.
False otherwise.
Notes
-----
A curve is a polyline if it consists of linear segments between a sequence of points.
"""
return (rs.IsPolyline(self.guid) and rs.CurveDegree(self.guid) == 1
and len(rs.CurvePoints(self.guid)) > 2)
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 is_curve_polyline(guid):
return rs.IsCurve(guid) and rs.IsPolyline(guid) and rs.CurveDegree(guid) == 1 and len(rs.CurvePoints(guid)) > 2
def is_polyline(self):
return (rs.IsPolyline(self.guid) and rs.CurveDegree(self.guid) == 1
and len(rs.CurvePoints(self.guid)) > 2)
import rhinoscriptsyntax as rs
iterationCount = 2
obj = rs.GetObject("Select a polyline")
if rs.IsPolyline(obj):
controlPoints = rs.PolylineVertices(obj)
# if points:
# for point in points: rs.AddPoint(point)
for j in range(iterationCount):
newControlPoints = []
for i in range(len(controlPoints) - 1):
oneQuarterPoint = rs.PointAdd(
rs.PointScale(controlPoints[i], 0.75),
rs.PointScale(controlPoints[i + 1], 0.25))
newControlPoints.append(rs.CreatePoint(oneQuarterPoint))
threeQuarterPoint = rs.PointAdd(
rs.PointScale(controlPoints[i], 0.25),
rs.PointScale(controlPoints[i + 1], 0.75))
newControlPoints.append(rs.CreatePoint(threeQuarterPoint))
controlPoints = newControlPoints
rs.AddPolyline(controlPoints)
def RunCommand(is_interactive):
# get input objects
objs = rs.GetObjects("Select object(s) to connect")
if (objs is None):
return 1
# select source handle
source = rs.GetObject("Select sender handle (L polyline)", rs.filter.curve)
if (source is None):
return 1
sPoly = rs.coercecurve(source)
# select destination handle
receiver = rs.GetObject("Select receiver handle (L polyline)",
rs.filter.curve)
if (receiver is None):
return 1
rPoly = rs.coercecurve(receiver)
if not (rs.IsPolyline(sPoly) & rs.IsPolyline(rPoly)): return 1
preview = []
while True:
# input rotation angle
rotation = rs.GetReal("Rotation angle (degrees)", 0, -360, 360)
if rotation is None: break
rs.EnableRedraw(False)
# precalculate points, planes and transformation
sPts = ptsFromPolyline(sPoly)
rPts = ptsFromPolyline(rPoly)
sPlane = planeFromPts(sPts)
rPlane = planeFromPts(rPts)
origin = rPts[0]
rPts = rs.RotateObjects(rPts, origin, 180, rPlane.YAxis)
rPts1 = rs.RotateObjects(rPts, origin, -rotation, rPlane.ZAxis)
for obj in objs:
preview.append(rs.OrientObject(obj, sPts, rPts1, 1))
rs.DeleteObjects(rPts1)
rs.EnableRedraw(True)
result = rs.GetString("Looks good?", "Yes", ("Yes", "No"))
if result is None:
rs.EnableRedraw(False)
for obj in preview:
rs.DeleteObject(obj)
rs.EnableRedraw(True)
break
result = result.upper()
if result == "YES":
group_map = []
for obj in preview:
obj = rs.coercerhinoobject(obj)
RhinoUpdateObjectGroups(obj, group_map)
break
elif result == "NO":
rs.EnableRedraw(False)
for obj in preview:
rs.DeleteObject(obj)
rs.EnableRedraw(True)
# you can optionally return a value from this function
# to signify command result. Return values that make
# sense are
# 0 == success
# 1 == cancel
# If this function does not return a value, success is assumed
return 0
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 RunCommand(is_interactive):
obj = rs.GetObject("Select a polyline")
if not rs.IsPolyline(obj):
return
save(obj)
