def get_mesh_vertex_colors(guid): colors = [] if guid: temp = rs.MeshVertexColors(guid) if temp: colors = map(list, temp) return colors
def RenderAgentsOnMesh(strMesh, arrIndexes): arrVertices = rs.MeshVertices(strMesh) arrVertexColors = [] for i in range(len(arrVertices)): arrVertexColors.append( [255,255,255] ) for index in arrIndexes: arrVertexColors[index] = [0,0,0] rs.MeshVertexColors (strMesh , arrVertexColors)
def meshExtrudePtsByVect(pts,vect,colorRow=None): extrudeVect=vect #rs.AddPoints(pts) meshes=[] #verts=[] #faces=[] for i in range(0,len(pts)-1): p1=pts[i] p2=pts[i+1] p1up=p1+extrudeVect p2up=p2+extrudeVect m=addMeshQuad([p1,p1up,p2up,p2]) if colorRow is not None: # rs.ObjectColor(m,colorRow[i]) rs.MeshVertexColors(m,[colorRow[i],colorRow[i],colorRow[i],colorRow[i]]) meshes.append(m) mesh=rs.JoinMeshes(meshes,True) return mesh
def set_mesh_vertex_colors(guid, colors): if not guid: return return rs.MeshVertexColors(guid, colors)
def unset_vertex_colors(self): return rs.MeshVertexColors(self.guid, None)
def set_vertex_colors(self, colors): return rs.MeshVertexColors(self.guid, colors)
def get_vertex_colors(self): return map(list, rs.MeshVertexColors(self.guid))
def plot_data(structure, step, field='um', layer=None, scale=1.0, radius=0.05, cbar=[None, None], iptype='mean', nodal='mean', mode='', colorbar_size=1): """ Plots analysis results on the deformed shape of the Structure. Parameters ---------- structure : obj Structure object. step : str Name of the Step. field : str Field to plot, e.g. 'um', 'sxx', 'sm1'. layer : str Layer name for plotting. scale : float Scale on displacements for the deformed plot. radius : float Radius of the pipe visualisation meshes. cbar : list Minimum and maximum limits on the colorbar. iptype : str 'mean', 'max' or 'min' of an element's integration point data. nodal : str 'mean', 'max' or 'min' for nodal values. mode : int Mode or frequency number to plot, for modal, harmonic or buckling analysis. colorbar_size : float Scale on the size of the colorbar. Returns ------- None Notes ----- - Pipe visualisation of line elements is not based on the element section. """ # Create and clear Rhino layer if not layer: layer = '{0}-{1}'.format(step, field) rs.CurrentLayer(rs.AddLayer(layer)) rs.DeleteObjects(rs.ObjectsByLayer(layer)) rs.EnableRedraw(False) # Node and element data nodes = structure.nodes_xyz() elements = [ structure.elements[i].nodes for i in sorted(structure.elements, key=int) ] nodal_data = structure.results[step]['nodal'] nkeys = sorted(structure.nodes, key=int) ux = [nodal_data['ux{0}'.format(mode)][i] for i in nkeys] uy = [nodal_data['uy{0}'.format(mode)][i] for i in nkeys] uz = [nodal_data['uz{0}'.format(mode)][i] for i in nkeys] try: data = [nodal_data['{0}{1}'.format(field, mode)][i] for i in nkeys] dtype = 'nodal' except (Exception): data = structure.results[step]['element'][field] dtype = 'element' # Postprocess basedir = utilities.__file__.split('__init__.py')[0] xfunc = XFunc('postprocess', basedir=basedir, tmpdir=structure.path) xfunc.funcname = 'functions.postprocess' result = xfunc(nodes, elements, ux, uy, uz, data, dtype, scale, cbar, 255, iptype, nodal) try: toc, U, cnodes, fabs, fscaled, celements, eabs = result print('\n***** Data processed : {0} s *****'.format(toc)) # Plot meshes mesh_faces = [] line_faces = [[0, 4, 5, 1], [1, 5, 6, 2], [2, 6, 7, 3], [3, 7, 4, 0]] block_faces = [[0, 1, 2, 3], [4, 5, 6, 7], [0, 1, 5, 4], [1, 2, 6, 5], [2, 3, 7, 6], [3, 0, 4, 7]] tet_faces = [[0, 2, 1, 1], [1, 2, 3, 3], [1, 3, 0, 0], [0, 3, 2, 2]] for element, nodes in enumerate(elements): n = len(nodes) if n == 2: u, v = nodes sp, ep = U[u], U[v] plane = rs.PlaneFromNormal(sp, subtract_vectors(ep, sp)) xa = plane.XAxis ya = plane.YAxis r = radius xa_pr = scale_vector(xa, +r) xa_mr = scale_vector(xa, -r) ya_pr = scale_vector(ya, +r) ya_mr = scale_vector(ya, -r) pts = [ add_vectors(sp, xa_pr), add_vectors(sp, ya_pr), add_vectors(sp, xa_mr), add_vectors(sp, ya_mr), add_vectors(ep, xa_pr), add_vectors(ep, ya_pr), add_vectors(ep, xa_mr), add_vectors(ep, ya_mr) ] guid = rs.AddMesh(pts, line_faces) if dtype == 'element': col1 = col2 = celements[element] elif dtype == 'nodal': col1 = cnodes[u] col2 = cnodes[v] rs.MeshVertexColors(guid, [col1] * 4 + [col2] * 4) elif n == 3: mesh_faces.append(nodes + [nodes[-1]]) elif n == 4: if structure.elements[element].__name__ in [ 'ShellElement', 'MembraneElement' ]: mesh_faces.append(nodes) else: for face in tet_faces: mesh_faces.append([nodes[i] for i in face]) elif n == 8: for block in block_faces: mesh_faces.append([nodes[i] for i in block]) if mesh_faces: guid = rs.AddMesh(U, mesh_faces) rs.MeshVertexColors(guid, cnodes) # Plot colorbar xr, yr, _ = structure.node_bounds() yran = yr[1] - yr[0] if yr[1] - yr[0] else 1 s = yran * 0.1 * colorbar_size xmin = xr[1] + 3 * s ymin = yr[0] xl = [xmin, xmin + s] yl = [ymin + i * s for i in range(11)] verts = [[xi, yi, 0] for xi in xl for yi in yl] faces = [[i, i + 1, i + 12, i + 11] for i in range(10)] id = rs.AddMesh(verts, faces) y = [i[1] for i in verts] yn = yran * colorbar_size colors = [ colorbar(2 * (yi - ymin - 0.5 * yn) / yn, input='float', type=255) for yi in y ] rs.MeshVertexColors(id, colors) h = 0.6 * s for i in range(5): x0 = xmin + 1.2 * s yu = ymin + (5.8 + i) * s yl = ymin + (3.8 - i) * s vu = float(+max(eabs, fabs) * (i + 1) / 5.) vl = float(-max(eabs, fabs) * (i + 1) / 5.) rs.AddText('{0:.5g}'.format(vu), [x0, yu, 0], height=h) rs.AddText('{0:.5g}'.format(vl), [x0, yl, 0], height=h) rs.AddText('0', [x0, ymin + 4.8 * s, 0], height=h) rs.AddText('Step:{0} Field:{1}'.format(step, field), [xmin, ymin + 12 * s, 0], height=h) if mode != '': freq = str(round(structure.results[step]['frequencies'][mode], 3)) rs.AddText('Mode:{0} Freq:{1}Hz'.format(mode, freq), [xmin, ymin - 1.5 * s, 0], height=h) # Return to Default layer rs.CurrentLayer(rs.AddLayer('Default')) rs.LayerVisible(layer, False) rs.EnableRedraw(True) except: print( '\n***** Error encountered during data processing or plotting *****' )