def assemble(list_conns):
bricks_ = bricks.Bricks(10000, '0')
z = 0
dir_cur = 0
brick_ = brick.Brick()
brick_.set_position([0, 0, z])
brick_.set_direction(dir_cur)
bricks_.add(brick_)
for conn in list_conns:
z += 1
print(list_rules[conn])
dir_cur = (dir_cur + list_rules[conn][1][0]) % 2
brick_ = brick.Brick()
brick_.set_position(list_rules[conn][1][1] + [z])
brick_.set_direction(dir_cur)
bricks_.add(brick_)
return bricks_
def align_bricks(bricks_):
list_bricks = bricks_.get_bricks()
list_positions = []
for brick_ in list_bricks:
list_positions.append(brick_.get_position())
positions = np.array(list_positions)
trans = np.array([
np.min(positions[:, 0]),
np.min(positions[:, 1]),
np.min(positions[:, 2]),
])
list_bricks_new = []
for brick_ in list_bricks:
position_new = copy.deepcopy(brick_.get_position())
direction_new = copy.deepcopy(brick_.get_direction())
position_new -= trans
brick_new = brick.Brick()
brick_new.set_position(position_new)
brick_new.set_direction(direction_new)
list_bricks_new.append(brick_new)
bricks_aligned = bricks.Bricks(bricks_.get_length())
bricks_aligned.bricks = list_bricks_new
bricks_aligned.validate_all()
return bricks_aligned
def test_set_configuration():
brick_ = brick.Brick()
assert brick_.get_position() == None
pos = [5, -2, 3]
direc = 1
config = {
'position': pos,
'direction': direc
}
brick_.set_configuration(config)
assert np.all(brick_.get_position() == np.array(pos))
vertices = np.array([
[7.0, -1.0, 3.0],
[7.0, -3.0, 3.0],
[3.0, -1.0, 3.0],
[3.0, -3.0, 3.0],
[7.0, -1.0, 4.0],
[7.0, -3.0, 4.0],
[3.0, -1.0, 4.0],
[3.0, -3.0, 4.0],
])
print(brick_.get_vertices())
assert np.all(brick_.get_vertices() == vertices)
def get_possible_contacts(self, str_type=None):
list_bricks = self.get_bricks()
new_bricks = []
for brick_ in list_bricks:
cur_type = get_cur_type(copy.deepcopy(brick_))
if self.str_type == 'mixed' and str_type is None:
ind_rules = np.random.choice(len(rules.ALL_TYPES))
str_type = rules.ALL_TYPES[ind_rules]
rules_, _, size_upper, size_lower = get_rules(cur_type, str_type)
elif self.str_type == 'mixed' and str_type is not None:
rules_, _, size_upper, size_lower = get_rules(cur_type, str_type)
else:
rules_, _, size_upper, size_lower = get_rules(cur_type, self.str_type)
cur_position = brick_.get_position()
cur_direction = brick_.get_direction()
for rule in rules_:
translations = rule['translations']
direction = rule['direction']
for trans in translations:
# upper
new_brick = brick.Brick(size_upper=size_upper, size_lower=size_lower)
new_brick.set_position(cur_position + np.concatenate((np.array(trans), [new_brick.height])))
new_brick.set_direction((cur_direction + direction) % 2)
if new_brick.get_position()[2] >= 0:
new_bricks.append(new_brick)
# lower
new_brick = brick.Brick(size_upper=size_upper, size_lower=size_lower)
new_brick.set_position(cur_position + np.concatenate((np.array(trans), [-1 * new_brick.height])))
new_brick.set_direction((cur_direction + direction) % 2)
if new_brick.get_position()[2] >= 0:
new_bricks.append(new_brick)
new_bricks = self._validate_bricks(new_bricks)
return new_bricks
def test_create_brick():
brick_ = brick.Brick()
assert brick_.get_position() == None
assert brick_.get_direction() == 0
assert brick_.get_vertices() == None
size_upper, size_lower, height = brick_.get_size()
assert np.all(size_upper == [2, 4])
assert np.all(size_lower == [2, 4])
assert height == 1
def _sample_one(self, str_type=None):
list_bricks = self.get_bricks()
ind_brick = np.random.choice(self.get_length())
brick_sampled = list_bricks[ind_brick]
cur_type = get_cur_type(copy.deepcopy(brick_sampled))
cur_position = brick_sampled.get_position()
cur_direction = brick_sampled.get_direction()
if self.str_type == 'mixed' and str_type is None:
ind_rules = np.random.choice(len(rules.ALL_TYPES))
str_type = rules.ALL_TYPES[ind_rules]
rules_, probs_rules_, size_upper, size_lower = get_rules(cur_type, str_type)
elif self.str_type == 'mixed' and str_type is not None:
rules_, probs_rules_, size_upper, size_lower = get_rules(cur_type, str_type)
else:
rules_, probs_rules_, size_upper, size_lower = get_rules(cur_type, self.str_type)
ind_rule = np.random.choice(len(rules_), p=probs_rules_)
cur_rule = rules_[ind_rule]
translations = copy.deepcopy(cur_rule['translations'])
direction = copy.deepcopy(cur_rule['direction'])
ind_trans = np.random.choice(len(translations))
trans = translations[ind_trans]
if cur_direction == 1:
angle = np.pi * 3.0 / 2.0
trans = np.dot(np.array([
[np.cos(angle), -np.sin(angle)],
[np.sin(angle), np.cos(angle)],
]), trans)
upper_lower = np.random.choice(2) * 2.0 - 1.0
new_brick = brick.Brick(size_upper=size_upper, size_lower=size_lower)
new_brick.set_position(cur_position + np.concatenate((np.array(trans), [new_brick.height * upper_lower])))
new_brick.set_direction((cur_direction + direction) % 2)
new_brick = self._validate_bricks([new_brick])
if len(new_brick) == 0:
return None
else:
return new_brick[0]
def convert_to_bricks(X, A):
list_bricks = []
for bx, ba in zip(X, A):
brick_ = brick.Brick()
brick_.set_position(bx[:3])
brick_.set_direction(bx[3])
list_bricks.append(brick_)
bricks_ = Bricks(len(list_bricks))
bricks_.bricks = list_bricks
try:
bricks_.validate_all()
except:
bricks_ = None
return bricks_
def align_bricks_to_origin(bricks_):
list_bricks = bricks_.get_bricks()
list_positions = []
for brick_ in list_bricks:
list_positions.append(brick_.get_position())
positions = np.array(list_positions)
bottoms = np.where(positions[:, 2] == np.min(positions[:, 2]))[0]
ind_origin = np.random.choice(bottoms, 1)
ind_origin = ind_origin[0]
brick_origin = copy.deepcopy(list_bricks[ind_origin])
list_bricks_new = []
for brick_ in list_bricks:
position_new = copy.deepcopy(brick_.get_position())
direction_new = copy.deepcopy(brick_.get_direction())
position_new -= brick_origin.get_position()
if brick_origin.get_direction() == 1:
angle_rotated = np.pi * 1.0 / 2.0
position_new_ = copy.deepcopy(position_new)
position_new_.astype(np.float)
position_new.astype(np.float)
position_new[0] = np.round(np.cos(angle_rotated) * position_new_[0]) - np.round(np.sin(angle_rotated) * position_new_[1])
position_new[1] = np.round(np.sin(angle_rotated) * position_new_[0]) + np.round(np.cos(angle_rotated) * position_new_[1])
position_new = np.round(position_new)
direction_new = (direction_new + brick_origin.get_direction()) % 2
brick_new = brick.Brick()
brick_new.set_position(position_new)
brick_new.set_direction(direction_new)
list_bricks_new.append(brick_new)
bricks_aligned = bricks.Bricks(bricks_.get_length())
bricks_aligned.bricks = list_bricks_new
bricks_aligned.validate_all()
return bricks_aligned
def test_set_position():
brick_ = brick.Brick()
assert brick_.get_position() == None
pos = [1, 2, 1]
brick_.set_position(pos)
assert np.all(brick_.get_position() == np.array(pos))
vertices = np.array([
[2.0, 4.0, 1.0],
[2.0, 0.0, 1.0],
[0.0, 4.0, 1.0],
[0.0, 0.0, 1.0],
[2.0, 4.0, 2.0],
[2.0, 0.0, 2.0],
[0.0, 4.0, 2.0],
[0.0, 0.0, 2.0],
])
print(brick_.get_vertices())
assert np.all(brick_.get_vertices() == vertices)
def test_set_direction():
brick_ = brick.Brick()
assert brick_.get_position() == None
pos = [1, 2, 1]
brick_.set_position(pos)
brick_.set_direction(1)
assert np.all(brick_.get_position() == np.array(pos))
vertices = np.array([
[3.0, 3.0, 1.0],
[3.0, 1.0, 1.0],
[-1.0, 3.0, 1.0],
[-1.0, 1.0, 1.0],
[3.0, 3.0, 2.0],
[3.0, 1.0, 2.0],
[-1.0, 3.0, 2.0],
[-1.0, 1.0, 2.0],
])
print(brick_.get_vertices())
assert np.all(brick_.get_vertices() == vertices)
import time
import copy
from geometric_primitives import brick
from geometric_primitives import bricks
from geometric_primitives import rules
from geometric_primitives import utils_io
from geometric_primitives import utils_meshes
size_brick = [2, 4]
brick_ = brick.Brick(size_upper=size_brick, size_lower=size_brick)
brick_.set_position([0, 0, 0])
brick_.set_direction(0)
bricks_ = bricks.Bricks(100, 'mixed')
bricks_.add(brick_)
list_bricks = bricks_.get_possible_contacts(str_type='2')
for elem in list_bricks:
bricks_copied = copy.deepcopy(bricks_)
bricks_copied.add(elem)
mesh_bricks, mesh_cubes = utils_meshes.get_mesh_bricks(bricks_copied)
utils_io.visualize(mesh_bricks)
import time
import copy
from geometric_primitives import brick
from geometric_primitives import bricks
from geometric_primitives import rules
from geometric_primitives import utils_io
from geometric_primitives import utils_meshes
brick_ = brick.Brick()
brick_.set_position([0, 0, 0])
brick_.set_direction(0)
bricks_ = bricks.Bricks(100, 'mixed')
bricks_.add(brick_)
for ind in range(0, 30):
brick_ = bricks_.sample()[0]
bricks_.add(brick_)
print(brick_.get_position(), brick_.get_direction())
mesh_bricks, mesh_cubes = utils_meshes.get_mesh_bricks(bricks_)
utils_io.visualize(mesh_bricks)
import time
import copy
from geometric_primitives import brick
from geometric_primitives import bricks
from geometric_primitives import rules
from geometric_primitives import utils_io
from geometric_primitives import utils_meshes
brick_ = brick.Brick(size_upper=[2, 2], size_lower=[2, 2])
brick_.set_position([0, 0, 0])
brick_.set_direction(0)
bricks_ = bricks.Bricks(100, '1')
bricks_.add(brick_)
for ind in range(0, 10):
brick_ = bricks_.sample()[0]
bricks_.add(brick_)
print(brick_.get_position(), brick_.get_direction())
mesh_bricks, mesh_cubes = utils_meshes.get_mesh_bricks(bricks_)
utils_io.visualize(mesh_bricks)
