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()