def ddd_problem():
problem = GeometricProblem(dimension=2)
problem.add_point('v1', vector([random.random() for i in [1,2]]))
problem.add_point('v2', vector([random.random() for i in [1,2]]))
problem.add_point('v3', vector([random.random() for i in [1,2]]))
problem.add_constraint(DistanceConstraint('v1','v2',distance_2p(problem.get_point('v1'), problem.get_point('v2'))))
problem.add_constraint(DistanceConstraint('v1','v3',distance_2p(problem.get_point('v1'), problem.get_point('v3'))))
problem.add_constraint(DistanceConstraint('v2','v3',distance_2p(problem.get_point('v2'), problem.get_point('v3'))))
return problem
def balloon_problem():
"""test angle propagation via balloon"""
problem = GeometricProblem(dimension=2)
problem.add_point('A', vector([0.0, 0.0]))
problem.add_point('B', vector([1.0, -1.0]))
problem.add_point('C', vector([1.0, +1.0]))
problem.add_point('D', vector([2.0, 0.0]))
problem.add_constraint(
AngleConstraint(
'B', 'A', 'C',
angle_3p(problem.get_point('B'), problem.get_point('A'),
problem.get_point('C'))))
problem.add_constraint(
AngleConstraint(
'A', 'B', 'C',
angle_3p(problem.get_point('A'), problem.get_point('B'),
problem.get_point('C'))))
problem.add_constraint(
AngleConstraint(
'B', 'C', 'D',
angle_3p(problem.get_point('B'), problem.get_point('C'),
problem.get_point('D'))))
problem.add_constraint(
AngleConstraint(
'C', 'D', 'B',
angle_3p(problem.get_point('C'), problem.get_point('D'),
problem.get_point('B'))))
problem.add_constraint(DistanceConstraint('A', 'D', 6.0))
return problem
def ada_3d_problem():
problem = GeometricProblem(dimension=3)
problem.add_point('v1', vector([random.random() for i in [1,2]]))
problem.add_point('v2', vector([random.random() for i in [1,2]]))
problem.add_point('v3', vector([random.random() for i in [1,2]]))
problem.add_constraint(DistanceConstraint('v1','v2',distance_2p(problem.get_point('v1'), problem.get_point('v2'))))
problem.add_constraint(AngleConstraint('v3', 'v1', 'v2',
angle_3p(problem.get_point('v3'), problem.get_point('v1'), problem.get_point('v2'))
))
problem.add_constraint(AngleConstraint('v1', 'v2', 'v3',
angle_3p(problem.get_point('v1'), problem.get_point('v2'), problem.get_point('v3'))
))
return problem
def random_distance_problem_3D(npoints, radius, roundoff):
"""creates a 3D problem with random distances"""
problem = GeometricProblem(dimension=3)
for i in range(npoints):
# add point
newvar = 'v' + str(i)
newpoint = vector([
_round(random.uniform(-radius, radius), roundoff),
_round(random.uniform(-radius, radius), roundoff),
_round(random.uniform(-radius, radius), roundoff)
])
sellist = list(problem.cg.variables())
problem.add_point(newvar, newpoint)
# add distance constraints
for j in range(min(3, len(sellist))):
index = random.randint(0, len(sellist) - 1)
var = sellist.pop(index)
point = problem.get_point(var)
dist = distance_2p(point, newpoint)
problem.add_constraint(DistanceConstraint(var, newvar, dist))
return problem
class Solver(object):
def __init__(self, joints, fixed, layers):
self.joints = joints
self.layers = layers
self.fixed = fixed
self.problem = GeometricProblem(dimension=3)
def solve(self):
joints = self.joints
layers = self.layers
# print(joints)
# print(layers)
self.solve_shape(layers)
self.solve_fixed(self.fixed, layers)
self.solve_joints(joints, layers)
self.test(self.problem)
def solve_shape(self, layers):
for layer in layers:
print("Solving shape ", layer.id)
pt0 = layer.named_pairs[0][0]
pt1 = layer.named_pairs[1][0]
pt2 = layer.named_pairs[2][0]
for i, point in enumerate(layer.named_pairs):
# Add initial points
self.problem.add_variable(point[0],
vector([point[1], point[2], 0]))
# Lock them together
if i > 0:
self.problem.add_constraint(
DistanceConstraint(
pt0, point[0],
distance_2p(self.problem.get_point(pt0),
self.problem.get_point(point[0]))))
if i > 1:
self.problem.add_constraint(
AngleConstraint(
pt0, pt1, point[0],
angle_3p(self.problem.get_point(pt0),
self.problem.get_point(pt1),
self.problem.get_point(point[0]))))
if i > 2:
self.problem.add_constraint(
AngleConstraint(
pt0, pt2, point[0],
angle_3p(self.problem.get_point(pt0),
self.problem.get_point(pt2),
self.problem.get_point(point[0]))))
def solve_fixed(self, fixed, layers):
for i, layer in enumerate(layers):
print("Solving fixed ", layer.id)
i = 0
for point in layer.named_pairs:
if point[0] in fixed:
self.problem.add_constraint(
FixConstraint(point[0], vector([point[1], point[2],
0])))
i += 1
# layers[i].volume = self.solve_layer(layer)
def solve_joints(self, joints, layers):
print("joints ", joints)
for jointid in joints:
joint = joints[jointid]
i = 1
while i < len(joint):
print("Solving joint ", joint[0], joint[i])
self.problem.add_constraint(
CoincidenceConstraint(joint[0], joint[i]))
i += 1
return layers
def test(self, problem):
"""Test solver on a given problem"""
#diag_select(".*")
print("problem:")
print(problem)
print("Solving...")
solver = GeometricSolver(problem)
print("...done")
print("drplan:")
print(solver.dr)
print("top-level rigids:", list(solver.dr.top_level()))
result = solver.get_result()
print("result:")
print(result)
print("result is", result.flag, "with", len(result.solutions),
"solutions")
check = True
if len(result.solutions) == 0:
check = False
diag_select("(GeometricProblem.verify)|(satisfied)")
for sol in result.solutions:
print("solution:", sol)
check = check and problem.verify(sol)
if check:
print("all solutions valid")
else:
print("INVALID")
def solve_layer(self, layer):
origin = self.find_origin(layer)
translate_x = layer.translate.x
translate_y = layer.translate.y
translate_z = layer.translate.z
solved = []
for i, point in enumerate(layer.straight_pairs):
x = (point[0] - origin[0]) # + translate_x
y = (point[1] - origin[1]) # + translate_y
z = 0 #translate_z
print("point: ", point, x, y)
# solved.append(self.point_transform(x, y, z, 0))
return solved
def point_transform(self, x, y, z, axis):
#Transform from rotation axis
base = Vector(0, 1, 0)
pnt = Vector(x, y, z)
# an = base.angle(pnt)
# print('a - ', base)
# print('b - ', pnt)
# print('c - ', an)
return pnt
def find_origin(self, layer):
#Bounding box to find path origin and translate to global origin
# xmin, xmax, ymin, ymax = paths2svg.big_bounding_box(path)
# origin = [(xmax + xmin) / 2, (ymax + ymin) / 2]
# return origin
max_x = 0
max_y = 0
min_x = 0
min_y = 0
first_run = True
for point in layer.straight_pairs:
if first_run == True:
max_x = point[0]
max_y = point[1]
min_x = point[0]
min_y = point[1]
first_run = False
else:
if point[0] > max_x:
max_x = point[0]
elif point[0] < min_x:
min_x = point[0]
if point[1] > max_y:
max_y = point[1]
elif point[1] < min_y:
min_y = point[1]
# print(point)
return [(max_x + min_x) / 2, (max_y + min_y) / 2]
def balloon_problem():
"""test angle propagation via balloon"""
problem = GeometricProblem(dimension=2)
problem.add_point('A', vector([0.0, 0.0]))
problem.add_point('B', vector([1.0, -1.0]))
problem.add_point('C', vector([1.0, +1.0]))
problem.add_point('D', vector([2.0, 0.0]))
problem.add_constraint(AngleConstraint('B','A','C',
angle_3p(problem.get_point('B'), problem.get_point('A'), problem.get_point('C'))
))
problem.add_constraint(AngleConstraint('A','B','C',
angle_3p(problem.get_point('A'), problem.get_point('B'), problem.get_point('C'))
))
problem.add_constraint(AngleConstraint('B','C','D',
angle_3p(problem.get_point('B'), problem.get_point('C'), problem.get_point('D'))
))
problem.add_constraint(AngleConstraint('C','D','B',
angle_3p(problem.get_point('C'), problem.get_point('D'), problem.get_point('B'))
))
problem.add_constraint(DistanceConstraint('A', 'D', 6.0))
return problem
