def from_data(cls, data): """Construct a slicer from its data representation. Parameters ---------- data: dict The data dictionary. Returns ------- layer The constructed slicer. """ mesh = Mesh.from_data(data['mesh']) slicer = cls(mesh) layers_data = data['layers'] for layer_key in layers_data: if layers_data[layer_key]['layer_type'] == 'horizontal_layer': slicer.layers.append(Layer.from_data(layers_data[layer_key])) else: # 'vertical_layer' slicer.layers.append( VerticalLayer.from_data(layers_data[layer_key])) slicer.layer_height = data['layer_height'] return slicer
def harmonic(geom_file, freq_range, freq_steps, damping): # add shell elements from mesh --------------------------------------------- with open(geom_file, 'rb') as fh: geom_data = json.load(fh) mesh = Mesh.from_data(geom_data['mesh']) s = structure.Structure() s.add_nodes_elements_from_mesh(mesh, element_type='ShellElement') # add displacements -------------------------------------------------------- pts = geom_data['pts'] nkeys = [] for pt in pts: nkeys.append(s.check_node_exists(pt)) s.add_set(name='support_nodes', type='NODE', selection=nkeys) supppots = FixedDisplacement(name='supports', nodes='support_nodes') s.add_displacement(supppots) # add materials and sections ----------------------------------------------- E35 = 35 * 10**9 concrete = ElasticIsotropic(name='MAT_CONCRETE', E=E35, v=0.2, p=2400) s.add_material(concrete) section = ShellSection(name='SEC_CONCRETE', t=0.020) s.add_section(section) prop = ElementProperties(type='SHELL', material='MAT_CONCRETE', section='SEC_CONCRETE', elsets=['ELSET_ALL']) s.add_element_properties(prop) # add loads ---------------------------------------------------------------- f_pts = geom_data['f_pts'] nodes = [s.check_node_exists(pt) for pt in f_pts] s.add_set(name='load_nodes', type='NODE', selection=nodes) load = PointLoad(name='hload', nodes='load_nodes', x=0, y=0, z=1, xx=0, yy=0, zz=0) s.add_load(load) # add modal step ----------------------------------------------------------- step = HarmonicStep(name='harmonic_analysis', displacements=['supports'], loads=['hload'], freq_range=freq_range, freq_steps=freq_steps, damping=damping) s.add_step(step) fnm = path + 'harmonic.inp' ansys.inp_generate(s, filename=fnm) # temp = path+'_Temp/' s.analyse(path=path, name='harmonic.inp', temp=None, software='ansys') return s
def trimesh_proxy_subtract_multiple(cls,meshes): """Computes boolean through trimesh by calling compas proxy. Returns ------- compas.datastructures.Mesh """ with Proxy(package='timber_grammar.Trimesh_proxy',python=python_exe_path) as f: result = f.trimesh_subtract_multiple(meshes) result_mesh = Mesh.from_data(result['value']) return result_mesh
def load_slicer(path, folder_name, json_name): """ Loads slicer data. """ data = load_json_file(path, folder_name, json_name) mesh = None paths_nested_list = [] are_closed = [] all_points = [] if data: if 'mesh' in data: compas_mesh = Mesh.from_data(data['mesh']) artist = MeshArtist(compas_mesh) mesh = artist.draw() else: print('No mesh has been saved in the json file.') if 'layers' in data: layers_data = data['layers'] for i in range(len(layers_data)): paths_nested_list.append( []) # save each layer on a different list layer_data = layers_data[str(i)] paths_data = layer_data['paths'] for j in range(len(paths_data)): path_data = paths_data[str(j)] pts = [] are_closed.append(path_data['is_closed']) if len(path_data['points'] ) > 2: # ignore smaller curves that throw errors for k in range(len(path_data['points'])): pt = path_data['points'][str(k)] pt = rs.AddPoint(pt[0], pt[1], pt[2]) # re-create points pts.append(pt) all_points.extend(pts) path = rs.AddPolyline(pts) paths_nested_list[-1].append(path) else: print( 'No layers have been saved in the json file. Is this the correct json?' ) print('The slicer contains %d layers. ' % len(paths_nested_list)) paths_nested_list = list_to_ghtree(paths_nested_list) return mesh, paths_nested_list, are_closed, all_points
def data(self, data): self.frame = Frame.from_data(data['frame']) if '_tool_frame' in data: self.tool_frame = Frame.from_data(data['_tool_frame']) if '_source' in data: self._source = _deserialize_from_data(data['_source']) if '_mesh' in data: #self._mesh = _deserialize_from_data(data['_mesh']) self._mesh = Mesh.from_data(data['_mesh']) if 'trajectory' in data: from compas_fab.robots import JointTrajectory self.trajectory = [ JointTrajectory.from_data(d) for d in data['trajectory'] ] #self.trajectory = _deserialize_from_data(data['trajectory']) if 'path' in data: self.path = [Frame.from_data(d) for d in data['path']]
def modal(geom_file, num_modes, path): # add shell elements from mesh --------------------------------------------- with open(geom_file, 'rb') as fh: geom_data = json.load(fh) mesh = Mesh.from_data(geom_data['mesh']) s = structure.Structure() s.add_nodes_elements_from_mesh(mesh, element_type='ShellElement') # add displacements -------------------------------------------------------- pts = geom_data['pts'] nkeys = [] for pt in pts: nkeys.append(s.check_node_exists(pt)) s.add_set(name='support_nodes', type='NODE', selection=nkeys) supppots = FixedDisplacement(name='supports', nodes='support_nodes') s.add_displacement(supppots) # add materials and sections ----------------------------------------------- E35 = 35 * 10**9 concrete = ElasticIsotropic(name='MAT_CONCRETE', E=E35, v=0.2, p=2400) s.add_material(concrete) section = ShellSection(name='SEC_CONCRETE', t=0.020) s.add_section(section) prop = ElementProperties(type='SHELL', material='MAT_CONCRETE', section='SEC_CONCRETE', elsets=['ELSET_ALL']) s.add_element_properties(prop) # add modal step ----------------------------------------------------------- step = ModalStep(name='modal_analysis', displacements=['supports'], num_modes=num_modes) s.add_step(step) fnm = path + 'modal.inp' ansys.inp_generate(s, filename=fnm) # temp = path + '_Temp/' s.analyse(path=path, name='modal.inp', temp=None, software='ansys') return s
def data(self, data): p_name = data.get('name') or None p_id = data.get('id') or None p_geo = data.get('geo') or {} p_connections = data.get('connections') or [] p_active_connections = data.get('active_connections') or [] p_transformation = data.get('transformation') or [] p_parent = data.get('parent') or None p_children = data.get('children') or [] self.name = p_name self.id = p_id self.geo = Mesh.from_data(p_geo) self.connections = [Connection.from_data(c) for c in p_connections] self.active_connections = p_active_connections self.transformation = Transformation.from_matrix(p_transformation) center_coords = self.geo.centroid() self.center = Point(center_coords[0], center_coords[1], center_coords[2]) self.parent = p_parent self.children = p_children
from compas.datastructures import Mesh from compas_rhino.artists.meshartist import MeshArtist from compas_rhino.helpers import mesh_select_face if __name__ == '__main__': # get mesh from json mesh = Mesh.from_json('tessellation_mesh.json') # draw tessellation mesh artist = MeshArtist(mesh, layer='tessellation_mesh') artist.draw_edges() artist.draw_facelabels() artist.redraw() # select a face fkey = mesh_select_face(mesh, message='Select face.') artist.clear_facelabels() # find neighboring faces fkeys = list(mesh.face_neighbors(fkey)) + [fkey] for fkey in fkeys: # get voussoir meshes stored as face attribute data = mesh.get_face_attribute(fkey, 'voussoir') voussoir_mesh = Mesh.from_data(data) # draw neighboring voussoir mesh artist = MeshArtist(voussoir_mesh, layer='voussoir_meshes') artist.draw_faces(join_faces=True)
from compas.geometry import Frame from compas.geometry import Box from compas.datastructures import Mesh from compas.rpc import Proxy #construct the mesh box = Box(Frame.worldXY(), 500, 100, 100) box_mesh = Mesh.from_vertices_and_faces(box.vertices, box.faces) box_2 = Box(([250, 20, 20], [300, 0, 100], [0, 100, 0]), 100, 50, 80) box_mesh_2 = Mesh.from_vertices_and_faces(box_2.vertices, box_2.faces) #call function python_exe_path = 'C:\ProgramData\Anaconda3\envs\compas_assembly\python.exe' import sys python_exe_path = sys.executable # with Proxy('Trimesh_proxy',python=python_exe_path) as t: with Proxy('timber_grammar.Trimesh_proxy', python=python_exe_path) as t: result = Mesh.from_data(t.trimesh_subtract(box_mesh, box_mesh_2)['value']) print(result) # exporting file # import os # HERE = os.path.dirname(__file__) # DATA = os.path.abspath(os.path.join(HERE, '..', 'data')) # FILE_O = os.path.join(DATA, 'compas_boolean_test.json') # result.to_json('FILE_O', pretty=True)
import os #construct the mesh box = Box(Frame.worldXY(), 500, 100, 100) box_mesh = Mesh.from_vertices_and_faces(box.vertices, box.faces) box_2 = Box(([250, 20, 20], [300, 0, 100], [0, 100, 0]), 100, 50, 80) box_mesh_2 = Mesh.from_vertices_and_faces(box_2.vertices, box_2.faces) #call function python_exe_path = 'C:\ProgramData\Anaconda3\envs\compas_assembly\python.exe' import sys python_exe_path = sys.executable with Proxy(package='Trimesh_proxy', python=python_exe_path) as f: result = f.trimesh_subtract(box_mesh, box_mesh_2) result_mesh = Mesh.from_data(result['value']) # print (result_mesh) # import os # HERE = os.path.dirname(_file_) # DATA = os.path.abspath(os.path.join(HERE, '..', 'data')) # FILE_O = os.path.join(DATA, 'compas_boolean_test_2.json') # result.to_json(FILE_O, pretty=True) # mesh = Mesh.from_json(FILE_I) artist = MeshArtist(result_mesh, layer='Layer1') artist.draw_vertices() artist.draw_faces(join_faces=True)
def transform_mesh_proxy(data, T): mesh = Mesh.from_data(data) mesh = mesh_transformed_numpy(mesh, T) return mesh.to_data()
def data(self, data): self.visual = Mesh.from_data(data['visual']) self.frame = Frame.from_data(data['frame']) self.collision = Mesh.from_data( data['collision']) if 'collision' in data else None self.name = data['name'] if 'name' in data else 'attached_tool'
def data(self, data): self.filename = data['filename'] self.scale = data['scale'] self.geometry = Mesh.from_data( data['geometry']) if data['geometry'] else None
def data(self, data_obj): self.id = data_obj['id'] self.mesh = Mesh.from_data(data_obj['mesh']) self.frame = Frame.from_data(data_obj['frame']) self.root_name = data_obj['root_name']
import os import compas from compas.datastructures import Mesh from compas_rhino.artists import MeshArtist HERE = os.path.dirname(__file__) FILE_I = os.path.join(HERE, 'sessions', 'bm_vertical_equilibrium', 'bm_a_06_vertical.rv2') FILE_O = os.path.join(HERE, 'data', 'form.json') session = compas.json_load(FILE_I) form = Mesh.from_data(session['data']['form']) form.to_json(FILE_O) artist = MeshArtist(form, layer="RV2::Mesh") artist.clear_layer() artist.draw_faces(join_faces=True)
with open(settings_file, 'r') as f: data = json.load(f) # load Element element0 = Element.from_data(data['element0']) # picking frame picking_frame = Frame.from_data(data['picking_frame']) picking_configuration = Configuration.from_data(data['picking_configuration']) # little tolerance to not 'crash' into collision objects tolerance_vector = Vector.from_data(data['tolerance_vector']) safelevel_vector = Vector.from_data(data['safelevel_vector']) safelevel_picking_frame = picking_frame.copy() safelevel_picking_frame.point += safelevel_vector picking_frame.point += tolerance_vector # collision_meshes scene_collision_meshes = [ CollisionMesh(Mesh.from_data(m), name) for m, name in zip(data['collision_meshes'], data['collision_names']) ] # load assembly from file or from existing if calculation failed at one point... filepath = os.path.join(DATA, "assembly.json") if LOAD_FROM_EXISTING and os.path.isfile(PATH_TO): assembly = Assembly.from_json(PATH_TO) else: assembly = Assembly.from_json(filepath) # create an attached collision mesh to be attached to the robot's end effector. T = Transformation.from_frame_to_frame(element0._tool_frame, tool.frame) element0_tool0 = element0.transformed(T) attached_element_mesh = AttachedCollisionMesh(