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"
