def arch_from_rise_and_span(height, span, depth, thickness, n):
"""Create a semicircular arch from rise and span.
Parameters
----------
height : float
...
span : float
Dimension of the span in meter measured at the impost level (intrados-intrados).
depth : float
Depth in meter of the arch perpendicular to the front view plane.
thickness : float
Thickness in meter of the arch.
n: int
number of voussoirs.
Returns
-------
Assembly
Data structure of the semicircular arch.
"""
assembly = Assembly()
if height > span / 2:
raise Exception("Not a semicircular arch.")
radius = height / 2 + (span**2 / (8 * height))
base = [0.0, 0.0, 0.0]
top = [0.0, 0.0, height]
left = [-span / 2, 0.0, 0.0]
center = [0.0, 0.0, height - radius]
vector = subtract_vectors(left, center)
springing = angle_vectors(vector, [-1.0, 0.0, 0.0])
sector = radians(180) - 2 * springing
angle = sector / n
a = top
b = add_vectors(top, [0, depth, 0])
c = add_vectors(top, [0, depth, thickness])
d = add_vectors(top, [0, 0, thickness])
R = Rotation.from_axis_and_angle([0, 1.0, 0], 0.5 * sector, center)
bottom = transform_points([a, b, c, d], R)
blocks = []
for i in range(n):
R = Rotation.from_axis_and_angle([0, 1.0, 0], -angle, center)
top = transform_points(bottom, R)
vertices = bottom + top
faces = [[0, 1, 2, 3], [7, 6, 5, 4], [3, 7, 4, 0], [6, 2, 1, 5],
[7, 3, 2, 6], [5, 1, 0, 4]]
block = Block.from_vertices_and_faces(vertices, faces)
assembly.add_block(block)
bottom = top
assembly.node_attribute(0, 'is_support', True)
assembly.node_attribute(n - 1, 'is_support', True)
return assembly
# prepare proxy for RPC
proxy = Proxy('compas_assembly.datastructures')
# load meshes
FILE = os.path.join(os.path.dirname(__file__), 'armadillo.json')
meshes = compas.json_load(FILE)
# construct assembly
assembly = Assembly()
for mesh in meshes:
block = mesh.copy(cls=Block)
assembly.add_block(block)
# identify interfaces
assembly = proxy.assembly_interfaces_numpy(assembly, tmax=0.02, amin=0.0001)
# ==============================================================================
# Visualization
# ==============================================================================
artist = AssemblyArtist(assembly, layer="Armadillo")
artist.clear_layer()
artist.draw_nodes()
artist.draw_blocks()
artist.draw_edges()
assembly = Assembly()
# default block
box = Box.from_width_height_depth(W, H, D)
block = Block.from_vertices_and_faces(box.vertices, box.faces)
# make all blocks
# place each block on top of previous
# shift block randomly in XY plane
for i in range(N):
b = block.copy()
factor = choice([0.01, -0.01, 0.05, -0.05, 0.1, -0.1])
axis = choice([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]])
vector = scale_vector(axis, factor)
T = Translation([vector[0], vector[1], i * H])
mesh_transform(b, T)
assembly.add_block(b, is_support=(i == 0))
# identify_interfaces
assembly_interfaces_numpy(assembly)
# compute interface forces
compute_interface_forces_cvx(assembly, solver='CPLEX', verbose=True)
# make all blocks
# place each block on top of previous
# shift block randomly in XY plane
for i in range(N):
block = brick.copy()
factor = choice([+0.01, -0.01, +0.05, -0.05, +0.1, -0.1])
axis = choice([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]])
vector = add_vectors(scale_vector(axis, factor), [0.0, 0.0, i * H])
mesh_transform(block, Translation(vector))
if i == 0:
assembly.add_block(block, is_support=True)
else:
assembly.add_block(block)
# export to json
assembly.to_json(compas_assembly.get('stack.json'))
# visualise
R = Rotation.from_axis_and_angle([1.0, 0, 0], -pi / 2)
assembly_transform(assembly, R)
plotter = AssemblyPlotter(assembly, tight=True)
plotter.draw_vertices(
assembly = Assembly()
b1 = Block.from_polyhedron(6)
b2 = Block.from_polyhedron(6)
u, v = list(b1.edges())[0]
l = b1.edge_length(u, v)
T1 = Translation([0, 0, -0.5 * l])
T2 = Translation([0, 0, +0.5 * l])
mesh_transform(b1, T1)
mesh_transform(b2, T2)
assembly.add_block(b1, is_support=True)
assembly.add_block(b2)
# identify block interfaces and update block_model
assembly_interfaces(
assembly,
nmax=10,
tmax=0.05,
amin=0.01,
lmin=0.01,
)
# equilibrium
compute_interface_forces_cvx(assembly, solver='CPLEX', verbose=True)
from compas_assembly.datastructures import Block
from compas_rhino.utilities import get_meshes
# get support meshes and block meshes from Rhino
rhino_supports = get_meshes("Supports")
rhino_blocks = get_meshes("Blocks")
# create and weld compas meshes
supports = []
for i in rhino_supports:
support = Block.from_rhinomesh(i)
support = mesh_weld(support)
supports.append(support)
blocks = []
for i in rhino_blocks:
block = Block.from_rhinomesh(i)
block = mesh_weld(block)
blocks.append(block)
# create an assembly
assembly = Assembly()
for i in supports:
assembly.add_block(i, is_support=True)
for i in blocks:
assembly.add_block(i, is_support=False)
# export the assembly in a .json file
assembly.to_json('assembly_taubman.json')
Object.register(Block, MeshObject)
Object.register(Assembly, NetworkObject)
# proxy = Proxy('compas_assembly.datastructures')
# proxy.restart_server()
b1 = Block.from_shape(Box.from_width_height_depth(1, 1, 1))
T = Translation.from_vector([0, 0, 1])
R = Rotation.from_axis_and_angle([0, 0, 1], radians(45))
b2 = b1.transformed(T * R)
assembly = Assembly()
assembly.add_block(b1)
assembly.add_block(b2)
# arch = Arch(rise=5, span=10, thickness=0.7, depth=0.5, n=40)
# assembly = Assembly.from_geometry(arch)
assembly_interfaces_numpy(assembly)
# # artist = AssemblyArtist(assembly, layer='Assembly')
# # artist.clear_layer()
# # artist.draw_nodes()
# # artist.draw_edges()
# # artist.draw_blocks(show_faces=False)
# # artist.draw_interfaces()