def transfer_to_assembly(self):
from assembly_information_model.assembly import Element, Assembly
assembly = Assembly()
for my_layer in self.timberboards:
for my_board in my_layer:
# box_update only precaution
my_board.box_update()
assembly_board = Element.from_box(my_board.box)
assembly.add_element(assembly_board)
return assembly
def transfer_to_assembly():
from assembly_information_model.assembly import Element, Assembly
assembly = Assembly()
assembly.__init_subclass__()
assembly.something = 5
for my_layer in self.timberboards:
for my_board in my_layer:
# box_update only precaution
my_board.box_update()
assembly_board = Element.from_box(my_board.box)
assembly_board.something = 5
assembly.add_element(assembly_board, somethinsdg=12)
return assembly
primary_falloff = 100.0
primary_dedensification = 1
secondary_interval = 24.0
secondary_interval_development = 1.0
skip_centrals = True
primary_direction = 0
secondary_direction = 1
origin_point = Point(0, 0, 0)
origin_vector_primary = Vector(0, 1, 0)
origin_vector_secondary = Vector(1, 0, 0)
origin_frame = Frame(origin_point, origin_vector_primary,
origin_vector_secondary)
Slabassembly = Assembly()
Slabassembly.layer_no = layer_no
Slabassembly.gap_min = gap_min
Slabassembly.primary_length = primary_length
Slabassembly.secondary_length = secondary_length
Slabassembly.omnidirectional = omnidirectional
Slabassembly.primary_board_width_outside = primary_board_width_outside
Slabassembly.primary_board_height_outside = primary_board_height_outside
Slabassembly.primary_board_width_inside = primary_board_width_inside
Slabassembly.primary_board_height_inside = primary_board_height_inside
Slabassembly.primary_board_outside_dimensions = [
Slabassembly.primary_board_width_outside,
Slabassembly.primary_board_height_outside, Slabassembly.primary_length
]
Slabassembly.primary_board_inside_dimensions = [
Slabassembly.primary_board_width_inside,
# create Element
element0 = Element.from_data(data['element0'])
# picking frame
picking_frame = Frame.from_data(data['picking_frame'])
# little tolerance to not 'crash' into collision objects
tolerance_vector = Vector.from_data(data['tolerance_vector'])
safelevel_vector = Vector.from_data(data['safelevel_vector'])
# define target frame
target_frame = Frame((0.325, 0.400, 0.006), (0.000, 1.000, 0.000),
(-1.000, 0.000, 0.000))
target_frame.point += tolerance_vector
# create Assembly with element at target_frame
assembly = Assembly()
T = Transformation.from_frame_to_frame(element0.frame, target_frame)
assembly.add_element(element0.transformed(T))
# Bring the element's mesh into the robot's tool0 frame
element_tool0 = element0.copy()
T = Transformation.from_frame_to_frame(element_tool0._tool_frame, tool.frame)
element_tool0.transform(T)
# define picking_configuration
picking_configuration = Configuration.from_data(data['picking_configuration'])
# define picking frame
picking_frame = Frame.from_data(data['picking_frame'])
picking_frame.point += tolerance_vector
HERE = os.path.dirname(__file__) DATA = os.path.abspath(os.path.join(HERE, "..", "data")) PATH_FROM = os.path.join(DATA, 'stretcher_bond.json') ASSEMBLY_PATH = os.path.abspath(os.path.join(HERE, "..", "src")) sys.path.append(ASSEMBLY_PATH) #PATH_TO = os.path.join(DATA, os.path.splitext(os.path.basename(__file__))[0] + ".json") PATH_TO = os.path.join(DATA, 'stretcher_bond_interfaces.json') print(PATH_TO) from assembly_information_model.assembly import Assembly from assembly_information_model.assembly.interfaces_numpy import assembly_interfaces_numpy # parameters NMAX = 100 AMIN = 0.0001 # load assembly from JSON assembly = Assembly.from_json(PATH_FROM) # identify the interfaces assembly_interfaces_numpy(assembly, nmax=100, amin=0.0001) # serialise assembly.to_json(PATH_TO) print(list(assembly.network.edges()))
print(r'| \ \__/|__)\__/ | \__\__/| \| | | \ \__/|__ ')
print()
username = input_non_empty_string('Please enter your name: ')
filename = input_non_empty_string(
'Please enter the assembly file name [{}]: '.format(DEFAULT_FILENAME),
DEFAULT_FILENAME)
filepath = os.path.join(DATA, filename)
if not os.path.isfile(filepath):
raise FileNotFoundError('Could not file assembly json file: ' +
filepath)
# Load assembly
print('\n[ ] Loading assembly...', end='\r')
assembly = Assembly.from_json(filepath)
print('[OK] Assembly loaded: {} '.format(filename))
planned_elemement_keys = get_planned_element_keys(assembly)
print('[OK] Found {} planned elements out of {} total elements'.format(
len(planned_elemement_keys), assembly.number_of_elements()))
print('[OK] Planned sequence: {}'.format(planned_elemement_keys))
# Connect client
print('[ ] Connecting to ROS {}:{}'.format(args.ros_host,
int(args.ros_port)),
end='\r')
with RosClient(host=args.ros_host, port=int(args.ros_port)) as client:
print('[OK] Connected to ROS: \n')
# Start UI loop to send elements
DATA = os.path.abspath(os.path.join(HERE, "..", "data")) PATH_FROM = os.path.join(DATA, 'stretcher_bond.json') ASSEMBLY_PATH = os.path.abspath(os.path.join(HERE, "..", "src")) sys.path.append(ASSEMBLY_PATH) #PATH_TO = os.path.join(DATA, os.path.splitext(os.path.basename(__file__))[0] + ".json") #print(PATH_TO) PATH_TO = os.path.join(DATA, 'stretcher_bond_interfaces.json') from assembly_information_model.assembly import Assembly from assembly_information_model.assembly.interfaces_numpy import assembly_interfaces_numpy_fromtojson # parameters NMAX = 100 AMIN = 0.0001 # load assembly from JSON # assembly = Assembly.from_json(PATH_FROM) # identify the interfaces assembly_interfaces_numpy_fromtojson(PATH_FROM, PATH_TO, nmax=100, amin=0.0001) # serialise # assembly.to_json(PATH_TO) assembly = Assembly.from_json(PATH_TO) print(list(assembly.network.edges()))
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(
CollisionMesh(element0_tool0.mesh, 'element'), 'ee_link')
# ==============================================================================
# From here on: fill in code, whereever you see this dots ...
# NOTE: If you run Docker Toolbox, change `localhost` to `192.168.99.100`
with RosClient('localhost') as client:
brick = Element.from_dimensions(length, width, height)
halfbrick = Element.from_dimensions(length / 2, width, height)
COURSES = 25
BRICKS_PER_COURSE = 4
MORTAR_PERPENDS = 0.025
total_length = BRICKS_PER_COURSE * length + (BRICKS_PER_COURSE -
1) * MORTAR_PERPENDS
gap_even = MORTAR_PERPENDS
gap_uneven = MORTAR_PERPENDS
gap_uneven = (total_length - (BRICKS_PER_COURSE *
(length))) / BRICKS_PER_COURSE
assembly = Assembly() # initialize an empty assembly class
for row in range(COURSES):
dy = row * height
half_brick_ends = row % 2 != 0
gap = gap_even if row % 2 == 0 else gap_uneven
dx = 0
bricks_in_course = BRICKS_PER_COURSE + (1 if half_brick_ends else 0)
for j in range(bricks_in_course):
first = j == 0
last = j == bricks_in_course - 1
is_half_brick = (first or last) and half_brick_ends
from assembly_information_model.assembly import Assembly
from assembly_information_model.assembly import Element
HERE = os.path.dirname(__file__)
DATA = os.path.abspath(os.path.join(HERE, "..", "data"))
# load settings (shared by GH)
settings_file = os.path.join(DATA, "settings.json")
with open(settings_file, 'r') as f:
data = json.load(f)
# create Element and move it to picking frame
element0 = Element.from_data(data['element0'])
# initialize an empty assembly class
assembly = Assembly()
cf = Frame(Point(0.4, 0.4, 0.), Vector(1., 0., 0.), Vector(0., 1., 0.))
for i in range(25): # loop through the number of layers i
axis = cf.zaxis
angle = math.radians(i * 3)
# Calculates a ``Rotation`` from a rotation axis and an angle and an optional point of rotation.
R = Rotation.from_axis_and_angle(axis, angle, point=cf.point)
T = Translation.from_vector([0, 0, 0.005 * i])
cft = cf.transformed(R * T) # transforms the origin plane
if i % 2 == 0:
