def xdraw_mesh(vertices, faces, name=None, color=None, **kwargs):
guid = rs.AddMesh(vertices, faces)
if color:
rs.ObjectColor(guid, color)
if name:
rs.ObjectName(guid, name)
return guid
def xdraw_mesh(vertices, faces, color, name):
guid = rs.AddMesh(vertices, faces)
if color:
rs.ObjectColor(guid, color)
if name:
rs.ObjectName(guid, name)
return guid
def ColorObjsRandomRange():
try:
objs = rs.GetObjects("Select objects to color",
1073750077,
preselect=True)
if objs is None: return
print "Select First Color"
firstColor = rs.GetColor()
if firstColor is None: return
print "Select Second Color"
secondColor = rs.GetColor(firstColor)
if secondColor is None: return
rs.EnableRedraw(False)
colorLine = rs.AddLine(firstColor, secondColor)
try:
colors = rs.DivideCurve(colorLine, len(objs) - 1)
shuffle(colors)
for i, obj in enumerate(objs):
rs.ObjectColor(obj, (colors[i].X, colors[i].Y, colors[i].Z))
except:
pass
rs.DeleteObject(colorLine)
rs.EnableRedraw(True)
return True
except:
return False
def get_pocket_entry(self, z_level, translation, pocket_list):
revised_list = []
last_obj = None
for obj in pocket_list:
if obj != "sec_plane":
revised_list.append(rs.CopyObject(obj, translation))
else:
if last_obj != obj:
revised_list.append(obj)
last_obj = obj
pocket_list = revised_list
for i in range(0, len(pocket_list)):
crv = pocket_list[i]
if crv == "sec_plane": #Cambio intermedio
pep = rs.CurveEndPoint(pocket_list[i - 1])
try:
nsp = rs.CurveStartPoint(pocket_list[i + 1])
except:
npt = rs.CurveStartPoint(self.cut_curve)
nsp = (npt[0], npt[1], z_level)
points = [
rs.CurveEndPoint(pocket_list[i - 1]),
(pep[0], pep[1], self.general_input["sec_plane"]),
(nsp[0], nsp[1], self.general_input["sec_plane"]), nsp
]
travel_line = rs.AddPolyline(points)
rs.ObjectColor(travel_line, color_palette["cut"])
pocket_list[i] = travel_line
return pocket_list
def change():
for i in range(200):
color = rand_color()
print color
rs.ObjectColor(obj, color )
time.sleep(.001)
Rhino.RhinoApp.Wait()
def SampleSynchronizeRenderColors():
objects = rs.AllObjects()
if objects is None: return
for obj in objects:
color = rs.ObjectColor(obj)
source = rs.ObjectColorSource(obj)
material = -1
if source == 0:
layer = rs.ObjectLayer(obj)
material = rs.LayerMaterialIndex(layer)
if material < 0:
material = rs.AddMaterialToLayer(layer)
elif source == 1:
material = rs.ObjectMaterialIndex(obj)
if material < 0:
material = rs.AddMaterialToObject(obj)
if material >= 0:
if color != rs.MaterialColor(material):
rs.MaterialColor(material, color)
rs.Redraw()
def addObject(self,
guid,
phase,
typeIndex,
parent=None,
description='',
needUpdate=False):
#print('add object ',shortGuid(guid))
if self.data.find('guid', guid):
print('obj exists in data')
return None
o = PhaseObject()
o.guid = guid
o.phase = phase
o.typeIndex = typeIndex
o.set_parent(parent)
o.description = description
o.needUpdate = needUpdate
#parent.add_child(o)
#rhino layer and attributes
rs.ObjectColor(guid, self.get_color(phase, typeIndex))
try:
layer = get_layer_name(phase)
print(layer)
rs.ObjectLayer(guid, layer)
except Exception as e:
print(e)
#layer=self.get_layer_name(phase)
#rs.ObjectLayer(guid,layer)
self.data.add_child(o)
self.logDataTree()
return o
def setObjectType(self, obj, typeIndex=0, index=None):
colorI = int(typeIndex) % len(COLOR_SET_01)
color = COLOR_SET_01[colorI]
rs.ObjectColor(obj.guid, color)
if index is None:
obj.typeIndex = int(typeIndex)
else:
obj.typeIndices[int(index)] = typeIndex
def AddTag(obj, text, color):
box = rs.BoundingBox(obj)
mid = (box[0] + box[-2])/2
tag = rs.AddTextDot(text, mid)
rs.SetUserText(obj, 'tag', text)
rs.ObjectColor(obj, color)
group = rs.AddGroup()
rs.AddObjectsToGroup([obj, tag], group)
def _moveTowards(self, vector):
if self._penDown:
newLocation = self._location.Origin + vector
line = rs.AddLine(self._location.Origin, newLocation)
rs.ObjectColor(line, self._color)
rs.ObjectPrintColor(line, self._color)
rs.ObjectPrintWidth(line, self._lineweight)
self._location.Translate(vector)
def drawLine(self, p1, p2):
if self.draw:
l = rs.AddLine(p1, p2)
rs.ObjectColor(l, self.color)
rs.ObjectPrintWidth(l, self.weight)
return l
else:
pass
def draw_faces(self, keys=None, color=None, join_faces=False):
"""Draw a selection of faces.
Parameters
----------
fkeys : list
A list of face keys identifying which faces to draw.
The default is ``None``, in which case all faces are drawn.
color : str, tuple, dict
The color specififcation for the faces.
Colors should be specified in the form of a string (hex colors) or
as a tuple of RGB components.
To apply the same color to all faces, provide a single color
specification. Individual colors can be assigned using a dictionary
of key-color pairs. Missing keys will be assigned the default face
color (``self.defaults['face.color']``).
The default is ``None``, in which case all faces are assigned the
default face color.
Notes
-----
The faces are named using the following template:
``"{}.face.{}".format(self.datastructure.name, key)``.
This name is used afterwards to identify faces in the Rhino model.
"""
keys = keys or list(self.datastructure.faces())
colordict = color_to_colordict(color,
keys,
default=self.defaults.get('color.face'),
colorformat='rgb',
normalize=False)
faces = []
for fkey in keys:
faces.append({
'points':
self.datastructure.face_coordinates(fkey),
'name':
self.datastructure.face_name(fkey),
'color':
colordict[fkey],
'layer':
self.datastructure.face_attribute(fkey, 'layer', None)
})
guids = compas_rhino.draw_faces(faces,
layer=self.layer,
clear=False,
redraw=False)
if not join_faces:
return guids
guid = rs.JoinMeshes(guids, delete_input=True)
rs.ObjectLayer(guid, self.layer)
rs.ObjectName(guid, '{}.mesh'.format(self.datastructure.name))
if color:
rs.ObjectColor(guid, color)
return guid
def select_mesh_polyedge(mesh):
"""Select mesh polyedge.
Parameters
----------
mesh : Mesh
The mesh.
Returns
-------
polyedge : list
The list of polyedge vertices.
"""
# add layer
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
# collect polyedge vertices
polyedge = []
lines = []
while True:
# define candidate vertices for polyedge
if len(polyedge) == 0:
vkey_candidates = mesh.vertices()
else:
vkey_candidates = mesh.vertex_neighbors(polyedge[-1])
# get vertex among candidates
artist.draw_vertexlabels(
text={key: str(key)
for key in vkey_candidates})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vertex')
artist.clear_layer()
artist.redraw()
# stop if no vertex is added
if vkey is None:
break
# add vertex to polyedge
polyedge.append(vkey)
if len(polyedge) > 1:
u = mesh.vertex_coordinates(polyedge[-2])
v = mesh.vertex_coordinates(polyedge[-1])
guid = rs.AddLine(u, v)
rs.ObjectColor(guid, [255, 255, 0])
lines.append(guid)
rs.DeleteLayer('mesh_artist')
rs.DeleteObjects(lines)
return polyedge
def plot_reaction_forces(structure, step, layer=None, scale=1.0):
""" Plots reaction forces for the Structure analysis results.
Parameters
----------
structure : obj
Structure object.
step : str
Name of the Step.
layer : str
Layer name for plotting.
scale : float
Scale of the arrows.
Returns
-------
None
"""
if not layer:
layer = '{0}-{1}'.format(step, 'reactions')
rs.CurrentLayer(rs.AddLayer(layer))
rs.DeleteObjects(rs.ObjectsByLayer(layer))
rs.EnableRedraw(False)
rfx = structure.results[step]['nodal']['rfx']
rfy = structure.results[step]['nodal']['rfy']
rfz = structure.results[step]['nodal']['rfz']
nkeys = rfx.keys()
v = [scale_vector([rfx[i], rfy[i], rfz[i]], -scale * 0.001) for i in nkeys]
rm = [length_vector(i) for i in v]
rmax = max(rm)
nodes = structure.nodes_xyz(nkeys)
for i in nkeys:
if rm[i] > 0.001:
l = rs.AddLine(nodes[i], add_vectors(nodes[i], v[i]))
rs.CurveArrows(l, 1)
col = [
int(j) for j in colorbar(rm[i] / rmax, input='float', type=255)
]
rs.ObjectColor(l, col)
vector = [rfx[i], rfy[i], rfz[i]]
name = json.dumps({
'rfx': rfx[i],
'rfy': rfy[i],
'rfz': rfz[i],
'rfm': length_vector(vector)
})
rs.ObjectName(l, '_' + name)
rs.CurrentLayer(rs.AddLayer('Default'))
rs.LayerVisible(layer, False)
rs.EnableRedraw(True)
def updatePhaseObjectColor(self, obj):
phase = obj.phase
index = obj.typeIndex
colors = PHASE_OBJECT_COLORS[phase]
colorIndex = index % len(colors)
color = colors[colorIndex]
#print('@updateColor:',color,obj.guid)
rs.ObjectColor(obj.guid, color)
def addBox(node):
box = []
lower = node.indxList[0]
upper = node.indxList[6]
center = []
for i in range(3):
center.append((ptsList[lower][i] + ptsList[upper][i]) / 2)
for indx in node.indxList:
box.append(ptsList[indx])
boxBody = rs.AddBox(box)
rs.AddText(node.nid, center, 0.05)
if (node.state == 1):
rs.ObjectColor(boxBody, [255, 0, 0])
elif (node.state == 3):
rs.ObjectColor(boxBody, [0, 255, 0])
elif (node.state == 4):
rs.ObjectColor(boxBody, [0, 0, 0])
def commond():
geos = rs.GetObjects("选择直线",
rs.filter.curve,
True,
True,
custom_filter=select_line)
color = rs.GetColor(0)
if geos and color:
[rs.ObjectColor(i, color) for i in geos]
def getOrientationPts(ref_srf):
ptO = EvaluateSurfaceParam(ref_srf, 0.5, 0.5)
ptU = EvaluateSurfaceParam(ref_srf, 1, 0.5)
ptV = EvaluateSurfaceParam(ref_srf, 0.5, 1)
pt_O = rs.AddPoint(ptO)
pt_U = rs.AddPoint(ptU)
pt_V = rs.AddPoint(ptV)
rs.ObjectColor(pt_O, (255, 0, 0))
rs.ObjectColor(pt_U, (0, 255, 0))
rs.ObjectColor(pt_V, (0, 0, 255))
lstPts = []
lstPts.append(ptO)
lstPts.append(ptU)
lstPts.append(ptV)
return lstPts
def childDoneStatus(self, ptList = []): #this method marks the isDone status of all the nodes of the subtree #by marking the done nodes in red and others in blue #this method also returns the list of the added point objects #so that they can be easily removed newPt = rs.AddPoint(self.pos) if self.isDone: #Add a red Point rs.ObjectColor(newPt, (255,0,0)) else: #Add a blue point rs.ObjectColor(newPt, (0,0,255)) ptList.append(newPt) for ch in self.child: ptList = ch.childDoneStatus(ptList) return ptList
def addpointat_r1_parameter(curve_id, parameter):
domain = rs.CurveDomain(curve_id)
if not domain: return
r1_param = domain[0] + parameter * (domain[1] - domain[0])
r3point = rs.EvaluateCurve(curve_id, r1_param)
if r3point:
point_id = rs.AddPoint(r3point)
rs.ObjectColor(point_id, parametercolor(parameter))
def ColorBySize():
try:
objs = rs.GetObjects("Select objects to color",
1073815613,
preselect=True)
if objs is None: return
print "Select First Color"
firstColor = rs.GetColor()
if firstColor is None: return
print "Select Second Color"
secondColor = rs.GetColor(firstColor)
if secondColor is None: return
rs.EnableRedraw(False)
colorLine = rs.AddLine(firstColor, secondColor)
areas = []
for obj in objs:
if rs.IsCurve(obj):
if rs.IsCurveClosed(obj):
areas.append(rs.CurveArea(obj)[0])
else:
areas.append(rs.CurveLength(obj))
elif rs.IsSurface(obj):
areas.append(rs.SurfaceArea(obj)[0])
elif rs.IsPolysurface(obj):
if rs.IsPolysurfaceClosed(obj):
areas.append(rs.SurfaceVolume(obj)[0])
elif rs.IsHatch(obj):
areas.append(rs.Area(obj))
else:
print "Only curves, hatches, and surfaces supported"
return
newAreas = list(areas)
objAreas = zip(newAreas, objs)
objAreas.sort()
objSorted = [objs for newAreas, objs in objAreas]
areas.sort()
normalParams = utils.RemapList(areas, 0, 1)
colors = []
for t in normalParams:
param = rs.CurveParameter(colorLine, t)
colors.append(rs.EvaluateCurve(colorLine, param))
for i, obj in enumerate(objSorted):
rs.ObjectColor(obj, (colors[i].X, colors[i].Y, colors[i].Z))
rs.DeleteObject(colorLine)
rs.EnableRedraw(True)
return True
except:
return False
def rampIntersection(route1, route2, width):
edges = []
offSeg1 = offsetLine(route1, width / 2)
offSeg2 = offsetLine(route2, width / 2)
test1 = rs.CurveCurveIntersection(offSeg1, offSeg2)
if (test1 == None):
side1 = False
else:
side1 = True
offSeg3 = offsetLine(route1, -width / 2)
offSeg4 = offsetLine(route2, -width / 2)
rs.ObjectColor(offSeg3, [255, 0, 0])
rs.ObjectColor(offSeg4, [255, 0, 0])
test2 = rs.CurveCurveIntersection(offSeg3, offSeg4)
if (test2 == None):
side2 = False
else:
side2 = True
if (side1):
pivotPt = rs.LineLineIntersection(offSeg1, offSeg2)[0]
perpPt1 = rs.EvaluateCurve(offSeg3,
rs.CurveClosestPoint(offSeg3, pivotPt))
perpPt2 = rs.EvaluateCurve(offSeg4,
rs.CurveClosestPoint(offSeg4, pivotPt))
edges.append(rs.AddLine(pivotPt, perpPt1))
edges.append(rs.AddLine(pivotPt, perpPt2))
elbowPt = rs.LineLineIntersection(offSeg3, offSeg4)[0]
else:
pivotPt = rs.LineLineIntersection(offSeg3, offSeg4)[0]
perpPt1 = rs.EvaluateCurve(offSeg1,
rs.CurveClosestPoint(offSeg1, pivotPt))
perpPt2 = rs.EvaluateCurve(offSeg2,
rs.CurveClosestPoint(offSeg2, pivotPt))
edges.append(rs.AddLine(pivotPt, perpPt1))
edges.append(rs.AddLine(pivotPt, perpPt2))
elbowPt = rs.LineLineIntersection(offSeg1, offSeg2)[0]
rs.DeleteObject(offSeg1)
rs.DeleteObject(offSeg2)
rs.DeleteObject(offSeg3)
rs.DeleteObject(offSeg4)
landing = rs.AddPolyline([pivotPt, perpPt1, elbowPt, perpPt2, pivotPt])
return edges, landing
def cylinders(self, num):
a = rs.GetPoint("Enter start point")
p = rs.AddPoint(a)
h = rs.GetReal("Enter the height")
for i in range(0, num):
a.X = a.X + 4
h = h + 5
r = 2
cylinder = rs.AddCylinder(a, h, r)
color02 = [i * 3, i * 2, 255 - i * 6] #magenta
rs.ObjectColor(cylinder, color02)
def get_cut_path_open(self, crv):
no_entries = self.input_data["entries"]
level_depth = self.input_data["depth"] / no_entries
sec_plane = self.general_input["sec_plane"]
#Lista final de operacion de cortador por curva
curves_cut_path = []
for entrie in range(1, int(no_entries) + 1):
translation = rs.VectorAdd((0, 0, 0), (0, 0, level_depth * entrie))
level_curve = rs.CopyObject(crv, translation)
rs.ObjectColor(level_curve, color_palette["cut"])
if entrie % 2 == 0: rs.ReverseCurve(level_curve)
if entrie == 1:
entry_end_point = rs.CurveStartPoint(level_curve)
in_curve = rs.AddLine(
(entry_end_point[0], entry_end_point[1], sec_plane),
entry_end_point)
rs.ObjectColor(in_curve, color_palette["plunge"])
curves_cut_path.append(in_curve)
curves_cut_path.append(level_curve)
if entrie < no_entries:
level_ept = rs.CurveEndPoint(level_curve)
plunge_curve = rs.AddLine(level_ept,
(level_ept[0], level_ept[1],
(entrie + 1) * level_depth))
rs.ObjectColor(plunge_curve, color_palette["plunge"])
curves_cut_path.append(plunge_curve)
final_point = rs.CurveEndPoint(level_curve)
out_curve = rs.AddLine(final_point,
(final_point[0], final_point[1], sec_plane))
rs.ObjectColor(out_curve, color_palette["cut"])
curves_cut_path.append(out_curve)
rs.DeleteObjects([crv])
return curves_cut_path
def createMarkSphere(curve_list):
curve = curve_list[0]
domain = rs.CurveDomain(curve)
t = domain[1] / 2.0
point = rs.EvaluateCurve(curve, t)
mark_collision = rs.AddSphere(point, 40)
rs.ObjectColor(mark_collision, [255, 0, 0])
return mark_collision
def addPoint(curve_id, parameter):
domain = rs.CurveDomain(curve_id)
r1_param = domain[0] + (parameter *
(domain[1] - domain[0])) # slice curve domain
r3point = rs.EvaluateCurve(curve_id,
r1_param) # at each domain chunk, store a var
if r3point:
point_id = rs.AddPoint(
r3point) # add new point object along each domain chunk
rs.ObjectColor(point_id, paramColor(
parameter)) # color each point with a incrementing param
def proof_placement(self, checkbuildspace=True):
# color objects
self.correctplacement = True
print 'Moving to zero level'
for obj in self.objIds:
BB = rs.BoundingBox(obj)
rs.MoveObject(obj, [0, 0, -BB[0][2]])
BB = rs.BoundingBox(obj)
if checkbuildspace:
print 'Checking positioning'
for point in BB:
if point[0] < 0 or point[0] > 241:
rs.ObjectColor(obj, (255, 0, 0))
self.correctplacement = False
break
else:
rs.ObjectColor(obj, (0, 255, 0))
if point[1] < 0 or point[1] > 209:
rs.ObjectColor(obj, (255, 0, 0))
self.correctplacement = False
break
else:
rs.ObjectColor(obj, (0, 255, 0))
if point[2] < 0 or point[2] > 205:
rs.ObjectColor(obj, (255, 0, 0))
self.correctplacement = False
break
else:
rs.ObjectColor(obj, (0, 255, 0))
def fixCurrentModel(self):
#fix srf in current scene
layer = 'GENTYPESRF'
srfs = rs.ObjectsByLayer(layer)
counter = 0
global SRFTYPECOLORS
for f in srfs:
rs.ObjectLayer(f, layer)
typeindex = int(rs.ObjectName(f))
index = typeindex % len(SRFTYPECOLORS)
color = SRFTYPECOLORS[index]
rs.ObjectColor(f, color)
counter += 1
def set_openings(mesh):
rs.EnableRedraw(False)
dots = {}
for fkey in mesh.faces():
cent = mesh.face_centroid(fkey)
if mesh.get_face_attribute(fkey, 'opening'):
dot = rs.AddTextDot(fkey, cent)
rs.ObjectColor(dot, [255, 0, 0])
else:
dot = rs.AddTextDot(fkey, cent)
rs.ObjectColor(dot, [0, 255, 0])
rs.TextDotHeight(dot, 12)
dots[str(dot)] = fkey
rs.EnableRedraw(True)
if not dots:
return None
dot_ids = dots.keys()
data = rs.GetObjectsEx(message="Select face for toggle openings",
filter=0,
preselect=False,
select=False,
objects=dot_ids)
rs.DeleteObjects(dot_ids)
if data:
for datum in data:
dot = datum[0]
fkey = dots[str(dot)]
if mesh.get_face_attribute(fkey, 'opening'):
mesh.set_face_attribute(fkey, 'opening', 0)
else:
mesh.set_face_attribute(fkey, 'opening', 1)
def plot_spl(room, spl, frequency):
spls = [spl[rec][frequency] for rec in spl]
minspl = min(spls)
maxspl = max(spls)
for rec in spl:
value = spl[rec][frequency]
pt = room.receivers[rec]['xyz']
sph = rs.AddSphere(pt, .2)
rs.ObjectName(sph, str(value))
i = (((value - minspl) * (1 - 0)) / (maxspl - minspl)) + 0
color = i_to_rgb(i)
# print(minspl, maxspl, value, i, color)
rs.ObjectColor(sph, color)
