def test_Rectangle_bounding_box():
rectangle = geometry.Rectangle(geometry.Point(10, 10), 20, 20, geometry.RotationDegrees(0))
bounding_box = rectangle.bounding_box
assert (bounding_box.upper_left.x, bounding_box.upper_left.y) == (0, 20)
assert (bounding_box.lower_left.x, bounding_box.lower_left.y) == (0, 0)
assert (bounding_box.lower_right.x, bounding_box.lower_right.y) == (20, 0)
assert (bounding_box.upper_right.x, bounding_box.upper_right.y) == (20, 20)
def test_rectangle(self):
r1 = geometry.Rectangle(3, 2)
self.assertEqual(6, r1.area)
r1.scale(2)
self.assertEqual(6, r1._length)
geometry.Rectangle.scale(r1, 0.5)
self.assertEqual(3, r1._length)
r1._length += 2
def main():
r = geometry.Rectangle(Point(10, 10), 100, 200)
# U listu dodajemo pocetni pravougaonik.
rects = [r]
# Generisemo jos nasumicnih 10.
for i in range(10):
# pseudoslucajno odabrani brojevi iz intervala [0, 30)
x = random.randrange(30)
y = random.randrange(30)
w = random.randrange(30)
h = random.randrange(30)
rects.append(geometry.Rectangle(Point(x, y), w, h))
for rect in rects:
print(rect)
def main(args):
"""
Generates a file containing the coordinates of a body.
Parameters
----------
args: namespace
Arguments parsed from the command-line.
"""
if args.body_type == 'file':
body = geometry.Geometry(file_path=args.file_path)
elif args.body_type == 'circle':
body = geometry.Circle(radius=args.circle[0],
center=geometry.Point(args.circle[1],
args.circle[2]),
n=args.n, ds=args.ds)
elif args.body_type == 'line':
body = geometry.Line(length=args.line[0],
start=geometry.Point(args.line[1], args.line[2]),
n=args.n, ds=args.ds)
elif args.body_type == 'rectangle':
body = geometry.Rectangle(bottom_left=geometry.Point(args.rectangle[0],
args.rectangle[1]),
top_right=geometry.Point(args.rectangle[2],
args.rectangle[3]),
nx=args.n,
ny=args.n,
ds=args.ds)
elif args.body_type == 'sphere':
body = geometry.Sphere(radius=args.sphere[0],
center=geometry.Point(args.sphere[1],
args.sphere[2],
args.sphere[3]),
n=args.n,
ds=args.ds)
body.scale(ratio=args.scale)
body.rotation(center=args.rotation,
roll=args.roll,
yaw=args.yaw,
pitch=args.pitch,
mode=args.mode)
body.translation(displacement=args.translation)
if body.dimensions == 2 and args.body_type == 'file':
body.discretization(n=args.n,
ds=args.ds)
if body.dimensions == 2 and args.extrusion:
body = body.extrusion(limits=args.extrusion,
n=args.n,
ds=args.ds,
force=args.force)
if args.save:
output_path = os.path.join(args.save_directory,
args.save_name + '.' + args.extension)
body.write(file_path=output_path)
if args.show:
body.plot()
def make_rectangle(self, edges):
all_y = set()
all_x = set()
for e in edges:
all_y.add(e.y0)
all_y.add(e.y1)
all_x.add(e.x0)
all_x.add(e.x1)
ys = sorted(list(all_y))
xs = sorted(list(all_x))
return geometry.Rectangle(ys[0], xs[0], ys[1], xs[1])
def make_rectangle_for_tab(self, main, adjacent, opposite):
one_len = adjacent[0].length
two_len = adjacent[1].length
length = min(one_len, two_len)
length = int(math.ceil(float(length) / 8) * 8)
dist = main.distance_from(opposite)
if length > dist:
length = dist
if main.facing == DIR_DOWN:
return geometry.Rectangle(main.y0, main.x0, main.y0 + length,
main.x1)
if main.facing == DIR_LEFT:
return geometry.Rectangle(main.y0, main.x0 - length, main.y1,
main.x0)
if main.facing == DIR_UP:
return geometry.Rectangle(main.y0 - length, main.x0, main.y0,
main.x1)
if main.facing == DIR_RIGHT:
return geometry.Rectangle(main.y0, main.x0, main.y1,
main.x0 + length)
def test_Rectangle():
rectangle = geometry.Rectangle(geometry.Point(10, 10), 20, 20, geometry.RotationDegrees(0))
print rectangle
print 'ul %r' % rectangle.upper_left
print 'lr %r' % rectangle.lower_right
print 'll %r' % rectangle.lower_left
print 'ur %r' % rectangle.upper_right
assert (rectangle.upper_left.x, rectangle.upper_left.y) == (0, 20)
assert (rectangle.lower_left.x, rectangle.lower_left.y) == (0, 0)
assert (rectangle.lower_right.x, rectangle.lower_right.y) == (20, 0)
assert (rectangle.upper_right.x, rectangle.upper_right.y) == (20, 20)
def main():
a = geometry.Rectangle(Point(0, 0), 10, 20)
b = geometry.Circle(Point(1, 1), 30)
c = geometry.Square(Point(3, 3), 40)
print(a)
print(b)
print(c)
shapes = [a, b, c]
for shape in shapes:
# Kako sistemski dobiti ime klase kojoj pripada objekat?
print("%s P=%g O=%g" %
(type(shape).__name__, shape.get_area(), shape.get_circum()))
def test_Rectangle_fifteen():
rectangle = geometry.Rectangle(geometry.Point(10, 10), 20, 20, geometry.RotationDegrees(15))
assert rectangle.center.x == 10
assert rectangle.center.y == 10
print 'rect %r' % rectangle
print 'ul %r' % rectangle.upper_left
print 'lr %r' % rectangle.lower_right
print 'll %r' % rectangle.lower_left
print 'ur %r' % rectangle.upper_right
assert (rectangle.upper_left.x, rectangle.upper_left.y) == (-2.247, 17.071)
assert (rectangle.lower_right.x, rectangle.lower_right.y) == (22.247, 2.929)
assert (rectangle.lower_left.x, rectangle.lower_left.y) == (2.929, -2.247)
assert (rectangle.upper_right.x, rectangle.upper_right.y) == (17.071, 22.247)
def __init__(self, object_list: dict, x=0, y=0, max_speed=200, acceleration=250, friction=400):
self.pos = Vector2.new(x, y)
self.vel = Vector2()
self.max_speed = max_speed
self.acceleration = acceleration
self.friction = friction
self.rect = geometry.Rectangle(x, y, 40, 40, color=(230, 50, 50))
self.jumped = False
self.teleported = False
self.alive = True
self.object_list = object_list
self.died = BindableEvent()
self.connection_on_died = self.died.connect(self.on_died)
self.connection_on_space = InputHandler.input_began.connect(self.on_space)
def bounds(self):
"""
Compute the bounding Rectangle of this Relation's members.
"""
# FIXME this fails if Relations have self-referencing members
# this will never happen in a PackedAtlas so it should be OK for now
# if pyatlas ever supports MultiAtlas then this will be a concern
members = self.get_members()
if len(members) == 0:
return geometry.Rectangle(0, 0)
entities_to_consider = []
for member in self.get_members():
entity = member.get_entity()
if entity is None:
raise ValueError('entity was None, how did this happen?')
entities_to_consider.append(entity)
return geometry.bounds_atlasentities(entities_to_consider)
def test_rectangle(self):
r = geometry.Rectangle(top=30, left=44, bot=58, right=73)
self.assertEqual('%s' % r,
'#<Rectangle top=30 left=44 bot=58 right=73>')
self.assertTrue(r.exclusively_inside(34, 56))
self.assertTrue(r.exclusively_inside(52, 71))
self.assertFalse(r.exclusively_inside(52, 73))
self.assertFalse(r.exclusively_inside(30, 71))
self.assertFalse(r.exclusively_inside(88, 99))
self.assertEqual('%s' % r.get_side(DIR_UP),
'#<Edge facing=up y=30 x0=44 x1=73>')
self.assertEqual('%s' % r.get_side(DIR_RIGHT),
'#<Edge facing=right y0=30 y1=58 x=73>')
self.assertEqual('%s' % r.get_side(DIR_DOWN),
'#<Edge facing=down y=58 x0=44 x1=73>')
self.assertEqual('%s' % r.get_side(DIR_LEFT),
'#<Edge facing=left y0=30 y1=58 x=44>')
self.assertEqual(r.width, 29)
self.assertEqual(r.height, 28)
def bounding_box(self):
return geometry.Rectangle(self.state.position, self.size)
construct_platform(600, 220, 200, 20)
construct_platform(640, 300, 200, 20)
construct_platform(640, 240, 20, 80)
construct_platform(400, 50, 20, 200)
BLUE = (50, 40, 240)
goal = game_objects.InteractiveRectangle(760, 260, 40, 40, color=BLUE)
def goal_touched(player):
#print(test_level)
change_level(end_level)
goal.on_touched.connect(goal_touched)
example_level.add_object(goal)
test_level = Level(50, 520)
base = geometry.Rectangle(0, 580, 800, 120)
goal2 = game_objects.InteractiveRectangle(760, 540, 40, 40, color=BLUE)
def goal_touched2(player):
change_level(level2)
test_level.add_object(base)
test_level.add_object(goal2)
goal2.on_touched.connect(goal_touched2)
level1_text = TextBox(size=UDim2(), pos=UDim2.from_scale(0.5, 0.5), anchor_point=Vector2(0.5, 0.5),
text_color=(255, 255, 255), font_size=24, text="Press A and D to move")
test_level.add_drawable(level1_text)
level2 = Level(50, 520)
level2.add_object(geometry.Rectangle(0, 580, 800, 120))
level2.add_object(game_objects.KillerRectangle(400, 540, 20, 60))
level2_goal = game_objects.InteractiveRectangle(760, 540, 40, 40, color=BLUE)
level2.add_object(level2_goal)
def add_rect(self, x, y, w, h):
rect = geometry.Rectangle(x, y, w, h)
self.objects.append(rect)
self.drawables.append(rect)
def construct_platform(x, y, w, h):
example_level.add_object(geometry.Rectangle(x, y, w, h))
def main():
np.set_printoptions(precision=3, suppress=True)
np.random.seed(0)
circles = [geo.Circle(7, 7, 1.5)]
rects = [
geo.Rectangle(-6, -10, -5, -1),
geo.Rectangle(-6, 1, -5, 10),
geo.Rectangle(0, -10, 1, -1),
geo.Rectangle(0, 1, 1, 10),
]
q_low = np.array([-10, -10])
q_high = np.array([10, 10])
q0 = np.array([-9, -9])
qf = np.array([9, 9])
tree = RRTreeStar(q0, obstacles=circles + rects)
# build the tree
for i in range(200):
print(i)
q = sample_config_space(q_low, q_high)
q_idx = tree.add_vertex(q)
# now start trying to connect qf
# i = 0
# while True:
# # try to connect the final node every 100th sample
# if i % 100 == 0:
# q = qf
# else:
# q = sample_config_space(q_low, q_high)
# q_idx = tree.add_vertex(q)
#
# if q_idx >= 0:
# if very_close(tree.vertices[q_idx].value, qf):
# print("qf connected")
# break
# i += 1
print(f"Number of vertices = {len(tree.vertices)}")
# print(f"Number of segments = {len(tree.segments)}")
path = tree.path_to_root(q_idx)
q_path = np.array([tree.vertices[idx].value for idx in path])
print(f"Length of path = {len(path)}")
plt.figure()
ax = plt.gca()
plt.xlim([-10, 10])
plt.ylim([-10, 10])
def plot_edges(ax, vertex):
q = vertex.value
for idx in vertex.children_idx:
child = tree.vertices[idx]
qc = child.value
ax.plot([q[0], qc[0]], [q[1], qc[1]], color="k")
plot_edges(ax, child)
plot_edges(ax, tree.vertices[0])
plt.plot(q0[0], q0[1], "o", color="g")
plt.plot(qf[0], qf[1], "o", color="r")
plt.plot(q_path[:, 0], q_path[:, 1], color="b")
for circle in circles:
ax.add_patch(plt.Circle(circle.center, circle.r, color="r", fill=True))
for rect in rects:
ax.add_patch(
plt.Rectangle(
(rect.x_min, rect.y_min), rect.width, rect.height, color="r", fill=True
)
)
plt.show()
def main():
"""
main function contains only printing methods, and user inputs for choosing action
"""
shapes = geometry.ShapeList() # object containing all shapes added by the user
while True:
os.system('clear')
print(
"LEARN GEOMETRY\n\n"
"What do you want to do?\n"
"\t(1) Add new shape\n"
"\t(2) Show all shapes\n"
"\t(3) Show shape with the largest perimeter\n"
"\t(4) Show shape with the largest area\n"
"\t(5) Show formulas\n"
"\t(0) Exit program\n"
)
option = input("Select an option: ")
if option == "1":
os.system('clear')
print_list_of_shapes()
user_choice = input('Select an option: ')
if user_choice == '1':
os.system('clear')
print('Enter the length of circle radius: ')
radius = input_value()
circle = geometry.Circle(radius)
shapes.add_shape(circle)
elif user_choice == '2':
os.system('clear')
print('Enter length of first side of triangle: ')
first_side = input_value()
print('Enter length of second side of triangle: ')
second_side = input_value()
print('Enter length of third side of triangle: ')
third_side = input_value()
try:
triangle = geometry.Triangle(first_side, second_side, third_side)
shapes.add_shape(triangle)
except ValueError:
input("Wrong value. Triangle cant be build with that length of sides {}, {}, {}."
.format(first_side, second_side, third_side))
elif user_choice == '3':
os.system('clear')
print('Enter length of equilateral triangle side:')
triangle_side = input_value()
equilateral_triangle = geometry.EquilateralTriangle(triangle_side)
shapes.add_shape(equilateral_triangle)
elif user_choice == '4':
os.system('clear')
print('Enter length of first side of rectangle: ')
first_side_of_rectangle = input_value()
print('Enter length of secound side of rectangle: ')
second_side_of_rectangle = input_value()
rectangle = geometry.Rectangle(first_side_of_rectangle, second_side_of_rectangle)
shapes.add_shape(rectangle)
elif user_choice == '5':
os.system('clear')
print('Enter length of side of square: ')
square_side = input_value()
square = geometry.Square(square_side)
shapes.add_shape(square)
elif user_choice == '6':
os.system('clear')
print('Enter length of side of regular pentagon: ')
pentagon_side = input_value()
pentagon = geometry.RegularPentagon(pentagon_side)
shapes.add_shape(pentagon)
elif user_choice == '0':
main()
else:
raise ValueError("Wrong input")
elif option == "2":
os.system('clear')
if len(shapes.shapes) == 0:
input('First add some shapes!\n\n Enter to back to menu')
else:
print(shapes.get_shapes_table())
input('\nEnter = main menu')
elif option == "3":
os.system('clear')
if len(shapes.shapes) == 0:
input('First add some shapes! \n Enter to back to menu')
else:
print('Shape with the largest perimeter:\n' +
str(shapes.get_largest_shape_by_perimeter()) + '\tperimeter:',
round(shapes.get_largest_shape_by_perimeter().get_perimeter(), 1))
input('\nEnter to back to menu')
elif option == "4":
os.system('clear')
if len(shapes.shapes) == 0:
input('First add some shapes! \n Enter to back menu')
else:
print('Shape with the largest area:\n' +
str(shapes.get_largest_shape_by_area()) + '\tarea:',
round(shapes.get_largest_shape_by_area().get_area(), 1))
input('\nEnter to back to menu')
elif option == "5":
os.system('clear')
print_list_of_shapes()
show_formulas = input("Enter number to get a shape formulas: ")
if show_formulas == '1':
shape = 'Circle'
area = geometry.Circle.get_area_formula()
perimeter = geometry.Circle.get_perimeter_formula()
elif show_formulas == '2':
shape = 'Triangle'
area = geometry.Triangle.get_area_formula()
perimeter = geometry.Triangle.get_perimeter_formula()
elif show_formulas == '3':
shape = 'Equilateral Triangle'
area = geometry.EquilateralTriangle.get_area_formula()
perimeter = geometry.Triangle.get_perimeter_formula()
elif show_formulas == '4':
shape = 'Rectangle'
area = geometry.Rectangle.get_area_formula()
perimeter = geometry.Rectangle.get_perimeter_formula()
elif show_formulas == '5':
shape = 'Square'
area = geometry.Square.get_area_formula()
perimeter = geometry.Square.get_perimeter_formula()
elif show_formulas == '6':
shape = 'Regular Pentagon'
area = geometry.RegularPentagon.get_area_formula()
perimeter = geometry.RegularPentagon.get_perimeter_formula()
elif show_formulas == '0':
main()
os.system('clear')
print('\n{}\n\nFormulas:\nArea: {}\nPerimeter: {}'.format(shape, area, perimeter))
input('\nEnter to back to menu')
elif option == "0":
sys.exit()
def draw(self):
return geometry.Rectangle(self.state.position, self.size)
################################################################################
# test rectangle class
# nicolas de toffoli
################################################################################
import pytest
import geometry
# global objects
rectangle_0 = geometry.Rectangle(0.0, 0.0)
rectangle_1 = geometry.Rectangle(10.0, 4.0)
def test_perimeter_0():
assert rectangle_0.perimeter() == 0.0
def test_perimeter_1():
assert rectangle_1.perimeter() == 28.0
def test_area_0():
assert rectangle_0.area() == 0.0
def test_area_1():
assert rectangle_1.area() == 40.0
def __init__(self, origin, width, height):
self.bounds = geometry.Rectangle(origin, width, height)
self.collisions = []
self.colliding = const.COLLISION_NONE
def main():
np.set_printoptions(precision=3, suppress=True)
np.random.seed(0)
circles = [geo.Circle(7, 7, 1.5)]
rects = [
geo.Rectangle(-6, -10, -5, -1),
geo.Rectangle(-6, 1, -5, 10),
geo.Rectangle(0, -10, 1, -1),
geo.Rectangle(0, 1, 1, 10),
]
q_low = np.array([-10, -10])
q_high = np.array([10, 10])
q0 = np.array([-9, -9])
qf = np.array([9, 9])
tree = RRTree(q0, obstacles=circles + rects)
while len(tree.vertices) < 2000:
q = sample_config_space(q_low, q_high)
q_idx = tree.add_vertex(q)
i = 0
while True:
# try to connect the final node every 100th sample
if i % 100 == 0:
q = qf
else:
q = sample_config_space(q_low, q_high)
q_idx = tree.add_vertex(q)
if q_idx >= 0:
if very_close(tree.vertices[q_idx].value, qf):
print("qf connected")
break
i += 1
print(f"Number of vertices = {len(tree.vertices)}")
print(f"Number of segments = {len(tree.segments)}")
path = tree.path_to_root(q_idx)
q_path = np.array([tree.vertices[idx].value for idx in path])
print(f"Length of path = {len(path)}")
plt.figure()
ax = plt.gca()
plt.xlim([-10, 10])
plt.ylim([-10, 10])
for segment in tree.segments:
q1 = segment.v1.value
q2 = segment.v2.value
plt.plot([q1[0], q2[0]], [q1[1], q2[1]], color="k")
# for i, vertex in enumerate(tree.vertices):
# q = vertex.value
# plt.plot(q[0], q[1], ".", color="b")
plt.plot(q0[0], q0[1], "o", color="g")
plt.plot(qf[0], qf[1], "o", color="r")
plt.plot(q_path[:, 0], q_path[:, 1], color="b")
for circle in circles:
ax.add_patch(plt.Circle(circle.center, circle.r, color="r", fill=True))
for rect in rects:
ax.add_patch(
plt.Rectangle((rect.x_min, rect.y_min),
rect.width,
rect.height,
color="r",
fill=True))
plt.show()