def __init__(self):
if constrainToAxis <> None: self.__m_constrainToAxis = constrainToAxis
if _geometry <> []:
for index, obj in enumerate(_geometry):
try:
if type(obj) == System.Guid:
if not rs.IsObject(obj):
self.warningData.append("Invalid geometry at #" +
str(index))
continue
objData = rs.ObjectName(obj) #extract data if any
geo = rc.DocObjects.ObjRef(obj).Brep()
if geo == None: geo = rc.DocObjects.ObjRef(obj).Curve()
geo.SetUserString('Data', objData)
self.__m_geometry.append(geo)
else:
obj.SetUserString('Data', " ")
self.__m_geometry.append(obj)
except:
self.warningData.append("Invalid geometry object item #" +
str(index + 1))
continue
if self.__m_geometry == []:
self.warningData.append("Missing '_geometry' input")
return
if minDist <> None: self.__m_minDist = minDist
if maxDist <> None: self.__m_maxDist = maxDist
if multipliers <> []: self.__m_globalMultiplier = multipliers
else: self.__m_globalMultiplier = [1]
self.__m_instanceMultiplierCounter = 0
def purge_objects(guids, redraw=True):
"""Purge objects from memory.
Parameters
----------
guids : list[System.Guid]
Object identifiers.
redraw : bool, optional
If True, redrawing will be enabled and enacted.
If False, redrawing will be disabled.
Returns
-------
None
"""
if not purge_object:
raise RuntimeError('Cannot purge outside Rhino script context')
rs.EnableRedraw(False)
for guid in guids:
if rs.IsObject(guid):
if rs.IsObjectHidden(guid):
rs.ShowObject(guid)
o = find_object(guid)
purge_object(o.RuntimeSerialNumber)
if redraw:
rs.EnableRedraw(True)
sc.doc.Views.Redraw()
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 deleteObjects(phaseIndex,typeIndex=None):
#deletes a phase object and returns upStream
upStream=None
trashGuid=[]
updatedList=[]
# print('before delete, ENGINE.data size:',len(ENGINE.data))
for o in ENGINE.data :
# print('@del ',o.phase,o.typeIndex,':',typeIndex)
if o.phase==phaseIndex:
if typeIndex is None: flag=True
elif typeIndex ==o.typeIndex: flag=True
else: flag=False
if flag:
# print('found type index match')
if rs.IsObject(o.guid):
trashGuid.append(o.guid)
upStream=o.upStream
try:#delete the object from upStream
index=upStream.downStream.index(o)
if index>=0: del upStream[index]
except Exception as e:print('except inside del ',e)
else:
updatedList.append(o)
#end if flag
else:
updatedList.append(o)
#end for o.phase
# print('updated list size:',updatedList)
ENGINE.data=updatedList
if len(trashGuid)>0:
# print('delteing ',len(trashGuid),' objects')
# print('..........................')
rs.DeleteObjects(trashGuid)
return upStream
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 genMeshType(typeIndex):
meshes = []
srfs = []
updatedList = []
#remove existing mesh
for AD in ENGINE.data.meshType:
if AD.srfType == typeIndex:
meshes.append(AD.guid)
else:
updatedList.append(AD)
ENGINE.data.meshType = updatedList
if len(meshes) > 0:
rs.DeleteObjects(meshes)
for AD in ENGINE.data.srfType:
if AD.srfType == typeIndex:
srfs.append(AD)
for sAD in srfs:
typeI = typeIndex
facadeType = ENGINE.facadeTypes[typeI]
print('facade type: ', facadeType)
try:
m = divideSrfToPattern(sAD.guid, facadeType)
if rs.IsObject(m):
mAD = AttrDict()
mAD.guid = m
mAD.srfType = typeI
mAD.srf = sAD.guid
ENGINE.data.meshType.append(mAD)
except:
print('exception in divideSrfToPatter')
rs.EnableRedraw(True)
def handle(self, sender, e):
if not self.toggle:
self.toggle = True
rs.UnselectAllObjects()
self.engine.clearSelections()
selection = []
#print('handle bt 1:',self.index)
for o in self.engine.data:
# print('bt1 Click:',o.typeIndex,self.index,o.guid)
if o.typeIndex == self.index:
# print('selected')
try:
if rs.IsObject(o.guid):
selection.append(o)
except Exception as e:
print('!except handleBt1 sselect ', e)
# print('bt1 Click selection size :',len(selection))
self.engine.setSelection(selection)
self.engine.highlightSelection()
else:
self.toggle = False
self.engine.setSelection([])
rs.UnselectAllObjects()
def purge_objects(guids):
rs.EnableRedraw(False)
if not purge_object:
raise RuntimeError('Cannot purge outside Rhino context.')
for guid in guids:
if rs.IsObject(guid):
if rs.IsObjectHidden(guid):
rs.ShowObject(guid)
o = find_object(guid)
purge_object(o.RuntimeSerialNumber)
def _are_5_objects(items):
value = True
if not len(items) == 5:
value = False
else:
for item in items:
if not rs.IsObject(item):
value = False
break
return value
def __init__(self):
sc.doc = rc.RhinoDoc.ActiveDoc
self.__m_functionType = 'Layout'
if modifierGeometry: self.__m_modifierObjects = modifierGeometry
if modifierDistThreshold:
self.__m_modifierDistThreshold = modifierDistThreshold
for index, obj in enumerate(self.__m_modifierObjects):
try:
if type(obj) == System.Guid:
if not rs.IsObject(obj):
self.warningData.append(
"Invalid 'modifierGeometry' value at #" +
str(index + 1))
self.__m_modifierObjects[index] = None
continue
objData = rs.ObjectName(obj) #extract data if any
geo = rc.DocObjects.ObjRef(obj).Brep()
if geo == None: geo = rc.DocObjects.ObjRef(obj).Curve()
geo.SetUserString('Data', objData)
self.__m_modifierObjects[index] = geo
else:
obj.SetUserString('Data', " ")
except:
self.warningData.append(
"Invalid 'modifierGeometry' value at #" +
str(index + 1))
self.__m_modifierObjects[index] = None
continue
try:
while True:
self.__m_modifierObjects.remove(None)
except:
pass
if modifierFalloff <> None:
self.__m_falloffRadius = modifierFalloff
if excludeBayIDs: self.__m_inmuneBayID_List = excludeBayIDs
self.__m_randomObject = random.Random(
) #Global Random generator object
self.__m_randomObject.seed(self.__m_randomSeed)
if _dataFunctionL:
if _dataFunctionL.__class__.__name__ <> "LayoutDataFunction":
self.warningData.append("Invalid 'dataFunction' input")
self.__m_DataFunction = None
else:
self.__m_DataFunction = _dataFunctionL
else:
self.warningData.append("Missing 'dataFunction' input")
sc.doc = ghdoc
def delete(self):
#print('@PhaseObject.delete self.parent=',self.parent)
if self.parent is not None:
#print('removing self from',self.parent)
self.parent.remove_child(self)
if self.children:
for c in self.children:
c.delete()
if self.guid is not None:
if rs.IsObject(self.guid):
rs.DeleteObject(self.guid)
def Orthographic_Cplane():
cpln_current = rs.ViewCPlane()
Bool_Osnap = rs.Osnap()
point = cpln_current.Origin
if Bool_Osnap:
rs.Osnap(False)
rs.Command("_Circle 0,0,0 ")
#
rs.EnableRedraw(False)
#
Circle = rs.LastCreatedObjects()
if Bool_Osnap:
rs.Osnap(True)
if Circle is None:
#
rs.EnableRedraw(True)
#
return
if not rs.IsObject(Circle):
rs.EnableRedraw(True)
return
rs.Command("_Point 0,0,1 ")
pt_pos = rs.LastCreatedObjects()
rs.Command("_Point 0,0,-1 ")
pt_neg = rs.LastCreatedObjects()
pt_cam = rs.ViewCamera()
dist_pos = rs.Distance(pt_cam,pt_pos)
dist_neg = rs.Distance(pt_cam,pt_neg)
print pt_cam
Disk = rs.AddPlanarSrf(Circle)
rs.UnselectAllObjects()
rs.SelectObjects(Disk)
if dist_pos>dist_neg:
rs.Command("OrientCameraToSrf _f 0,0,0 _pause")
else:
rs.Command("OrientCameraToSrf 0,0,0 _pause")
rs.DeleteObjects((pt_pos,pt_neg,Circle,Disk))
rs.ViewProjection(None,1)
def purge_objects(guids):
if not purge_object:
raise RuntimeError('Cannot purge outside Rhino script context')
rs.EnableRedraw(False)
for guid in guids:
if rs.IsObject(guid):
if rs.IsObjectHidden(guid):
rs.ShowObject(guid)
o = find_object(guid)
purge_object(o.RuntimeSerialNumber)
rs.EnableRedraw(True)
sc.doc.Views.Redraw()
def __init__(self):
sc.doc = rc.RhinoDoc.ActiveDoc
self.__m_functionType = 'Layout'
if layoutRegions: self.__m_modifierObjects = layoutRegions
if regionsDistanceTH:
self.__m_modifierDistThreshold = regionsDistanceTH
for index, obj in enumerate(self.__m_modifierObjects):
try:
if type(obj) == System.Guid:
if not rs.IsObject(obj):
self.warningData.append(
"Invalid 'layoutRegions' value at #" +
str(index + 1))
self.__m_modifierObjects[index] = None
continue
objData = rs.ObjectName(obj) #extract data if any
geo = rc.DocObjects.ObjRef(obj).Brep()
if geo == None: geo = rc.DocObjects.ObjRef(obj).Curve()
geo.SetUserString('Data', objData)
self.__m_modifierObjects[index] = geo
else:
obj.SetUserString('Data', " ")
except:
self.warningData.append(
"Invalid 'layoutRegions' value at #" + str(index + 1))
self.__m_modifierObjects[index] = None
continue
try:
while True:
self.__m_modifierObjects.remove(None)
except:
pass
if regionsEdgeDithering <> None:
self.__m_falloffRadius = regionsEdgeDithering
if filter: self.__m_filterBayID_List = filter
self.__m_randomObject = random.Random(
) #Global Random generator object
self.__m_randomObject.seed(self.__m_randomSeed)
if _layoutType:
if _layoutType.__class__.__name__ <> "LayoutDataFunction":
self.warningData.append("Invalid 'layoutType' input")
self.__m_DataFunction = None
else:
self.__m_DataFunction = _layoutType
else:
self.warningData.append("Missing 'layoutType' input")
sc.doc = ghdoc
def handle(self, sender, e):
rs.UnselectAllObjects()
self.engine.clearSelections()
print('handle bt 1:', self.index)
selection = []
for o in self.engine.data:
if o.typeIndex == self.index:
try:
if rs.IsObject(o.guid):
selection.append(o)
except:
print('not guid returned in selection')
self.engine.setSelection(selection)
highlightSelection(self.engine)
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"
def genTypeMesh(self, typeIndex=None):
#if not typeIndex given, will regenerate all types
rs.EnableRedraw(False)
meshes = []
srfs = []
updatedList = []
phaseIndex = 'TYPEMESH'
upStreamIndex = 'TYPESRF'
layerName = get_layer_name('TYPEMESH')
#remove existing mesh
try:
self.deleteObjects(phaseIndex, typeIndex)
except Exception as e:
print('except at delete :', e)
#find all the TYPESRF
try:
srfs = self.getObject(upStreamIndex, typeIndex)
except Exception as e:
print('except genTypeMesh->self.getObject:', e)
for o in srfs:
if typeIndex is not None:
if not o.typeIndex == typeIndex: continue
#typeI=typeIndex%len(self.facadeTypes)
typeI = o.typeIndex
#print('typeI:',typeI,self.facadeTypes)
try:
facadeType = self.facadeTypes[typeI]
#print('facade type: ',facadeType)
except Exception as e:
print('exception in getting self.facadeTypes', e)
#rs.EnableRedraw(True)
return
try:
m = divideSrfToPattern(o.guid, facadeType)
if rs.IsObject(m):
rs.ObjectLayer(m, layerName)
self.addObject(m, phaseIndex, typeI, o)
except Exception as e:
#rs.EnableRedraw(True)
print('exception in divideSrfToPattern:', Exception, ':', e)
#rs.EnableRedraw(True)
rs.EnableRedraw(True)
def UniqueRename(name_map):
selected = SelectedObjects()
for object in selected:
old_name = rs.ObjectName(object)
new_name = SafeObjectName(old_name)
if len(new_name) == 0:
new_name = "Unknown"
if rs.IsObject(object):
new_name = "Object"
# NOTE: IsObject and IsLight can both be true
# so IsLight must be checked after
if rs.IsLight(object):
new_name = "Light"
if old_name is None or len(old_name) == 0 or new_name in name_map:
suffix = len(name_map)
while new_name + "_" + str(suffix) in name_map:
suffix += 1
new_name += "_" + str(suffix)
name_map[new_name] = old_name
rs.ObjectName(object, new_name)
def genTypeMeshObject(self, obj):
facadeType = self.facadeTypes[obj.typeIndex]
downStream = obj.downStream
layerName = 'GENTYPEMESH'
phaseIndex = 'TYPEMESH'
print('!!! downStrem size:', len(downStream))
print(downStream)
for ds in downStream:
self.deleteObject(ds)
#pass
try:
m = divideSrfToPattern(obj.guid, facadeType)
if rs.IsObject(m):
rs.ObjectLayer(m, layerName)
self.addObject(m, phaseIndex, obj.typeIndex, obj)
except Exception as e:
print('exception in divideSrfToPattern:', Exception, ':', e)
rs.EnableRedraw(True)
pass
def deleteObject(obj):
if obj is None: return None
print('delete object')
print('---',obj.guid)
print('---',obj.phase)
print('---',obj.typeIndex)
print('---',obj.upStream)
if rs.IsObject(obj.guid): rs.DeleteObject(obj.guid)
upStream=obj.upStream
inspectObject(upStream.guid)
try:#delete the object from upStream
index=upStream.downStream.index(obj)
if index>=0: del upStream[index]
except Exception as e:print('!except at deleteOjbect() 1',e)
try:#delete the object from data
index=ENGINE.data.index(obj)
if index>=0: del ENGINE.data[index]
except Exception as e:print('!except at deleteOjbect() 2',e)
return upStream
def genAllMesh(sender=None, e=None):
global ENGINE
srfs = ENGINE.data.srfType
rs.CurrentLayer('genMesh')
meshes = rs.ObjectsByLayer('genMesh')
if len(meshes) > 0:
rs.DeleteObjects(meshes)
ENGINE.data.meshType = []
for sAD in srfs:
typeI = sAD.srfType
facadeType = ENGINE.facadeTypes[typeI]
try:
m = divideSrfToPattern(sAD.guid, facadeType)
if rs.IsObject(m):
mAD = AttrDict()
mAD.guid = m
mAD.srfType = typeI
mAD.srf = sAD.guid
ENGINE.data.meshType.append(mAD)
except:
print('exception in divideSrfToPatter')
rs.EnableRedraw(True)
def handle_GENBLOCK_bt_view_srf(self, sender, e):
self.suspendInteraction()
rs.EnableRedraw(False)
try:
layername = get_layer_name('MASSING')
tolerance = 0.0001
self.isolateLayer(layername)
sel = rs.ObjectsByLayer(layername)
print('sel from MASSING layer:', sel)
self.deleteObjectsByGuid(sel)
rs.CurrentLayer(layername)
#blocks=rs.ObjectsByLayer(get_layer_name('BLOCK'))
cons = [('phase', 'BLOCK')]
obj_blocks = self.data.find_all(cons)
print('flag_1')
rhi_blocks = self.data.find_all_guids(cons)
print('flag_2', rhi_blocks)
cblocks = rs.CopyObjects(rhi_blocks)
ublocks = rs.BooleanUnion(cblocks, True)
splitedSrfs = []
horzSrfs = []
vertSrfs = []
#找出union block里的横竖面
print('Sparate horz and vert srfs')
for b in ublocks:
os = rs.ExplodePolysurfaces(b, True)
print('os', os)
#先把水平面分走
horzSrfs = []
vertSrfs = []
for s in os:
print('line 740')
if s is None:
continue
if not rs.IsObject(s):
continue
isHor, direct = isHorizonalSrf(s, True)
if isHorizonalSrf(s):
if direct < 0:
rs.ObjectColor(s, (255, 0, 0))
else:
rs.ObjectColor(s, COLOR_SET_01[5])
horzSrfs.append(s)
else:
vertSrfs.append(s)
blockedSrf = []
parentDic = {}
wheel = 0
print('assign parent objects')
#Union block的横竖面找parent
for po in obj_blocks:
srfs = rs.ExplodePolysurfaces(po.guid, False)
for vsrf in vertSrfs:
pts2 = rs.SurfaceEditPoints(vsrf)
for s in srfs:
pts1 = rs.SurfaceEditPoints(s)
if listsEqual(pts1, pts2):
parentDic[vsrf] = po
rs.DeleteObjects(srfs)
print(parentDic)
print('split irregular polygons')
for s in vertSrfs:
parent = parentDic[s]
if parent is None:
print('parent is None')
rs.SelectObject(s)
continue
#rs.EnableRedraw(True)
phaseIndex = 'MASSING'
typeIndex = parent.typeIndices[0]
boundary = rs.DuplicateSurfaceBorder(s)
pts = rs.CurveEditPoints(boundary)
if len(pts) > 5:
#print('splitting polygon')
#rs.EnableRedraw(False)
srfs = splitIrregularPolygon(s)
#print('splitIregPoly srfs=',srfs)
if srfs is None:
continue
splitedSrfs += srfs
for ss in srfs:
#print(shortGuid(parent.guid))
o = self.addObject(ss, phaseIndex, typeIndex, parent)
if o is None: continue
self.setObjectType(o, typeIndex)
#rs.EnableRedraw(True)
else:
splitedSrfs.append(s)
o = None
try:
o = self.addObject(s, phaseIndex, typeIndex, parent)
except Exception as e:
print(e, s, phaseIndex, typeIndex, parent)
if o is None: continue
#print('o=',o)
self.setObjectType(o, typeIndex)
#self.logDataTree()
rs.DeleteObject(boundary)
except Exception as e:
print('exception:', e)
#PrintException()
rs.EnableRedraw(True)
self.resumeInteraction()
rs.EnableRedraw(True)
#sort by types
colors=[(200,200,255),
(180,220,255),
(160,240,255),
(140,260,255)]
t1=[]
t2=[]
t3=[]
types=[t1,t2,t3]
#clear and set active genType layer
rs.CurrentLayer('genType')
trash=rs.ObjectsByLayer('genType')
for t in trash:
if rs.IsObject(t):rs.DeleteObject(t)
#sort srfs by types ->types[i]->[]
for f in srfs:
name=rs.ObjectName(f)
for i in range(0,3):
txt=str(i+1)
if name==txt:
print('txt: ',txt)
print('name :',name)
nf=rs.CopyObject(f)
rs.ObjectLayer(nf,'genType')
rs.ObjectColor(nf,colors[i])
types[i].append(nf)
break
