def checkCurvePosition(objs): layers = [] selection = [] for obj in objs: if rs.IsCurve(obj): if not isCurveOnCPlane(obj): # print "Curve {} not on Cplane".format(obj) selection.append(obj) appendLayer(layers, obj) elif rs.IsPoint(obj): if not isPointOnCplane(obj): # print "Curve {} not on Cplane".format(obj) rs.SelectObject(obj) appendLayer(layers, obj) else: print "object {} is not a curve or point. {}".format( obj, rs.ObjectType(obj)) if len(selection) > 0: rs.SelectObjects(selection) # when an object is found on > 0 layers, prompt for proceed if len(layers) > 0: msg = "there were non-planar or elevated curves found on layers:\n" for layer in layers: msg = msg + "- " + layer + " \n" msg = msg + '\n Do you want to proceed?' if rs.MessageBox(msg, 1) != 1: return False # else return True
def add_node_set(structure, guids, name): """ Adds node set information from Rhino point guids. Parameters ---------- structure : obj Structure object to update. guids : list Rhino point guids. name : str Name of the new node set. Returns ------- None """ nodes = [] for guid in guids: if rs.IsPoint(guid): node = structure.check_node_exists(rs.PointCoordinates(guid)) if node is not None: nodes.append(node) structure.add_set(name=name, type='node', selection=nodes)
def setObjZPair(obj): if rs.IsBlockInstance(obj): # pt = rs.CreatePoint(obj) return [obj, round(objBBPts(obj)[0].Z, 3)] elif rs.IsCurve(obj): return crvPtZpair(obj) elif rs.IsPolysurfaceClosed(obj): return brepPtZPair(obj) elif rs.IsSurface(obj): return srfPtZPair(obj) elif rs.IsPoint(obj): pt = rs.CreatePoint(obj) return [obj, round(pt.Z, 3)] # elif rs.IsBlockInstance(obj): # # pt = rs.CreatePoint(obj) # return [obj, round(objBBPts(obj)[0].Z, 3)] else: pass
def connect(objects): points = [] c = rs.GetPoint("inclusion radius - center") if not c: sys.exit("no center point specified") r = rs.GetPoint("inclusion radius - distance") if not c: sys.exit("no distance specified") maxradius = rs.Distance(c, r) blen = len(objects) print "before: ", blen, " objects" for i in range(len(objects) - 1): if rs.IsPoint(objects[i]): points.append(objects[i]) alen = len(points) print "after: ", alen, " objects" for j in range(len(points) - 1): # for each point, for k in range(len(points) - 1): # go through each of the other objects: p1 = points[j] p2 = points[k] if p1 != p2: if rs.Distance(p1, p2) < maxradius: rs.AddLine(p1, p2)
def checkCurvePosition(objs): layers = [] for obj in objs: if rs.IsCurve(obj): if not isCurveOnCPlane(obj): # print "Curve {} not on Cplane".format(obj) rs.SelectObject(obj) appendLayer(layers, obj) elif rs.IsPoint(obj): if not isPointOnCplane(obj): # print "Curve {} not on Cplane".format(obj) rs.SelectObject(obj) appendLayer(layers, obj) else: print "object {} is not a curve or point".format(obj) # when an object is found on > 0 layers, prompt for proceed if len(layers) > 0: msg = "there were curves found on layers:\n" for layer in layers: msg = msg + "- " + layer + " \n" if rs.MessageBox(msg, 1) != 1: return False # else return True
def new(cls, label, point): """Draws a new labeled point (Rhino text object). Receives: label str point Point3d or [num, num, num] or (num, num, num) Both arguments are validated upstream, but we're checking again. Returns: guid the ID of the labeled point, if successful None otherwise """ method_name = 'new' try: if not (type(label) == str and (type(point) == list or type(point) == tuple or rs.IsPoint(point))): raise TypeError if not (cn.ComponentName._is_well_formed(label)): raise ValueError except TypeError: message = "The arguments must be a string and a point (or triple)" print("%s.%s:\n %s" % (cls.__name__, method_name, message)) return_value = None except ValueError: message = "The label must not contain spaces or #s" print("%s.%s:\n %s" % (cls.__name__, method_name, message)) return_value = None else: guid = rs.AddText(label, point, cls.text_height) return_value = guid finally: return return_value
def filterObjects(objs): new_list = [] for obj in objs: if rs.LayerVisible( rs.ObjectLayer(obj) ): # only export visible layers if rs.IsCurve(obj): new_list.append(obj) elif rs.IsPoint(obj): # convert to circle layer = rs.ObjectLayer(obj) point=rs.coerce3dpoint(obj) circle = rs.AddCircle(rs.WorldXYPlane(),3) rs.ObjectLayer(circle, layer) rs.MoveObject(circle, [point.X, point.Y, point.Z]) new_list.append(circle) rs.DeleteObject(obj) # rs.DeleteObject(point) else: # remove from obj list rs.DeleteObject(obj) else: # remove from obj list rs.DeleteObject(obj) return new_list
def add_node_set(structure, pt_guids, name): nodes = [] for pt_guid in pt_guids: if rs.IsPoint(pt_guid): node = structure.check_node_exists(rs.PointCoordinates(pt_guid)) if node is not None: nodes.append(node) structure.add_set(name=name, type='node', selection=nodes)
def add_points_sets(structure, points, names): for idx, point_list in enumerate(points.Branches): name = names[idx] check_points = [rs.IsPoint(pt) for pt in point_list] if all(check_points): add_node_set(structure=structure, pt_guids=point_list, name=name) else: print('*****.set not created *****'.format(name))
def process(self): if rs.IsPoint(self.nurbs_curve): self.preview = self.get_cut_path_point(self.cut_curve) elif self.compensation == 0 and not rs.IsCurveClosed(self.nurbs_curve): self.preview = self.get_cut_path_open(self.cut_curve) else: self.preview = self.get_cut_path_closed(self.cut_curve) self.gcode = self.get_g_code(self.preview)
def filterObjects(objs): new_list = [] for obj in objs: if rs.IsCurve(obj) or rs.IsPoint(obj): new_list.append(obj) else: # remove from obj list rs.DeleteObject(obj) return new_list
def setObjZPair(obj): if rs.IsCurve(obj): return crvPtZpair(obj) elif rs.IsSurface(obj): return srfPtZPair(obj) elif rs.IsPoint(obj): pt = rs.CreatePoint(obj) return [obj, round(pt.Z, 3)] else: pass
def __init__(self, curve, input_data, general_input, compensation, pocketing): self.log = [] self.input_data = input_data self.general_input = general_input self.compensation = compensation self.pocketing = pocketing self.asignedcluster = -1 self.iscluster = False self.nurbs_curve = curve self.curve = curve #Curva original2 self.type = "point" if rs.IsPoint( self.nurbs_curve) else "curve" if rs.IsCurveClosed( self.nurbs_curve) else "open_curve" self.point = self.curve if rs.IsPoint( self.nurbs_curve) else rs.CurveAreaCentroid( self.nurbs_curve)[0] if rs.IsCurveClosed( self.nurbs_curve) else rs.CurveStartPoint( self.nurbs_curve) # Centroide curva original self.start_point = rs.PointCoordinates( self.nurbs_curve, False) if rs.IsPoint( self.nurbs_curve) else rs.CurveStartPoint(self.nurbs_curve) self.cut_curve = self.get_cut_curve() self.time = 10
def filterObjects(objs): new_list = [] for obj in objs: layername = rs.ObjectLayer(obj) if rs.LayerVisible(layername) and not (re.search( 'hulp', layername, re.IGNORECASE)): # if rs.LayerVisible( layername ): # only export visible layers if rs.IsCurve(obj): new_list.append(obj) elif rs.IsPoint(obj): # convert to circle layer = rs.ObjectLayer(obj) point = rs.coerce3dpoint(obj) circle = rs.AddCircle(rs.WorldXYPlane(), 3) rs.ObjectLayer(circle, layer) rs.MoveObject(circle, [point.X, point.Y, point.Z]) new_list.append(circle) rs.DeleteObject(obj) # rs.DeleteObject(point) elif rs.IsText(obj) and (re.search('CNC::', layername, re.IGNORECASE)): # only export text if it is in CNC layer new_list.append(obj) else: # remove from obj list rs.DeleteObject(obj) else: # remove from obj list rs.DeleteObject(obj) # for i, obja in enumerate(new_list): # for j, objb in enumerate(new_list): # if(i != j): # if rs.IsCurve(obja) and rs.IsCurve(objb): # compare objects: return new_list
def ExportPoints(objectIds, filename): if (objectIds == None): return if (filename == None): return """ Using a 'with' loop to open the file, we do not need to clean up or close the file when we are done, Python takes care of it. Here, we'll write the points with a line break, otherwise all the points will end up on one line. """ with open(filename, "w") as file: for id in objectIds: #process point clouds if (rs.IsPointCloud(id)): points = rs.PointCloudPoints(id) for pt in points: # convert the point list to a string, # add a new line character, and write to the file file.write(str(pt) + "\n") elif (rs.IsPoint(id)): point = rs.PointCoordinates(id) file.write(str(point) + "\n")
def add_sets_from_layers(structure, layers): """ Add node and element sets to the Structure object from Rhino layers. Parameters ---------- structure : obj Structure object to update. layers : list List of layer string names to take objects from. Returns ------- None Notes ----- - Layers should exclusively contain nodes or elements. - Mixed elements, e.g. lines and meshes, are allowed on a layer. - Sets will inherit the layer names as their set name. """ if isinstance(layers, str): layers = [layers] for layer in layers: guids = rs.ObjectsByLayer(layer) if guids: name = layer.split('::')[-1] if '::' in layer else layer check_points = [rs.IsPoint(guid) for guid in guids] if all(check_points): add_node_set(structure=structure, guids=guids, name=name) elif not any(check_points): add_element_set(structure=structure, guids=guids, name=name) else: print( '***** Layer {0} contained a mixture of points and elements, set not created *****' .format(name))
def ExportPoints(): #Get the points to export objectIds = rs.GetObjects("Select Points", rs.filter.point | rs.filter.pointcloud, True, True) if (objectIds == None): return #Get the filename to create filter = "Text File (*.txt)|*.txt|All Files (*.*)|*.*||" filename = rs.SaveFileName("Save point coordinates as", filter) if (filename == None): return file = open(filename, "w") for id in objectIds: #process point clouds if (rs.IsPointCloud(id)): points = rs.PointCloudPoints(id) for pt in points: file.writeline(str(pt)) elif (rs.IsPoint(id)): point = rs.PointCoordinates(id) file.writeline(str(point)) file.close()
def select_button(self,sender, e): w = self.form.panel.Controls.Find("sel_objects", True)[0] w.Text = TXT["selobj"] objects = rs.GetObjects(TXT["seldesc"],7,True,True,) points = [] curves_inside = [] curves_outside = [] curves_open = [] curves_pocketing = [] curve_material = False validated = False if objects: for object in objects: if rs.IsCurve(object): color = rs.ObjectColor(object) rgb = (rs.ColorRedValue(color),rs.ColorGreenValue(color),rs.ColorBlueValue(color)) if rs.IsCurveClosed(object): if rgb == (0,0,255): validated = True curves_inside.append(object) if rgb == (255,0,0): validated = True curves_outside.append(object) if rgb == (255,0,255): validated = True curves_pocketing.append(object) if rgb == (0,255,255): curve_material = object if rgb == (0,255,0): validated = True curves_open.append(object) if rs.IsPoint(object): validated = True points.append(object) if validated: self.rhino_objects = {"points":points,"curves_open":curves_open,"curves_pocketing":curves_pocketing,"curves_inside":curves_inside,"curves_outside":curves_outside,"curve_material":curve_material} try: w = self.form.panel.Controls.Find("sel_objects", True)[0] obj = 0 for key in self.rhino_objects: if self.rhino_objects[key]: obj += len(self.rhino_objects[key]) texts = "%s %s" % (str(obj),TXT["selobj_res"]) w.Text = texts except: pass else: try: w = self.form.panel.Controls.Find("sel_objects", True)[0] w.Text = TXT["selobj_res_no"] except: pass rs.UnselectAllObjects()
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
p_plus_q = rs.PointAdd(p, q) # coords_p_plus_q = rs.PointCoordinates(p_plus_q) ## "must be a guid" print("p: %s" % p) ## guid print("type(p): %s" % type(p)) ## guid print("type(q): %s" % type(q)) ## tuple print("coords_p: %s" % coords_p) ## 10,10,10 print("type(coords_p): %s" % type(coords_p)) ## Point3d # print("tuple(p): %s" % tuple(p)) print("type(p_plus_q): %s" % type(p_plus_q)) ## Point3d print("p_plus_q: %s" % p_plus_q) ## 30,30,30 print("p_plus_q[0]: %s" % p_plus_q[0]) ## print("p_plus_q[1]: %s" % p_plus_q[1]) ## print("p_plus_q[2]: %s" % p_plus_q[2]) ## # print("coords_p_plus_q: %s" % coords_p_plus_q) ## # print("p == q" % p == q) print("rs.PointCompare(p, q): %s" % rs.PointCompare(p, q)) # print("coords_p == q" % coords_p == q) # print("rs.PointCompare(coords_p, q)" % rs.PointCompare(coords_p, q)) # print("len(p) = %i"% len(p)) # print('tuple(coords_p) %s' % tuple(coords_p)) print('p[x]: %s' % coords_p[0]) ## 10.0 print('rs.IsPoint(p): %s' % rs.IsPoint(p)) ## True print('rs.IsPoint(coords_p): %s' % rs.IsPoint(coords_p)) ## False print(coords_p) ## 10,10,10 xyz = tuple(coords_p) print(xyz) ## (10.0, 10.0, 10.0) print('coords_p_x = %s' % coords_p[0]) ## 10.0
# Loads loads = FormDiagram.from_lines(lines, delete_boundary_face=True) for key in loads.vertices(): form.vertex[key]['pz'] = loads.vertex_area(key=key) # Symmetry for i in rs.ObjectsByLayer('Symmetry'): if rs.IsCurve(i): u = gkey_key[geometric_key(rs.CurveStartPoint(i))] v = gkey_key[geometric_key(rs.CurveEndPoint(i))] form.set_edge_attribute((u, v), name='is_symmetry', value=True) elif rs.IsPoint(i): u = gkey_key[geometric_key(rs.PointCoordinates(i))] name = rs.ObjectName(i) form.set_vertex_attribute(u, name='pz', value=float(name)) # TextDots rs.EnableRedraw(False) rs.DeleteObjects(rs.ObjectsByLayer('Dots')) rs.CurrentLayer('Dots') pzt = 0 for key in form.vertices(): pz = form.vertex[key].get('pz', 0) pzt += pz if pz:
from package.scripts import grammar as g import rhinoscriptsyntax as rs g.Grammar.clear_all() point = rs.GetPoint("Click somewhere") print("point: %s" % point) print("len(point): %i" % len(point)) print("point[0], point[1], point[2]: %i, %i, %i" % (point[0], point[1], point[2])) # print("rs.IsObject(point): %s" % rs.IsObject(point)) print("type(point) == list: %s" % (type(point) == list)) print("rs.IsPoint(point): %s" % rs.IsPoint(point)) print("type(point): %s" % type(point)) print("type(point) == Point3d: %s" % (type(point) == 'Point3d')) print("type(point) == rs.Geometry.Point3d: %s" % (type(point) == 'rs.Geometry.Point3d')) # print("type(point) == rs.Geometry.Point3d: %s" % ( # type(point) == rs.Geometry.Point3d)) print("point[2]: %s" % point[2])
def try_rs_point_from_triple(): triple = [0, 0, 0] rs_point_from_triple = rs.AddPoint(triple) value = rs.IsPoint(rs_point_from_triple) print("rs.IsPoint(rs_point_from_triple): %s" % value)
def try_triple(): triple = [0, 0, 0] value = rs.IsPoint(triple) print("rs.IsPoint(triple): %s" % value)
def try_none(): none_point = None value = rs.IsPoint(none_point) print("rs.IsPoint(none_point): %s" % value)
def try_rs_point_from_singleton(): singleton = 5 rs_point_from_singleton = rs.AddPoint(singleton) value = rs.IsPoint(rs_point_from_singleton) print("rs.IsPoint(rs_point_from_singleton): %s" % value)
def make_code_thread(self,threadName,delay): object_list = [] for e, i in self.spkmodel_objects.iteritems(): for rhinoobject in i: if not rs.IsPoint(rhinoobject.start_point): rhinoobject.start_point = rs.AddPoint(rhinoobject.start_point) object_list.append((rhinoobject,rs.PointCoordinates(rhinoobject.start_point)[0],rs.PointCoordinates(rhinoobject.start_point)[1])) if self.user_data["sorting"]: object_list = [i[0] for i in sorted(object_list, key = operator.itemgetter(2, 1))] else: object_list = [i[0] for i in object_list] if self.user_data["sort_closest"] and len(object_list) > 1: object_list = self.closest_points(object_list) #self.closest_points(object_list) if self.user_data["autocluster"]: self.asign_clusters() cluster_list = [] for spkmodelobject in object_list: if spkmodelobject.asignedcluster == -1: cluster_list.append(spkmodelobject) if spkmodelobject.type == "curve": if spkmodelobject.iscluster: for cluster_object in object_list: if cluster_object.asignedcluster == spkmodelobject.asignedcluster: if cluster_object.type == "curve": if cluster_object.iscluster == False: cluster_list.append(cluster_object) else: cluster_list.append(cluster_object) cluster_list.append(spkmodelobject) object_list = cluster_list time = 0 count = 0 ccount = 0 for rh_object in object_list: if self.code_thread: rh_object.process() if rh_object.type == "curve": if rh_object.iscluster: cluster_dot = rs.AddTextDot("cluster: %s"%ccount,rh_object.point) rs.ObjectLayer(cluster_dot,LAYER_CLUSTER) ccount +=1 rs.ObjectLayer(rh_object.preview,PREVIEW_LAYER_NAME) dot = rs.AddTextDot(str(count),rh_object.start_point) rs.DeleteObject(rh_object.start_point) rs.ObjectLayer(dot,LAYER_SORTING) rs.ObjectColor(dot,(100,100,100)) time += rh_object.time count += 1 else: break self.time = time self.sorted_objects = object_list self.form.panel.Controls.Find("gcode_text", True)[0].Text = TXT["gencodeok"] self.code_thread = False
def MultiUnroll(): msg = "Select surface/polysurface objects to unroll" brepIDs = rs.GetObjects(msg, 8 + 16, preselect=True) if not brepIDs: return msg = "Select curves and/or points to unroll with surfaces, or Enter to continue" otherIDs = rs.GetObjects(msg, 1 + 4 + 8192) if "MultiUR_Numbering" in sc.sticky: user_num = sc.sticky["MultiUR_Numbering"] else: user_num = True if "MultiUR_Explode" in sc.sticky: user_exp = sc.sticky["MultiUR_Explode"] else: user_exp = False if "MultiUR_Properties" in sc.sticky: user_prop = sc.sticky["MultiUR_Properties"] else: user_prop = False if "MultiUR_Spacing" in sc.sticky: user_space = sc.sticky["MultiUR_Spacing"] else: user_space = 1.0 if "MultiUR_XLimit" in sc.sticky: user_xl = sc.sticky["MultiUR_XLimit"] else: user_xl = 0 prompt = "Start point for unrolls - press Enter for world 0" msg = [ "NumberObjects", "Explode", "KeepProperties", "LayoutSpacing", "XExtents" ] ini = [user_num, user_exp, user_prop, user_space, user_xl] limits = [["No", "Yes"], ["No", "Yes"], ["No", "Yes"], [True, 0], [True, 0]] result = CommandLineOptions(prompt, msg, ini, limits) if not result: return x_extents = result[4] new_sp = result[5] #initialize max_y = new_sp.Y x_origin = new_sp.X exceed_warning = False ur_number = 0 no_unroll = 0 crvs = [] pts = [] dots = [] tol = sc.doc.ModelAbsoluteTolerance #get underlying geometry objects objs = [sc.doc.Objects.Find(objID).Geometry for objID in brepIDs] if otherIDs: for objID in otherIDs: if rs.IsCurve(objID): crvs.append(sc.doc.Objects.Find(objID).Geometry) elif rs.IsPoint(objID): pts.append(sc.doc.Objects.Find(objID).Geometry) else: dots.append(sc.doc.Objects.Find(objID).Geometry) #run the unroller rs.EnableRedraw(False) for i, obj in enumerate(objs): if isinstance(obj, Rhino.Geometry.Extrusion): obj = obj.ToBrep() ur = Rhino.Geometry.Unroller(obj) if result[1]: ur.ExplodeOutput = True if len(crvs) > 0: for crv in crvs: ur.AddFollowingGeometry(crv) if len(pts) > 0: for pt in pts: ur.AddFollowingGeometry(pt) if len(dots) > 0: for dot in dots: ur.AddFollowingGeometry(dot) unroll = ur.PerformUnroll() if unroll[0]: #something was unrolled ur_number += 1 if result[1]: ur_objs = unroll[0] else: ur_objs = Rhino.Geometry.Brep.JoinBreps(unroll[0], tol) ur_IDs = [sc.doc.Objects.AddBrep(ur_obj) for ur_obj in ur_objs] bb = rs.BoundingBox(ur_IDs) if x_extents > 0: if bb[3].Y - bb[0].Y > max_y: max_y = bb[3].Y - bb[0].Y if bb[1].X - bb[0].X > x_extents: x_extents = bb[1].X - bb[0].X exceed_warning = True if new_sp.X + bb[1].X > (x_origin + x_extents): #need to reset start point to x_origin, y_max new_sp.X = x_origin new_sp.Y += max_y + result[3] move_vec = new_sp - bb[0] if unroll[1]: ur_crv_IDs = [ sc.doc.Objects.AddCurve(ur_obj) for ur_obj in unroll[1] ] ur_IDs.extend(ur_crv_IDs) if unroll[2]: ur_pt_IDs = [ sc.doc.Objects.AddPoint(ur_obj) for ur_obj in unroll[2] ] ur_IDs.extend(ur_pt_IDs) if unroll[3]: ur_dot_IDs = [ sc.doc.Objects.AddTextDot(ur_obj) for ur_obj in unroll[3] ] ur_IDs.extend(ur_dot_IDs) if result[2]: #keep properties (MatchAttributes() causes problems with grouping) TransferColorLayer(ur_IDs, brepIDs[i]) if result[0]: #number objects and group AddDotToObjCtr(ur_IDs, str(ur_number), result[2]) #add number dot to original object AddDotToObjCtr([brepIDs[i]], ur_number, result[2]) #move all objs into position rs.MoveObjects(ur_IDs, move_vec) new_sp = (bb[1] + (move_vec + Rhino.Geometry.Vector3d(result[3], 0, 0))) else: no_unroll += 1 #Clean up, store settings, report sc.sticky["MultiUR_Numbering"] = result[0] sc.sticky["MultiUR_Explode"] = result[1] sc.sticky["MultiUR_Properties"] = result[2] sc.sticky["MultiUR_Spacing"] = result[3] sc.sticky["MultiUR_XLimit"] = x_extents if exceed_warning: us = rs.UnitSystemName(abbreviate=True) msg = "At least one of the unrolled objects exceeded the X extents limit!\n" msg += "Limit has been extended to {:.2f} {} ".format(x_extents, us) msg += "to allow all objects to unroll." rs.MessageBox(msg, 48) msg = "Sucessfully unrolled {} objects".format(len(brepIDs) - no_unroll) if no_unroll > 0: msg += " | Unable to unroll {} objects".format(no_unroll) print msg
def make_code_button(self,sender,e): self.form.panel.Controls.Find("gcode_text", True)[0].Text = TXT["gencode"] self.code_thread = True #thread.start_new_thread(self.make_code_thread,(False,False)) #self.make_code_thread(False,False) self.clean_layers() if self.user_data["selected_preset"] and self.rhino_objects: spkmodel_objects = {} for colorcode, objects in self.rhino_objects.iteritems(): if objects: spkmodel_objects[colorcode] =[] for rh_object in objects: try: rs.UnselectAllObjects() if colorcode == "points": curve = g_curve(rh_object,self.machining_settings[self.user_data["selected_preset"]]["barrenado"],self.general_settings,0,False) if colorcode == "curves_open": curve = g_curve(rh_object,self.machining_settings[self.user_data["selected_preset"]]["grabado"],self.general_settings,0,False) if colorcode == "curves_pocketing": curve = g_curve(rh_object,self.machining_settings[self.user_data["selected_preset"]]["desbaste"],self.general_settings,-1,True) #rs.ObjectLayer(curve.cut_curve,PREVIEW_LAYER_NAME) if colorcode == "curves_outside": curve = g_curve(rh_object,self.machining_settings[self.user_data["selected_preset"]]["corte"],self.general_settings,1,False) #rs.ObjectLayer(curve.cut_curve,PREVIEW_LAYER_NAME) if colorcode == "curves_inside": curve = g_curve(rh_object,self.machining_settings[self.user_data["selected_preset"]]["corte"],self.general_settings,-1,False) #rs.ObjectLayer(curve.cut_curve,PREVIEW_LAYER_NAME) spkmodel_objects[colorcode].append(curve) except ZeroDivisionError: if rs.IsObject(rh_object): dot = rs.AddTextDot("Error",rs.CurveStartPoint(rh_object) if not rs.IsPoint(rh_object) else rh_object) rs.ObjectLayer(dot,PREVIEW_LAYER_NAME) objects_remaining = rs.ObjectsByLayer(OFFSET_LAYER) if objects_remaining: rs.DeleteObjects(objects_remaining) self.spkmodel_objects = spkmodel_objects objects_remaining = rs.ObjectsByLayer(OFFSET_LAYER) if objects_remaining: rs.DeleteObjects(objects_remaining) thread.start_new_thread(self.make_code_thread,(False,False)) else: rs.MessageBox(TXT["selobj_res_no"],0) self.form.panel.Controls.Find("gcode_text", True)[0].Text = "Error"