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))