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(
