def render( self, svg ): bar_group = group.Group() if self.shadow and self.length > 0: shadow_paint = Paint() shadow_paint.fill = "#BBB" shadow_paint.fill_opacity = 0.6 shadow = rect.Rect() shadow.x = self.x shadow.y = self.y - 3 shadow.width = self.length + 3 shadow.height = self.width utils.copy_object( shadow_paint, shadow ) bar_group.append( shadow ) r = rect.Rect() r.x = self.x r.y = self.y r.width = self.length r.height = self.width utils.copy_object( self.paint, r ) bar_group.append( r ) svg.append( bar_group )
def getClusters(contours, i_w, i_h, thresh): boxes, clusters = [], [] for c in contours: x, y, w, h = cv2.boundingRect(c) if w * h > i_w * i_h * thresh: clusters.append(rect.Rect(x, y, w, h)) else: boxes.append(rect.Rect(x, y, w, h)) clusters += rect.Rect.cluster(boxes) clusters = [ clusters[c] for c in range(len(clusters)) if clusters[c].area > i_w * i_h * thresh ] distThresh = ((i_w + i_h) / 2) * (thresh / 2) final = [] for c1 in clusters: tooClose = False for c2 in clusters: if c1 != c2 and c1.dist(c2) < distThresh: r = c1.maxRect(c2) tooClose = True if r not in final: final.append(r) break if tooClose == False: final.append(c1) return final
def __init__(self, width, height): self.width = width self.height = height self.sky = rect.Rect(0, 0, width, height, (20, 235, 250)) self.grass = rect.Rect(0, 640, width, 320, (120, 190, 50)) self.mountain1 = mountain.Mountain(200, 80, 640, 640, (50, 60, 160)) self.mountain2 = mountain.Mountain(400, 120, 500, 640, (5, 15, 120)) self.house = house.House(800, 540, 100, 100) self.house2 = house.House(850, 540, 150, 150)
def get_AABB(self): '''Returns a local-coordinates Axis aligned Bounding Box''' v = self._vertex_list.vertices x = v[0], v[2], v[4], v[6] y = v[1], v[3], v[5], v[7] return rect.Rect(min(x), min(y), max(x) - min(x), max(y) - min(y))
def __init__(self, values, vertical=False, grid=False): r = rect.Rect() r.x = 0 r.y = 0 r.width = 10 r.height = 10 r.rx = 0 b = Bars(r, values, vertical) p = Paint() p.fill = "red" p.stroke = "black" p.stroke_width = 2 if vertical: axisx_length = b.viewport.h axisy_length = b.viewport.w else: axisx_length = b.viewport.w axisy_length = b.viewport.h axis = (AxisX(axisx_length, 25, None, p), AxisY(axisy_length, 25, None, p)) Chart.__init__(self, b.viewport, axis, grid) self.append(b)
def get_box( self ): """Returns the box that contains the menu item. :rtype: (x1,x2,y1,y2) """ width = self.get_item_width () height = self.get_item_height () if self.item_halign == CENTER: x_diff = - width / 2 elif self.item_halign == RIGHT: x_diff = - width elif self.item_halign == LEFT: x_diff = 0 else: raise Exception("Invalid halign: %s" % str(self.item_halign) ) y_diff = - height/ 2 x1 = self.get_item_x() + x_diff y1 = self.get_item_y() + y_diff # x1 += self.parent.x # y1 += self.parent.y # x2 = x1 + width # y2 = y1 + height # return (x1,y1,x2,y2) return rect.Rect(x1,y1,width,height)
def __init__(self, values): r = rect.Rect() r.x = 0 r.y = 0 r.width = 10 r.height = 10 r.rx = 0 b = Bars(r, values, True) p = Paint() p.fill = "red" p.stroke = "grey" p.stroke_width = 2 axisx_length = 100 axisy_length = len(values) axis = (AxisX(axisx_length, 25, None, p), AxisY(axisy_length, 1, None, p)) Chart.__init__(self, b.viewport, axis) #grid = Grid( b.viewport, 25, 1, p ) #self.append(grid) self.append(b)
def __init__(self, x, y, width, height): self.x = x self.y = y self.width = width self.height = height self.walls = rect.Rect(x + width//6, y + height//3, width//3*2, height//3*2, (224,204,74)) self.roof = mountain.Mountain(x + width//2, y, width, y + height//3, (0, 0, 0))
def load_level(self, filename, tile_size): "Loads the level that corresponds to the given filename and initializes the rects" # Parse the level file self.level.parse_file(filename) # Create a rect for Pac-Man self.pacman_rect = rect.Rect(self.level.pacman_home, (tile_size, tile_size)) # Total number of pellets originally for this level self.total_pellets = self.level.num_pellets # Create the ghost rects for i in range(GHOSTS): self.ghost_rect[i] = rect.Rect(self.level.ghost_home[i], (tile_size, tile_size))
def motion_notify_event(self, widget, event): x = int(event.x) y = int(event.y) image_width = self.image.get_allocation().width image_height = self.image.get_allocation().height if self.select_state == SelectState.DRAG: self.select_area.left = clip(0, x - self.drag_x, image_width - self.select_area.width) self.select_area.top = clip(0, y - self.drag_y, image_height - self.select_area.height) self.queue_draw() elif self.select_state == SelectState.RESIZE: if self.resize_direction in [ rect.Edge.SE, rect.Edge.E, rect.Edge.NE ]: right = x - self.drag_x self.select_area.width = right - self.select_area.left if self.resize_direction in [ rect.Edge.SW, rect.Edge.S, rect.Edge.SE ]: bottom = y - self.drag_y self.select_area.height = bottom - self.select_area.top if self.resize_direction in [ rect.Edge.SW, rect.Edge.W, rect.Edge.NW ]: left = x - self.drag_x self.select_area.width = self.select_area.right() - left self.select_area.left = left if self.resize_direction in [ rect.Edge.NW, rect.Edge.N, rect.Edge.NE ]: top = y - self.drag_y self.select_area.height = self.select_area.bottom() - top self.select_area.top = top self.select_area.normalise() image = rect.Rect(0, 0, image_width, image_height) self.select_area = self.select_area.intersection(image) self.queue_draw() elif self.select_state == SelectState.WAIT: window = self.image.get_window() direction = self.select_area.which_corner(select_corner, x, y) if self.select_visible and \ direction != rect.Edge.NONE: window.set_cursor(resize_cursor_shape[direction]) elif self.select_visible and \ self.select_area.includes_point(x, y): window.set_cursor(drag_cursor_shape) else: window.set_cursor(None)
def __init__(self): r = rect.Rect() r.x = 1.0 r.y = 1.0 r.width = 1.0 r.height = 1.0 r.rx = 20 self.append(r)
def __init__(self, width, height): self.mWidth = width self.mHeight = height self.mSun = sun.Sun( (247, 238, 101), 175, 125, 50) self.mSky = rect.Rect((101, 233, 247), 0, 0, 900, 450) self.mGrass = rect.Rect((86, 219, 110), 0, 450, 900, 350) self.mTree1 = tree.Tree((143, 102, 26), (71, 153, 17), 650, 325, 75, 125) self.mTree2 = tree.Tree((168, 141, 50), (168, 50, 100), 800, 375, 50, 75) adult = 'adult' child = 'child' self.mParent1 = person.Person(adult, 225, 300 ) self.mParent2 = person.Person(adult, 100, 300) self.mChild1 = person.Person(child, 350, 350) self.mChild2 = person.Person(child, 450, 350) self.mChild3 = person.Person(child, 550, 350) self.mCloud1 = cloud.Cloud(400, 50, 150, 100) self.mCloud2 = cloud.Cloud(650, 70, 200, 100) self.mBlanket = blanket.Blanket((219, 50, 107), 100, 500, 350, 150) return
def get_selection(self): """Return a rect.Rect for the selection, or None if no selection is active. """ if not self.select_visible: return None return rect.Rect(self.select_area.left / scale, self.select_area.top / scale, self.select_area.width / scale, self.select_area.height / scale)
def get_selection(self): """Return a rect.Rect for the selection, or None if no selection is active. """ if not self.select_visible: return None image_width = self.image.get_allocation().width image_height = self.image.get_allocation().height return rect.Rect(1000 * self.select_area.left / image_width, 1000 * self.select_area.top / image_height, 1000 * self.select_area.width / image_width, 1000 * self.select_area.height / image_height)
def focus_cb(self, widget, data=None): self.preview.set_live(False) if self.focus_window: self.focus_window.present() else: sel = self.preview.get_selection() or rect.Rect( 0, 0, 1060 * 4, 706 * 4) self.focus_window = focus.Focus(self.camera, sel) self.focus_window.connect('destroy', self.focus_destroy_cb) self.focus_window.set_modal(True) self.focus_window.show()
def make_level(self, items=None, MAX_ENEMIES_PER_ROOM=0): #self.rooms = [] num_rooms = 0 for r in range(self.max_rooms): w = random.randint(self.room_min_size, self.room_max_size) h = random.randint(self.room_min_size, self.room_max_size) x = random.randint(1, self.level_width - w - 1) y = random.randint(1, self.level_height - h - 1) new_room = rect.Rect(x, y, w, h) failed = False for other_room in self.rooms: if new_room.intersect(other_room): failed = True break if not failed: self.create_room(new_room) (new_x, new_y) = new_room.center() if num_rooms == 0: try: self.entities[0].x = new_x self.entities[0].y = new_y except: print('No entities') pass try: items[0].x = new_x + 1 items[0].y = new_y + 1 except: print('No items') pass else: (prev_x, prev_y) = self.rooms[num_rooms-1].center() if random.randint(0, 2) == 1: self.create_h_tunnel(prev_x, new_x, prev_y) self.create_v_tunnel(prev_y, new_y, new_x) else: self.create_v_tunnel(prev_y, new_y, prev_x) self.create_h_tunnel(prev_x, new_x, new_y) self.rooms.append(new_room) if MAX_ENEMIES_PER_ROOM != 0: for i in range(MAX_ENEMIES_PER_ROOM): x_coord = random.randint(x+1, x+w-1) y_coord = random.randint(y+1, y+h-1) if not (x_coord, y_coord) in self.entities: self.entities.append((x_coord, y_coord)) num_rooms += 1
def create_collision_buffer(parms): buffer_size = 10 # pixels def get_buffer_val(self, parms): if len(parms) == 1: return parms[0] * buffer_size elif len(parms) == 2: return self.gnav(parms[1]) + (parms[0] * buffer_size) else: return parms[1].gnav(parms[2]) + (parms[0] * buffer_size) ## create_collision_buffer() if parms: left = get_buffer_val(self, parms[0]) top = get_buffer_val(self, parms[1]) width = get_buffer_val(self, parms[2]) height = get_buffer_val(self, parms[3]) self.collision_buffer = rect_lib.Rect((left, top, width, height))
def get_rect(self): '''Get a cocos.rect.Rect for this sprite. Note that this rect's position is most likely NOT the same as the Sprite's position - in fact by default the rect's center is the Sprite's position. If you move the rect around and wish to reflect this change in the Sprite, you will probably have to do something like (again with the default image anchor in the center):: rect = sprite.get_rect() rect.midbottom = (0, 100) sprite.position = rect.center Returns a cocos.rect.Rect instance. ''' x, y = self.position x -= self.image_anchor_x y -= self.image_anchor_y return rect.Rect(x, y, self.width, self.height)
def __init__(self, camera, selection): Gtk.Window.__init__(self) self.connect('destroy', self.destroy_cb) left = selection.left + int(selection.width / 2) - 400 top = selection.top + int(selection.height / 2) - 300 self.times = [] camera.focus_area(rect.Rect(0, 0, 800, 600)) self.image = Gtk.Image() self.add(self.image) self.image.show() self.image.set_app_paintable(True) self.frame_buffer = None self.preview_timeout = GLib.timeout_add(frame_timeout, self.live_cb) self.fps_timeout = GLib.timeout_add(1000, self.fps_cb) self.camera = camera self.frame = 0
def __init__(self, camera): """ Startup. camera -- the camera to display, see camera.py The preview starts at 640x426 pixels, this may change if the camera turns out to have a different size for its preview image. """ gtk.EventBox.__init__(self) self.image = gtk.Image() self.add(self.image) self.image.show() # start with a blank 640x426 image, we overwrite this with jpg from # the camera during live preview self.pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 640, 426) self.image.set_from_pixbuf(self.pixbuf) self.image.set_app_paintable(True) self.preview_timeout = 0 self.camera = camera self.frame = 0 self.select_visible = False self.select_area = rect.Rect(10, 10, 100, 100) self.select_state = SelectState.WAIT self.resize_direction = rect.Edge.N self.drag_x = 0 self.drag_y = 0 self.image.connect_after('expose-event', self.expose_event) self.add_events(gtk.gdk.POINTER_MOTION_MASK) self.connect('button-press-event', self.button_press_event) self.connect('motion-notify-event', self.motion_notify_event) self.connect('button-release-event', self.button_release_event)
def __init__(self, camera): """ Startup. camera -- the camera to display, see camera.py The preview starts at 640x426 pixels, this may change if the camera turns out to have a different size for its preview image. """ Gtk.EventBox.__init__(self) self.times = [] self.image = Gtk.Image() self.add(self.image) self.image.show() self.image.set_app_paintable(True) self.frame_image = None self.frame_buffer = None self.preview_timeout = 0 self.camera = camera self.frame = 0 self.select_visible = False self.select_area = rect.Rect(10, 10, 100, 100) self.select_state = SelectState.WAIT self.resize_direction = rect.Edge.N self.drag_x = 0 self.drag_y = 0 self.image.connect_after('draw', self.expose_event) self.add_events(Gdk.EventMask.POINTER_MOTION_MASK) self.connect('button-press-event', self.button_press_event) self.connect('motion-notify-event', self.motion_notify_event) self.connect('button-release-event', self.button_release_event) self.score = None
try: import dxvideo video_available = 1 video_select_keys = '0123456789' except ImportError: video_available = 0 linear = transition.Transition() exports = [ 'Drawable', 'Text', 'Image', 'Fill', 'BulletedList', 'Anim', 'Interactive', 'Video' ] default_camera = rect.Rect(0, 0, 400, 0, 4.0 / 3.0) class Element(object): def __str__(self): return '<animation element>' def __getattr__(self, name): if name == '_current_params' or name == '_params': raise AttributeError plist = [i[0] for i in getattr(self, '_current_params', self._params)] if name in plist: raise AttributeError, "'%s' element is not on stage; can't access '%s' parameter" % ( self.__class__.__name__, name) else: raise AttributeError, "'%s' element has no '%s' parameter" % (
def viewport(self): """Rect: The drawing area for rendering on the current target.""" viewport = rect.Rect(0, 0, 0, 0) check_int_err(lib.SDL_RenderGetViewport(self._ptr, viewport._ptr)) return viewport
def get_rect(self): '''Get a cocos.rect.Rect for this sprite.''' x = -self.image_anchor_x y = -self.image_anchor_y return rect.Rect(x, y, self.width, self.height)
from helper import * from rect import Rect import rect import math world_w, world_h = (200, 100) new_platforms = [ rect.Rect(0, 50, 50, 5), rect.Rect(55, 10, 5, 100), rect.Rect(30, 0, 5, 40), rect.Rect(55, 40, 200, 5), rect.Rect(300, 45, 300, 5), ] new_player = R(y=0, vy=0, x=10, vx=0) new_game = R(platforms=new_platforms, player=new_player) player_thickness = 5 platform_thickness = 5 def player_rect(player): return rect.Rect(player.x - player_thickness / 2, player.y - player_thickness / 2, player_thickness, player_thickness) def intersection_direction(player_r, i): if i.w >= i.h: if abs(i.y - player_r.y) > player_r.h / 2: return 'N'
def setUp(self): self.r = rect.Rect(10, 10, 10, 10)
def player_rect(player): return rect.Rect(player.x - player_thickness / 2, player.y - player_thickness / 2, player_thickness, player_thickness)
def test_Rect(): cmp(rect.return_Rect(), (18, 4, 154, 150)) rect.receive_Rect(rect.Rect(69, 43, 13, 89))
def initRects(self): for i in range(10): r = rect.Rect(random.randrange(0, 1920), self.id_index) self.id_index += 1 self.allGameObjects[self.id_index] = r